[PATCH 1/1] winevulkan: Always use params to return Unix thunks result.

[Jacek Caban]

From: Jacek Caban

---
 dlls/winevulkan/loader.c        |   28 +-
 dlls/winevulkan/loader_thunks.c |  453 ++++++---
 dlls/winevulkan/loader_thunks.h |  157 ++++
 dlls/winevulkan/make_vulkan     |   20 +-
 dlls/winevulkan/vulkan_thunks.c | 1570 +++++++++++++------------------
 5 files changed, 1107 insertions(+), 1121 deletions(-)

diff --git a/dlls/winevulkan/loader.c b/dlls/winevulkan/loader.c
index 847207f8cee..d6fe9fe078f 100644
--- a/dlls/winevulkan/loader.c
+++ b/dlls/winevulkan/loader.c
@@ -257,7 +257,6 @@ VkResult WINAPI vkCreateInstance(const VkInstanceCreateInfo *create_info,
     struct vkCreateInstance_params params;
     struct VkInstance_T *instance;
     uint32_t phys_dev_count = 8, i;
-    VkResult result;

TRACE("create_info %p, allocator %p, instance %p\n", create_info, allocator, ret);

@@ -276,7 +275,7 @@ VkResult WINAPI vkCreateInstance(const VkInstanceCreateInfo *create_info,
         params.pAllocator = allocator;
         params.pInstance = ret;
         params.client_ptr = instance;
-        result = vk_unix_call(unix_vkCreateInstance, &params);
+        vk_unix_call(unix_vkCreateInstance, &params);
         if (instance->phys_dev_count <= phys_dev_count)
             break;
         phys_dev_count = instance->phys_dev_count;
@@ -285,7 +284,7 @@ VkResult WINAPI vkCreateInstance(const VkInstanceCreateInfo *create_info,

if (!instance->base.unix_handle)
         free(instance);
-    return result;
+    return params.result;
 }

void WINAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
@@ -319,7 +318,8 @@ VkResult WINAPI vkEnumerateInstanceExtensionProperties(const char *layer_name,
     params.pLayerName = layer_name;
     params.pPropertyCount = count;
     params.pProperties = properties;
-    return vk_unix_call(unix_vkEnumerateInstanceExtensionProperties, &params);
+    vk_unix_call(unix_vkEnumerateInstanceExtensionProperties, &params);
+    return params.result;
 }

VkResult WINAPI vkEnumerateInstanceVersion(uint32_t *version)
@@ -335,7 +335,8 @@ VkResult WINAPI vkEnumerateInstanceVersion(uint32_t *version)
     }

params.pApiVersion = version;
-    return vk_unix_call(unix_vkEnumerateInstanceVersion, &params);
+    vk_unix_call(unix_vkEnumerateInstanceVersion, &params);
+    return params.result;
 }

static HANDLE get_display_device_init_mutex(void)
@@ -461,7 +462,6 @@ VkResult WINAPI vkCreateDevice(VkPhysicalDevice phys_dev, const VkDeviceCreateIn
     struct vkCreateDevice_params params;
     uint32_t queue_count = 0, i;
     VkDevice device;
-    VkResult result;

for (i = 0; i < create_info->queueCreateInfoCount; i++)
         queue_count += create_info->pQueueCreateInfos[i].queueCount;
@@ -475,10 +475,10 @@ VkResult WINAPI vkCreateDevice(VkPhysicalDevice phys_dev, const VkDeviceCreateIn
     params.pAllocator = allocator;
     params.pDevice = ret;
     params.client_ptr = device;
-    result = vk_unix_call(unix_vkCreateDevice, &params);
+    vk_unix_call(unix_vkCreateDevice, &params);
     if (!device->base.unix_handle)
         free(device);
-    return result;
+    return params.result;
 }

void WINAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *allocator)
@@ -496,7 +496,6 @@ VkResult WINAPI vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateIn
 {
     struct vkCreateCommandPool_params params;
     struct vk_command_pool *cmd_pool;
-    VkResult result;

if (!(cmd_pool = malloc(sizeof(*cmd_pool))))
         return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -508,10 +507,10 @@ VkResult WINAPI vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateIn
     params.pAllocator = allocator;
     params.pCommandPool = ret;
     params.client_ptr = cmd_pool;
-    result = vk_unix_call(unix_vkCreateCommandPool, &params);
+    vk_unix_call(unix_vkCreateCommandPool, &params);
     if (!cmd_pool->unix_handle)
         free(cmd_pool);
-    return result;
+    return params.result;
 }

void WINAPI vkDestroyCommandPool(VkDevice device, VkCommandPool handle, const VkAllocationCallbacks *allocator)
@@ -545,7 +544,6 @@ VkResult WINAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferA
     struct vk_command_pool *pool = command_pool_from_handle(allocate_info->commandPool);
     struct vkAllocateCommandBuffers_params params;
     uint32_t i;
-    VkResult result;

for (i = 0; i < allocate_info->commandBufferCount; i++)
         buffers[i] = alloc_vk_object(sizeof(*buffers[i]));
@@ -553,8 +551,8 @@ VkResult WINAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferA
     params.device = device;
     params.pAllocateInfo = allocate_info;
     params.pCommandBuffers = buffers;
-    result = vk_unix_call(unix_vkAllocateCommandBuffers, &params);
-    if (result == VK_SUCCESS)
+    vk_unix_call(unix_vkAllocateCommandBuffers, &params);
+    if (params.result == VK_SUCCESS)
     {
         for (i = 0; i < allocate_info->commandBufferCount; i++)
             list_add_tail(&pool->command_buffers, &buffers[i]->pool_link);
@@ -567,7 +565,7 @@ VkResult WINAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferA
             buffers[i] = NULL;
         }
     }
-    return result;
+    return params.result;
 }

void WINAPI vkFreeCommandBuffers(VkDevice device, VkCommandPool cmd_pool, uint32_t count,
diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c
index 22f70e530ec..708021a49f1 100644
--- a/dlls/winevulkan/loader_thunks.c
+++ b/dlls/winevulkan/loader_thunks.c
@@ -19,7 +19,8 @@ VkResult WINAPI vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImage
     params.device = device;
     params.pAcquireInfo = pAcquireInfo;
     params.pImageIndex = pImageIndex;
-    return vk_unix_call(unix_vkAcquireNextImage2KHR, &params);
+    vk_unix_call(unix_vkAcquireNextImage2KHR, &params);
+    return params.result;
 }

VkResult WINAPI vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
@@ -31,7 +32,8 @@ VkResult WINAPI vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain,
     params.semaphore = semaphore;
     params.fence = fence;
     params.pImageIndex = pImageIndex;
-    return vk_unix_call(unix_vkAcquireNextImageKHR, &params);
+    vk_unix_call(unix_vkAcquireNextImageKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
@@ -40,7 +42,8 @@ VkResult WINAPI vkAcquirePerformanceConfigurationINTEL(VkDevice device, const Vk
     params.device = device;
     params.pAcquireInfo = pAcquireInfo;
     params.pConfiguration = pConfiguration;
-    return vk_unix_call(unix_vkAcquirePerformanceConfigurationINTEL, &params);
+    vk_unix_call(unix_vkAcquirePerformanceConfigurationINTEL, &params);
+    return params.result;
 }

VkResult WINAPI vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
@@ -48,7 +51,8 @@ VkResult WINAPI vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfil
     struct vkAcquireProfilingLockKHR_params params;
     params.device = device;
     params.pInfo = pInfo;
-    return vk_unix_call(unix_vkAcquireProfilingLockKHR, &params);
+    vk_unix_call(unix_vkAcquireProfilingLockKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
@@ -57,7 +61,8 @@ VkResult WINAPI vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetA
     params.device = device;
     params.pAllocateInfo = pAllocateInfo;
     params.pDescriptorSets = pDescriptorSets;
-    return vk_unix_call(unix_vkAllocateDescriptorSets, &params);
+    vk_unix_call(unix_vkAllocateDescriptorSets, &params);
+    return params.result;
 }

VkResult WINAPI vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
@@ -67,7 +72,8 @@ VkResult WINAPI vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pA
     params.pAllocateInfo = pAllocateInfo;
     params.pAllocator = pAllocator;
     params.pMemory = pMemory;
-    return vk_unix_call(unix_vkAllocateMemory, &params);
+    vk_unix_call(unix_vkAllocateMemory, &params);
+    return params.result;
 }

VkResult WINAPI vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
@@ -75,7 +81,8 @@ VkResult WINAPI vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkComm
     struct vkBeginCommandBuffer_params params;
     params.commandBuffer = commandBuffer;
     params.pBeginInfo = pBeginInfo;
-    return vk_unix_call(unix_vkBeginCommandBuffer, &params);
+    vk_unix_call(unix_vkBeginCommandBuffer, &params);
+    return params.result;
 }

VkResult WINAPI vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
@@ -84,7 +91,8 @@ VkResult WINAPI vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bi
     params.device = device;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfos = pBindInfos;
-    return vk_unix_call(unix_vkBindAccelerationStructureMemoryNV, &params);
+    vk_unix_call(unix_vkBindAccelerationStructureMemoryNV, &params);
+    return params.result;
 }

VkResult WINAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
@@ -94,7 +102,8 @@ VkResult WINAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMem
     params.buffer = buffer;
     params.memory = memory;
     params.memoryOffset = memoryOffset;
-    return vk_unix_call(unix_vkBindBufferMemory, &params);
+    vk_unix_call(unix_vkBindBufferMemory, &params);
+    return params.result;
 }

VkResult WINAPI vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
@@ -103,7 +112,8 @@ VkResult WINAPI vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, con
     params.device = device;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfos = pBindInfos;
-    return vk_unix_call(unix_vkBindBufferMemory2, &params);
+    vk_unix_call(unix_vkBindBufferMemory2, &params);
+    return params.result;
 }

VkResult WINAPI vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
@@ -112,7 +122,8 @@ VkResult WINAPI vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
     params.device = device;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfos = pBindInfos;
-    return vk_unix_call(unix_vkBindBufferMemory2KHR, &params);
+    vk_unix_call(unix_vkBindBufferMemory2KHR, &params);
+    return params.result;
 }

VkResult WINAPI vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
@@ -122,7 +133,8 @@ VkResult WINAPI vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory
     params.image = image;
     params.memory = memory;
     params.memoryOffset = memoryOffset;
-    return vk_unix_call(unix_vkBindImageMemory, &params);
+    vk_unix_call(unix_vkBindImageMemory, &params);
+    return params.result;
 }

VkResult WINAPI vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
@@ -131,7 +143,8 @@ VkResult WINAPI vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, cons
     params.device = device;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfos = pBindInfos;
-    return vk_unix_call(unix_vkBindImageMemory2, &params);
+    vk_unix_call(unix_vkBindImageMemory2, &params);
+    return params.result;
 }

VkResult WINAPI vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
@@ -140,7 +153,8 @@ VkResult WINAPI vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, c
     params.device = device;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfos = pBindInfos;
-    return vk_unix_call(unix_vkBindImageMemory2KHR, &params);
+    vk_unix_call(unix_vkBindImageMemory2KHR, &params);
+    return params.result;
 }

VkResult WINAPI vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
@@ -151,7 +165,8 @@ VkResult WINAPI vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOper
     params.infoCount = infoCount;
     params.pInfos = pInfos;
     params.ppBuildRangeInfos = ppBuildRangeInfos;
-    return vk_unix_call(unix_vkBuildAccelerationStructuresKHR, &params);
+    vk_unix_call(unix_vkBuildAccelerationStructuresKHR, &params);
+    return params.result;
 }

void WINAPI vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
@@ -1491,7 +1506,8 @@ VkResult WINAPI vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, co
     struct vkCmdSetPerformanceMarkerINTEL_params params;
     params.commandBuffer = commandBuffer;
     params.pMarkerInfo = pMarkerInfo;
-    return p_vk_direct_unix_call(unix_handle, unix_vkCmdSetPerformanceMarkerINTEL, &params);
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetPerformanceMarkerINTEL, &params);
+    return params.result;
 }

VkResult WINAPI vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
@@ -1499,7 +1515,8 @@ VkResult WINAPI vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer,
     struct vkCmdSetPerformanceOverrideINTEL_params params;
     params.commandBuffer = commandBuffer;
     params.pOverrideInfo = pOverrideInfo;
-    return p_vk_direct_unix_call(unix_handle, unix_vkCmdSetPerformanceOverrideINTEL, &params);
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetPerformanceOverrideINTEL, &params);
+    return params.result;
 }

VkResult WINAPI vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
@@ -1507,7 +1524,8 @@ VkResult WINAPI vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuff
     struct vkCmdSetPerformanceStreamMarkerINTEL_params params;
     params.commandBuffer = commandBuffer;
     params.pMarkerInfo = pMarkerInfo;
-    return p_vk_direct_unix_call(unix_handle, unix_vkCmdSetPerformanceStreamMarkerINTEL, &params);
+    p_vk_direct_unix_call(unix_handle, unix_vkCmdSetPerformanceStreamMarkerINTEL, &params);
+    return params.result;
 }

void WINAPI vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
@@ -1920,7 +1938,8 @@ VkResult WINAPI vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32
     params.device = device;
     params.pipeline = pipeline;
     params.shader = shader;
-    return vk_unix_call(unix_vkCompileDeferredNV, &params);
+    vk_unix_call(unix_vkCompileDeferredNV, &params);
+    return params.result;
 }

VkResult WINAPI vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
@@ -1929,7 +1948,8 @@ VkResult WINAPI vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperat
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.pInfo = pInfo;
-    return vk_unix_call(unix_vkCopyAccelerationStructureKHR, &params);
+    vk_unix_call(unix_vkCopyAccelerationStructureKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
@@ -1938,7 +1958,8 @@ VkResult WINAPI vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferr
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.pInfo = pInfo;
-    return vk_unix_call(unix_vkCopyAccelerationStructureToMemoryKHR, &params);
+    vk_unix_call(unix_vkCopyAccelerationStructureToMemoryKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
@@ -1947,7 +1968,8 @@ VkResult WINAPI vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferr
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.pInfo = pInfo;
-    return vk_unix_call(unix_vkCopyMemoryToAccelerationStructureKHR, &params);
+    vk_unix_call(unix_vkCopyMemoryToAccelerationStructureKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
@@ -1957,7 +1979,8 @@ VkResult WINAPI vkCreateAccelerationStructureKHR(VkDevice device, const VkAccele
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pAccelerationStructure = pAccelerationStructure;
-    return vk_unix_call(unix_vkCreateAccelerationStructureKHR, &params);
+    vk_unix_call(unix_vkCreateAccelerationStructureKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
@@ -1967,7 +1990,8 @@ VkResult WINAPI vkCreateAccelerationStructureNV(VkDevice device, const VkAcceler
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pAccelerationStructure = pAccelerationStructure;
-    return vk_unix_call(unix_vkCreateAccelerationStructureNV, &params);
+    vk_unix_call(unix_vkCreateAccelerationStructureNV, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
@@ -1977,7 +2001,8 @@ VkResult WINAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreat
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pBuffer = pBuffer;
-    return vk_unix_call(unix_vkCreateBuffer, &params);
+    vk_unix_call(unix_vkCreateBuffer, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
@@ -1987,7 +2012,8 @@ VkResult WINAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pView = pView;
-    return vk_unix_call(unix_vkCreateBufferView, &params);
+    vk_unix_call(unix_vkCreateBufferView, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
@@ -1999,7 +2025,8 @@ VkResult WINAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipeli
     params.pCreateInfos = pCreateInfos;
     params.pAllocator = pAllocator;
     params.pPipelines = pPipelines;
-    return vk_unix_call(unix_vkCreateComputePipelines, &params);
+    vk_unix_call(unix_vkCreateComputePipelines, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
@@ -2009,7 +2036,8 @@ VkResult WINAPI vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateI
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pFunction = pFunction;
-    return vk_unix_call(unix_vkCreateCuFunctionNVX, &params);
+    vk_unix_call(unix_vkCreateCuFunctionNVX, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule)
@@ -2019,7 +2047,8 @@ VkResult WINAPI vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoN
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pModule = pModule;
-    return vk_unix_call(unix_vkCreateCuModuleNVX, &params);
+    vk_unix_call(unix_vkCreateCuModuleNVX, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
@@ -2029,7 +2058,8 @@ VkResult WINAPI vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebu
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pCallback = pCallback;
-    return vk_unix_call(unix_vkCreateDebugReportCallbackEXT, &params);
+    vk_unix_call(unix_vkCreateDebugReportCallbackEXT, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
@@ -2039,7 +2069,8 @@ VkResult WINAPI vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebu
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pMessenger = pMessenger;
-    return vk_unix_call(unix_vkCreateDebugUtilsMessengerEXT, &params);
+    vk_unix_call(unix_vkCreateDebugUtilsMessengerEXT, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
@@ -2048,7 +2079,8 @@ VkResult WINAPI vkCreateDeferredOperationKHR(VkDevice device, const VkAllocation
     params.device = device;
     params.pAllocator = pAllocator;
     params.pDeferredOperation = pDeferredOperation;
-    return vk_unix_call(unix_vkCreateDeferredOperationKHR, &params);
+    vk_unix_call(unix_vkCreateDeferredOperationKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
@@ -2058,7 +2090,8 @@ VkResult WINAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCr
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pDescriptorPool = pDescriptorPool;
-    return vk_unix_call(unix_vkCreateDescriptorPool, &params);
+    vk_unix_call(unix_vkCreateDescriptorPool, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
@@ -2068,7 +2101,8 @@ VkResult WINAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorS
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pSetLayout = pSetLayout;
-    return vk_unix_call(unix_vkCreateDescriptorSetLayout, &params);
+    vk_unix_call(unix_vkCreateDescriptorSetLayout, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
@@ -2078,7 +2112,8 @@ VkResult WINAPI vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescri
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pDescriptorUpdateTemplate = pDescriptorUpdateTemplate;
-    return vk_unix_call(unix_vkCreateDescriptorUpdateTemplate, &params);
+    vk_unix_call(unix_vkCreateDescriptorUpdateTemplate, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
@@ -2088,7 +2123,8 @@ VkResult WINAPI vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDes
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pDescriptorUpdateTemplate = pDescriptorUpdateTemplate;
-    return vk_unix_call(unix_vkCreateDescriptorUpdateTemplateKHR, &params);
+    vk_unix_call(unix_vkCreateDescriptorUpdateTemplateKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
@@ -2098,7 +2134,8 @@ VkResult WINAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateI
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pEvent = pEvent;
-    return vk_unix_call(unix_vkCreateEvent, &params);
+    vk_unix_call(unix_vkCreateEvent, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
@@ -2108,7 +2145,8 @@ VkResult WINAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateI
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pFence = pFence;
-    return vk_unix_call(unix_vkCreateFence, &params);
+    vk_unix_call(unix_vkCreateFence, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
@@ -2118,7 +2156,8 @@ VkResult WINAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateIn
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pFramebuffer = pFramebuffer;
-    return vk_unix_call(unix_vkCreateFramebuffer, &params);
+    vk_unix_call(unix_vkCreateFramebuffer, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
@@ -2130,7 +2169,8 @@ VkResult WINAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipel
     params.pCreateInfos = pCreateInfos;
     params.pAllocator = pAllocator;
     params.pPipelines = pPipelines;
-    return vk_unix_call(unix_vkCreateGraphicsPipelines, &params);
+    vk_unix_call(unix_vkCreateGraphicsPipelines, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
@@ -2140,7 +2180,8 @@ VkResult WINAPI vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateI
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pImage = pImage;
-    return vk_unix_call(unix_vkCreateImage, &params);
+    vk_unix_call(unix_vkCreateImage, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
@@ -2150,7 +2191,8 @@ VkResult WINAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pView = pView;
-    return vk_unix_call(unix_vkCreateImageView, &params);
+    vk_unix_call(unix_vkCreateImageView, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
@@ -2160,7 +2202,8 @@ VkResult WINAPI vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndire
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pIndirectCommandsLayout = pIndirectCommandsLayout;
-    return vk_unix_call(unix_vkCreateIndirectCommandsLayoutNV, &params);
+    vk_unix_call(unix_vkCreateIndirectCommandsLayoutNV, &params);
+    return params.result;
 }

VkResult WINAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
@@ -2170,7 +2213,8 @@ VkResult WINAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCrea
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pPipelineCache = pPipelineCache;
-    return vk_unix_call(unix_vkCreatePipelineCache, &params);
+    vk_unix_call(unix_vkCreatePipelineCache, &params);
+    return params.result;
 }

VkResult WINAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
@@ -2180,7 +2224,8 @@ VkResult WINAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCr
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pPipelineLayout = pPipelineLayout;
-    return vk_unix_call(unix_vkCreatePipelineLayout, &params);
+    vk_unix_call(unix_vkCreatePipelineLayout, &params);
+    return params.result;
 }

VkResult WINAPI vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
@@ -2190,7 +2235,8 @@ VkResult WINAPI vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlot
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pPrivateDataSlot = pPrivateDataSlot;
-    return vk_unix_call(unix_vkCreatePrivateDataSlot, &params);
+    vk_unix_call(unix_vkCreatePrivateDataSlot, &params);
+    return params.result;
 }

VkResult WINAPI vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
@@ -2200,7 +2246,8 @@ VkResult WINAPI vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataS
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pPrivateDataSlot = pPrivateDataSlot;
-    return vk_unix_call(unix_vkCreatePrivateDataSlotEXT, &params);
+    vk_unix_call(unix_vkCreatePrivateDataSlotEXT, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
@@ -2210,7 +2257,8 @@ VkResult WINAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pQueryPool = pQueryPool;
-    return vk_unix_call(unix_vkCreateQueryPool, &params);
+    vk_unix_call(unix_vkCreateQueryPool, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
@@ -2223,7 +2271,8 @@ VkResult WINAPI vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperat
     params.pCreateInfos = pCreateInfos;
     params.pAllocator = pAllocator;
     params.pPipelines = pPipelines;
-    return vk_unix_call(unix_vkCreateRayTracingPipelinesKHR, &params);
+    vk_unix_call(unix_vkCreateRayTracingPipelinesKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
@@ -2235,7 +2284,8 @@ VkResult WINAPI vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache p
     params.pCreateInfos = pCreateInfos;
     params.pAllocator = pAllocator;
     params.pPipelines = pPipelines;
-    return vk_unix_call(unix_vkCreateRayTracingPipelinesNV, &params);
+    vk_unix_call(unix_vkCreateRayTracingPipelinesNV, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
@@ -2245,7 +2295,8 @@ VkResult WINAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pRenderPass = pRenderPass;
-    return vk_unix_call(unix_vkCreateRenderPass, &params);
+    vk_unix_call(unix_vkCreateRenderPass, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
@@ -2255,7 +2306,8 @@ VkResult WINAPI vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInf
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pRenderPass = pRenderPass;
-    return vk_unix_call(unix_vkCreateRenderPass2, &params);
+    vk_unix_call(unix_vkCreateRenderPass2, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
@@ -2265,7 +2317,8 @@ VkResult WINAPI vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreate
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pRenderPass = pRenderPass;
-    return vk_unix_call(unix_vkCreateRenderPass2KHR, &params);
+    vk_unix_call(unix_vkCreateRenderPass2KHR, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
@@ -2275,7 +2328,8 @@ VkResult WINAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCre
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pSampler = pSampler;
-    return vk_unix_call(unix_vkCreateSampler, &params);
+    vk_unix_call(unix_vkCreateSampler, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
@@ -2285,7 +2339,8 @@ VkResult WINAPI vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerY
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pYcbcrConversion = pYcbcrConversion;
-    return vk_unix_call(unix_vkCreateSamplerYcbcrConversion, &params);
+    vk_unix_call(unix_vkCreateSamplerYcbcrConversion, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
@@ -2295,7 +2350,8 @@ VkResult WINAPI vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSampl
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pYcbcrConversion = pYcbcrConversion;
-    return vk_unix_call(unix_vkCreateSamplerYcbcrConversionKHR, &params);
+    vk_unix_call(unix_vkCreateSamplerYcbcrConversionKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
@@ -2305,7 +2361,8 @@ VkResult WINAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pSemaphore = pSemaphore;
-    return vk_unix_call(unix_vkCreateSemaphore, &params);
+    vk_unix_call(unix_vkCreateSemaphore, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
@@ -2315,7 +2372,8 @@ VkResult WINAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreate
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pShaderModule = pShaderModule;
-    return vk_unix_call(unix_vkCreateShaderModule, &params);
+    vk_unix_call(unix_vkCreateShaderModule, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
@@ -2325,7 +2383,8 @@ VkResult WINAPI vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInf
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pSwapchain = pSwapchain;
-    return vk_unix_call(unix_vkCreateSwapchainKHR, &params);
+    vk_unix_call(unix_vkCreateSwapchainKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
@@ -2335,7 +2394,8 @@ VkResult WINAPI vkCreateValidationCacheEXT(VkDevice device, const VkValidationCa
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pValidationCache = pValidationCache;
-    return vk_unix_call(unix_vkCreateValidationCacheEXT, &params);
+    vk_unix_call(unix_vkCreateValidationCacheEXT, &params);
+    return params.result;
 }

VkResult WINAPI vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
@@ -2345,7 +2405,8 @@ VkResult WINAPI vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32Surfac
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pSurface = pSurface;
-    return vk_unix_call(unix_vkCreateWin32SurfaceKHR, &params);
+    vk_unix_call(unix_vkCreateWin32SurfaceKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
@@ -2353,7 +2414,8 @@ VkResult WINAPI vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMark
     struct vkDebugMarkerSetObjectNameEXT_params params;
     params.device = device;
     params.pNameInfo = pNameInfo;
-    return vk_unix_call(unix_vkDebugMarkerSetObjectNameEXT, &params);
+    vk_unix_call(unix_vkDebugMarkerSetObjectNameEXT, &params);
+    return params.result;
 }

VkResult WINAPI vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
@@ -2361,7 +2423,8 @@ VkResult WINAPI vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarke
     struct vkDebugMarkerSetObjectTagEXT_params params;
     params.device = device;
     params.pTagInfo = pTagInfo;
-    return vk_unix_call(unix_vkDebugMarkerSetObjectTagEXT, &params);
+    vk_unix_call(unix_vkDebugMarkerSetObjectTagEXT, &params);
+    return params.result;
 }

void WINAPI vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
@@ -2383,7 +2446,8 @@ VkResult WINAPI vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationK
     struct vkDeferredOperationJoinKHR_params params;
     params.device = device;
     params.operation = operation;
-    return vk_unix_call(unix_vkDeferredOperationJoinKHR, &params);
+    vk_unix_call(unix_vkDeferredOperationJoinKHR, &params);
+    return params.result;
 }

void WINAPI vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
@@ -2696,14 +2760,16 @@ VkResult WINAPI vkDeviceWaitIdle(VkDevice device)
 {
     struct vkDeviceWaitIdle_params params;
     params.device = device;
-    return vk_unix_call(unix_vkDeviceWaitIdle, &params);
+    vk_unix_call(unix_vkDeviceWaitIdle, &params);
+    return params.result;
 }

VkResult WINAPI vkEndCommandBuffer(VkCommandBuffer commandBuffer)
 {
     struct vkEndCommandBuffer_params params;
     params.commandBuffer = commandBuffer;
-    return vk_unix_call(unix_vkEndCommandBuffer, &params);
+    vk_unix_call(unix_vkEndCommandBuffer, &params);
+    return params.result;
 }

VkResult WINAPI vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
@@ -2713,7 +2779,8 @@ VkResult WINAPI vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDe
     params.pLayerName = pLayerName;
     params.pPropertyCount = pPropertyCount;
     params.pProperties = pProperties;
-    return vk_unix_call(unix_vkEnumerateDeviceExtensionProperties, &params);
+    vk_unix_call(unix_vkEnumerateDeviceExtensionProperties, &params);
+    return params.result;
 }

VkResult WINAPI vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
@@ -2722,7 +2789,8 @@ VkResult WINAPI vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice
     params.physicalDevice = physicalDevice;
     params.pPropertyCount = pPropertyCount;
     params.pProperties = pProperties;
-    return vk_unix_call(unix_vkEnumerateDeviceLayerProperties, &params);
+    vk_unix_call(unix_vkEnumerateDeviceLayerProperties, &params);
+    return params.result;
 }

VkResult WINAPI vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
@@ -2731,7 +2799,8 @@ VkResult WINAPI vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *p
     params.instance = instance;
     params.pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount;
     params.pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties;
-    return vk_unix_call(unix_vkEnumeratePhysicalDeviceGroups, &params);
+    vk_unix_call(unix_vkEnumeratePhysicalDeviceGroups, &params);
+    return params.result;
 }

VkResult WINAPI vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
@@ -2740,7 +2809,8 @@ VkResult WINAPI vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t
     params.instance = instance;
     params.pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount;
     params.pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties;
-    return vk_unix_call(unix_vkEnumeratePhysicalDeviceGroupsKHR, &params);
+    vk_unix_call(unix_vkEnumeratePhysicalDeviceGroupsKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
@@ -2751,7 +2821,8 @@ VkResult WINAPI vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
     params.pCounterCount = pCounterCount;
     params.pCounters = pCounters;
     params.pCounterDescriptions = pCounterDescriptions;
-    return vk_unix_call(unix_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, &params);
+    vk_unix_call(unix_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
@@ -2760,7 +2831,8 @@ VkResult WINAPI vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysi
     params.instance = instance;
     params.pPhysicalDeviceCount = pPhysicalDeviceCount;
     params.pPhysicalDevices = pPhysicalDevices;
-    return vk_unix_call(unix_vkEnumeratePhysicalDevices, &params);
+    vk_unix_call(unix_vkEnumeratePhysicalDevices, &params);
+    return params.result;
 }

VkResult WINAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
@@ -2769,7 +2841,8 @@ VkResult WINAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeC
     params.device = device;
     params.memoryRangeCount = memoryRangeCount;
     params.pMemoryRanges = pMemoryRanges;
-    return vk_unix_call(unix_vkFlushMappedMemoryRanges, &params);
+    vk_unix_call(unix_vkFlushMappedMemoryRanges, &params);
+    return params.result;
 }

VkResult WINAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
@@ -2779,7 +2852,8 @@ VkResult WINAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descripto
     params.descriptorPool = descriptorPool;
     params.descriptorSetCount = descriptorSetCount;
     params.pDescriptorSets = pDescriptorSets;
-    return vk_unix_call(unix_vkFreeDescriptorSets, &params);
+    vk_unix_call(unix_vkFreeDescriptorSets, &params);
+    return params.result;
 }

void WINAPI vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
@@ -2818,7 +2892,8 @@ VkResult WINAPI vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerati
     params.accelerationStructure = accelerationStructure;
     params.dataSize = dataSize;
     params.pData = pData;
-    return vk_unix_call(unix_vkGetAccelerationStructureHandleNV, &params);
+    vk_unix_call(unix_vkGetAccelerationStructureHandleNV, &params);
+    return params.result;
 }

void WINAPI vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
@@ -2910,7 +2985,8 @@ VkResult WINAPI vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestamp
     params.pTimestampInfos = pTimestampInfos;
     params.pTimestamps = pTimestamps;
     params.pMaxDeviation = pMaxDeviation;
-    return vk_unix_call(unix_vkGetCalibratedTimestampsEXT, &params);
+    vk_unix_call(unix_vkGetCalibratedTimestampsEXT, &params);
+    return params.result;
 }

uint32_t WINAPI vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
@@ -2918,7 +2994,8 @@ uint32_t WINAPI vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDefer
     struct vkGetDeferredOperationMaxConcurrencyKHR_params params;
     params.device = device;
     params.operation = operation;
-    return vk_unix_call(unix_vkGetDeferredOperationMaxConcurrencyKHR, &params);
+    vk_unix_call(unix_vkGetDeferredOperationMaxConcurrencyKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
@@ -2926,7 +3003,8 @@ VkResult WINAPI vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOpera
     struct vkGetDeferredOperationResultKHR_params params;
     params.device = device;
     params.operation = operation;
-    return vk_unix_call(unix_vkGetDeferredOperationResultKHR, &params);
+    vk_unix_call(unix_vkGetDeferredOperationResultKHR, &params);
+    return params.result;
 }

void WINAPI vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
@@ -3019,7 +3097,8 @@ VkResult WINAPI vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDevice
     struct vkGetDeviceGroupPresentCapabilitiesKHR_params params;
     params.device = device;
     params.pDeviceGroupPresentCapabilities = pDeviceGroupPresentCapabilities;
-    return vk_unix_call(unix_vkGetDeviceGroupPresentCapabilitiesKHR, &params);
+    vk_unix_call(unix_vkGetDeviceGroupPresentCapabilitiesKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
@@ -3028,7 +3107,8 @@ VkResult WINAPI vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfac
     params.device = device;
     params.surface = surface;
     params.pModes = pModes;
-    return vk_unix_call(unix_vkGetDeviceGroupSurfacePresentModesKHR, &params);
+    vk_unix_call(unix_vkGetDeviceGroupSurfacePresentModesKHR, &params);
+    return params.result;
 }

void WINAPI vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
@@ -3121,7 +3201,8 @@ VkResult WINAPI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device,
     params.device = device;
     params.renderpass = renderpass;
     params.pMaxWorkgroupSize = pMaxWorkgroupSize;
-    return vk_unix_call(unix_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, &params);
+    vk_unix_call(unix_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, &params);
+    return params.result;
 }

VkResult WINAPI vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties)
@@ -3130,7 +3211,8 @@ VkResult WINAPI vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const V
     params.device = device;
     params.pRenderingInfo = pRenderingInfo;
     params.pProperties = pProperties;
-    return vk_unix_call(unix_vkGetDynamicRenderingTilePropertiesQCOM, &params);
+    vk_unix_call(unix_vkGetDynamicRenderingTilePropertiesQCOM, &params);
+    return params.result;
 }

VkResult WINAPI vkGetEventStatus(VkDevice device, VkEvent event)
@@ -3138,7 +3220,8 @@ VkResult WINAPI vkGetEventStatus(VkDevice device, VkEvent event)
     struct vkGetEventStatus_params params;
     params.device = device;
     params.event = event;
-    return vk_unix_call(unix_vkGetEventStatus, &params);
+    vk_unix_call(unix_vkGetEventStatus, &params);
+    return params.result;
 }

VkResult WINAPI vkGetFenceStatus(VkDevice device, VkFence fence)
@@ -3146,7 +3229,8 @@ VkResult WINAPI vkGetFenceStatus(VkDevice device, VkFence fence)
     struct vkGetFenceStatus_params params;
     params.device = device;
     params.fence = fence;
-    return vk_unix_call(unix_vkGetFenceStatus, &params);
+    vk_unix_call(unix_vkGetFenceStatus, &params);
+    return params.result;
 }

VkResult WINAPI vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties)
@@ -3156,7 +3240,8 @@ VkResult WINAPI vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffe
     params.framebuffer = framebuffer;
     params.pPropertiesCount = pPropertiesCount;
     params.pProperties = pProperties;
-    return vk_unix_call(unix_vkGetFramebufferTilePropertiesQCOM, &params);
+    vk_unix_call(unix_vkGetFramebufferTilePropertiesQCOM, &params);
+    return params.result;
 }

void WINAPI vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
@@ -3251,7 +3336,8 @@ VkResult WINAPI vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView,
     params.device = device;
     params.imageView = imageView;
     params.pProperties = pProperties;
-    return vk_unix_call(unix_vkGetImageViewAddressNVX, &params);
+    vk_unix_call(unix_vkGetImageViewAddressNVX, &params);
+    return params.result;
 }

uint32_t WINAPI vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
@@ -3259,7 +3345,8 @@ uint32_t WINAPI vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandle
     struct vkGetImageViewHandleNVX_params params;
     params.device = device;
     params.pInfo = pInfo;
-    return vk_unix_call(unix_vkGetImageViewHandleNVX, &params);
+    vk_unix_call(unix_vkGetImageViewHandleNVX, &params);
+    return params.result;
 }

VkResult WINAPI vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
@@ -3269,7 +3356,8 @@ VkResult WINAPI vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalM
     params.handleType = handleType;
     params.pHostPointer = pHostPointer;
     params.pMemoryHostPointerProperties = pMemoryHostPointerProperties;
-    return vk_unix_call(unix_vkGetMemoryHostPointerPropertiesEXT, &params);
+    vk_unix_call(unix_vkGetMemoryHostPointerPropertiesEXT, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
@@ -3278,7 +3366,8 @@ VkResult WINAPI vkGetPerformanceParameterINTEL(VkDevice device, VkPerformancePar
     params.device = device;
     params.parameter = parameter;
     params.pValue = pValue;
-    return vk_unix_call(unix_vkGetPerformanceParameterINTEL, &params);
+    vk_unix_call(unix_vkGetPerformanceParameterINTEL, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
@@ -3287,7 +3376,8 @@ VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice
     params.physicalDevice = physicalDevice;
     params.pTimeDomainCount = pTimeDomainCount;
     params.pTimeDomains = pTimeDomains;
-    return vk_unix_call(unix_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
@@ -3296,7 +3386,8 @@ VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevic
     params.physicalDevice = physicalDevice;
     params.pPropertyCount = pPropertyCount;
     params.pProperties = pProperties;
-    return vk_unix_call(unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, &params);
+    return params.result;
 }

void WINAPI vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
@@ -3410,7 +3501,8 @@ VkResult WINAPI vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice phys
     params.physicalDevice = physicalDevice;
     params.pFragmentShadingRateCount = pFragmentShadingRateCount;
     params.pFragmentShadingRates = pFragmentShadingRates;
-    return vk_unix_call(unix_vkGetPhysicalDeviceFragmentShadingRatesKHR, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceFragmentShadingRatesKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
@@ -3423,7 +3515,8 @@ VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physic
     params.usage = usage;
     params.flags = flags;
     params.pImageFormatProperties = pImageFormatProperties;
-    return vk_unix_call(unix_vkGetPhysicalDeviceImageFormatProperties, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceImageFormatProperties, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
@@ -3432,7 +3525,8 @@ VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physi
     params.physicalDevice = physicalDevice;
     params.pImageFormatInfo = pImageFormatInfo;
     params.pImageFormatProperties = pImageFormatProperties;
-    return vk_unix_call(unix_vkGetPhysicalDeviceImageFormatProperties2, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceImageFormatProperties2, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
@@ -3441,7 +3535,8 @@ VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice ph
     params.physicalDevice = physicalDevice;
     params.pImageFormatInfo = pImageFormatInfo;
     params.pImageFormatProperties = pImageFormatProperties;
-    return vk_unix_call(unix_vkGetPhysicalDeviceImageFormatProperties2KHR, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceImageFormatProperties2KHR, &params);
+    return params.result;
 }

void WINAPI vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
@@ -3484,7 +3579,8 @@ VkResult WINAPI vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physica
     params.surface = surface;
     params.pRectCount = pRectCount;
     params.pRects = pRects;
-    return vk_unix_call(unix_vkGetPhysicalDevicePresentRectanglesKHR, &params);
+    vk_unix_call(unix_vkGetPhysicalDevicePresentRectanglesKHR, &params);
+    return params.result;
 }

void WINAPI vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
@@ -3571,7 +3667,8 @@ VkResult WINAPI vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsN
     params.physicalDevice = physicalDevice;
     params.pCombinationCount = pCombinationCount;
     params.pCombinations = pCombinations;
-    return vk_unix_call(unix_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
@@ -3580,7 +3677,8 @@ VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice phys
     params.physicalDevice = physicalDevice;
     params.pSurfaceInfo = pSurfaceInfo;
     params.pSurfaceCapabilities = pSurfaceCapabilities;
-    return vk_unix_call(unix_vkGetPhysicalDeviceSurfaceCapabilities2KHR, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceSurfaceCapabilities2KHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
@@ -3589,7 +3687,8 @@ VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physi
     params.physicalDevice = physicalDevice;
     params.surface = surface;
     params.pSurfaceCapabilities = pSurfaceCapabilities;
-    return vk_unix_call(unix_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
@@ -3599,7 +3698,8 @@ VkResult WINAPI vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalD
     params.pSurfaceInfo = pSurfaceInfo;
     params.pSurfaceFormatCount = pSurfaceFormatCount;
     params.pSurfaceFormats = pSurfaceFormats;
-    return vk_unix_call(unix_vkGetPhysicalDeviceSurfaceFormats2KHR, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceSurfaceFormats2KHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
@@ -3609,7 +3709,8 @@ VkResult WINAPI vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDe
     params.surface = surface;
     params.pSurfaceFormatCount = pSurfaceFormatCount;
     params.pSurfaceFormats = pSurfaceFormats;
-    return vk_unix_call(unix_vkGetPhysicalDeviceSurfaceFormatsKHR, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceSurfaceFormatsKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
@@ -3619,7 +3720,8 @@ VkResult WINAPI vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physi
     params.surface = surface;
     params.pPresentModeCount = pPresentModeCount;
     params.pPresentModes = pPresentModes;
-    return vk_unix_call(unix_vkGetPhysicalDeviceSurfacePresentModesKHR, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceSurfacePresentModesKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
@@ -3629,7 +3731,8 @@ VkResult WINAPI vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDe
     params.queueFamilyIndex = queueFamilyIndex;
     params.surface = surface;
     params.pSupported = pSupported;
-    return vk_unix_call(unix_vkGetPhysicalDeviceSurfaceSupportKHR, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceSurfaceSupportKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
@@ -3638,7 +3741,8 @@ VkResult WINAPI vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevic
     params.physicalDevice = physicalDevice;
     params.pToolCount = pToolCount;
     params.pToolProperties = pToolProperties;
-    return vk_unix_call(unix_vkGetPhysicalDeviceToolProperties, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceToolProperties, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
@@ -3647,7 +3751,8 @@ VkResult WINAPI vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDe
     params.physicalDevice = physicalDevice;
     params.pToolCount = pToolCount;
     params.pToolProperties = pToolProperties;
-    return vk_unix_call(unix_vkGetPhysicalDeviceToolPropertiesEXT, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceToolPropertiesEXT, &params);
+    return params.result;
 }

VkBool32 WINAPI vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
@@ -3655,7 +3760,8 @@ VkBool32 WINAPI vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice
     struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params params;
     params.physicalDevice = physicalDevice;
     params.queueFamilyIndex = queueFamilyIndex;
-    return vk_unix_call(unix_vkGetPhysicalDeviceWin32PresentationSupportKHR, &params);
+    vk_unix_call(unix_vkGetPhysicalDeviceWin32PresentationSupportKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
@@ -3665,7 +3771,8 @@ VkResult WINAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipeline
     params.pipelineCache = pipelineCache;
     params.pDataSize = pDataSize;
     params.pData = pData;
-    return vk_unix_call(unix_vkGetPipelineCacheData, &params);
+    vk_unix_call(unix_vkGetPipelineCacheData, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
@@ -3675,7 +3782,8 @@ VkResult WINAPI vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice devic
     params.pExecutableInfo = pExecutableInfo;
     params.pInternalRepresentationCount = pInternalRepresentationCount;
     params.pInternalRepresentations = pInternalRepresentations;
-    return vk_unix_call(unix_vkGetPipelineExecutableInternalRepresentationsKHR, &params);
+    vk_unix_call(unix_vkGetPipelineExecutableInternalRepresentationsKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
@@ -3685,7 +3793,8 @@ VkResult WINAPI vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPi
     params.pPipelineInfo = pPipelineInfo;
     params.pExecutableCount = pExecutableCount;
     params.pProperties = pProperties;
-    return vk_unix_call(unix_vkGetPipelineExecutablePropertiesKHR, &params);
+    vk_unix_call(unix_vkGetPipelineExecutablePropertiesKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
@@ -3695,7 +3804,8 @@ VkResult WINAPI vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPi
     params.pExecutableInfo = pExecutableInfo;
     params.pStatisticCount = pStatisticCount;
     params.pStatistics = pStatistics;
-    return vk_unix_call(unix_vkGetPipelineExecutableStatisticsKHR, &params);
+    vk_unix_call(unix_vkGetPipelineExecutableStatisticsKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties)
@@ -3704,7 +3814,8 @@ VkResult WINAPI vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfo
     params.device = device;
     params.pPipelineInfo = pPipelineInfo;
     params.pPipelineProperties = pPipelineProperties;
-    return vk_unix_call(unix_vkGetPipelinePropertiesEXT, &params);
+    vk_unix_call(unix_vkGetPipelinePropertiesEXT, &params);
+    return params.result;
 }

void WINAPI vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
@@ -3740,7 +3851,8 @@ VkResult WINAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, ui
     params.pData = pData;
     params.stride = stride;
     params.flags = flags;
-    return vk_unix_call(unix_vkGetQueryPoolResults, &params);
+    vk_unix_call(unix_vkGetQueryPoolResults, &params);
+    return params.result;
 }

void WINAPI vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
@@ -3770,7 +3882,8 @@ VkResult WINAPI vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice devic
     params.groupCount = groupCount;
     params.dataSize = dataSize;
     params.pData = pData;
-    return vk_unix_call(unix_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, &params);
+    vk_unix_call(unix_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
@@ -3782,7 +3895,8 @@ VkResult WINAPI vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline
     params.groupCount = groupCount;
     params.dataSize = dataSize;
     params.pData = pData;
-    return vk_unix_call(unix_vkGetRayTracingShaderGroupHandlesKHR, &params);
+    vk_unix_call(unix_vkGetRayTracingShaderGroupHandlesKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
@@ -3794,7 +3908,8 @@ VkResult WINAPI vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline
     params.groupCount = groupCount;
     params.dataSize = dataSize;
     params.pData = pData;
-    return vk_unix_call(unix_vkGetRayTracingShaderGroupHandlesNV, &params);
+    vk_unix_call(unix_vkGetRayTracingShaderGroupHandlesNV, &params);
+    return params.result;
 }

VkDeviceSize WINAPI vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
@@ -3804,7 +3919,8 @@ VkDeviceSize WINAPI vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPi
     params.pipeline = pipeline;
     params.group = group;
     params.groupShader = groupShader;
-    return vk_unix_call(unix_vkGetRayTracingShaderGroupStackSizeKHR, &params);
+    vk_unix_call(unix_vkGetRayTracingShaderGroupStackSizeKHR, &params);
+    return params.result;
 }

void WINAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
@@ -3822,7 +3938,8 @@ VkResult WINAPI vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphor
     params.device = device;
     params.semaphore = semaphore;
     params.pValue = pValue;
-    return vk_unix_call(unix_vkGetSemaphoreCounterValue, &params);
+    vk_unix_call(unix_vkGetSemaphoreCounterValue, &params);
+    return params.result;
 }

VkResult WINAPI vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
@@ -3831,7 +3948,8 @@ VkResult WINAPI vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semap
     params.device = device;
     params.semaphore = semaphore;
     params.pValue = pValue;
-    return vk_unix_call(unix_vkGetSemaphoreCounterValueKHR, &params);
+    vk_unix_call(unix_vkGetSemaphoreCounterValueKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
@@ -3843,7 +3961,8 @@ VkResult WINAPI vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShade
     params.infoType = infoType;
     params.pInfoSize = pInfoSize;
     params.pInfo = pInfo;
-    return vk_unix_call(unix_vkGetShaderInfoAMD, &params);
+    vk_unix_call(unix_vkGetShaderInfoAMD, &params);
+    return params.result;
 }

void WINAPI vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier)
@@ -3871,7 +3990,8 @@ VkResult WINAPI vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchai
     params.swapchain = swapchain;
     params.pSwapchainImageCount = pSwapchainImageCount;
     params.pSwapchainImages = pSwapchainImages;
-    return vk_unix_call(unix_vkGetSwapchainImagesKHR, &params);
+    vk_unix_call(unix_vkGetSwapchainImagesKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
@@ -3881,7 +4001,8 @@ VkResult WINAPI vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEX
     params.validationCache = validationCache;
     params.pDataSize = pDataSize;
     params.pData = pData;
-    return vk_unix_call(unix_vkGetValidationCacheDataEXT, &params);
+    vk_unix_call(unix_vkGetValidationCacheDataEXT, &params);
+    return params.result;
 }

VkResult WINAPI vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
@@ -3889,7 +4010,8 @@ VkResult WINAPI vkInitializePerformanceApiINTEL(VkDevice device, const VkInitial
     struct vkInitializePerformanceApiINTEL_params params;
     params.device = device;
     params.pInitializeInfo = pInitializeInfo;
-    return vk_unix_call(unix_vkInitializePerformanceApiINTEL, &params);
+    vk_unix_call(unix_vkInitializePerformanceApiINTEL, &params);
+    return params.result;
 }

VkResult WINAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
@@ -3898,7 +4020,8 @@ VkResult WINAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryR
     params.device = device;
     params.memoryRangeCount = memoryRangeCount;
     params.pMemoryRanges = pMemoryRanges;
-    return vk_unix_call(unix_vkInvalidateMappedMemoryRanges, &params);
+    vk_unix_call(unix_vkInvalidateMappedMemoryRanges, &params);
+    return params.result;
 }

VkResult WINAPI vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
@@ -3910,7 +4033,8 @@ VkResult WINAPI vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize
     params.size = size;
     params.flags = flags;
     params.ppData = ppData;
-    return vk_unix_call(unix_vkMapMemory, &params);
+    vk_unix_call(unix_vkMapMemory, &params);
+    return params.result;
 }

VkResult WINAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
@@ -3920,7 +4044,8 @@ VkResult WINAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
     params.dstCache = dstCache;
     params.srcCacheCount = srcCacheCount;
     params.pSrcCaches = pSrcCaches;
-    return vk_unix_call(unix_vkMergePipelineCaches, &params);
+    vk_unix_call(unix_vkMergePipelineCaches, &params);
+    return params.result;
 }

VkResult WINAPI vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
@@ -3930,7 +4055,8 @@ VkResult WINAPI vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT
     params.dstCache = dstCache;
     params.srcCacheCount = srcCacheCount;
     params.pSrcCaches = pSrcCaches;
-    return vk_unix_call(unix_vkMergeValidationCachesEXT, &params);
+    vk_unix_call(unix_vkMergeValidationCachesEXT, &params);
+    return params.result;
 }

void WINAPI vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
@@ -3948,7 +4074,8 @@ VkResult WINAPI vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const V
     params.bindInfoCount = bindInfoCount;
     params.pBindInfo = pBindInfo;
     params.fence = fence;
-    return vk_unix_call(unix_vkQueueBindSparse, &params);
+    vk_unix_call(unix_vkQueueBindSparse, &params);
+    return params.result;
 }

void WINAPI vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
@@ -3971,7 +4098,8 @@ VkResult WINAPI vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresen
     struct vkQueuePresentKHR_params params;
     params.queue = queue;
     params.pPresentInfo = pPresentInfo;
-    return vk_unix_call(unix_vkQueuePresentKHR, &params);
+    vk_unix_call(unix_vkQueuePresentKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
@@ -3979,7 +4107,8 @@ VkResult WINAPI vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerform
     struct vkQueueSetPerformanceConfigurationINTEL_params params;
     params.queue = queue;
     params.configuration = configuration;
-    return vk_unix_call(unix_vkQueueSetPerformanceConfigurationINTEL, &params);
+    vk_unix_call(unix_vkQueueSetPerformanceConfigurationINTEL, &params);
+    return params.result;
 }

VkResult WINAPI vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
@@ -3989,7 +4118,8 @@ VkResult WINAPI vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmi
     params.submitCount = submitCount;
     params.pSubmits = pSubmits;
     params.fence = fence;
-    return vk_unix_call(unix_vkQueueSubmit, &params);
+    vk_unix_call(unix_vkQueueSubmit, &params);
+    return params.result;
 }

VkResult WINAPI vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
@@ -3999,7 +4129,8 @@ VkResult WINAPI vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubm
     params.submitCount = submitCount;
     params.pSubmits = pSubmits;
     params.fence = fence;
-    return vk_unix_call(unix_vkQueueSubmit2, &params);
+    vk_unix_call(unix_vkQueueSubmit2, &params);
+    return params.result;
 }

VkResult WINAPI vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
@@ -4009,14 +4140,16 @@ VkResult WINAPI vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkS
     params.submitCount = submitCount;
     params.pSubmits = pSubmits;
     params.fence = fence;
-    return vk_unix_call(unix_vkQueueSubmit2KHR, &params);
+    vk_unix_call(unix_vkQueueSubmit2KHR, &params);
+    return params.result;
 }

VkResult WINAPI vkQueueWaitIdle(VkQueue queue)
 {
     struct vkQueueWaitIdle_params params;
     params.queue = queue;
-    return vk_unix_call(unix_vkQueueWaitIdle, &params);
+    vk_unix_call(unix_vkQueueWaitIdle, &params);
+    return params.result;
 }

VkResult WINAPI vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
@@ -4024,7 +4157,8 @@ VkResult WINAPI vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerfor
     struct vkReleasePerformanceConfigurationINTEL_params params;
     params.device = device;
     params.configuration = configuration;
-    return vk_unix_call(unix_vkReleasePerformanceConfigurationINTEL, &params);
+    vk_unix_call(unix_vkReleasePerformanceConfigurationINTEL, &params);
+    return params.result;
 }

void WINAPI vkReleaseProfilingLockKHR(VkDevice device)
@@ -4039,7 +4173,8 @@ VkResult WINAPI vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBuf
     struct vkResetCommandBuffer_params params;
     params.commandBuffer = commandBuffer;
     params.flags = flags;
-    return vk_unix_call(unix_vkResetCommandBuffer, &params);
+    vk_unix_call(unix_vkResetCommandBuffer, &params);
+    return params.result;
 }

VkResult WINAPI vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
@@ -4048,7 +4183,8 @@ VkResult WINAPI vkResetCommandPool(VkDevice device, VkCommandPool commandPool, V
     params.device = device;
     params.commandPool = commandPool;
     params.flags = flags;
-    return vk_unix_call(unix_vkResetCommandPool, &params);
+    vk_unix_call(unix_vkResetCommandPool, &params);
+    return params.result;
 }

VkResult WINAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
@@ -4057,7 +4193,8 @@ VkResult WINAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descript
     params.device = device;
     params.descriptorPool = descriptorPool;
     params.flags = flags;
-    return vk_unix_call(unix_vkResetDescriptorPool, &params);
+    vk_unix_call(unix_vkResetDescriptorPool, &params);
+    return params.result;
 }

VkResult WINAPI vkResetEvent(VkDevice device, VkEvent event)
@@ -4065,7 +4202,8 @@ VkResult WINAPI vkResetEvent(VkDevice device, VkEvent event)
     struct vkResetEvent_params params;
     params.device = device;
     params.event = event;
-    return vk_unix_call(unix_vkResetEvent, &params);
+    vk_unix_call(unix_vkResetEvent, &params);
+    return params.result;
 }

VkResult WINAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
@@ -4074,7 +4212,8 @@ VkResult WINAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFenc
     params.device = device;
     params.fenceCount = fenceCount;
     params.pFences = pFences;
-    return vk_unix_call(unix_vkResetFences, &params);
+    vk_unix_call(unix_vkResetFences, &params);
+    return params.result;
 }

void WINAPI vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
@@ -4102,7 +4241,8 @@ VkResult WINAPI vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtils
     struct vkSetDebugUtilsObjectNameEXT_params params;
     params.device = device;
     params.pNameInfo = pNameInfo;
-    return vk_unix_call(unix_vkSetDebugUtilsObjectNameEXT, &params);
+    vk_unix_call(unix_vkSetDebugUtilsObjectNameEXT, &params);
+    return params.result;
 }

VkResult WINAPI vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
@@ -4110,7 +4250,8 @@ VkResult WINAPI vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsO
     struct vkSetDebugUtilsObjectTagEXT_params params;
     params.device = device;
     params.pTagInfo = pTagInfo;
-    return vk_unix_call(unix_vkSetDebugUtilsObjectTagEXT, &params);
+    vk_unix_call(unix_vkSetDebugUtilsObjectTagEXT, &params);
+    return params.result;
 }

void WINAPI vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority)
@@ -4127,7 +4268,8 @@ VkResult WINAPI vkSetEvent(VkDevice device, VkEvent event)
     struct vkSetEvent_params params;
     params.device = device;
     params.event = event;
-    return vk_unix_call(unix_vkSetEvent, &params);
+    vk_unix_call(unix_vkSetEvent, &params);
+    return params.result;
 }

VkResult WINAPI vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
@@ -4138,7 +4280,8 @@ VkResult WINAPI vkSetPrivateData(VkDevice device, VkObjectType objectType, uint6
     params.objectHandle = objectHandle;
     params.privateDataSlot = privateDataSlot;
     params.data = data;
-    return vk_unix_call(unix_vkSetPrivateData, &params);
+    vk_unix_call(unix_vkSetPrivateData, &params);
+    return params.result;
 }

VkResult WINAPI vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
@@ -4149,7 +4292,8 @@ VkResult WINAPI vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, ui
     params.objectHandle = objectHandle;
     params.privateDataSlot = privateDataSlot;
     params.data = data;
-    return vk_unix_call(unix_vkSetPrivateDataEXT, &params);
+    vk_unix_call(unix_vkSetPrivateDataEXT, &params);
+    return params.result;
 }

VkResult WINAPI vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
@@ -4157,7 +4301,8 @@ VkResult WINAPI vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *
     struct vkSignalSemaphore_params params;
     params.device = device;
     params.pSignalInfo = pSignalInfo;
-    return vk_unix_call(unix_vkSignalSemaphore, &params);
+    vk_unix_call(unix_vkSignalSemaphore, &params);
+    return params.result;
 }

VkResult WINAPI vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
@@ -4165,7 +4310,8 @@ VkResult WINAPI vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInf
     struct vkSignalSemaphoreKHR_params params;
     params.device = device;
     params.pSignalInfo = pSignalInfo;
-    return vk_unix_call(unix_vkSignalSemaphoreKHR, &params);
+    vk_unix_call(unix_vkSignalSemaphoreKHR, &params);
+    return params.result;
 }

void WINAPI vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
@@ -4250,7 +4396,8 @@ VkResult WINAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFe
     params.pFences = pFences;
     params.waitAll = waitAll;
     params.timeout = timeout;
-    return vk_unix_call(unix_vkWaitForFences, &params);
+    vk_unix_call(unix_vkWaitForFences, &params);
+    return params.result;
 }

VkResult WINAPI vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
@@ -4260,7 +4407,8 @@ VkResult WINAPI vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, u
     params.swapchain = swapchain;
     params.presentId = presentId;
     params.timeout = timeout;
-    return vk_unix_call(unix_vkWaitForPresentKHR, &params);
+    vk_unix_call(unix_vkWaitForPresentKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
@@ -4269,7 +4417,8 @@ VkResult WINAPI vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWa
     params.device = device;
     params.pWaitInfo = pWaitInfo;
     params.timeout = timeout;
-    return vk_unix_call(unix_vkWaitSemaphores, &params);
+    vk_unix_call(unix_vkWaitSemaphores, &params);
+    return params.result;
 }

VkResult WINAPI vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
@@ -4278,7 +4427,8 @@ VkResult WINAPI vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *
     params.device = device;
     params.pWaitInfo = pWaitInfo;
     params.timeout = timeout;
-    return vk_unix_call(unix_vkWaitSemaphoresKHR, &params);
+    vk_unix_call(unix_vkWaitSemaphoresKHR, &params);
+    return params.result;
 }

VkResult WINAPI vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
@@ -4291,7 +4441,8 @@ VkResult WINAPI vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint
     params.dataSize = dataSize;
     params.pData = pData;
     params.stride = stride;
-    return vk_unix_call(unix_vkWriteAccelerationStructuresPropertiesKHR, &params);
+    vk_unix_call(unix_vkWriteAccelerationStructuresPropertiesKHR, &params);
+    return params.result;
 }

static const struct vulkan_func vk_device_dispatch_table[] =
diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h
index 57fbacb31ef..4590fa1dbc6 100644
--- a/dlls/winevulkan/loader_thunks.h
+++ b/dlls/winevulkan/loader_thunks.h
@@ -485,6 +485,7 @@ struct vkAcquireNextImage2KHR_params
     VkDevice device;
     const VkAcquireNextImageInfoKHR *pAcquireInfo;
     uint32_t *pImageIndex;
+    VkResult result;
 };

struct vkAcquireNextImageKHR_params
@@ -495,6 +496,7 @@ struct vkAcquireNextImageKHR_params
     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
     VkFence DECLSPEC_ALIGN(8) fence;
     uint32_t *pImageIndex;
+    VkResult result;
 };

struct vkAcquirePerformanceConfigurationINTEL_params
@@ -502,12 +504,14 @@ struct vkAcquirePerformanceConfigurationINTEL_params
     VkDevice device;
     const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo;
     VkPerformanceConfigurationINTEL *pConfiguration;
+    VkResult result;
 };

struct vkAcquireProfilingLockKHR_params
 {
     VkDevice device;
     const VkAcquireProfilingLockInfoKHR *pInfo;
+    VkResult result;
 };

struct vkAllocateCommandBuffers_params
@@ -515,6 +519,7 @@ struct vkAllocateCommandBuffers_params
     VkDevice device;
     const VkCommandBufferAllocateInfo *pAllocateInfo;
     VkCommandBuffer *pCommandBuffers;
+    VkResult result;
 };

struct vkAllocateDescriptorSets_params
@@ -522,6 +527,7 @@ struct vkAllocateDescriptorSets_params
     VkDevice device;
     const VkDescriptorSetAllocateInfo *pAllocateInfo;
     VkDescriptorSet *pDescriptorSets;
+    VkResult result;
 };

struct vkAllocateMemory_params
@@ -530,12 +536,14 @@ struct vkAllocateMemory_params
     const VkMemoryAllocateInfo *pAllocateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkDeviceMemory *pMemory;
+    VkResult result;
 };

struct vkBeginCommandBuffer_params
 {
     VkCommandBuffer commandBuffer;
     const VkCommandBufferBeginInfo *pBeginInfo;
+    VkResult result;
 };

struct vkBindAccelerationStructureMemoryNV_params
@@ -543,6 +551,7 @@ struct vkBindAccelerationStructureMemoryNV_params
     VkDevice device;
     uint32_t bindInfoCount;
     const VkBindAccelerationStructureMemoryInfoNV *pBindInfos;
+    VkResult result;
 };

struct vkBindBufferMemory_params
@@ -551,6 +560,7 @@ struct vkBindBufferMemory_params
     VkBuffer DECLSPEC_ALIGN(8) buffer;
     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
+    VkResult result;
 };

struct vkBindBufferMemory2_params
@@ -558,6 +568,7 @@ struct vkBindBufferMemory2_params
     VkDevice device;
     uint32_t bindInfoCount;
     const VkBindBufferMemoryInfo *pBindInfos;
+    VkResult result;
 };

struct vkBindBufferMemory2KHR_params
@@ -565,6 +576,7 @@ struct vkBindBufferMemory2KHR_params
     VkDevice device;
     uint32_t bindInfoCount;
     const VkBindBufferMemoryInfo *pBindInfos;
+    VkResult result;
 };

struct vkBindImageMemory_params
@@ -573,6 +585,7 @@ struct vkBindImageMemory_params
     VkImage DECLSPEC_ALIGN(8) image;
     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
+    VkResult result;
 };

struct vkBindImageMemory2_params
@@ -580,6 +593,7 @@ struct vkBindImageMemory2_params
     VkDevice device;
     uint32_t bindInfoCount;
     const VkBindImageMemoryInfo *pBindInfos;
+    VkResult result;
 };

struct vkBindImageMemory2KHR_params
@@ -587,6 +601,7 @@ struct vkBindImageMemory2KHR_params
     VkDevice device;
     uint32_t bindInfoCount;
     const VkBindImageMemoryInfo *pBindInfos;
+    VkResult result;
 };

struct vkBuildAccelerationStructuresKHR_params
@@ -596,6 +611,7 @@ struct vkBuildAccelerationStructuresKHR_params
     uint32_t infoCount;
     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos;
     const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos;
+    VkResult result;
 };

struct vkCmdBeginConditionalRenderingEXT_params
@@ -1660,18 +1676,21 @@ struct vkCmdSetPerformanceMarkerINTEL_params
 {
     VkCommandBuffer commandBuffer;
     const VkPerformanceMarkerInfoINTEL *pMarkerInfo;
+    VkResult result;
 };

struct vkCmdSetPerformanceOverrideINTEL_params
 {
     VkCommandBuffer commandBuffer;
     const VkPerformanceOverrideInfoINTEL *pOverrideInfo;
+    VkResult result;
 };

struct vkCmdSetPerformanceStreamMarkerINTEL_params
 {
     VkCommandBuffer commandBuffer;
     const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo;
+    VkResult result;
 };

struct vkCmdSetPrimitiveRestartEnable_params
@@ -2003,6 +2022,7 @@ struct vkCompileDeferredNV_params
     VkDevice device;
     VkPipeline DECLSPEC_ALIGN(8) pipeline;
     uint32_t shader;
+    VkResult result;
 };

struct vkCopyAccelerationStructureKHR_params
@@ -2010,6 +2030,7 @@ struct vkCopyAccelerationStructureKHR_params
     VkDevice device;
     VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
     const VkCopyAccelerationStructureInfoKHR *pInfo;
+    VkResult result;
 };

struct vkCopyAccelerationStructureToMemoryKHR_params
@@ -2017,6 +2038,7 @@ struct vkCopyAccelerationStructureToMemoryKHR_params
     VkDevice device;
     VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
     const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo;
+    VkResult result;
 };

struct vkCopyMemoryToAccelerationStructureKHR_params
@@ -2024,6 +2046,7 @@ struct vkCopyMemoryToAccelerationStructureKHR_params
     VkDevice device;
     VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
     const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo;
+    VkResult result;
 };

struct vkCreateAccelerationStructureKHR_params
@@ -2032,6 +2055,7 @@ struct vkCreateAccelerationStructureKHR_params
     const VkAccelerationStructureCreateInfoKHR *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkAccelerationStructureKHR *pAccelerationStructure;
+    VkResult result;
 };

struct vkCreateAccelerationStructureNV_params
@@ -2040,6 +2064,7 @@ struct vkCreateAccelerationStructureNV_params
     const VkAccelerationStructureCreateInfoNV *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkAccelerationStructureNV *pAccelerationStructure;
+    VkResult result;
 };

struct vkCreateBuffer_params
@@ -2048,6 +2073,7 @@ struct vkCreateBuffer_params
     const VkBufferCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkBuffer *pBuffer;
+    VkResult result;
 };

struct vkCreateBufferView_params
@@ -2056,6 +2082,7 @@ struct vkCreateBufferView_params
     const VkBufferViewCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkBufferView *pView;
+    VkResult result;
 };

struct vkCreateCommandPool_params
@@ -2065,6 +2092,7 @@ struct vkCreateCommandPool_params
     const VkAllocationCallbacks *pAllocator;
     VkCommandPool *pCommandPool;
     void *client_ptr;
+    VkResult result;
 };

struct vkCreateComputePipelines_params
@@ -2075,6 +2103,7 @@ struct vkCreateComputePipelines_params
     const VkComputePipelineCreateInfo *pCreateInfos;
     const VkAllocationCallbacks *pAllocator;
     VkPipeline *pPipelines;
+    VkResult result;
 };

struct vkCreateCuFunctionNVX_params
@@ -2083,6 +2112,7 @@ struct vkCreateCuFunctionNVX_params
     const VkCuFunctionCreateInfoNVX *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkCuFunctionNVX *pFunction;
+    VkResult result;
 };

struct vkCreateCuModuleNVX_params
@@ -2091,6 +2121,7 @@ struct vkCreateCuModuleNVX_params
     const VkCuModuleCreateInfoNVX *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkCuModuleNVX *pModule;
+    VkResult result;
 };

struct vkCreateDebugReportCallbackEXT_params
@@ -2099,6 +2130,7 @@ struct vkCreateDebugReportCallbackEXT_params
     const VkDebugReportCallbackCreateInfoEXT *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkDebugReportCallbackEXT *pCallback;
+    VkResult result;
 };

struct vkCreateDebugUtilsMessengerEXT_params
@@ -2107,6 +2139,7 @@ struct vkCreateDebugUtilsMessengerEXT_params
     const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkDebugUtilsMessengerEXT *pMessenger;
+    VkResult result;
 };

struct vkCreateDeferredOperationKHR_params
@@ -2114,6 +2147,7 @@ struct vkCreateDeferredOperationKHR_params
     VkDevice device;
     const VkAllocationCallbacks *pAllocator;
     VkDeferredOperationKHR *pDeferredOperation;
+    VkResult result;
 };

struct vkCreateDescriptorPool_params
@@ -2122,6 +2156,7 @@ struct vkCreateDescriptorPool_params
     const VkDescriptorPoolCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkDescriptorPool *pDescriptorPool;
+    VkResult result;
 };

struct vkCreateDescriptorSetLayout_params
@@ -2130,6 +2165,7 @@ struct vkCreateDescriptorSetLayout_params
     const VkDescriptorSetLayoutCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkDescriptorSetLayout *pSetLayout;
+    VkResult result;
 };

struct vkCreateDescriptorUpdateTemplate_params
@@ -2138,6 +2174,7 @@ struct vkCreateDescriptorUpdateTemplate_params
     const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate;
+    VkResult result;
 };

struct vkCreateDescriptorUpdateTemplateKHR_params
@@ -2146,6 +2183,7 @@ struct vkCreateDescriptorUpdateTemplateKHR_params
     const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate;
+    VkResult result;
 };

struct vkCreateDevice_params
@@ -2155,6 +2193,7 @@ struct vkCreateDevice_params
     const VkAllocationCallbacks *pAllocator;
     VkDevice *pDevice;
     void *client_ptr;
+    VkResult result;
 };

struct vkCreateEvent_params
@@ -2163,6 +2202,7 @@ struct vkCreateEvent_params
     const VkEventCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkEvent *pEvent;
+    VkResult result;
 };

struct vkCreateFence_params
@@ -2171,6 +2211,7 @@ struct vkCreateFence_params
     const VkFenceCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkFence *pFence;
+    VkResult result;
 };

struct vkCreateFramebuffer_params
@@ -2179,6 +2220,7 @@ struct vkCreateFramebuffer_params
     const VkFramebufferCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkFramebuffer *pFramebuffer;
+    VkResult result;
 };

struct vkCreateGraphicsPipelines_params
@@ -2189,6 +2231,7 @@ struct vkCreateGraphicsPipelines_params
     const VkGraphicsPipelineCreateInfo *pCreateInfos;
     const VkAllocationCallbacks *pAllocator;
     VkPipeline *pPipelines;
+    VkResult result;
 };

struct vkCreateImage_params
@@ -2197,6 +2240,7 @@ struct vkCreateImage_params
     const VkImageCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkImage *pImage;
+    VkResult result;
 };

struct vkCreateImageView_params
@@ -2205,6 +2249,7 @@ struct vkCreateImageView_params
     const VkImageViewCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkImageView *pView;
+    VkResult result;
 };

struct vkCreateIndirectCommandsLayoutNV_params
@@ -2213,6 +2258,7 @@ struct vkCreateIndirectCommandsLayoutNV_params
     const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkIndirectCommandsLayoutNV *pIndirectCommandsLayout;
+    VkResult result;
 };

struct vkCreateInstance_params
@@ -2221,6 +2267,7 @@ struct vkCreateInstance_params
     const VkAllocationCallbacks *pAllocator;
     VkInstance *pInstance;
     void *client_ptr;
+    VkResult result;
 };

struct vkCreatePipelineCache_params
@@ -2229,6 +2276,7 @@ struct vkCreatePipelineCache_params
     const VkPipelineCacheCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkPipelineCache *pPipelineCache;
+    VkResult result;
 };

struct vkCreatePipelineLayout_params
@@ -2237,6 +2285,7 @@ struct vkCreatePipelineLayout_params
     const VkPipelineLayoutCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkPipelineLayout *pPipelineLayout;
+    VkResult result;
 };

struct vkCreatePrivateDataSlot_params
@@ -2245,6 +2294,7 @@ struct vkCreatePrivateDataSlot_params
     const VkPrivateDataSlotCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkPrivateDataSlot *pPrivateDataSlot;
+    VkResult result;
 };

struct vkCreatePrivateDataSlotEXT_params
@@ -2253,6 +2303,7 @@ struct vkCreatePrivateDataSlotEXT_params
     const VkPrivateDataSlotCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkPrivateDataSlot *pPrivateDataSlot;
+    VkResult result;
 };

struct vkCreateQueryPool_params
@@ -2261,6 +2312,7 @@ struct vkCreateQueryPool_params
     const VkQueryPoolCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkQueryPool *pQueryPool;
+    VkResult result;
 };

struct vkCreateRayTracingPipelinesKHR_params
@@ -2272,6 +2324,7 @@ struct vkCreateRayTracingPipelinesKHR_params
     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos;
     const VkAllocationCallbacks *pAllocator;
     VkPipeline *pPipelines;
+    VkResult result;
 };

struct vkCreateRayTracingPipelinesNV_params
@@ -2282,6 +2335,7 @@ struct vkCreateRayTracingPipelinesNV_params
     const VkRayTracingPipelineCreateInfoNV *pCreateInfos;
     const VkAllocationCallbacks *pAllocator;
     VkPipeline *pPipelines;
+    VkResult result;
 };

struct vkCreateRenderPass_params
@@ -2290,6 +2344,7 @@ struct vkCreateRenderPass_params
     const VkRenderPassCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkRenderPass *pRenderPass;
+    VkResult result;
 };

struct vkCreateRenderPass2_params
@@ -2298,6 +2353,7 @@ struct vkCreateRenderPass2_params
     const VkRenderPassCreateInfo2 *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkRenderPass *pRenderPass;
+    VkResult result;
 };

struct vkCreateRenderPass2KHR_params
@@ -2306,6 +2362,7 @@ struct vkCreateRenderPass2KHR_params
     const VkRenderPassCreateInfo2 *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkRenderPass *pRenderPass;
+    VkResult result;
 };

struct vkCreateSampler_params
@@ -2314,6 +2371,7 @@ struct vkCreateSampler_params
     const VkSamplerCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkSampler *pSampler;
+    VkResult result;
 };

struct vkCreateSamplerYcbcrConversion_params
@@ -2322,6 +2380,7 @@ struct vkCreateSamplerYcbcrConversion_params
     const VkSamplerYcbcrConversionCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkSamplerYcbcrConversion *pYcbcrConversion;
+    VkResult result;
 };

struct vkCreateSamplerYcbcrConversionKHR_params
@@ -2330,6 +2389,7 @@ struct vkCreateSamplerYcbcrConversionKHR_params
     const VkSamplerYcbcrConversionCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkSamplerYcbcrConversion *pYcbcrConversion;
+    VkResult result;
 };

struct vkCreateSemaphore_params
@@ -2338,6 +2398,7 @@ struct vkCreateSemaphore_params
     const VkSemaphoreCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkSemaphore *pSemaphore;
+    VkResult result;
 };

struct vkCreateShaderModule_params
@@ -2346,6 +2407,7 @@ struct vkCreateShaderModule_params
     const VkShaderModuleCreateInfo *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkShaderModule *pShaderModule;
+    VkResult result;
 };

struct vkCreateSwapchainKHR_params
@@ -2354,6 +2416,7 @@ struct vkCreateSwapchainKHR_params
     const VkSwapchainCreateInfoKHR *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkSwapchainKHR *pSwapchain;
+    VkResult result;
 };

struct vkCreateValidationCacheEXT_params
@@ -2362,6 +2425,7 @@ struct vkCreateValidationCacheEXT_params
     const VkValidationCacheCreateInfoEXT *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkValidationCacheEXT *pValidationCache;
+    VkResult result;
 };

struct vkCreateWin32SurfaceKHR_params
@@ -2370,18 +2434,21 @@ struct vkCreateWin32SurfaceKHR_params
     const VkWin32SurfaceCreateInfoKHR *pCreateInfo;
     const VkAllocationCallbacks *pAllocator;
     VkSurfaceKHR *pSurface;
+    VkResult result;
 };

struct vkDebugMarkerSetObjectNameEXT_params
 {
     VkDevice device;
     const VkDebugMarkerObjectNameInfoEXT *pNameInfo;
+    VkResult result;
 };

struct vkDebugMarkerSetObjectTagEXT_params
 {
     VkDevice device;
     const VkDebugMarkerObjectTagInfoEXT *pTagInfo;
+    VkResult result;
 };

struct vkDebugReportMessageEXT_params
@@ -2400,6 +2467,7 @@ struct vkDeferredOperationJoinKHR_params
 {
     VkDevice device;
     VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
+    VkResult result;
 };

struct vkDestroyAccelerationStructureKHR_params
@@ -2662,11 +2730,13 @@ struct vkDestroyValidationCacheEXT_params
 struct vkDeviceWaitIdle_params
 {
     VkDevice device;
+    VkResult result;
 };

struct vkEndCommandBuffer_params
 {
     VkCommandBuffer commandBuffer;
+    VkResult result;
 };

struct vkEnumerateDeviceExtensionProperties_params
@@ -2675,6 +2745,7 @@ struct vkEnumerateDeviceExtensionProperties_params
     const char *pLayerName;
     uint32_t *pPropertyCount;
     VkExtensionProperties *pProperties;
+    VkResult result;
 };

struct vkEnumerateDeviceLayerProperties_params
@@ -2682,6 +2753,7 @@ struct vkEnumerateDeviceLayerProperties_params
     VkPhysicalDevice physicalDevice;
     uint32_t *pPropertyCount;
     VkLayerProperties *pProperties;
+    VkResult result;
 };

struct vkEnumerateInstanceExtensionProperties_params
@@ -2689,11 +2761,13 @@ struct vkEnumerateInstanceExtensionProperties_params
     const char *pLayerName;
     uint32_t *pPropertyCount;
     VkExtensionProperties *pProperties;
+    VkResult result;
 };

struct vkEnumerateInstanceVersion_params
 {
     uint32_t *pApiVersion;
+    VkResult result;
 };

struct vkEnumeratePhysicalDeviceGroups_params
@@ -2701,6 +2775,7 @@ struct vkEnumeratePhysicalDeviceGroups_params
     VkInstance instance;
     uint32_t *pPhysicalDeviceGroupCount;
     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties;
+    VkResult result;
 };

struct vkEnumeratePhysicalDeviceGroupsKHR_params
@@ -2708,6 +2783,7 @@ struct vkEnumeratePhysicalDeviceGroupsKHR_params
     VkInstance instance;
     uint32_t *pPhysicalDeviceGroupCount;
     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties;
+    VkResult result;
 };

struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params
@@ -2717,6 +2793,7 @@ struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params
     uint32_t *pCounterCount;
     VkPerformanceCounterKHR *pCounters;
     VkPerformanceCounterDescriptionKHR *pCounterDescriptions;
+    VkResult result;
 };

struct vkEnumeratePhysicalDevices_params
@@ -2724,6 +2801,7 @@ struct vkEnumeratePhysicalDevices_params
     VkInstance instance;
     uint32_t *pPhysicalDeviceCount;
     VkPhysicalDevice *pPhysicalDevices;
+    VkResult result;
 };

struct vkFlushMappedMemoryRanges_params
@@ -2731,6 +2809,7 @@ struct vkFlushMappedMemoryRanges_params
     VkDevice device;
     uint32_t memoryRangeCount;
     const VkMappedMemoryRange *pMemoryRanges;
+    VkResult result;
 };

struct vkFreeCommandBuffers_params
@@ -2747,6 +2826,7 @@ struct vkFreeDescriptorSets_params
     VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
     uint32_t descriptorSetCount;
     const VkDescriptorSet *pDescriptorSets;
+    VkResult result;
 };

struct vkFreeMemory_params
@@ -2778,6 +2858,7 @@ struct vkGetAccelerationStructureHandleNV_params
     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
     size_t dataSize;
     void *pData;
+    VkResult result;
 };

struct vkGetAccelerationStructureMemoryRequirementsNV_params
@@ -2850,18 +2931,21 @@ struct vkGetCalibratedTimestampsEXT_params
     const VkCalibratedTimestampInfoEXT *pTimestampInfos;
     uint64_t *pTimestamps;
     uint64_t *pMaxDeviation;
+    VkResult result;
 };

struct vkGetDeferredOperationMaxConcurrencyKHR_params
 {
     VkDevice device;
     VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
+    uint32_t result;
 };

struct vkGetDeferredOperationResultKHR_params
 {
     VkDevice device;
     VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
+    VkResult result;
 };

struct vkGetDescriptorSetHostMappingVALVE_params
@@ -2935,6 +3019,7 @@ struct vkGetDeviceGroupPresentCapabilitiesKHR_params
 {
     VkDevice device;
     VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities;
+    VkResult result;
 };

struct vkGetDeviceGroupSurfacePresentModesKHR_params
@@ -2942,6 +3027,7 @@ struct vkGetDeviceGroupSurfacePresentModesKHR_params
     VkDevice device;
     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
     VkDeviceGroupPresentModeFlagsKHR *pModes;
+    VkResult result;
 };

struct vkGetDeviceImageMemoryRequirements_params
@@ -3015,6 +3101,7 @@ struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params
     VkDevice device;
     VkRenderPass DECLSPEC_ALIGN(8) renderpass;
     VkExtent2D *pMaxWorkgroupSize;
+    VkResult result;
 };

struct vkGetDynamicRenderingTilePropertiesQCOM_params
@@ -3022,18 +3109,21 @@ struct vkGetDynamicRenderingTilePropertiesQCOM_params
     VkDevice device;
     const VkRenderingInfo *pRenderingInfo;
     VkTilePropertiesQCOM *pProperties;
+    VkResult result;
 };

struct vkGetEventStatus_params
 {
     VkDevice device;
     VkEvent DECLSPEC_ALIGN(8) event;
+    VkResult result;
 };

struct vkGetFenceStatus_params
 {
     VkDevice device;
     VkFence DECLSPEC_ALIGN(8) fence;
+    VkResult result;
 };

struct vkGetFramebufferTilePropertiesQCOM_params
@@ -3042,6 +3132,7 @@ struct vkGetFramebufferTilePropertiesQCOM_params
     VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
     uint32_t *pPropertiesCount;
     VkTilePropertiesQCOM *pProperties;
+    VkResult result;
 };

struct vkGetGeneratedCommandsMemoryRequirementsNV_params
@@ -3117,12 +3208,14 @@ struct vkGetImageViewAddressNVX_params
     VkDevice device;
     VkImageView DECLSPEC_ALIGN(8) imageView;
     VkImageViewAddressPropertiesNVX *pProperties;
+    VkResult result;
 };

struct vkGetImageViewHandleNVX_params
 {
     VkDevice device;
     const VkImageViewHandleInfoNVX *pInfo;
+    uint32_t result;
 };

struct vkGetMemoryHostPointerPropertiesEXT_params
@@ -3131,6 +3224,7 @@ struct vkGetMemoryHostPointerPropertiesEXT_params
     VkExternalMemoryHandleTypeFlagBits handleType;
     const void *pHostPointer;
     VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties;
+    VkResult result;
 };

struct vkGetPerformanceParameterINTEL_params
@@ -3138,6 +3232,7 @@ struct vkGetPerformanceParameterINTEL_params
     VkDevice device;
     VkPerformanceParameterTypeINTEL parameter;
     VkPerformanceValueINTEL *pValue;
+    VkResult result;
 };

struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params
@@ -3145,6 +3240,7 @@ struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params
     VkPhysicalDevice physicalDevice;
     uint32_t *pTimeDomainCount;
     VkTimeDomainEXT *pTimeDomains;
+    VkResult result;
 };

struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params
@@ -3152,6 +3248,7 @@ struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params
     VkPhysicalDevice physicalDevice;
     uint32_t *pPropertyCount;
     VkCooperativeMatrixPropertiesNV *pProperties;
+    VkResult result;
 };

struct vkGetPhysicalDeviceExternalBufferProperties_params
@@ -3240,6 +3337,7 @@ struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params
     VkPhysicalDevice physicalDevice;
     uint32_t *pFragmentShadingRateCount;
     VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates;
+    VkResult result;
 };

struct vkGetPhysicalDeviceImageFormatProperties_params
@@ -3251,6 +3349,7 @@ struct vkGetPhysicalDeviceImageFormatProperties_params
     VkImageUsageFlags usage;
     VkImageCreateFlags flags;
     VkImageFormatProperties *pImageFormatProperties;
+    VkResult result;
 };

struct vkGetPhysicalDeviceImageFormatProperties2_params
@@ -3258,6 +3357,7 @@ struct vkGetPhysicalDeviceImageFormatProperties2_params
     VkPhysicalDevice physicalDevice;
     const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo;
     VkImageFormatProperties2 *pImageFormatProperties;
+    VkResult result;
 };

struct vkGetPhysicalDeviceImageFormatProperties2KHR_params
@@ -3265,6 +3365,7 @@ struct vkGetPhysicalDeviceImageFormatProperties2KHR_params
     VkPhysicalDevice physicalDevice;
     const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo;
     VkImageFormatProperties2 *pImageFormatProperties;
+    VkResult result;
 };

struct vkGetPhysicalDeviceMemoryProperties_params
@@ -3298,6 +3399,7 @@ struct vkGetPhysicalDevicePresentRectanglesKHR_params
     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
     uint32_t *pRectCount;
     VkRect2D *pRects;
+    VkResult result;
 };

struct vkGetPhysicalDeviceProperties_params
@@ -3379,6 +3481,7 @@ struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params
     VkPhysicalDevice physicalDevice;
     uint32_t *pCombinationCount;
     VkFramebufferMixedSamplesCombinationNV *pCombinations;
+    VkResult result;
 };

struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params
@@ -3386,6 +3489,7 @@ struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params
     VkPhysicalDevice physicalDevice;
     const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo;
     VkSurfaceCapabilities2KHR *pSurfaceCapabilities;
+    VkResult result;
 };

struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params
@@ -3393,6 +3497,7 @@ struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params
     VkPhysicalDevice physicalDevice;
     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
     VkSurfaceCapabilitiesKHR *pSurfaceCapabilities;
+    VkResult result;
 };

struct vkGetPhysicalDeviceSurfaceFormats2KHR_params
@@ -3401,6 +3506,7 @@ struct vkGetPhysicalDeviceSurfaceFormats2KHR_params
     const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo;
     uint32_t *pSurfaceFormatCount;
     VkSurfaceFormat2KHR *pSurfaceFormats;
+    VkResult result;
 };

struct vkGetPhysicalDeviceSurfaceFormatsKHR_params
@@ -3409,6 +3515,7 @@ struct vkGetPhysicalDeviceSurfaceFormatsKHR_params
     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
     uint32_t *pSurfaceFormatCount;
     VkSurfaceFormatKHR *pSurfaceFormats;
+    VkResult result;
 };

struct vkGetPhysicalDeviceSurfacePresentModesKHR_params
@@ -3417,6 +3524,7 @@ struct vkGetPhysicalDeviceSurfacePresentModesKHR_params
     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
     uint32_t *pPresentModeCount;
     VkPresentModeKHR *pPresentModes;
+    VkResult result;
 };

struct vkGetPhysicalDeviceSurfaceSupportKHR_params
@@ -3425,6 +3533,7 @@ struct vkGetPhysicalDeviceSurfaceSupportKHR_params
     uint32_t queueFamilyIndex;
     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
     VkBool32 *pSupported;
+    VkResult result;
 };

struct vkGetPhysicalDeviceToolProperties_params
@@ -3432,6 +3541,7 @@ struct vkGetPhysicalDeviceToolProperties_params
     VkPhysicalDevice physicalDevice;
     uint32_t *pToolCount;
     VkPhysicalDeviceToolProperties *pToolProperties;
+    VkResult result;
 };

struct vkGetPhysicalDeviceToolPropertiesEXT_params
@@ -3439,12 +3549,14 @@ struct vkGetPhysicalDeviceToolPropertiesEXT_params
     VkPhysicalDevice physicalDevice;
     uint32_t *pToolCount;
     VkPhysicalDeviceToolProperties *pToolProperties;
+    VkResult result;
 };

struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params
 {
     VkPhysicalDevice physicalDevice;
     uint32_t queueFamilyIndex;
+    VkBool32 result;
 };

struct vkGetPipelineCacheData_params
@@ -3453,6 +3565,7 @@ struct vkGetPipelineCacheData_params
     VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
     size_t *pDataSize;
     void *pData;
+    VkResult result;
 };

struct vkGetPipelineExecutableInternalRepresentationsKHR_params
@@ -3461,6 +3574,7 @@ struct vkGetPipelineExecutableInternalRepresentationsKHR_params
     const VkPipelineExecutableInfoKHR *pExecutableInfo;
     uint32_t *pInternalRepresentationCount;
     VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations;
+    VkResult result;
 };

struct vkGetPipelineExecutablePropertiesKHR_params
@@ -3469,6 +3583,7 @@ struct vkGetPipelineExecutablePropertiesKHR_params
     const VkPipelineInfoKHR *pPipelineInfo;
     uint32_t *pExecutableCount;
     VkPipelineExecutablePropertiesKHR *pProperties;
+    VkResult result;
 };

struct vkGetPipelineExecutableStatisticsKHR_params
@@ -3477,6 +3592,7 @@ struct vkGetPipelineExecutableStatisticsKHR_params
     const VkPipelineExecutableInfoKHR *pExecutableInfo;
     uint32_t *pStatisticCount;
     VkPipelineExecutableStatisticKHR *pStatistics;
+    VkResult result;
 };

struct vkGetPipelinePropertiesEXT_params
@@ -3484,6 +3600,7 @@ struct vkGetPipelinePropertiesEXT_params
     VkDevice device;
     const VkPipelineInfoEXT *pPipelineInfo;
     VkBaseOutStructure *pPipelineProperties;
+    VkResult result;
 };

struct vkGetPrivateData_params
@@ -3514,6 +3631,7 @@ struct vkGetQueryPoolResults_params
     void *pData;
     VkDeviceSize DECLSPEC_ALIGN(8) stride;
     VkQueryResultFlags flags;
+    VkResult result;
 };

struct vkGetQueueCheckpointData2NV_params
@@ -3538,6 +3656,7 @@ struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params
     uint32_t groupCount;
     size_t dataSize;
     void *pData;
+    VkResult result;
 };

struct vkGetRayTracingShaderGroupHandlesKHR_params
@@ -3548,6 +3667,7 @@ struct vkGetRayTracingShaderGroupHandlesKHR_params
     uint32_t groupCount;
     size_t dataSize;
     void *pData;
+    VkResult result;
 };

struct vkGetRayTracingShaderGroupHandlesNV_params
@@ -3558,6 +3678,7 @@ struct vkGetRayTracingShaderGroupHandlesNV_params
     uint32_t groupCount;
     size_t dataSize;
     void *pData;
+    VkResult result;
 };

struct vkGetRayTracingShaderGroupStackSizeKHR_params
@@ -3566,6 +3687,7 @@ struct vkGetRayTracingShaderGroupStackSizeKHR_params
     VkPipeline DECLSPEC_ALIGN(8) pipeline;
     uint32_t group;
     VkShaderGroupShaderKHR groupShader;
+    VkDeviceSize result;
 };

struct vkGetRenderAreaGranularity_params
@@ -3580,6 +3702,7 @@ struct vkGetSemaphoreCounterValue_params
     VkDevice device;
     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
     uint64_t *pValue;
+    VkResult result;
 };

struct vkGetSemaphoreCounterValueKHR_params
@@ -3587,6 +3710,7 @@ struct vkGetSemaphoreCounterValueKHR_params
     VkDevice device;
     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
     uint64_t *pValue;
+    VkResult result;
 };

struct vkGetShaderInfoAMD_params
@@ -3597,6 +3721,7 @@ struct vkGetShaderInfoAMD_params
     VkShaderInfoTypeAMD infoType;
     size_t *pInfoSize;
     void *pInfo;
+    VkResult result;
 };

struct vkGetShaderModuleCreateInfoIdentifierEXT_params
@@ -3619,6 +3744,7 @@ struct vkGetSwapchainImagesKHR_params
     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
     uint32_t *pSwapchainImageCount;
     VkImage *pSwapchainImages;
+    VkResult result;
 };

struct vkGetValidationCacheDataEXT_params
@@ -3627,12 +3753,14 @@ struct vkGetValidationCacheDataEXT_params
     VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
     size_t *pDataSize;
     void *pData;
+    VkResult result;
 };

struct vkInitializePerformanceApiINTEL_params
 {
     VkDevice device;
     const VkInitializePerformanceApiInfoINTEL *pInitializeInfo;
+    VkResult result;
 };

struct vkInvalidateMappedMemoryRanges_params
@@ -3640,6 +3768,7 @@ struct vkInvalidateMappedMemoryRanges_params
     VkDevice device;
     uint32_t memoryRangeCount;
     const VkMappedMemoryRange *pMemoryRanges;
+    VkResult result;
 };

struct vkMapMemory_params
@@ -3650,6 +3779,7 @@ struct vkMapMemory_params
     VkDeviceSize DECLSPEC_ALIGN(8) size;
     VkMemoryMapFlags flags;
     void **ppData;
+    VkResult result;
 };

struct vkMergePipelineCaches_params
@@ -3658,6 +3788,7 @@ struct vkMergePipelineCaches_params
     VkPipelineCache DECLSPEC_ALIGN(8) dstCache;
     uint32_t srcCacheCount;
     const VkPipelineCache *pSrcCaches;
+    VkResult result;
 };

struct vkMergeValidationCachesEXT_params
@@ -3666,6 +3797,7 @@ struct vkMergeValidationCachesEXT_params
     VkValidationCacheEXT DECLSPEC_ALIGN(8) dstCache;
     uint32_t srcCacheCount;
     const VkValidationCacheEXT *pSrcCaches;
+    VkResult result;
 };

struct vkQueueBeginDebugUtilsLabelEXT_params
@@ -3680,6 +3812,7 @@ struct vkQueueBindSparse_params
     uint32_t bindInfoCount;
     const VkBindSparseInfo *pBindInfo;
     VkFence DECLSPEC_ALIGN(8) fence;
+    VkResult result;
 };

struct vkQueueEndDebugUtilsLabelEXT_params
@@ -3697,12 +3830,14 @@ struct vkQueuePresentKHR_params
 {
     VkQueue queue;
     const VkPresentInfoKHR *pPresentInfo;
+    VkResult result;
 };

struct vkQueueSetPerformanceConfigurationINTEL_params
 {
     VkQueue queue;
     VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
+    VkResult result;
 };

struct vkQueueSubmit_params
@@ -3711,6 +3846,7 @@ struct vkQueueSubmit_params
     uint32_t submitCount;
     const VkSubmitInfo *pSubmits;
     VkFence DECLSPEC_ALIGN(8) fence;
+    VkResult result;
 };

struct vkQueueSubmit2_params
@@ -3719,6 +3855,7 @@ struct vkQueueSubmit2_params
     uint32_t submitCount;
     const VkSubmitInfo2 *pSubmits;
     VkFence DECLSPEC_ALIGN(8) fence;
+    VkResult result;
 };

struct vkQueueSubmit2KHR_params
@@ -3727,17 +3864,20 @@ struct vkQueueSubmit2KHR_params
     uint32_t submitCount;
     const VkSubmitInfo2 *pSubmits;
     VkFence DECLSPEC_ALIGN(8) fence;
+    VkResult result;
 };

struct vkQueueWaitIdle_params
 {
     VkQueue queue;
+    VkResult result;
 };

struct vkReleasePerformanceConfigurationINTEL_params
 {
     VkDevice device;
     VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
+    VkResult result;
 };

struct vkReleaseProfilingLockKHR_params
@@ -3749,6 +3889,7 @@ struct vkResetCommandBuffer_params
 {
     VkCommandBuffer commandBuffer;
     VkCommandBufferResetFlags flags;
+    VkResult result;
 };

struct vkResetCommandPool_params
@@ -3756,6 +3897,7 @@ struct vkResetCommandPool_params
     VkDevice device;
     VkCommandPool DECLSPEC_ALIGN(8) commandPool;
     VkCommandPoolResetFlags flags;
+    VkResult result;
 };

struct vkResetDescriptorPool_params
@@ -3763,12 +3905,14 @@ struct vkResetDescriptorPool_params
     VkDevice device;
     VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
     VkDescriptorPoolResetFlags flags;
+    VkResult result;
 };

struct vkResetEvent_params
 {
     VkDevice device;
     VkEvent DECLSPEC_ALIGN(8) event;
+    VkResult result;
 };

struct vkResetFences_params
@@ -3776,6 +3920,7 @@ struct vkResetFences_params
     VkDevice device;
     uint32_t fenceCount;
     const VkFence *pFences;
+    VkResult result;
 };

struct vkResetQueryPool_params
@@ -3798,12 +3943,14 @@ struct vkSetDebugUtilsObjectNameEXT_params
 {
     VkDevice device;
     const VkDebugUtilsObjectNameInfoEXT *pNameInfo;
+    VkResult result;
 };

struct vkSetDebugUtilsObjectTagEXT_params
 {
     VkDevice device;
     const VkDebugUtilsObjectTagInfoEXT *pTagInfo;
+    VkResult result;
 };

struct vkSetDeviceMemoryPriorityEXT_params
@@ -3817,6 +3964,7 @@ struct vkSetEvent_params
 {
     VkDevice device;
     VkEvent DECLSPEC_ALIGN(8) event;
+    VkResult result;
 };

struct vkSetPrivateData_params
@@ -3826,6 +3974,7 @@ struct vkSetPrivateData_params
     uint64_t DECLSPEC_ALIGN(8) objectHandle;
     VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
     uint64_t DECLSPEC_ALIGN(8) data;
+    VkResult result;
 };

struct vkSetPrivateDataEXT_params
@@ -3835,18 +3984,21 @@ struct vkSetPrivateDataEXT_params
     uint64_t DECLSPEC_ALIGN(8) objectHandle;
     VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
     uint64_t DECLSPEC_ALIGN(8) data;
+    VkResult result;
 };

struct vkSignalSemaphore_params
 {
     VkDevice device;
     const VkSemaphoreSignalInfo *pSignalInfo;
+    VkResult result;
 };

struct vkSignalSemaphoreKHR_params
 {
     VkDevice device;
     const VkSemaphoreSignalInfo *pSignalInfo;
+    VkResult result;
 };

struct vkSubmitDebugUtilsMessageEXT_params
@@ -3914,6 +4066,7 @@ struct vkWaitForFences_params
     const VkFence *pFences;
     VkBool32 waitAll;
     uint64_t DECLSPEC_ALIGN(8) timeout;
+    VkResult result;
 };

struct vkWaitForPresentKHR_params
@@ -3922,6 +4075,7 @@ struct vkWaitForPresentKHR_params
     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
     uint64_t DECLSPEC_ALIGN(8) presentId;
     uint64_t DECLSPEC_ALIGN(8) timeout;
+    VkResult result;
 };

struct vkWaitSemaphores_params
@@ -3929,6 +4083,7 @@ struct vkWaitSemaphores_params
     VkDevice device;
     const VkSemaphoreWaitInfo *pWaitInfo;
     uint64_t DECLSPEC_ALIGN(8) timeout;
+    VkResult result;
 };

struct vkWaitSemaphoresKHR_params
@@ -3936,6 +4091,7 @@ struct vkWaitSemaphoresKHR_params
     VkDevice device;
     const VkSemaphoreWaitInfo *pWaitInfo;
     uint64_t DECLSPEC_ALIGN(8) timeout;
+    VkResult result;
 };

struct vkWriteAccelerationStructuresPropertiesKHR_params
@@ -3947,6 +4103,7 @@ struct vkWriteAccelerationStructuresPropertiesKHR_params
     size_t dataSize;
     void *pData;
     size_t stride;
+    VkResult result;
 };

#endif /* __WINE_VULKAN_LOADER_THUNKS_H */
diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index fd61130cab1..c0377ca9f17 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -764,24 +764,18 @@ class VkFunction(object):
         body += "    ";

# Call the Unix function.
-        if self.type != "void" and not self.returns_longlong():
-            body += "return "
         if self.needs_direct_call():
             body += "p_vk_direct_unix_call(unix_handle, unix_{0}, &params);\n".format(self.name)
         else:
             body += "vk_unix_call(unix_{0}, &params);\n".format(self.name)
-        if self.returns_longlong():
+        if self.type != "void":
             body += "    return params.result;\n"
         return body

def body(self, conv, unwrap=True, params_prefix=""):
         body = ""
-        result_prefix = ""

-        # Declare a variable to hold the result for non-void functions.
-        if self.returns_longlong():
-            result_prefix = "params->"
-        elif self.type != "void":
+        if params_prefix == "" and self.type != "void":
             body += "    {0} result;\n".format(self.type)

# Declare any tmp parameters for conversion.
@@ -820,7 +814,7 @@ class VkFunction(object):
         if self.type == "void":
             body += "    {0}{1}({2});\n".format(func_prefix, self.name, params)
         else:
-            body += "    {0}result = {1}{2}({3});\n".format(result_prefix, func_prefix, self.name, params)
+            body += "    {0}result = {1}{2}({3});\n".format(params_prefix, func_prefix, self.name, params)

# Call any host_to_win conversion calls.
         if conv and unwrap:
@@ -836,10 +830,10 @@ class VkFunction(object):
                 body += p.free(prefix=params_prefix)

# Finally return the result.
-        if self.type != "void" and not self.returns_longlong():
-            body += "    return result;\n"
-        else:
+        if params_prefix != "":
             body += "    return STATUS_SUCCESS;\n"
+        elif self.type != "void":
+            body += "    return result;\n"

return body

@@ -3060,7 +3054,7 @@ class VkGenerator(object):
                 f.write("    {0};\n".format(p.definition(is_member=True)))
             if vk_func.extra_param:
                 f.write("    void *{0};\n".format(vk_func.extra_param))
-            if vk_func.returns_longlong():
+            if vk_func.type != "void":
                 f.write("    {0} result;\n".format(vk_func.type))
             f.write("};\n\n");

diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index b7c2d5d2625..8d958ebee8f 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -5283,11 +5283,10 @@ void free_VkInstanceCreateInfo_struct_chain(VkInstanceCreateInfo *s)
 static NTSTATUS thunk64_vkAcquireNextImage2KHR(void *args)
 {
     struct vkAcquireNextImage2KHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pImageIndex);

-    result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pImageIndex);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pImageIndex);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5295,13 +5294,12 @@ static NTSTATUS thunk64_vkAcquireNextImage2KHR(void *args)
 static NTSTATUS thunk32_vkAcquireNextImage2KHR(void *args)
 {
     struct vkAcquireNextImage2KHR_params *params = args;
-    VkResult result;
     VkAcquireNextImageInfoKHR_host pAcquireInfo_host;
     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pImageIndex);

convert_VkAcquireNextImageInfoKHR_win_to_host(params->pAcquireInfo, &pAcquireInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, &pAcquireInfo_host, params->pImageIndex);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, &pAcquireInfo_host, params->pImageIndex);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5311,11 +5309,10 @@ static NTSTATUS thunk32_vkAcquireNextImage2KHR(void *args)
 static NTSTATUS thunk64_vkAcquireNextImageKHR(void *args)
 {
     struct vkAcquireNextImageKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->timeout), wine_dbgstr_longlong(params->semaphore), wine_dbgstr_longlong(params->fence), params->pImageIndex);

-    result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImageKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->timeout, params->semaphore, params->fence, params->pImageIndex);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImageKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->timeout, params->semaphore, params->fence, params->pImageIndex);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5323,11 +5320,10 @@ static NTSTATUS thunk64_vkAcquireNextImageKHR(void *args)
 static NTSTATUS thunk32_vkAcquireNextImageKHR(void *args)
 {
     struct vkAcquireNextImageKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->timeout), wine_dbgstr_longlong(params->semaphore), wine_dbgstr_longlong(params->fence), params->pImageIndex);

-    result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImageKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->timeout, params->semaphore, params->fence, params->pImageIndex);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImageKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->timeout, params->semaphore, params->fence, params->pImageIndex);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5337,11 +5333,10 @@ static NTSTATUS thunk32_vkAcquireNextImageKHR(void *args)
 static NTSTATUS thunk64_vkAcquirePerformanceConfigurationINTEL(void *args)
 {
     struct vkAcquirePerformanceConfigurationINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pConfiguration);

-    result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pConfiguration);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pConfiguration);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5349,11 +5344,10 @@ static NTSTATUS thunk64_vkAcquirePerformanceConfigurationINTEL(void *args)
 static NTSTATUS thunk32_vkAcquirePerformanceConfigurationINTEL(void *args)
 {
     struct vkAcquirePerformanceConfigurationINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pConfiguration);

-    result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pConfiguration);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pConfiguration);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5363,11 +5357,10 @@ static NTSTATUS thunk32_vkAcquirePerformanceConfigurationINTEL(void *args)
 static NTSTATUS thunk64_vkAcquireProfilingLockKHR(void *args)
 {
     struct vkAcquireProfilingLockKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->device, params->pInfo);

-    result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, params->pInfo);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, params->pInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5375,13 +5368,12 @@ static NTSTATUS thunk64_vkAcquireProfilingLockKHR(void *args)
 static NTSTATUS thunk32_vkAcquireProfilingLockKHR(void *args)
 {
     struct vkAcquireProfilingLockKHR_params *params = args;
-    VkResult result;
     VkAcquireProfilingLockInfoKHR_host pInfo_host;
     TRACE("%p, %p\n", params->device, params->pInfo);

convert_VkAcquireProfilingLockInfoKHR_win_to_host(params->pInfo, &pInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5391,11 +5383,10 @@ static NTSTATUS thunk32_vkAcquireProfilingLockKHR(void *args)
 static NTSTATUS thunk64_vkAllocateCommandBuffers(void *args)
 {
     struct vkAllocateCommandBuffers_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pCommandBuffers);

-    result = wine_vkAllocateCommandBuffers(params->device, params->pAllocateInfo, params->pCommandBuffers);
-    return result;
+    params->result = wine_vkAllocateCommandBuffers(params->device, params->pAllocateInfo, params->pCommandBuffers);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5403,11 +5394,10 @@ static NTSTATUS thunk64_vkAllocateCommandBuffers(void *args)
 static NTSTATUS thunk32_vkAllocateCommandBuffers(void *args)
 {
     struct vkAllocateCommandBuffers_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pCommandBuffers);

-    result = wine_vkAllocateCommandBuffers(params->device, params->pAllocateInfo, params->pCommandBuffers);
-    return result;
+    params->result = wine_vkAllocateCommandBuffers(params->device, params->pAllocateInfo, params->pCommandBuffers);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5417,11 +5407,10 @@ static NTSTATUS thunk32_vkAllocateCommandBuffers(void *args)
 static NTSTATUS thunk64_vkAllocateDescriptorSets(void *args)
 {
     struct vkAllocateDescriptorSets_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pDescriptorSets);

-    result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, params->pAllocateInfo, params->pDescriptorSets);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, params->pAllocateInfo, params->pDescriptorSets);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5429,13 +5418,12 @@ static NTSTATUS thunk64_vkAllocateDescriptorSets(void *args)
 static NTSTATUS thunk32_vkAllocateDescriptorSets(void *args)
 {
     struct vkAllocateDescriptorSets_params *params = args;
-    VkResult result;
     VkDescriptorSetAllocateInfo_host pAllocateInfo_host;
     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pDescriptorSets);

convert_VkDescriptorSetAllocateInfo_win_to_host(params->pAllocateInfo, &pAllocateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, &pAllocateInfo_host, params->pDescriptorSets);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, &pAllocateInfo_host, params->pDescriptorSets);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5445,11 +5433,10 @@ static NTSTATUS thunk32_vkAllocateDescriptorSets(void *args)
 static NTSTATUS thunk64_vkAllocateMemory(void *args)
 {
     struct vkAllocateMemory_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);

-    result = wine_device_from_handle(params->device)->funcs.p_vkAllocateMemory(wine_device_from_handle(params->device)->device, params->pAllocateInfo, NULL, params->pMemory);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateMemory(wine_device_from_handle(params->device)->device, params->pAllocateInfo, NULL, params->pMemory);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5457,13 +5444,12 @@ static NTSTATUS thunk64_vkAllocateMemory(void *args)
 static NTSTATUS thunk32_vkAllocateMemory(void *args)
 {
     struct vkAllocateMemory_params *params = args;
-    VkResult result;
     VkMemoryAllocateInfo_host pAllocateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);

convert_VkMemoryAllocateInfo_win_to_host(params->pAllocateInfo, &pAllocateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkAllocateMemory(wine_device_from_handle(params->device)->device, &pAllocateInfo_host, NULL, params->pMemory);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateMemory(wine_device_from_handle(params->device)->device, &pAllocateInfo_host, NULL, params->pMemory);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5473,11 +5459,10 @@ static NTSTATUS thunk32_vkAllocateMemory(void *args)
 static NTSTATUS thunk64_vkBeginCommandBuffer(void *args)
 {
     struct vkBeginCommandBuffer_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->commandBuffer, params->pBeginInfo);

-    result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBeginInfo);
-    return result;
+    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBeginInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5485,14 +5470,13 @@ static NTSTATUS thunk64_vkBeginCommandBuffer(void *args)
 static NTSTATUS thunk32_vkBeginCommandBuffer(void *args)
 {
     struct vkBeginCommandBuffer_params *params = args;
-    VkResult result;
     VkCommandBufferBeginInfo_host pBeginInfo_host;
     TRACE("%p, %p\n", params->commandBuffer, params->pBeginInfo);

convert_VkCommandBufferBeginInfo_win_to_host(params->pBeginInfo, &pBeginInfo_host);
-    result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pBeginInfo_host);
+    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pBeginInfo_host);
     free_VkCommandBufferBeginInfo(&pBeginInfo_host);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5502,11 +5486,10 @@ static NTSTATUS thunk32_vkBeginCommandBuffer(void *args)
 static NTSTATUS thunk64_vkBindAccelerationStructureMemoryNV(void *args)
 {
     struct vkBindAccelerationStructureMemoryNV_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);

-    result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5514,14 +5497,13 @@ static NTSTATUS thunk64_vkBindAccelerationStructureMemoryNV(void *args)
 static NTSTATUS thunk32_vkBindAccelerationStructureMemoryNV(void *args)
 {
     struct vkBindAccelerationStructureMemoryNV_params *params = args;
-    VkResult result;
     VkBindAccelerationStructureMemoryInfoNV_host *pBindInfos_host;
     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);

pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win_to_host(params->pBindInfos, params->bindInfoCount);
-    result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
     free_VkBindAccelerationStructureMemoryInfoNV_array(pBindInfos_host, params->bindInfoCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5531,11 +5513,10 @@ static NTSTATUS thunk32_vkBindAccelerationStructureMemoryNV(void *args)
 static NTSTATUS thunk64_vkBindBufferMemory(void *args)
 {
     struct vkBindBufferMemory_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));

-    result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory(wine_device_from_handle(params->device)->device, params->buffer, params->memory, params->memoryOffset);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory(wine_device_from_handle(params->device)->device, params->buffer, params->memory, params->memoryOffset);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5543,11 +5524,10 @@ static NTSTATUS thunk64_vkBindBufferMemory(void *args)
 static NTSTATUS thunk32_vkBindBufferMemory(void *args)
 {
     struct vkBindBufferMemory_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));

-    result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory(wine_device_from_handle(params->device)->device, params->buffer, params->memory, params->memoryOffset);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory(wine_device_from_handle(params->device)->device, params->buffer, params->memory, params->memoryOffset);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5557,11 +5537,10 @@ static NTSTATUS thunk32_vkBindBufferMemory(void *args)
 static NTSTATUS thunk64_vkBindBufferMemory2(void *args)
 {
     struct vkBindBufferMemory2_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);

-    result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5569,14 +5548,13 @@ static NTSTATUS thunk64_vkBindBufferMemory2(void *args)
 static NTSTATUS thunk32_vkBindBufferMemory2(void *args)
 {
     struct vkBindBufferMemory2_params *params = args;
-    VkResult result;
     VkBindBufferMemoryInfo_host *pBindInfos_host;
     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);

pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win_to_host(params->pBindInfos, params->bindInfoCount);
-    result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
     free_VkBindBufferMemoryInfo_array(pBindInfos_host, params->bindInfoCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5586,11 +5564,10 @@ static NTSTATUS thunk32_vkBindBufferMemory2(void *args)
 static NTSTATUS thunk64_vkBindBufferMemory2KHR(void *args)
 {
     struct vkBindBufferMemory2KHR_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);

-    result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5598,14 +5575,13 @@ static NTSTATUS thunk64_vkBindBufferMemory2KHR(void *args)
 static NTSTATUS thunk32_vkBindBufferMemory2KHR(void *args)
 {
     struct vkBindBufferMemory2KHR_params *params = args;
-    VkResult result;
     VkBindBufferMemoryInfo_host *pBindInfos_host;
     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);

pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win_to_host(params->pBindInfos, params->bindInfoCount);
-    result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
     free_VkBindBufferMemoryInfo_array(pBindInfos_host, params->bindInfoCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5615,11 +5591,10 @@ static NTSTATUS thunk32_vkBindBufferMemory2KHR(void *args)
 static NTSTATUS thunk64_vkBindImageMemory(void *args)
 {
     struct vkBindImageMemory_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->image), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));

-    result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory(wine_device_from_handle(params->device)->device, params->image, params->memory, params->memoryOffset);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory(wine_device_from_handle(params->device)->device, params->image, params->memory, params->memoryOffset);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5627,11 +5602,10 @@ static NTSTATUS thunk64_vkBindImageMemory(void *args)
 static NTSTATUS thunk32_vkBindImageMemory(void *args)
 {
     struct vkBindImageMemory_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->image), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));

-    result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory(wine_device_from_handle(params->device)->device, params->image, params->memory, params->memoryOffset);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory(wine_device_from_handle(params->device)->device, params->image, params->memory, params->memoryOffset);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5641,11 +5615,10 @@ static NTSTATUS thunk32_vkBindImageMemory(void *args)
 static NTSTATUS thunk64_vkBindImageMemory2(void *args)
 {
     struct vkBindImageMemory2_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);

-    result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5653,14 +5626,13 @@ static NTSTATUS thunk64_vkBindImageMemory2(void *args)
 static NTSTATUS thunk32_vkBindImageMemory2(void *args)
 {
     struct vkBindImageMemory2_params *params = args;
-    VkResult result;
     VkBindImageMemoryInfo_host *pBindInfos_host;
     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);

pBindInfos_host = convert_VkBindImageMemoryInfo_array_win_to_host(params->pBindInfos, params->bindInfoCount);
-    result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
     free_VkBindImageMemoryInfo_array(pBindInfos_host, params->bindInfoCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5670,11 +5642,10 @@ static NTSTATUS thunk32_vkBindImageMemory2(void *args)
 static NTSTATUS thunk64_vkBindImageMemory2KHR(void *args)
 {
     struct vkBindImageMemory2KHR_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);

-    result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5682,14 +5653,13 @@ static NTSTATUS thunk64_vkBindImageMemory2KHR(void *args)
 static NTSTATUS thunk32_vkBindImageMemory2KHR(void *args)
 {
     struct vkBindImageMemory2KHR_params *params = args;
-    VkResult result;
     VkBindImageMemoryInfo_host *pBindInfos_host;
     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);

pBindInfos_host = convert_VkBindImageMemoryInfo_array_win_to_host(params->pBindInfos, params->bindInfoCount);
-    result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
     free_VkBindImageMemoryInfo_array(pBindInfos_host, params->bindInfoCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -5699,11 +5669,10 @@ static NTSTATUS thunk32_vkBindImageMemory2KHR(void *args)
 static NTSTATUS thunk64_vkBuildAccelerationStructuresKHR(void *args)
 {
     struct vkBuildAccelerationStructuresKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);

-    result = wine_device_from_handle(params->device)->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -5711,14 +5680,13 @@ static NTSTATUS thunk64_vkBuildAccelerationStructuresKHR(void *args)
 static NTSTATUS thunk32_vkBuildAccelerationStructuresKHR(void *args)
 {
     struct vkBuildAccelerationStructuresKHR_params *params = args;
-    VkResult result;
     VkAccelerationStructureBuildGeometryInfoKHR_host *pInfos_host;
     TRACE("%p, 0x%s, %u, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);

pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win_to_host(params->pInfos, params->infoCount);
-    result = wine_device_from_handle(params->device)->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, pInfos_host, params->ppBuildRangeInfos);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, pInfos_host, params->ppBuildRangeInfos);
     free_VkAccelerationStructureBuildGeometryInfoKHR_array(pInfos_host, params->infoCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -9119,11 +9087,10 @@ static NTSTATUS thunk32_vkCmdSetPatchControlPointsEXT(void *args)
 static NTSTATUS thunk64_vkCmdSetPerformanceMarkerINTEL(void *args)
 {
     struct vkCmdSetPerformanceMarkerINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);

-    result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
-    return result;
+    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -9131,13 +9098,12 @@ static NTSTATUS thunk64_vkCmdSetPerformanceMarkerINTEL(void *args)
 static NTSTATUS thunk32_vkCmdSetPerformanceMarkerINTEL(void *args)
 {
     struct vkCmdSetPerformanceMarkerINTEL_params *params = args;
-    VkResult result;
     VkPerformanceMarkerInfoINTEL_host pMarkerInfo_host;
     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);

convert_VkPerformanceMarkerInfoINTEL_win_to_host(params->pMarkerInfo, &pMarkerInfo_host);
-    result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pMarkerInfo_host);
-    return result;
+    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pMarkerInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -9147,11 +9113,10 @@ static NTSTATUS thunk32_vkCmdSetPerformanceMarkerINTEL(void *args)
 static NTSTATUS thunk64_vkCmdSetPerformanceOverrideINTEL(void *args)
 {
     struct vkCmdSetPerformanceOverrideINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->commandBuffer, params->pOverrideInfo);

-    result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pOverrideInfo);
-    return result;
+    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pOverrideInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -9159,13 +9124,12 @@ static NTSTATUS thunk64_vkCmdSetPerformanceOverrideINTEL(void *args)
 static NTSTATUS thunk32_vkCmdSetPerformanceOverrideINTEL(void *args)
 {
     struct vkCmdSetPerformanceOverrideINTEL_params *params = args;
-    VkResult result;
     VkPerformanceOverrideInfoINTEL_host pOverrideInfo_host;
     TRACE("%p, %p\n", params->commandBuffer, params->pOverrideInfo);

convert_VkPerformanceOverrideInfoINTEL_win_to_host(params->pOverrideInfo, &pOverrideInfo_host);
-    result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pOverrideInfo_host);
-    return result;
+    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pOverrideInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -9175,11 +9139,10 @@ static NTSTATUS thunk32_vkCmdSetPerformanceOverrideINTEL(void *args)
 static NTSTATUS thunk64_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
 {
     struct vkCmdSetPerformanceStreamMarkerINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);

-    result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
-    return result;
+    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -9187,11 +9150,10 @@ static NTSTATUS thunk64_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
 static NTSTATUS thunk32_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
 {
     struct vkCmdSetPerformanceStreamMarkerINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);

-    result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
-    return result;
+    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10189,11 +10151,10 @@ static NTSTATUS thunk32_vkCmdWriteTimestamp2KHR(void *args)
 static NTSTATUS thunk64_vkCompileDeferredNV(void *args)
 {
     struct vkCompileDeferredNV_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10201,11 +10162,10 @@ static NTSTATUS thunk64_vkCompileDeferredNV(void *args)
 static NTSTATUS thunk32_vkCompileDeferredNV(void *args)
 {
     struct vkCompileDeferredNV_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10215,11 +10175,10 @@ static NTSTATUS thunk32_vkCompileDeferredNV(void *args)
 static NTSTATUS thunk64_vkCopyAccelerationStructureKHR(void *args)
 {
     struct vkCopyAccelerationStructureKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10227,13 +10186,12 @@ static NTSTATUS thunk64_vkCopyAccelerationStructureKHR(void *args)
 static NTSTATUS thunk32_vkCopyAccelerationStructureKHR(void *args)
 {
     struct vkCopyAccelerationStructureKHR_params *params = args;
-    VkResult result;
     VkCopyAccelerationStructureInfoKHR_host pInfo_host;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);

convert_VkCopyAccelerationStructureInfoKHR_win_to_host(params->pInfo, &pInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10243,11 +10201,10 @@ static NTSTATUS thunk32_vkCopyAccelerationStructureKHR(void *args)
 static NTSTATUS thunk64_vkCopyAccelerationStructureToMemoryKHR(void *args)
 {
     struct vkCopyAccelerationStructureToMemoryKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10255,13 +10212,12 @@ static NTSTATUS thunk64_vkCopyAccelerationStructureToMemoryKHR(void *args)
 static NTSTATUS thunk32_vkCopyAccelerationStructureToMemoryKHR(void *args)
 {
     struct vkCopyAccelerationStructureToMemoryKHR_params *params = args;
-    VkResult result;
     VkCopyAccelerationStructureToMemoryInfoKHR_host pInfo_host;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);

convert_VkCopyAccelerationStructureToMemoryInfoKHR_win_to_host(params->pInfo, &pInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10271,11 +10227,10 @@ static NTSTATUS thunk32_vkCopyAccelerationStructureToMemoryKHR(void *args)
 static NTSTATUS thunk64_vkCopyMemoryToAccelerationStructureKHR(void *args)
 {
     struct vkCopyMemoryToAccelerationStructureKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10283,13 +10238,12 @@ static NTSTATUS thunk64_vkCopyMemoryToAccelerationStructureKHR(void *args)
 static NTSTATUS thunk32_vkCopyMemoryToAccelerationStructureKHR(void *args)
 {
     struct vkCopyMemoryToAccelerationStructureKHR_params *params = args;
-    VkResult result;
     VkCopyMemoryToAccelerationStructureInfoKHR_host pInfo_host;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);

convert_VkCopyMemoryToAccelerationStructureInfoKHR_win_to_host(params->pInfo, &pInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10299,11 +10253,10 @@ static NTSTATUS thunk32_vkCopyMemoryToAccelerationStructureKHR(void *args)
 static NTSTATUS thunk64_vkCreateAccelerationStructureKHR(void *args)
 {
     struct vkCreateAccelerationStructureKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10311,13 +10264,12 @@ static NTSTATUS thunk64_vkCreateAccelerationStructureKHR(void *args)
 static NTSTATUS thunk32_vkCreateAccelerationStructureKHR(void *args)
 {
     struct vkCreateAccelerationStructureKHR_params *params = args;
-    VkResult result;
     VkAccelerationStructureCreateInfoKHR_host pCreateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);

convert_VkAccelerationStructureCreateInfoKHR_win_to_host(params->pCreateInfo, &pCreateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pAccelerationStructure);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pAccelerationStructure);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10327,11 +10279,10 @@ static NTSTATUS thunk32_vkCreateAccelerationStructureKHR(void *args)
 static NTSTATUS thunk64_vkCreateAccelerationStructureNV(void *args)
 {
     struct vkCreateAccelerationStructureNV_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10339,13 +10290,12 @@ static NTSTATUS thunk64_vkCreateAccelerationStructureNV(void *args)
 static NTSTATUS thunk32_vkCreateAccelerationStructureNV(void *args)
 {
     struct vkCreateAccelerationStructureNV_params *params = args;
-    VkResult result;
     VkAccelerationStructureCreateInfoNV_host pCreateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);

convert_VkAccelerationStructureCreateInfoNV_win_to_host(params->pCreateInfo, &pCreateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pAccelerationStructure);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pAccelerationStructure);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10355,11 +10305,10 @@ static NTSTATUS thunk32_vkCreateAccelerationStructureNV(void *args)
 static NTSTATUS thunk64_vkCreateBuffer(void *args)
 {
     struct vkCreateBuffer_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateBuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pBuffer);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pBuffer);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10367,13 +10316,12 @@ static NTSTATUS thunk64_vkCreateBuffer(void *args)
 static NTSTATUS thunk32_vkCreateBuffer(void *args)
 {
     struct vkCreateBuffer_params *params = args;
-    VkResult result;
     VkBufferCreateInfo_host pCreateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);

convert_VkBufferCreateInfo_win_to_host(params->pCreateInfo, &pCreateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateBuffer(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pBuffer);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBuffer(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pBuffer);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10383,11 +10331,10 @@ static NTSTATUS thunk32_vkCreateBuffer(void *args)
 static NTSTATUS thunk64_vkCreateBufferView(void *args)
 {
     struct vkCreateBufferView_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10395,13 +10342,12 @@ static NTSTATUS thunk64_vkCreateBufferView(void *args)
 static NTSTATUS thunk32_vkCreateBufferView(void *args)
 {
     struct vkCreateBufferView_params *params = args;
-    VkResult result;
     VkBufferViewCreateInfo_host pCreateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);

convert_VkBufferViewCreateInfo_win_to_host(params->pCreateInfo, &pCreateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pView);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pView);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10411,11 +10357,10 @@ static NTSTATUS thunk32_vkCreateBufferView(void *args)
 static NTSTATUS thunk64_vkCreateCommandPool(void *args)
 {
     struct vkCreateCommandPool_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);

-    result = wine_vkCreateCommandPool(params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool, params->client_ptr);
-    return result;
+    params->result = wine_vkCreateCommandPool(params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool, params->client_ptr);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10423,11 +10368,10 @@ static NTSTATUS thunk64_vkCreateCommandPool(void *args)
 static NTSTATUS thunk32_vkCreateCommandPool(void *args)
 {
     struct vkCreateCommandPool_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);

-    result = wine_vkCreateCommandPool(params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool, params->client_ptr);
-    return result;
+    params->result = wine_vkCreateCommandPool(params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool, params->client_ptr);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10444,11 +10388,10 @@ VkResult thunk_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelin
 static NTSTATUS thunk64_vkCreateComputePipelines(void *args)
 {
     struct vkCreateComputePipelines_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);

-    result = wine_vkCreateComputePipelines(params->device, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
-    return result;
+    params->result = wine_vkCreateComputePipelines(params->device, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10466,11 +10409,10 @@ VkResult thunk_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelin
 static NTSTATUS thunk32_vkCreateComputePipelines(void *args)
 {
     struct vkCreateComputePipelines_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);

-    result = wine_vkCreateComputePipelines(params->device, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
-    return result;
+    params->result = wine_vkCreateComputePipelines(params->device, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10480,11 +10422,10 @@ static NTSTATUS thunk32_vkCreateComputePipelines(void *args)
 static NTSTATUS thunk64_vkCreateCuFunctionNVX(void *args)
 {
     struct vkCreateCuFunctionNVX_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFunction);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFunction);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10492,13 +10433,12 @@ static NTSTATUS thunk64_vkCreateCuFunctionNVX(void *args)
 static NTSTATUS thunk32_vkCreateCuFunctionNVX(void *args)
 {
     struct vkCreateCuFunctionNVX_params *params = args;
-    VkResult result;
     VkCuFunctionCreateInfoNVX_host pCreateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);

convert_VkCuFunctionCreateInfoNVX_win_to_host(params->pCreateInfo, &pCreateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pFunction);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pFunction);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10508,11 +10448,10 @@ static NTSTATUS thunk32_vkCreateCuFunctionNVX(void *args)
 static NTSTATUS thunk64_vkCreateCuModuleNVX(void *args)
 {
     struct vkCreateCuModuleNVX_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pModule);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pModule);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10520,11 +10459,10 @@ static NTSTATUS thunk64_vkCreateCuModuleNVX(void *args)
 static NTSTATUS thunk32_vkCreateCuModuleNVX(void *args)
 {
     struct vkCreateCuModuleNVX_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pModule);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pModule);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10534,11 +10472,10 @@ static NTSTATUS thunk32_vkCreateCuModuleNVX(void *args)
 static NTSTATUS thunk64_vkCreateDebugReportCallbackEXT(void *args)
 {
     struct vkCreateDebugReportCallbackEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);

-    result = wine_vkCreateDebugReportCallbackEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
-    return result;
+    params->result = wine_vkCreateDebugReportCallbackEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10546,11 +10483,10 @@ static NTSTATUS thunk64_vkCreateDebugReportCallbackEXT(void *args)
 static NTSTATUS thunk32_vkCreateDebugReportCallbackEXT(void *args)
 {
     struct vkCreateDebugReportCallbackEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);

-    result = wine_vkCreateDebugReportCallbackEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
-    return result;
+    params->result = wine_vkCreateDebugReportCallbackEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10560,11 +10496,10 @@ static NTSTATUS thunk32_vkCreateDebugReportCallbackEXT(void *args)
 static NTSTATUS thunk64_vkCreateDebugUtilsMessengerEXT(void *args)
 {
     struct vkCreateDebugUtilsMessengerEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);

-    result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
-    return result;
+    params->result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10572,11 +10507,10 @@ static NTSTATUS thunk64_vkCreateDebugUtilsMessengerEXT(void *args)
 static NTSTATUS thunk32_vkCreateDebugUtilsMessengerEXT(void *args)
 {
     struct vkCreateDebugUtilsMessengerEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);

-    result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
-    return result;
+    params->result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10586,11 +10520,10 @@ static NTSTATUS thunk32_vkCreateDebugUtilsMessengerEXT(void *args)
 static NTSTATUS thunk64_vkCreateDeferredOperationKHR(void *args)
 {
     struct vkCreateDeferredOperationKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->device, params->pAllocator, params->pDeferredOperation);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle(params->device)->device, NULL, params->pDeferredOperation);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle(params->device)->device, NULL, params->pDeferredOperation);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10598,11 +10531,10 @@ static NTSTATUS thunk64_vkCreateDeferredOperationKHR(void *args)
 static NTSTATUS thunk32_vkCreateDeferredOperationKHR(void *args)
 {
     struct vkCreateDeferredOperationKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->device, params->pAllocator, params->pDeferredOperation);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle(params->device)->device, NULL, params->pDeferredOperation);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle(params->device)->device, NULL, params->pDeferredOperation);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10612,11 +10544,10 @@ static NTSTATUS thunk32_vkCreateDeferredOperationKHR(void *args)
 static NTSTATUS thunk64_vkCreateDescriptorPool(void *args)
 {
     struct vkCreateDescriptorPool_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorPool);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorPool);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10624,11 +10555,10 @@ static NTSTATUS thunk64_vkCreateDescriptorPool(void *args)
 static NTSTATUS thunk32_vkCreateDescriptorPool(void *args)
 {
     struct vkCreateDescriptorPool_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorPool);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorPool);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10638,11 +10568,10 @@ static NTSTATUS thunk32_vkCreateDescriptorPool(void *args)
 static NTSTATUS thunk64_vkCreateDescriptorSetLayout(void *args)
 {
     struct vkCreateDescriptorSetLayout_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSetLayout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSetLayout);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10650,11 +10579,10 @@ static NTSTATUS thunk64_vkCreateDescriptorSetLayout(void *args)
 static NTSTATUS thunk32_vkCreateDescriptorSetLayout(void *args)
 {
     struct vkCreateDescriptorSetLayout_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSetLayout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSetLayout);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10664,11 +10592,10 @@ static NTSTATUS thunk32_vkCreateDescriptorSetLayout(void *args)
 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplate(void *args)
 {
     struct vkCreateDescriptorUpdateTemplate_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10676,13 +10603,12 @@ static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplate(void *args)
 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplate(void *args)
 {
     struct vkCreateDescriptorUpdateTemplate_params *params = args;
-    VkResult result;
     VkDescriptorUpdateTemplateCreateInfo_host pCreateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);

convert_VkDescriptorUpdateTemplateCreateInfo_win_to_host(params->pCreateInfo, &pCreateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pDescriptorUpdateTemplate);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pDescriptorUpdateTemplate);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10692,11 +10618,10 @@ static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplate(void *args)
 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplateKHR(void *args)
 {
     struct vkCreateDescriptorUpdateTemplateKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10704,13 +10629,12 @@ static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplateKHR(void *args)
 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplateKHR(void *args)
 {
     struct vkCreateDescriptorUpdateTemplateKHR_params *params = args;
-    VkResult result;
     VkDescriptorUpdateTemplateCreateInfo_host pCreateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);

convert_VkDescriptorUpdateTemplateCreateInfo_win_to_host(params->pCreateInfo, &pCreateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pDescriptorUpdateTemplate);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pDescriptorUpdateTemplate);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10720,11 +10644,10 @@ static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplateKHR(void *args)
 static NTSTATUS thunk64_vkCreateDevice(void *args)
 {
     struct vkCreateDevice_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);

-    result = wine_vkCreateDevice(params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice, params->client_ptr);
-    return result;
+    params->result = wine_vkCreateDevice(params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice, params->client_ptr);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10732,11 +10655,10 @@ static NTSTATUS thunk64_vkCreateDevice(void *args)
 static NTSTATUS thunk32_vkCreateDevice(void *args)
 {
     struct vkCreateDevice_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);

-    result = wine_vkCreateDevice(params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice, params->client_ptr);
-    return result;
+    params->result = wine_vkCreateDevice(params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice, params->client_ptr);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10746,11 +10668,10 @@ static NTSTATUS thunk32_vkCreateDevice(void *args)
 static NTSTATUS thunk64_vkCreateEvent(void *args)
 {
     struct vkCreateEvent_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pEvent);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pEvent);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10758,11 +10679,10 @@ static NTSTATUS thunk64_vkCreateEvent(void *args)
 static NTSTATUS thunk32_vkCreateEvent(void *args)
 {
     struct vkCreateEvent_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pEvent);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pEvent);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10772,11 +10692,10 @@ static NTSTATUS thunk32_vkCreateEvent(void *args)
 static NTSTATUS thunk64_vkCreateFence(void *args)
 {
     struct vkCreateFence_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFence);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFence);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10784,11 +10703,10 @@ static NTSTATUS thunk64_vkCreateFence(void *args)
 static NTSTATUS thunk32_vkCreateFence(void *args)
 {
     struct vkCreateFence_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFence);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFence);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10798,11 +10716,10 @@ static NTSTATUS thunk32_vkCreateFence(void *args)
 static NTSTATUS thunk64_vkCreateFramebuffer(void *args)
 {
     struct vkCreateFramebuffer_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFramebuffer);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFramebuffer);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10810,13 +10727,12 @@ static NTSTATUS thunk64_vkCreateFramebuffer(void *args)
 static NTSTATUS thunk32_vkCreateFramebuffer(void *args)
 {
     struct vkCreateFramebuffer_params *params = args;
-    VkResult result;
     VkFramebufferCreateInfo_host pCreateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);

convert_VkFramebufferCreateInfo_win_to_host(params->pCreateInfo, &pCreateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pFramebuffer);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pFramebuffer);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10833,11 +10749,10 @@ VkResult thunk_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipeli
 static NTSTATUS thunk64_vkCreateGraphicsPipelines(void *args)
 {
     struct vkCreateGraphicsPipelines_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);

-    result = wine_vkCreateGraphicsPipelines(params->device, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
-    return result;
+    params->result = wine_vkCreateGraphicsPipelines(params->device, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10855,11 +10770,10 @@ VkResult thunk_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipeli
 static NTSTATUS thunk32_vkCreateGraphicsPipelines(void *args)
 {
     struct vkCreateGraphicsPipelines_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);

-    result = wine_vkCreateGraphicsPipelines(params->device, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
-    return result;
+    params->result = wine_vkCreateGraphicsPipelines(params->device, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10869,11 +10783,10 @@ static NTSTATUS thunk32_vkCreateGraphicsPipelines(void *args)
 static NTSTATUS thunk64_vkCreateImage(void *args)
 {
     struct vkCreateImage_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateImage(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pImage);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImage(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pImage);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10881,11 +10794,10 @@ static NTSTATUS thunk64_vkCreateImage(void *args)
 static NTSTATUS thunk32_vkCreateImage(void *args)
 {
     struct vkCreateImage_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateImage(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pImage);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImage(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pImage);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10895,11 +10807,10 @@ static NTSTATUS thunk32_vkCreateImage(void *args)
 static NTSTATUS thunk64_vkCreateImageView(void *args)
 {
     struct vkCreateImageView_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10907,13 +10818,12 @@ static NTSTATUS thunk64_vkCreateImageView(void *args)
 static NTSTATUS thunk32_vkCreateImageView(void *args)
 {
     struct vkCreateImageView_params *params = args;
-    VkResult result;
     VkImageViewCreateInfo_host pCreateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);

convert_VkImageViewCreateInfo_win_to_host(params->pCreateInfo, &pCreateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pView);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pView);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10923,11 +10833,10 @@ static NTSTATUS thunk32_vkCreateImageView(void *args)
 static NTSTATUS thunk64_vkCreateIndirectCommandsLayoutNV(void *args)
 {
     struct vkCreateIndirectCommandsLayoutNV_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pIndirectCommandsLayout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pIndirectCommandsLayout);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10935,14 +10844,13 @@ static NTSTATUS thunk64_vkCreateIndirectCommandsLayoutNV(void *args)
 static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutNV(void *args)
 {
     struct vkCreateIndirectCommandsLayoutNV_params *params = args;
-    VkResult result;
     VkIndirectCommandsLayoutCreateInfoNV_host pCreateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);

convert_VkIndirectCommandsLayoutCreateInfoNV_win_to_host(params->pCreateInfo, &pCreateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pIndirectCommandsLayout);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pIndirectCommandsLayout);
     free_VkIndirectCommandsLayoutCreateInfoNV(&pCreateInfo_host);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10952,11 +10860,10 @@ static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutNV(void *args)
 static NTSTATUS thunk64_vkCreateInstance(void *args)
 {
     struct vkCreateInstance_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->pCreateInfo, params->pAllocator, params->pInstance);

-    result = wine_vkCreateInstance(params->pCreateInfo, params->pAllocator, params->pInstance, params->client_ptr);
-    return result;
+    params->result = wine_vkCreateInstance(params->pCreateInfo, params->pAllocator, params->pInstance, params->client_ptr);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10964,11 +10871,10 @@ static NTSTATUS thunk64_vkCreateInstance(void *args)
 static NTSTATUS thunk32_vkCreateInstance(void *args)
 {
     struct vkCreateInstance_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->pCreateInfo, params->pAllocator, params->pInstance);

-    result = wine_vkCreateInstance(params->pCreateInfo, params->pAllocator, params->pInstance, params->client_ptr);
-    return result;
+    params->result = wine_vkCreateInstance(params->pCreateInfo, params->pAllocator, params->pInstance, params->client_ptr);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -10978,11 +10884,10 @@ static NTSTATUS thunk32_vkCreateInstance(void *args)
 static NTSTATUS thunk64_vkCreatePipelineCache(void *args)
 {
     struct vkCreatePipelineCache_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineCache);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineCache);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -10990,11 +10895,10 @@ static NTSTATUS thunk64_vkCreatePipelineCache(void *args)
 static NTSTATUS thunk32_vkCreatePipelineCache(void *args)
 {
     struct vkCreatePipelineCache_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineCache);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineCache);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11004,11 +10908,10 @@ static NTSTATUS thunk32_vkCreatePipelineCache(void *args)
 static NTSTATUS thunk64_vkCreatePipelineLayout(void *args)
 {
     struct vkCreatePipelineLayout_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineLayout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineLayout);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11016,11 +10919,10 @@ static NTSTATUS thunk64_vkCreatePipelineLayout(void *args)
 static NTSTATUS thunk32_vkCreatePipelineLayout(void *args)
 {
     struct vkCreatePipelineLayout_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineLayout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineLayout);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11030,11 +10932,10 @@ static NTSTATUS thunk32_vkCreatePipelineLayout(void *args)
 static NTSTATUS thunk64_vkCreatePrivateDataSlot(void *args)
 {
     struct vkCreatePrivateDataSlot_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11042,11 +10943,10 @@ static NTSTATUS thunk64_vkCreatePrivateDataSlot(void *args)
 static NTSTATUS thunk32_vkCreatePrivateDataSlot(void *args)
 {
     struct vkCreatePrivateDataSlot_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11056,11 +10956,10 @@ static NTSTATUS thunk32_vkCreatePrivateDataSlot(void *args)
 static NTSTATUS thunk64_vkCreatePrivateDataSlotEXT(void *args)
 {
     struct vkCreatePrivateDataSlotEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11068,11 +10967,10 @@ static NTSTATUS thunk64_vkCreatePrivateDataSlotEXT(void *args)
 static NTSTATUS thunk32_vkCreatePrivateDataSlotEXT(void *args)
 {
     struct vkCreatePrivateDataSlotEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11082,11 +10980,10 @@ static NTSTATUS thunk32_vkCreatePrivateDataSlotEXT(void *args)
 static NTSTATUS thunk64_vkCreateQueryPool(void *args)
 {
     struct vkCreateQueryPool_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pQueryPool);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pQueryPool);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11094,11 +10991,10 @@ static NTSTATUS thunk64_vkCreateQueryPool(void *args)
 static NTSTATUS thunk32_vkCreateQueryPool(void *args)
 {
     struct vkCreateQueryPool_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pQueryPool);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pQueryPool);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11115,11 +11011,10 @@ VkResult thunk_vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperati
 static NTSTATUS thunk64_vkCreateRayTracingPipelinesKHR(void *args)
 {
     struct vkCreateRayTracingPipelinesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);

-    result = wine_vkCreateRayTracingPipelinesKHR(params->device, params->deferredOperation, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
-    return result;
+    params->result = wine_vkCreateRayTracingPipelinesKHR(params->device, params->deferredOperation, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11137,11 +11032,10 @@ VkResult thunk_vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperati
 static NTSTATUS thunk32_vkCreateRayTracingPipelinesKHR(void *args)
 {
     struct vkCreateRayTracingPipelinesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);

-    result = wine_vkCreateRayTracingPipelinesKHR(params->device, params->deferredOperation, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
-    return result;
+    params->result = wine_vkCreateRayTracingPipelinesKHR(params->device, params->deferredOperation, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11158,11 +11052,10 @@ VkResult thunk_vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pi
 static NTSTATUS thunk64_vkCreateRayTracingPipelinesNV(void *args)
 {
     struct vkCreateRayTracingPipelinesNV_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);

-    result = wine_vkCreateRayTracingPipelinesNV(params->device, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
-    return result;
+    params->result = wine_vkCreateRayTracingPipelinesNV(params->device, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11180,11 +11073,10 @@ VkResult thunk_vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pi
 static NTSTATUS thunk32_vkCreateRayTracingPipelinesNV(void *args)
 {
     struct vkCreateRayTracingPipelinesNV_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);

-    result = wine_vkCreateRayTracingPipelinesNV(params->device, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
-    return result;
+    params->result = wine_vkCreateRayTracingPipelinesNV(params->device, params->pipelineCache, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11194,11 +11086,10 @@ static NTSTATUS thunk32_vkCreateRayTracingPipelinesNV(void *args)
 static NTSTATUS thunk64_vkCreateRenderPass(void *args)
 {
     struct vkCreateRenderPass_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11206,11 +11097,10 @@ static NTSTATUS thunk64_vkCreateRenderPass(void *args)
 static NTSTATUS thunk32_vkCreateRenderPass(void *args)
 {
     struct vkCreateRenderPass_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11220,11 +11110,10 @@ static NTSTATUS thunk32_vkCreateRenderPass(void *args)
 static NTSTATUS thunk64_vkCreateRenderPass2(void *args)
 {
     struct vkCreateRenderPass2_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11232,11 +11121,10 @@ static NTSTATUS thunk64_vkCreateRenderPass2(void *args)
 static NTSTATUS thunk32_vkCreateRenderPass2(void *args)
 {
     struct vkCreateRenderPass2_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11246,11 +11134,10 @@ static NTSTATUS thunk32_vkCreateRenderPass2(void *args)
 static NTSTATUS thunk64_vkCreateRenderPass2KHR(void *args)
 {
     struct vkCreateRenderPass2KHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11258,11 +11145,10 @@ static NTSTATUS thunk64_vkCreateRenderPass2KHR(void *args)
 static NTSTATUS thunk32_vkCreateRenderPass2KHR(void *args)
 {
     struct vkCreateRenderPass2KHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11272,11 +11158,10 @@ static NTSTATUS thunk32_vkCreateRenderPass2KHR(void *args)
 static NTSTATUS thunk64_vkCreateSampler(void *args)
 {
     struct vkCreateSampler_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSampler);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSampler);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11284,11 +11169,10 @@ static NTSTATUS thunk64_vkCreateSampler(void *args)
 static NTSTATUS thunk32_vkCreateSampler(void *args)
 {
     struct vkCreateSampler_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSampler);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSampler);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11298,11 +11182,10 @@ static NTSTATUS thunk32_vkCreateSampler(void *args)
 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversion(void *args)
 {
     struct vkCreateSamplerYcbcrConversion_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11310,11 +11193,10 @@ static NTSTATUS thunk64_vkCreateSamplerYcbcrConversion(void *args)
 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversion(void *args)
 {
     struct vkCreateSamplerYcbcrConversion_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11324,11 +11206,10 @@ static NTSTATUS thunk32_vkCreateSamplerYcbcrConversion(void *args)
 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversionKHR(void *args)
 {
     struct vkCreateSamplerYcbcrConversionKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11336,11 +11217,10 @@ static NTSTATUS thunk64_vkCreateSamplerYcbcrConversionKHR(void *args)
 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversionKHR(void *args)
 {
     struct vkCreateSamplerYcbcrConversionKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11350,11 +11230,10 @@ static NTSTATUS thunk32_vkCreateSamplerYcbcrConversionKHR(void *args)
 static NTSTATUS thunk64_vkCreateSemaphore(void *args)
 {
     struct vkCreateSemaphore_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSemaphore);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSemaphore);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11362,11 +11241,10 @@ static NTSTATUS thunk64_vkCreateSemaphore(void *args)
 static NTSTATUS thunk32_vkCreateSemaphore(void *args)
 {
     struct vkCreateSemaphore_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSemaphore);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSemaphore);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11376,11 +11254,10 @@ static NTSTATUS thunk32_vkCreateSemaphore(void *args)
 static NTSTATUS thunk64_vkCreateShaderModule(void *args)
 {
     struct vkCreateShaderModule_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pShaderModule);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pShaderModule);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11388,11 +11265,10 @@ static NTSTATUS thunk64_vkCreateShaderModule(void *args)
 static NTSTATUS thunk32_vkCreateShaderModule(void *args)
 {
     struct vkCreateShaderModule_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pShaderModule);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pShaderModule);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11402,13 +11278,12 @@ static NTSTATUS thunk32_vkCreateShaderModule(void *args)
 static NTSTATUS thunk64_vkCreateSwapchainKHR(void *args)
 {
     struct vkCreateSwapchainKHR_params *params = args;
-    VkResult result;
     VkSwapchainCreateInfoKHR pCreateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);

convert_VkSwapchainCreateInfoKHR_win_to_host(params->pCreateInfo, &pCreateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11416,13 +11291,12 @@ static NTSTATUS thunk64_vkCreateSwapchainKHR(void *args)
 static NTSTATUS thunk32_vkCreateSwapchainKHR(void *args)
 {
     struct vkCreateSwapchainKHR_params *params = args;
-    VkResult result;
     VkSwapchainCreateInfoKHR_host pCreateInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);

convert_VkSwapchainCreateInfoKHR_win_to_host(params->pCreateInfo, &pCreateInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11432,11 +11306,10 @@ static NTSTATUS thunk32_vkCreateSwapchainKHR(void *args)
 static NTSTATUS thunk64_vkCreateValidationCacheEXT(void *args)
 {
     struct vkCreateValidationCacheEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pValidationCache);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pValidationCache);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11444,11 +11317,10 @@ static NTSTATUS thunk64_vkCreateValidationCacheEXT(void *args)
 static NTSTATUS thunk32_vkCreateValidationCacheEXT(void *args)
 {
     struct vkCreateValidationCacheEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);

-    result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pValidationCache);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pValidationCache);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11458,11 +11330,10 @@ static NTSTATUS thunk32_vkCreateValidationCacheEXT(void *args)
 static NTSTATUS thunk64_vkCreateWin32SurfaceKHR(void *args)
 {
     struct vkCreateWin32SurfaceKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);

-    result = wine_vkCreateWin32SurfaceKHR(params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
-    return result;
+    params->result = wine_vkCreateWin32SurfaceKHR(params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11470,11 +11341,10 @@ static NTSTATUS thunk64_vkCreateWin32SurfaceKHR(void *args)
 static NTSTATUS thunk32_vkCreateWin32SurfaceKHR(void *args)
 {
     struct vkCreateWin32SurfaceKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);

-    result = wine_vkCreateWin32SurfaceKHR(params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
-    return result;
+    params->result = wine_vkCreateWin32SurfaceKHR(params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11484,13 +11354,12 @@ static NTSTATUS thunk32_vkCreateWin32SurfaceKHR(void *args)
 static NTSTATUS thunk64_vkDebugMarkerSetObjectNameEXT(void *args)
 {
     struct vkDebugMarkerSetObjectNameEXT_params *params = args;
-    VkResult result;
     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
     TRACE("%p, %p\n", params->device, params->pNameInfo);

convert_VkDebugMarkerObjectNameInfoEXT_win_to_host(params->pNameInfo, &pNameInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11498,13 +11367,12 @@ static NTSTATUS thunk64_vkDebugMarkerSetObjectNameEXT(void *args)
 static NTSTATUS thunk32_vkDebugMarkerSetObjectNameEXT(void *args)
 {
     struct vkDebugMarkerSetObjectNameEXT_params *params = args;
-    VkResult result;
     VkDebugMarkerObjectNameInfoEXT_host pNameInfo_host;
     TRACE("%p, %p\n", params->device, params->pNameInfo);

convert_VkDebugMarkerObjectNameInfoEXT_win_to_host(params->pNameInfo, &pNameInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11514,13 +11382,12 @@ static NTSTATUS thunk32_vkDebugMarkerSetObjectNameEXT(void *args)
 static NTSTATUS thunk64_vkDebugMarkerSetObjectTagEXT(void *args)
 {
     struct vkDebugMarkerSetObjectTagEXT_params *params = args;
-    VkResult result;
     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
     TRACE("%p, %p\n", params->device, params->pTagInfo);

convert_VkDebugMarkerObjectTagInfoEXT_win_to_host(params->pTagInfo, &pTagInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11528,13 +11395,12 @@ static NTSTATUS thunk64_vkDebugMarkerSetObjectTagEXT(void *args)
 static NTSTATUS thunk32_vkDebugMarkerSetObjectTagEXT(void *args)
 {
     struct vkDebugMarkerSetObjectTagEXT_params *params = args;
-    VkResult result;
     VkDebugMarkerObjectTagInfoEXT_host pTagInfo_host;
     TRACE("%p, %p\n", params->device, params->pTagInfo);

convert_VkDebugMarkerObjectTagInfoEXT_win_to_host(params->pTagInfo, &pTagInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -11568,11 +11434,10 @@ static NTSTATUS thunk32_vkDebugReportMessageEXT(void *args)
 static NTSTATUS thunk64_vkDeferredOperationJoinKHR(void *args)
 {
     struct vkDeferredOperationJoinKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));

-    result = wine_device_from_handle(params->device)->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle(params->device)->device, params->operation);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle(params->device)->device, params->operation);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -11580,11 +11445,10 @@ static NTSTATUS thunk64_vkDeferredOperationJoinKHR(void *args)
 static NTSTATUS thunk32_vkDeferredOperationJoinKHR(void *args)
 {
     struct vkDeferredOperationJoinKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));

-    result = wine_device_from_handle(params->device)->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle(params->device)->device, params->operation);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle(params->device)->device, params->operation);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12482,11 +12346,10 @@ static NTSTATUS thunk32_vkDestroyValidationCacheEXT(void *args)
 static NTSTATUS thunk64_vkDeviceWaitIdle(void *args)
 {
     struct vkDeviceWaitIdle_params *params = args;
-    VkResult result;
     TRACE("%p\n", params->device);

-    result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12494,11 +12357,10 @@ static NTSTATUS thunk64_vkDeviceWaitIdle(void *args)
 static NTSTATUS thunk32_vkDeviceWaitIdle(void *args)
 {
     struct vkDeviceWaitIdle_params *params = args;
-    VkResult result;
     TRACE("%p\n", params->device);

-    result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12508,11 +12370,10 @@ static NTSTATUS thunk32_vkDeviceWaitIdle(void *args)
 static NTSTATUS thunk64_vkEndCommandBuffer(void *args)
 {
     struct vkEndCommandBuffer_params *params = args;
-    VkResult result;
     TRACE("%p\n", params->commandBuffer);

-    result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
-    return result;
+    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12520,11 +12381,10 @@ static NTSTATUS thunk64_vkEndCommandBuffer(void *args)
 static NTSTATUS thunk32_vkEndCommandBuffer(void *args)
 {
     struct vkEndCommandBuffer_params *params = args;
-    VkResult result;
     TRACE("%p\n", params->commandBuffer);

-    result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
-    return result;
+    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12534,11 +12394,10 @@ static NTSTATUS thunk32_vkEndCommandBuffer(void *args)
 static NTSTATUS thunk64_vkEnumerateDeviceExtensionProperties(void *args)
 {
     struct vkEnumerateDeviceExtensionProperties_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);

-    result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
-    return result;
+    params->result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12546,11 +12405,10 @@ static NTSTATUS thunk64_vkEnumerateDeviceExtensionProperties(void *args)
 static NTSTATUS thunk32_vkEnumerateDeviceExtensionProperties(void *args)
 {
     struct vkEnumerateDeviceExtensionProperties_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);

-    result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
-    return result;
+    params->result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12560,11 +12418,10 @@ static NTSTATUS thunk32_vkEnumerateDeviceExtensionProperties(void *args)
 static NTSTATUS thunk64_vkEnumerateDeviceLayerProperties(void *args)
 {
     struct vkEnumerateDeviceLayerProperties_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);

-    result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
-    return result;
+    params->result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12572,11 +12429,10 @@ static NTSTATUS thunk64_vkEnumerateDeviceLayerProperties(void *args)
 static NTSTATUS thunk32_vkEnumerateDeviceLayerProperties(void *args)
 {
     struct vkEnumerateDeviceLayerProperties_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);

-    result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
-    return result;
+    params->result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12586,11 +12442,10 @@ static NTSTATUS thunk32_vkEnumerateDeviceLayerProperties(void *args)
 static NTSTATUS thunk64_vkEnumerateInstanceExtensionProperties(void *args)
 {
     struct vkEnumerateInstanceExtensionProperties_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->pLayerName, params->pPropertyCount, params->pProperties);

-    result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
-    return result;
+    params->result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12598,11 +12453,10 @@ static NTSTATUS thunk64_vkEnumerateInstanceExtensionProperties(void *args)
 static NTSTATUS thunk32_vkEnumerateInstanceExtensionProperties(void *args)
 {
     struct vkEnumerateInstanceExtensionProperties_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->pLayerName, params->pPropertyCount, params->pProperties);

-    result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
-    return result;
+    params->result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12612,11 +12466,10 @@ static NTSTATUS thunk32_vkEnumerateInstanceExtensionProperties(void *args)
 static NTSTATUS thunk64_vkEnumerateInstanceVersion(void *args)
 {
     struct vkEnumerateInstanceVersion_params *params = args;
-    VkResult result;
     TRACE("%p\n", params->pApiVersion);

-    result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
-    return result;
+    params->result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12624,11 +12477,10 @@ static NTSTATUS thunk64_vkEnumerateInstanceVersion(void *args)
 static NTSTATUS thunk32_vkEnumerateInstanceVersion(void *args)
 {
     struct vkEnumerateInstanceVersion_params *params = args;
-    VkResult result;
     TRACE("%p\n", params->pApiVersion);

-    result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
-    return result;
+    params->result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12638,11 +12490,10 @@ static NTSTATUS thunk32_vkEnumerateInstanceVersion(void *args)
 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroups(void *args)
 {
     struct vkEnumeratePhysicalDeviceGroups_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);

-    result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
-    return result;
+    params->result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12650,11 +12501,10 @@ static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroups(void *args)
 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroups(void *args)
 {
     struct vkEnumeratePhysicalDeviceGroups_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);

-    result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
-    return result;
+    params->result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12664,11 +12514,10 @@ static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroups(void *args)
 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
 {
     struct vkEnumeratePhysicalDeviceGroupsKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);

-    result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
-    return result;
+    params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12676,11 +12525,10 @@ static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
 {
     struct vkEnumeratePhysicalDeviceGroupsKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);

-    result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
-    return result;
+    params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12690,11 +12538,10 @@ static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
 {
     struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p, %p, %p\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12702,11 +12549,10 @@ static NTSTATUS thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCoun
 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
 {
     struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p, %p, %p\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12716,11 +12562,10 @@ static NTSTATUS thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCoun
 static NTSTATUS thunk64_vkEnumeratePhysicalDevices(void *args)
 {
     struct vkEnumeratePhysicalDevices_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);

-    result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
-    return result;
+    params->result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12728,11 +12573,10 @@ static NTSTATUS thunk64_vkEnumeratePhysicalDevices(void *args)
 static NTSTATUS thunk32_vkEnumeratePhysicalDevices(void *args)
 {
     struct vkEnumeratePhysicalDevices_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);

-    result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
-    return result;
+    params->result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12742,11 +12586,10 @@ static NTSTATUS thunk32_vkEnumeratePhysicalDevices(void *args)
 static NTSTATUS thunk64_vkFlushMappedMemoryRanges(void *args)
 {
     struct vkFlushMappedMemoryRanges_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);

-    result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, params->pMemoryRanges);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, params->pMemoryRanges);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12754,14 +12597,13 @@ static NTSTATUS thunk64_vkFlushMappedMemoryRanges(void *args)
 static NTSTATUS thunk32_vkFlushMappedMemoryRanges(void *args)
 {
     struct vkFlushMappedMemoryRanges_params *params = args;
-    VkResult result;
     VkMappedMemoryRange_host *pMemoryRanges_host;
     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);

pMemoryRanges_host = convert_VkMappedMemoryRange_array_win_to_host(params->pMemoryRanges, params->memoryRangeCount);
-    result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
     free_VkMappedMemoryRange_array(pMemoryRanges_host, params->memoryRangeCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12795,11 +12637,10 @@ static NTSTATUS thunk32_vkFreeCommandBuffers(void *args)
 static NTSTATUS thunk64_vkFreeDescriptorSets(void *args)
 {
     struct vkFreeDescriptorSets_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);

-    result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12807,11 +12648,10 @@ static NTSTATUS thunk64_vkFreeDescriptorSets(void *args)
 static NTSTATUS thunk32_vkFreeDescriptorSets(void *args)
 {
     struct vkFreeDescriptorSets_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);

-    result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -12899,11 +12739,10 @@ static NTSTATUS thunk32_vkGetAccelerationStructureDeviceAddressKHR(void *args)
 static NTSTATUS thunk64_vkGetAccelerationStructureHandleNV(void *args)
 {
     struct vkGetAccelerationStructureHandleNV_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -12911,11 +12750,10 @@ static NTSTATUS thunk64_vkGetAccelerationStructureHandleNV(void *args)
 static NTSTATUS thunk32_vkGetAccelerationStructureHandleNV(void *args)
 {
     struct vkGetAccelerationStructureHandleNV_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -13168,11 +13006,10 @@ static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddressKHR(void *args)
 static NTSTATUS thunk64_vkGetCalibratedTimestampsEXT(void *args)
 {
     struct vkGetCalibratedTimestampsEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);

-    result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
-    return result;
+    params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -13180,11 +13017,10 @@ static NTSTATUS thunk64_vkGetCalibratedTimestampsEXT(void *args)
 static NTSTATUS thunk32_vkGetCalibratedTimestampsEXT(void *args)
 {
     struct vkGetCalibratedTimestampsEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);

-    result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
-    return result;
+    params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -13194,11 +13030,10 @@ static NTSTATUS thunk32_vkGetCalibratedTimestampsEXT(void *args)
 static NTSTATUS thunk64_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
 {
     struct vkGetDeferredOperationMaxConcurrencyKHR_params *params = args;
-    uint32_t result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle(params->device)->device, params->operation);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle(params->device)->device, params->operation);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -13206,11 +13041,10 @@ static NTSTATUS thunk64_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
 static NTSTATUS thunk32_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
 {
     struct vkGetDeferredOperationMaxConcurrencyKHR_params *params = args;
-    uint32_t result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle(params->device)->device, params->operation);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle(params->device)->device, params->operation);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -13220,11 +13054,10 @@ static NTSTATUS thunk32_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
 static NTSTATUS thunk64_vkGetDeferredOperationResultKHR(void *args)
 {
     struct vkGetDeferredOperationResultKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle(params->device)->device, params->operation);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle(params->device)->device, params->operation);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -13232,11 +13065,10 @@ static NTSTATUS thunk64_vkGetDeferredOperationResultKHR(void *args)
 static NTSTATUS thunk32_vkGetDeferredOperationResultKHR(void *args)
 {
     struct vkGetDeferredOperationResultKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle(params->device)->device, params->operation);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle(params->device)->device, params->operation);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -13476,11 +13308,10 @@ static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
 static NTSTATUS thunk64_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
 {
     struct vkGetDeviceGroupPresentCapabilitiesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->device, params->pDeviceGroupPresentCapabilities);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, params->pDeviceGroupPresentCapabilities);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, params->pDeviceGroupPresentCapabilities);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -13488,11 +13319,10 @@ static NTSTATUS thunk64_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
 static NTSTATUS thunk32_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
 {
     struct vkGetDeviceGroupPresentCapabilitiesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->device, params->pDeviceGroupPresentCapabilities);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, params->pDeviceGroupPresentCapabilities);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, params->pDeviceGroupPresentCapabilities);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -13502,11 +13332,10 @@ static NTSTATUS thunk32_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
 static NTSTATUS thunk64_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
 {
     struct vkGetDeviceGroupSurfacePresentModesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(wine_device_from_handle(params->device)->device, wine_surface_from_handle(params->surface)->driver_surface, params->pModes);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(wine_device_from_handle(params->device)->device, wine_surface_from_handle(params->surface)->driver_surface, params->pModes);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -13514,11 +13343,10 @@ static NTSTATUS thunk64_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
 static NTSTATUS thunk32_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
 {
     struct vkGetDeviceGroupSurfacePresentModesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(wine_device_from_handle(params->device)->device, wine_surface_from_handle(params->surface)->driver_surface, params->pModes);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(wine_device_from_handle(params->device)->device, wine_surface_from_handle(params->surface)->driver_surface, params->pModes);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -13754,11 +13582,10 @@ static NTSTATUS thunk32_vkGetDeviceQueue2(void *args)
 static NTSTATUS thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
 {
     struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -13766,11 +13593,10 @@ static NTSTATUS thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *ar
 static NTSTATUS thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
 {
     struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -13780,11 +13606,10 @@ static NTSTATUS thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *ar
 static NTSTATUS thunk64_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
 {
     struct vkGetDynamicRenderingTilePropertiesQCOM_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->device, params->pRenderingInfo, params->pProperties);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->pRenderingInfo, params->pProperties);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->pRenderingInfo, params->pProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -13792,14 +13617,13 @@ static NTSTATUS thunk64_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
 static NTSTATUS thunk32_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
 {
     struct vkGetDynamicRenderingTilePropertiesQCOM_params *params = args;
-    VkResult result;
     VkRenderingInfo_host pRenderingInfo_host;
     TRACE("%p, %p, %p\n", params->device, params->pRenderingInfo, params->pProperties);

convert_VkRenderingInfo_win_to_host(params->pRenderingInfo, &pRenderingInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, &pRenderingInfo_host, params->pProperties);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, &pRenderingInfo_host, params->pProperties);
     free_VkRenderingInfo(&pRenderingInfo_host);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -13809,11 +13633,10 @@ static NTSTATUS thunk32_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
 static NTSTATUS thunk64_vkGetEventStatus(void *args)
 {
     struct vkGetEventStatus_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -13821,11 +13644,10 @@ static NTSTATUS thunk64_vkGetEventStatus(void *args)
 static NTSTATUS thunk32_vkGetEventStatus(void *args)
 {
     struct vkGetEventStatus_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -13835,11 +13657,10 @@ static NTSTATUS thunk32_vkGetEventStatus(void *args)
 static NTSTATUS thunk64_vkGetFenceStatus(void *args)
 {
     struct vkGetFenceStatus_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -13847,11 +13668,10 @@ static NTSTATUS thunk64_vkGetFenceStatus(void *args)
 static NTSTATUS thunk32_vkGetFenceStatus(void *args)
 {
     struct vkGetFenceStatus_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -13861,11 +13681,10 @@ static NTSTATUS thunk32_vkGetFenceStatus(void *args)
 static NTSTATUS thunk64_vkGetFramebufferTilePropertiesQCOM(void *args)
 {
     struct vkGetFramebufferTilePropertiesQCOM_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, params->pProperties);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, params->pProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -13873,11 +13692,10 @@ static NTSTATUS thunk64_vkGetFramebufferTilePropertiesQCOM(void *args)
 static NTSTATUS thunk32_vkGetFramebufferTilePropertiesQCOM(void *args)
 {
     struct vkGetFramebufferTilePropertiesQCOM_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, params->pProperties);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, params->pProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -14129,11 +13947,10 @@ static NTSTATUS thunk32_vkGetImageSubresourceLayout2EXT(void *args)
 static NTSTATUS thunk64_vkGetImageViewAddressNVX(void *args)
 {
     struct vkGetImageViewAddressNVX_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, params->pProperties);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, params->pProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -14141,14 +13958,13 @@ static NTSTATUS thunk64_vkGetImageViewAddressNVX(void *args)
 static NTSTATUS thunk32_vkGetImageViewAddressNVX(void *args)
 {
     struct vkGetImageViewAddressNVX_params *params = args;
-    VkResult result;
     VkImageViewAddressPropertiesNVX_host pProperties_host;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);

convert_VkImageViewAddressPropertiesNVX_win_to_host(params->pProperties, &pProperties_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, &pProperties_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, &pProperties_host);
     convert_VkImageViewAddressPropertiesNVX_host_to_win(&pProperties_host, params->pProperties);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -14158,11 +13974,10 @@ static NTSTATUS thunk32_vkGetImageViewAddressNVX(void *args)
 static NTSTATUS thunk64_vkGetImageViewHandleNVX(void *args)
 {
     struct vkGetImageViewHandleNVX_params *params = args;
-    uint32_t result;
     TRACE("%p, %p\n", params->device, params->pInfo);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, params->pInfo);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, params->pInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -14170,13 +13985,12 @@ static NTSTATUS thunk64_vkGetImageViewHandleNVX(void *args)
 static NTSTATUS thunk32_vkGetImageViewHandleNVX(void *args)
 {
     struct vkGetImageViewHandleNVX_params *params = args;
-    uint32_t result;
     VkImageViewHandleInfoNVX_host pInfo_host;
     TRACE("%p, %p\n", params->device, params->pInfo);

convert_VkImageViewHandleInfoNVX_win_to_host(params->pInfo, &pInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, &pInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, &pInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -14186,11 +14000,10 @@ static NTSTATUS thunk32_vkGetImageViewHandleNVX(void *args)
 static NTSTATUS thunk64_vkGetMemoryHostPointerPropertiesEXT(void *args)
 {
     struct vkGetMemoryHostPointerPropertiesEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %#x, %p, %p\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -14198,11 +14011,10 @@ static NTSTATUS thunk64_vkGetMemoryHostPointerPropertiesEXT(void *args)
 static NTSTATUS thunk32_vkGetMemoryHostPointerPropertiesEXT(void *args)
 {
     struct vkGetMemoryHostPointerPropertiesEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %#x, %p, %p\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -14212,11 +14024,10 @@ static NTSTATUS thunk32_vkGetMemoryHostPointerPropertiesEXT(void *args)
 static NTSTATUS thunk64_vkGetPerformanceParameterINTEL(void *args)
 {
     struct vkGetPerformanceParameterINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, %#x, %p\n", params->device, params->parameter, params->pValue);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, params->pValue);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, params->pValue);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -14224,11 +14035,10 @@ static NTSTATUS thunk64_vkGetPerformanceParameterINTEL(void *args)
 static NTSTATUS thunk32_vkGetPerformanceParameterINTEL(void *args)
 {
     struct vkGetPerformanceParameterINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, %#x, %p\n", params->device, params->parameter, params->pValue);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, params->pValue);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, params->pValue);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -14238,11 +14048,10 @@ static NTSTATUS thunk32_vkGetPerformanceParameterINTEL(void *args)
 static NTSTATUS thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
 {
     struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);

-    result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
-    return result;
+    params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -14250,11 +14059,10 @@ static NTSTATUS thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *arg
 static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
 {
     struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);

-    result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
-    return result;
+    params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -14264,11 +14072,10 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *arg
 static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
 {
     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPropertyCount, params->pProperties);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPropertyCount, params->pProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -14276,11 +14083,10 @@ static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *a
 static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
 {
     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPropertyCount, params->pProperties);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPropertyCount, params->pProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -14578,11 +14384,10 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
 static NTSTATUS thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
 {
     struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFragmentShadingRatesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFragmentShadingRatesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -14590,11 +14395,10 @@ static NTSTATUS thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
 static NTSTATUS thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
 {
     struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFragmentShadingRatesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFragmentShadingRatesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -14604,11 +14408,10 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties(void *args)
 {
     struct vkGetPhysicalDeviceImageFormatProperties_params *params = args;
-    VkResult result;
     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -14616,13 +14419,12 @@ static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties(void *args)
 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties(void *args)
 {
     struct vkGetPhysicalDeviceImageFormatProperties_params *params = args;
-    VkResult result;
     VkImageFormatProperties_host pImageFormatProperties_host;
     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->type, params->tiling, params->usage, params->flags, &pImageFormatProperties_host);
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->type, params->tiling, params->usage, params->flags, &pImageFormatProperties_host);
     convert_VkImageFormatProperties_host_to_win(&pImageFormatProperties_host, params->pImageFormatProperties);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -14639,11 +14441,10 @@ VkResult thunk_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physic
 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2(void *args)
 {
     struct vkGetPhysicalDeviceImageFormatProperties2_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);

-    result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
-    return result;
+    params->result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -14661,11 +14462,10 @@ VkResult thunk_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physic
 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2(void *args)
 {
     struct vkGetPhysicalDeviceImageFormatProperties2_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);

-    result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
-    return result;
+    params->result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -14682,11 +14482,10 @@ VkResult thunk_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice phy
 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
 {
     struct vkGetPhysicalDeviceImageFormatProperties2KHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);

-    result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
-    return result;
+    params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -14704,11 +14503,10 @@ VkResult thunk_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice phy
 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
 {
     struct vkGetPhysicalDeviceImageFormatProperties2KHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);

-    result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
-    return result;
+    params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -14822,11 +14620,10 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
 static NTSTATUS thunk64_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
 {
     struct vkGetPhysicalDevicePresentRectanglesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pRectCount, params->pRects);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pRectCount, params->pRects);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -14834,11 +14631,10 @@ static NTSTATUS thunk64_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
 static NTSTATUS thunk32_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
 {
     struct vkGetPhysicalDevicePresentRectanglesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pRectCount, params->pRects);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pRectCount, params->pRects);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15096,11 +14892,10 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void
 static NTSTATUS thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
 {
     struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pCombinationCount, params->pCombinations);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pCombinationCount, params->pCombinations);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15108,11 +14903,10 @@ static NTSTATUS thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombi
 static NTSTATUS thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
 {
     struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pCombinationCount, params->pCombinations);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pCombinationCount, params->pCombinations);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15131,11 +14925,10 @@ VkResult thunk_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physi
 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
 {
     struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);

-    result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
-    return result;
+    params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15152,11 +14945,10 @@ VkResult thunk_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physi
 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
 {
     struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);

-    result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
-    return result;
+    params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15173,11 +14965,10 @@ VkResult thunk_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physic
 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
 {
     struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);

-    result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
-    return result;
+    params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15192,11 +14983,10 @@ VkResult thunk_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physic
 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
 {
     struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);

-    result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
-    return result;
+    params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15206,13 +14996,12 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
 {
     struct vkGetPhysicalDeviceSurfaceFormats2KHR_params *params = args;
-    VkResult result;
     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);

convert_VkPhysicalDeviceSurfaceInfo2KHR_win_to_host(params->pSurfaceInfo, &pSurfaceInfo_host);
-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pSurfaceInfo_host, params->pSurfaceFormatCount, params->pSurfaceFormats);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pSurfaceInfo_host, params->pSurfaceFormatCount, params->pSurfaceFormats);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15220,13 +15009,12 @@ static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
 {
     struct vkGetPhysicalDeviceSurfaceFormats2KHR_params *params = args;
-    VkResult result;
     VkPhysicalDeviceSurfaceInfo2KHR_host pSurfaceInfo_host;
     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);

convert_VkPhysicalDeviceSurfaceInfo2KHR_win_to_host(params->pSurfaceInfo, &pSurfaceInfo_host);
-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pSurfaceInfo_host, params->pSurfaceFormatCount, params->pSurfaceFormats);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pSurfaceInfo_host, params->pSurfaceFormatCount, params->pSurfaceFormats);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15236,11 +15024,10 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
 {
     struct vkGetPhysicalDeviceSurfaceFormatsKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pSurfaceFormatCount, params->pSurfaceFormats);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pSurfaceFormatCount, params->pSurfaceFormats);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15248,11 +15035,10 @@ static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
 {
     struct vkGetPhysicalDeviceSurfaceFormatsKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pSurfaceFormatCount, params->pSurfaceFormats);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pSurfaceFormatCount, params->pSurfaceFormats);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15262,11 +15048,10 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
 {
     struct vkGetPhysicalDeviceSurfacePresentModesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pPresentModeCount, params->pPresentModes);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pPresentModeCount, params->pPresentModes);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15274,11 +15059,10 @@ static NTSTATUS thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
 {
     struct vkGetPhysicalDeviceSurfacePresentModesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pPresentModeCount, params->pPresentModes);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pPresentModeCount, params->pPresentModes);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15288,11 +15072,10 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
 {
     struct vkGetPhysicalDeviceSurfaceSupportKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %u, 0x%s, %p\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, wine_surface_from_handle(params->surface)->driver_surface, params->pSupported);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, wine_surface_from_handle(params->surface)->driver_surface, params->pSupported);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15300,11 +15083,10 @@ static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
 {
     struct vkGetPhysicalDeviceSurfaceSupportKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %u, 0x%s, %p\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, wine_surface_from_handle(params->surface)->driver_surface, params->pSupported);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, wine_surface_from_handle(params->surface)->driver_surface, params->pSupported);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15314,11 +15096,10 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
 static NTSTATUS thunk64_vkGetPhysicalDeviceToolProperties(void *args)
 {
     struct vkGetPhysicalDeviceToolProperties_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, params->pToolProperties);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, params->pToolProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15326,11 +15107,10 @@ static NTSTATUS thunk64_vkGetPhysicalDeviceToolProperties(void *args)
 static NTSTATUS thunk32_vkGetPhysicalDeviceToolProperties(void *args)
 {
     struct vkGetPhysicalDeviceToolProperties_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, params->pToolProperties);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, params->pToolProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15340,11 +15120,10 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceToolProperties(void *args)
 static NTSTATUS thunk64_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
 {
     struct vkGetPhysicalDeviceToolPropertiesEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolPropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, params->pToolProperties);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolPropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, params->pToolProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15352,11 +15131,10 @@ static NTSTATUS thunk64_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
 static NTSTATUS thunk32_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
 {
     struct vkGetPhysicalDeviceToolPropertiesEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolPropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, params->pToolProperties);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolPropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, params->pToolProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15366,11 +15144,10 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
 static NTSTATUS thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
 {
     struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params *params = args;
-    VkBool32 result;
     TRACE("%p, %u\n", params->physicalDevice, params->queueFamilyIndex);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15378,11 +15155,10 @@ static NTSTATUS thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *arg
 static NTSTATUS thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
 {
     struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params *params = args;
-    VkBool32 result;
     TRACE("%p, %u\n", params->physicalDevice, params->queueFamilyIndex);

-    result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
-    return result;
+    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15392,11 +15168,10 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *arg
 static NTSTATUS thunk64_vkGetPipelineCacheData(void *args)
 {
     struct vkGetPipelineCacheData_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, params->pDataSize, params->pData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, params->pDataSize, params->pData);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15404,11 +15179,10 @@ static NTSTATUS thunk64_vkGetPipelineCacheData(void *args)
 static NTSTATUS thunk32_vkGetPipelineCacheData(void *args)
 {
     struct vkGetPipelineCacheData_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, params->pDataSize, params->pData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, params->pDataSize, params->pData);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15418,11 +15192,10 @@ static NTSTATUS thunk32_vkGetPipelineCacheData(void *args)
 static NTSTATUS thunk64_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
 {
     struct vkGetPipelineExecutableInternalRepresentationsKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15430,13 +15203,12 @@ static NTSTATUS thunk64_vkGetPipelineExecutableInternalRepresentationsKHR(void *
 static NTSTATUS thunk32_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
 {
     struct vkGetPipelineExecutableInternalRepresentationsKHR_params *params = args;
-    VkResult result;
     VkPipelineExecutableInfoKHR_host pExecutableInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);

convert_VkPipelineExecutableInfoKHR_win_to_host(params->pExecutableInfo, &pExecutableInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, &pExecutableInfo_host, params->pInternalRepresentationCount, params->pInternalRepresentations);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, &pExecutableInfo_host, params->pInternalRepresentationCount, params->pInternalRepresentations);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15446,11 +15218,10 @@ static NTSTATUS thunk32_vkGetPipelineExecutableInternalRepresentationsKHR(void *
 static NTSTATUS thunk64_vkGetPipelineExecutablePropertiesKHR(void *args)
 {
     struct vkGetPipelineExecutablePropertiesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15458,13 +15229,12 @@ static NTSTATUS thunk64_vkGetPipelineExecutablePropertiesKHR(void *args)
 static NTSTATUS thunk32_vkGetPipelineExecutablePropertiesKHR(void *args)
 {
     struct vkGetPipelineExecutablePropertiesKHR_params *params = args;
-    VkResult result;
     VkPipelineInfoKHR_host pPipelineInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);

convert_VkPipelineInfoKHR_win_to_host(params->pPipelineInfo, &pPipelineInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, &pPipelineInfo_host, params->pExecutableCount, params->pProperties);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, &pPipelineInfo_host, params->pExecutableCount, params->pProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15474,11 +15244,10 @@ static NTSTATUS thunk32_vkGetPipelineExecutablePropertiesKHR(void *args)
 static NTSTATUS thunk64_vkGetPipelineExecutableStatisticsKHR(void *args)
 {
     struct vkGetPipelineExecutableStatisticsKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15486,13 +15255,12 @@ static NTSTATUS thunk64_vkGetPipelineExecutableStatisticsKHR(void *args)
 static NTSTATUS thunk32_vkGetPipelineExecutableStatisticsKHR(void *args)
 {
     struct vkGetPipelineExecutableStatisticsKHR_params *params = args;
-    VkResult result;
     VkPipelineExecutableInfoKHR_host pExecutableInfo_host;
     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);

convert_VkPipelineExecutableInfoKHR_win_to_host(params->pExecutableInfo, &pExecutableInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, &pExecutableInfo_host, params->pStatisticCount, params->pStatistics);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, &pExecutableInfo_host, params->pStatisticCount, params->pStatistics);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15502,11 +15270,10 @@ static NTSTATUS thunk32_vkGetPipelineExecutableStatisticsKHR(void *args)
 static NTSTATUS thunk64_vkGetPipelinePropertiesEXT(void *args)
 {
     struct vkGetPipelinePropertiesEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %p, %p\n", params->device, params->pPipelineInfo, params->pPipelineProperties);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pPipelineProperties);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pPipelineProperties);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15514,13 +15281,12 @@ static NTSTATUS thunk64_vkGetPipelinePropertiesEXT(void *args)
 static NTSTATUS thunk32_vkGetPipelinePropertiesEXT(void *args)
 {
     struct vkGetPipelinePropertiesEXT_params *params = args;
-    VkResult result;
     VkPipelineInfoEXT_host pPipelineInfo_host;
     TRACE("%p, %p, %p\n", params->device, params->pPipelineInfo, params->pPipelineProperties);

convert_VkPipelineInfoEXT_win_to_host(params->pPipelineInfo, &pPipelineInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, &pPipelineInfo_host, params->pPipelineProperties);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, &pPipelineInfo_host, params->pPipelineProperties);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15578,11 +15344,10 @@ static NTSTATUS thunk32_vkGetPrivateDataEXT(void *args)
 static NTSTATUS thunk64_vkGetQueryPoolResults(void *args)
 {
     struct vkGetQueryPoolResults_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride), params->flags);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetQueryPoolResults(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount, params->dataSize, params->pData, params->stride, params->flags);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetQueryPoolResults(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount, params->dataSize, params->pData, params->stride, params->flags);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15590,11 +15355,10 @@ static NTSTATUS thunk64_vkGetQueryPoolResults(void *args)
 static NTSTATUS thunk32_vkGetQueryPoolResults(void *args)
 {
     struct vkGetQueryPoolResults_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride), params->flags);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetQueryPoolResults(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount, params->dataSize, params->pData, params->stride, params->flags);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetQueryPoolResults(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount, params->dataSize, params->pData, params->stride, params->flags);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15652,11 +15416,10 @@ static NTSTATUS thunk32_vkGetQueueCheckpointDataNV(void *args)
 static NTSTATUS thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
 {
     struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15664,11 +15427,10 @@ static NTSTATUS thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *
 static NTSTATUS thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
 {
     struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15678,11 +15440,10 @@ static NTSTATUS thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *
 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesKHR(void *args)
 {
     struct vkGetRayTracingShaderGroupHandlesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15690,11 +15451,10 @@ static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesKHR(void *args)
 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesKHR(void *args)
 {
     struct vkGetRayTracingShaderGroupHandlesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15704,11 +15464,10 @@ static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesKHR(void *args)
 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesNV(void *args)
 {
     struct vkGetRayTracingShaderGroupHandlesNV_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesNV(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesNV(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15716,11 +15475,10 @@ static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesNV(void *args)
 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesNV(void *args)
 {
     struct vkGetRayTracingShaderGroupHandlesNV_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesNV(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesNV(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15730,11 +15488,10 @@ static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesNV(void *args)
 static NTSTATUS thunk64_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
 {
     struct vkGetRayTracingShaderGroupStackSizeKHR_params *params = args;
-    VkDeviceSize result;
     TRACE("%p, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15742,11 +15499,10 @@ static NTSTATUS thunk64_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
 static NTSTATUS thunk32_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
 {
     struct vkGetRayTracingShaderGroupStackSizeKHR_params *params = args;
-    VkDeviceSize result;
     TRACE("%p, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15780,11 +15536,10 @@ static NTSTATUS thunk32_vkGetRenderAreaGranularity(void *args)
 static NTSTATUS thunk64_vkGetSemaphoreCounterValue(void *args)
 {
     struct vkGetSemaphoreCounterValue_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15792,11 +15547,10 @@ static NTSTATUS thunk64_vkGetSemaphoreCounterValue(void *args)
 static NTSTATUS thunk32_vkGetSemaphoreCounterValue(void *args)
 {
     struct vkGetSemaphoreCounterValue_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15806,11 +15560,10 @@ static NTSTATUS thunk32_vkGetSemaphoreCounterValue(void *args)
 static NTSTATUS thunk64_vkGetSemaphoreCounterValueKHR(void *args)
 {
     struct vkGetSemaphoreCounterValueKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15818,11 +15571,10 @@ static NTSTATUS thunk64_vkGetSemaphoreCounterValueKHR(void *args)
 static NTSTATUS thunk32_vkGetSemaphoreCounterValueKHR(void *args)
 {
     struct vkGetSemaphoreCounterValueKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15832,11 +15584,10 @@ static NTSTATUS thunk32_vkGetSemaphoreCounterValueKHR(void *args)
 static NTSTATUS thunk64_vkGetShaderInfoAMD(void *args)
 {
     struct vkGetShaderInfoAMD_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetShaderInfoAMD(wine_device_from_handle(params->device)->device, params->pipeline, params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetShaderInfoAMD(wine_device_from_handle(params->device)->device, params->pipeline, params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15844,11 +15595,10 @@ static NTSTATUS thunk64_vkGetShaderInfoAMD(void *args)
 static NTSTATUS thunk32_vkGetShaderInfoAMD(void *args)
 {
     struct vkGetShaderInfoAMD_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetShaderInfoAMD(wine_device_from_handle(params->device)->device, params->pipeline, params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetShaderInfoAMD(wine_device_from_handle(params->device)->device, params->pipeline, params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15906,11 +15656,10 @@ static NTSTATUS thunk32_vkGetShaderModuleIdentifierEXT(void *args)
 static NTSTATUS thunk64_vkGetSwapchainImagesKHR(void *args)
 {
     struct vkGetSwapchainImagesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15918,11 +15667,10 @@ static NTSTATUS thunk64_vkGetSwapchainImagesKHR(void *args)
 static NTSTATUS thunk32_vkGetSwapchainImagesKHR(void *args)
 {
     struct vkGetSwapchainImagesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15932,11 +15680,10 @@ static NTSTATUS thunk32_vkGetSwapchainImagesKHR(void *args)
 static NTSTATUS thunk64_vkGetValidationCacheDataEXT(void *args)
 {
     struct vkGetValidationCacheDataEXT_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, params->pDataSize, params->pData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, params->pDataSize, params->pData);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15944,11 +15691,10 @@ static NTSTATUS thunk64_vkGetValidationCacheDataEXT(void *args)
 static NTSTATUS thunk32_vkGetValidationCacheDataEXT(void *args)
 {
     struct vkGetValidationCacheDataEXT_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, params->pDataSize, params->pData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, params->pDataSize, params->pData);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15958,11 +15704,10 @@ static NTSTATUS thunk32_vkGetValidationCacheDataEXT(void *args)
 static NTSTATUS thunk64_vkInitializePerformanceApiINTEL(void *args)
 {
     struct vkInitializePerformanceApiINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->device, params->pInitializeInfo);

-    result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, params->pInitializeInfo);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, params->pInitializeInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15970,11 +15715,10 @@ static NTSTATUS thunk64_vkInitializePerformanceApiINTEL(void *args)
 static NTSTATUS thunk32_vkInitializePerformanceApiINTEL(void *args)
 {
     struct vkInitializePerformanceApiINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->device, params->pInitializeInfo);

-    result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, params->pInitializeInfo);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, params->pInitializeInfo);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -15984,11 +15728,10 @@ static NTSTATUS thunk32_vkInitializePerformanceApiINTEL(void *args)
 static NTSTATUS thunk64_vkInvalidateMappedMemoryRanges(void *args)
 {
     struct vkInvalidateMappedMemoryRanges_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);

-    result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, params->pMemoryRanges);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, params->pMemoryRanges);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -15996,14 +15739,13 @@ static NTSTATUS thunk64_vkInvalidateMappedMemoryRanges(void *args)
 static NTSTATUS thunk32_vkInvalidateMappedMemoryRanges(void *args)
 {
     struct vkInvalidateMappedMemoryRanges_params *params = args;
-    VkResult result;
     VkMappedMemoryRange_host *pMemoryRanges_host;
     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);

pMemoryRanges_host = convert_VkMappedMemoryRange_array_win_to_host(params->pMemoryRanges, params->memoryRangeCount);
-    result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
     free_VkMappedMemoryRange_array(pMemoryRanges_host, params->memoryRangeCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16013,11 +15755,10 @@ static NTSTATUS thunk32_vkInvalidateMappedMemoryRanges(void *args)
 static NTSTATUS thunk64_vkMapMemory(void *args)
 {
     struct vkMapMemory_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, 0x%s, %#x, %p\n", params->device, wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->size), params->flags, params->ppData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkMapMemory(wine_device_from_handle(params->device)->device, params->memory, params->offset, params->size, params->flags, params->ppData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkMapMemory(wine_device_from_handle(params->device)->device, params->memory, params->offset, params->size, params->flags, params->ppData);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16025,11 +15766,10 @@ static NTSTATUS thunk64_vkMapMemory(void *args)
 static NTSTATUS thunk32_vkMapMemory(void *args)
 {
     struct vkMapMemory_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, 0x%s, %#x, %p\n", params->device, wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->size), params->flags, params->ppData);

-    result = wine_device_from_handle(params->device)->funcs.p_vkMapMemory(wine_device_from_handle(params->device)->device, params->memory, params->offset, params->size, params->flags, params->ppData);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkMapMemory(wine_device_from_handle(params->device)->device, params->memory, params->offset, params->size, params->flags, params->ppData);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16039,11 +15779,10 @@ static NTSTATUS thunk32_vkMapMemory(void *args)
 static NTSTATUS thunk64_vkMergePipelineCaches(void *args)
 {
     struct vkMergePipelineCaches_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);

-    result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16051,11 +15790,10 @@ static NTSTATUS thunk64_vkMergePipelineCaches(void *args)
 static NTSTATUS thunk32_vkMergePipelineCaches(void *args)
 {
     struct vkMergePipelineCaches_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);

-    result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16065,11 +15803,10 @@ static NTSTATUS thunk32_vkMergePipelineCaches(void *args)
 static NTSTATUS thunk64_vkMergeValidationCachesEXT(void *args)
 {
     struct vkMergeValidationCachesEXT_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);

-    result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16077,11 +15814,10 @@ static NTSTATUS thunk64_vkMergeValidationCachesEXT(void *args)
 static NTSTATUS thunk32_vkMergeValidationCachesEXT(void *args)
 {
     struct vkMergeValidationCachesEXT_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);

-    result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16115,11 +15851,10 @@ static NTSTATUS thunk32_vkQueueBeginDebugUtilsLabelEXT(void *args)
 static NTSTATUS thunk64_vkQueueBindSparse(void *args)
 {
     struct vkQueueBindSparse_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));

-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBindSparse(wine_queue_from_handle(params->queue)->queue, params->bindInfoCount, params->pBindInfo, params->fence);
-    return result;
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBindSparse(wine_queue_from_handle(params->queue)->queue, params->bindInfoCount, params->pBindInfo, params->fence);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16127,14 +15862,13 @@ static NTSTATUS thunk64_vkQueueBindSparse(void *args)
 static NTSTATUS thunk32_vkQueueBindSparse(void *args)
 {
     struct vkQueueBindSparse_params *params = args;
-    VkResult result;
     VkBindSparseInfo_host *pBindInfo_host;
     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));

pBindInfo_host = convert_VkBindSparseInfo_array_win_to_host(params->pBindInfo, params->bindInfoCount);
-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBindSparse(wine_queue_from_handle(params->queue)->queue, params->bindInfoCount, pBindInfo_host, params->fence);
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBindSparse(wine_queue_from_handle(params->queue)->queue, params->bindInfoCount, pBindInfo_host, params->fence);
     free_VkBindSparseInfo_array(pBindInfo_host, params->bindInfoCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16192,11 +15926,10 @@ static NTSTATUS thunk32_vkQueueInsertDebugUtilsLabelEXT(void *args)
 static NTSTATUS thunk64_vkQueuePresentKHR(void *args)
 {
     struct vkQueuePresentKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->queue, params->pPresentInfo);

-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, params->pPresentInfo);
-    return result;
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, params->pPresentInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16204,11 +15937,10 @@ static NTSTATUS thunk64_vkQueuePresentKHR(void *args)
 static NTSTATUS thunk32_vkQueuePresentKHR(void *args)
 {
     struct vkQueuePresentKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->queue, params->pPresentInfo);

-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, params->pPresentInfo);
-    return result;
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, params->pPresentInfo);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16218,11 +15950,10 @@ static NTSTATUS thunk32_vkQueuePresentKHR(void *args)
 static NTSTATUS thunk64_vkQueueSetPerformanceConfigurationINTEL(void *args)
 {
     struct vkQueueSetPerformanceConfigurationINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));

-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
-    return result;
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16230,11 +15961,10 @@ static NTSTATUS thunk64_vkQueueSetPerformanceConfigurationINTEL(void *args)
 static NTSTATUS thunk32_vkQueueSetPerformanceConfigurationINTEL(void *args)
 {
     struct vkQueueSetPerformanceConfigurationINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));

-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
-    return result;
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16244,14 +15974,13 @@ static NTSTATUS thunk32_vkQueueSetPerformanceConfigurationINTEL(void *args)
 static NTSTATUS thunk64_vkQueueSubmit(void *args)
 {
     struct vkQueueSubmit_params *params = args;
-    VkResult result;
     VkSubmitInfo *pSubmits_host;
     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));

pSubmits_host = convert_VkSubmitInfo_array_win_to_host(params->pSubmits, params->submitCount);
-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
     free_VkSubmitInfo_array(pSubmits_host, params->submitCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16259,14 +15988,13 @@ static NTSTATUS thunk64_vkQueueSubmit(void *args)
 static NTSTATUS thunk32_vkQueueSubmit(void *args)
 {
     struct vkQueueSubmit_params *params = args;
-    VkResult result;
     VkSubmitInfo *pSubmits_host;
     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));

pSubmits_host = convert_VkSubmitInfo_array_win_to_host(params->pSubmits, params->submitCount);
-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
     free_VkSubmitInfo_array(pSubmits_host, params->submitCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16276,14 +16004,13 @@ static NTSTATUS thunk32_vkQueueSubmit(void *args)
 static NTSTATUS thunk64_vkQueueSubmit2(void *args)
 {
     struct vkQueueSubmit2_params *params = args;
-    VkResult result;
     VkSubmitInfo2 *pSubmits_host;
     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));

pSubmits_host = convert_VkSubmitInfo2_array_win_to_host(params->pSubmits, params->submitCount);
-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
     free_VkSubmitInfo2_array(pSubmits_host, params->submitCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16291,14 +16018,13 @@ static NTSTATUS thunk64_vkQueueSubmit2(void *args)
 static NTSTATUS thunk32_vkQueueSubmit2(void *args)
 {
     struct vkQueueSubmit2_params *params = args;
-    VkResult result;
     VkSubmitInfo2_host *pSubmits_host;
     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));

pSubmits_host = convert_VkSubmitInfo2_array_win_to_host(params->pSubmits, params->submitCount);
-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
     free_VkSubmitInfo2_array(pSubmits_host, params->submitCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16308,14 +16034,13 @@ static NTSTATUS thunk32_vkQueueSubmit2(void *args)
 static NTSTATUS thunk64_vkQueueSubmit2KHR(void *args)
 {
     struct vkQueueSubmit2KHR_params *params = args;
-    VkResult result;
     VkSubmitInfo2 *pSubmits_host;
     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));

pSubmits_host = convert_VkSubmitInfo2_array_win_to_host(params->pSubmits, params->submitCount);
-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2KHR(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2KHR(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
     free_VkSubmitInfo2_array(pSubmits_host, params->submitCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16323,14 +16048,13 @@ static NTSTATUS thunk64_vkQueueSubmit2KHR(void *args)
 static NTSTATUS thunk32_vkQueueSubmit2KHR(void *args)
 {
     struct vkQueueSubmit2KHR_params *params = args;
-    VkResult result;
     VkSubmitInfo2_host *pSubmits_host;
     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));

pSubmits_host = convert_VkSubmitInfo2_array_win_to_host(params->pSubmits, params->submitCount);
-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2KHR(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2KHR(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
     free_VkSubmitInfo2_array(pSubmits_host, params->submitCount);
-    return result;
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16340,11 +16064,10 @@ static NTSTATUS thunk32_vkQueueSubmit2KHR(void *args)
 static NTSTATUS thunk64_vkQueueWaitIdle(void *args)
 {
     struct vkQueueWaitIdle_params *params = args;
-    VkResult result;
     TRACE("%p\n", params->queue);

-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
-    return result;
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16352,11 +16075,10 @@ static NTSTATUS thunk64_vkQueueWaitIdle(void *args)
 static NTSTATUS thunk32_vkQueueWaitIdle(void *args)
 {
     struct vkQueueWaitIdle_params *params = args;
-    VkResult result;
     TRACE("%p\n", params->queue);

-    result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
-    return result;
+    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16366,11 +16088,10 @@ static NTSTATUS thunk32_vkQueueWaitIdle(void *args)
 static NTSTATUS thunk64_vkReleasePerformanceConfigurationINTEL(void *args)
 {
     struct vkReleasePerformanceConfigurationINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));

-    result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16378,11 +16099,10 @@ static NTSTATUS thunk64_vkReleasePerformanceConfigurationINTEL(void *args)
 static NTSTATUS thunk32_vkReleasePerformanceConfigurationINTEL(void *args)
 {
     struct vkReleasePerformanceConfigurationINTEL_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));

-    result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16416,11 +16136,10 @@ static NTSTATUS thunk32_vkReleaseProfilingLockKHR(void *args)
 static NTSTATUS thunk64_vkResetCommandBuffer(void *args)
 {
     struct vkResetCommandBuffer_params *params = args;
-    VkResult result;
     TRACE("%p, %#x\n", params->commandBuffer, params->flags);

-    result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
-    return result;
+    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16428,11 +16147,10 @@ static NTSTATUS thunk64_vkResetCommandBuffer(void *args)
 static NTSTATUS thunk32_vkResetCommandBuffer(void *args)
 {
     struct vkResetCommandBuffer_params *params = args;
-    VkResult result;
     TRACE("%p, %#x\n", params->commandBuffer, params->flags);

-    result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
-    return result;
+    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16442,11 +16160,10 @@ static NTSTATUS thunk32_vkResetCommandBuffer(void *args)
 static NTSTATUS thunk64_vkResetCommandPool(void *args)
 {
     struct vkResetCommandPool_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);

-    result = wine_device_from_handle(params->device)->funcs.p_vkResetCommandPool(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkResetCommandPool(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16454,11 +16171,10 @@ static NTSTATUS thunk64_vkResetCommandPool(void *args)
 static NTSTATUS thunk32_vkResetCommandPool(void *args)
 {
     struct vkResetCommandPool_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);

-    result = wine_device_from_handle(params->device)->funcs.p_vkResetCommandPool(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkResetCommandPool(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16468,11 +16184,10 @@ static NTSTATUS thunk32_vkResetCommandPool(void *args)
 static NTSTATUS thunk64_vkResetDescriptorPool(void *args)
 {
     struct vkResetDescriptorPool_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);

-    result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16480,11 +16195,10 @@ static NTSTATUS thunk64_vkResetDescriptorPool(void *args)
 static NTSTATUS thunk32_vkResetDescriptorPool(void *args)
 {
     struct vkResetDescriptorPool_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);

-    result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16494,11 +16208,10 @@ static NTSTATUS thunk32_vkResetDescriptorPool(void *args)
 static NTSTATUS thunk64_vkResetEvent(void *args)
 {
     struct vkResetEvent_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));

-    result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16506,11 +16219,10 @@ static NTSTATUS thunk64_vkResetEvent(void *args)
 static NTSTATUS thunk32_vkResetEvent(void *args)
 {
     struct vkResetEvent_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));

-    result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16520,11 +16232,10 @@ static NTSTATUS thunk32_vkResetEvent(void *args)
 static NTSTATUS thunk64_vkResetFences(void *args)
 {
     struct vkResetFences_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p\n", params->device, params->fenceCount, params->pFences);

-    result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16532,11 +16243,10 @@ static NTSTATUS thunk64_vkResetFences(void *args)
 static NTSTATUS thunk32_vkResetFences(void *args)
 {
     struct vkResetFences_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p\n", params->device, params->fenceCount, params->pFences);

-    result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16594,13 +16304,12 @@ static NTSTATUS thunk32_vkResetQueryPoolEXT(void *args)
 static NTSTATUS thunk64_vkSetDebugUtilsObjectNameEXT(void *args)
 {
     struct vkSetDebugUtilsObjectNameEXT_params *params = args;
-    VkResult result;
     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
     TRACE("%p, %p\n", params->device, params->pNameInfo);

convert_VkDebugUtilsObjectNameInfoEXT_win_to_host(params->pNameInfo, &pNameInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16608,13 +16317,12 @@ static NTSTATUS thunk64_vkSetDebugUtilsObjectNameEXT(void *args)
 static NTSTATUS thunk32_vkSetDebugUtilsObjectNameEXT(void *args)
 {
     struct vkSetDebugUtilsObjectNameEXT_params *params = args;
-    VkResult result;
     VkDebugUtilsObjectNameInfoEXT_host pNameInfo_host;
     TRACE("%p, %p\n", params->device, params->pNameInfo);

convert_VkDebugUtilsObjectNameInfoEXT_win_to_host(params->pNameInfo, &pNameInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16624,13 +16332,12 @@ static NTSTATUS thunk32_vkSetDebugUtilsObjectNameEXT(void *args)
 static NTSTATUS thunk64_vkSetDebugUtilsObjectTagEXT(void *args)
 {
     struct vkSetDebugUtilsObjectTagEXT_params *params = args;
-    VkResult result;
     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
     TRACE("%p, %p\n", params->device, params->pTagInfo);

convert_VkDebugUtilsObjectTagInfoEXT_win_to_host(params->pTagInfo, &pTagInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16638,13 +16345,12 @@ static NTSTATUS thunk64_vkSetDebugUtilsObjectTagEXT(void *args)
 static NTSTATUS thunk32_vkSetDebugUtilsObjectTagEXT(void *args)
 {
     struct vkSetDebugUtilsObjectTagEXT_params *params = args;
-    VkResult result;
     VkDebugUtilsObjectTagInfoEXT_host pTagInfo_host;
     TRACE("%p, %p\n", params->device, params->pTagInfo);

convert_VkDebugUtilsObjectTagInfoEXT_win_to_host(params->pTagInfo, &pTagInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16678,11 +16384,10 @@ static NTSTATUS thunk32_vkSetDeviceMemoryPriorityEXT(void *args)
 static NTSTATUS thunk64_vkSetEvent(void *args)
 {
     struct vkSetEvent_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));

-    result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16690,11 +16395,10 @@ static NTSTATUS thunk64_vkSetEvent(void *args)
 static NTSTATUS thunk32_vkSetEvent(void *args)
 {
     struct vkSetEvent_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));

-    result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16704,11 +16408,10 @@ static NTSTATUS thunk32_vkSetEvent(void *args)
 static NTSTATUS thunk64_vkSetPrivateData(void *args)
 {
     struct vkSetPrivateData_params *params = args;
-    VkResult result;
     TRACE("%p, %#x, 0x%s, 0x%s, 0x%s\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), wine_dbgstr_longlong(params->data));

-    result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateData(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateData(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16716,11 +16419,10 @@ static NTSTATUS thunk64_vkSetPrivateData(void *args)
 static NTSTATUS thunk32_vkSetPrivateData(void *args)
 {
     struct vkSetPrivateData_params *params = args;
-    VkResult result;
     TRACE("%p, %#x, 0x%s, 0x%s, 0x%s\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), wine_dbgstr_longlong(params->data));

-    result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateData(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateData(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16730,11 +16432,10 @@ static NTSTATUS thunk32_vkSetPrivateData(void *args)
 static NTSTATUS thunk64_vkSetPrivateDataEXT(void *args)
 {
     struct vkSetPrivateDataEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %#x, 0x%s, 0x%s, 0x%s\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), wine_dbgstr_longlong(params->data));

-    result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateDataEXT(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateDataEXT(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16742,11 +16443,10 @@ static NTSTATUS thunk64_vkSetPrivateDataEXT(void *args)
 static NTSTATUS thunk32_vkSetPrivateDataEXT(void *args)
 {
     struct vkSetPrivateDataEXT_params *params = args;
-    VkResult result;
     TRACE("%p, %#x, 0x%s, 0x%s, 0x%s\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), wine_dbgstr_longlong(params->data));

-    result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateDataEXT(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateDataEXT(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16756,11 +16456,10 @@ static NTSTATUS thunk32_vkSetPrivateDataEXT(void *args)
 static NTSTATUS thunk64_vkSignalSemaphore(void *args)
 {
     struct vkSignalSemaphore_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->device, params->pSignalInfo);

-    result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, params->pSignalInfo);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, params->pSignalInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16768,13 +16467,12 @@ static NTSTATUS thunk64_vkSignalSemaphore(void *args)
 static NTSTATUS thunk32_vkSignalSemaphore(void *args)
 {
     struct vkSignalSemaphore_params *params = args;
-    VkResult result;
     VkSemaphoreSignalInfo_host pSignalInfo_host;
     TRACE("%p, %p\n", params->device, params->pSignalInfo);

convert_VkSemaphoreSignalInfo_win_to_host(params->pSignalInfo, &pSignalInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, &pSignalInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, &pSignalInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -16784,11 +16482,10 @@ static NTSTATUS thunk32_vkSignalSemaphore(void *args)
 static NTSTATUS thunk64_vkSignalSemaphoreKHR(void *args)
 {
     struct vkSignalSemaphoreKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p\n", params->device, params->pSignalInfo);

-    result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, params->pSignalInfo);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, params->pSignalInfo);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -16796,13 +16493,12 @@ static NTSTATUS thunk64_vkSignalSemaphoreKHR(void *args)
 static NTSTATUS thunk32_vkSignalSemaphoreKHR(void *args)
 {
     struct vkSignalSemaphoreKHR_params *params = args;
-    VkResult result;
     VkSemaphoreSignalInfo_host pSignalInfo_host;
     TRACE("%p, %p\n", params->device, params->pSignalInfo);

convert_VkSemaphoreSignalInfo_win_to_host(params->pSignalInfo, &pSignalInfo_host);
-    result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, &pSignalInfo_host);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, &pSignalInfo_host);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -17016,11 +16712,10 @@ static NTSTATUS thunk32_vkUpdateDescriptorSets(void *args)
 static NTSTATUS thunk64_vkWaitForFences(void *args)
 {
     struct vkWaitForFences_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));

-    result = wine_device_from_handle(params->device)->funcs.p_vkWaitForFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences, params->waitAll, params->timeout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences, params->waitAll, params->timeout);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -17028,11 +16723,10 @@ static NTSTATUS thunk64_vkWaitForFences(void *args)
 static NTSTATUS thunk32_vkWaitForFences(void *args)
 {
     struct vkWaitForFences_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));

-    result = wine_device_from_handle(params->device)->funcs.p_vkWaitForFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences, params->waitAll, params->timeout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences, params->waitAll, params->timeout);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -17042,11 +16736,10 @@ static NTSTATUS thunk32_vkWaitForFences(void *args)
 static NTSTATUS thunk64_vkWaitForPresentKHR(void *args)
 {
     struct vkWaitForPresentKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->presentId), wine_dbgstr_longlong(params->timeout));

-    result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -17054,11 +16747,10 @@ static NTSTATUS thunk64_vkWaitForPresentKHR(void *args)
 static NTSTATUS thunk32_vkWaitForPresentKHR(void *args)
 {
     struct vkWaitForPresentKHR_params *params = args;
-    VkResult result;
     TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->presentId), wine_dbgstr_longlong(params->timeout));

-    result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -17068,11 +16760,10 @@ static NTSTATUS thunk32_vkWaitForPresentKHR(void *args)
 static NTSTATUS thunk64_vkWaitSemaphores(void *args)
 {
     struct vkWaitSemaphores_params *params = args;
-    VkResult result;
     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));

-    result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -17080,11 +16771,10 @@ static NTSTATUS thunk64_vkWaitSemaphores(void *args)
 static NTSTATUS thunk32_vkWaitSemaphores(void *args)
 {
     struct vkWaitSemaphores_params *params = args;
-    VkResult result;
     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));

-    result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -17094,11 +16784,10 @@ static NTSTATUS thunk32_vkWaitSemaphores(void *args)
 static NTSTATUS thunk64_vkWaitSemaphoresKHR(void *args)
 {
     struct vkWaitSemaphoresKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));

-    result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -17106,11 +16795,10 @@ static NTSTATUS thunk64_vkWaitSemaphoresKHR(void *args)
 static NTSTATUS thunk32_vkWaitSemaphoresKHR(void *args)
 {
     struct vkWaitSemaphoresKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));

-    result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */
@@ -17120,11 +16808,10 @@ static NTSTATUS thunk32_vkWaitSemaphoresKHR(void *args)
 static NTSTATUS thunk64_vkWriteAccelerationStructuresPropertiesKHR(void *args)
 {
     struct vkWriteAccelerationStructuresPropertiesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p, %#x, 0x%s, %p, 0x%s\n", params->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));

-    result = wine_device_from_handle(params->device)->funcs.p_vkWriteAccelerationStructuresPropertiesKHR(wine_device_from_handle(params->device)->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->dataSize, params->pData, params->stride);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkWriteAccelerationStructuresPropertiesKHR(wine_device_from_handle(params->device)->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->dataSize, params->pData, params->stride);
+    return STATUS_SUCCESS;
 }

#else /* USE_STRUCT_CONVERSION */
@@ -17132,11 +16819,10 @@ static NTSTATUS thunk64_vkWriteAccelerationStructuresPropertiesKHR(void *args)
 static NTSTATUS thunk32_vkWriteAccelerationStructuresPropertiesKHR(void *args)
 {
     struct vkWriteAccelerationStructuresPropertiesKHR_params *params = args;
-    VkResult result;
     TRACE("%p, %u, %p, %#x, 0x%s, %p, 0x%s\n", params->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));

-    result = wine_device_from_handle(params->device)->funcs.p_vkWriteAccelerationStructuresPropertiesKHR(wine_device_from_handle(params->device)->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->dataSize, params->pData, params->stride);
-    return result;
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkWriteAccelerationStructuresPropertiesKHR(wine_device_from_handle(params->device)->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->dataSize, params->pData, params->stride);
+    return STATUS_SUCCESS;
 }

#endif /* USE_STRUCT_CONVERSION */