1/*
2 *
3 * Copyright (c) 2015-2016 The Khronos Group Inc.
4 * Copyright (c) 2015-2016 Valve Corporation
5 * Copyright (c) 2015-2016 LunarG, Inc.
6 * Copyright (C) 2015 Google Inc.
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 *     http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 * Author: Courtney Goeltzenleuchter <courtney@lunarg.com>
21 * Author: Jon Ashburn <jon@lunarg.com>
22 * Author: Tony Barbour <tony@LunarG.com>
23 * Author: Chia-I Wu <olv@lunarg.com>
24 */
25#define _GNU_SOURCE
26#include <stdlib.h>
27#include <string.h>
28
29#include "vk_loader_platform.h"
30#include "loader.h"
31#include "debug_report.h"
32#include "wsi.h"
33#include "vk_loader_extensions.h"
34#include "gpa_helper.h"
35
36// Trampoline entrypoints are in this file for core Vulkan commands
37
38// Get an instance level or global level entry point address.
39// @param instance
40// @param pName
41// @return
42//    If instance == NULL returns a global level functions only
43//    If instance is valid returns a trampoline entry point for all dispatchable Vulkan
44//    functions both core and extensions.
45LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName) {
46    void *addr;
47
48    addr = globalGetProcAddr(pName);
49    if (instance == VK_NULL_HANDLE || addr != NULL) {
50        return addr;
51    }
52
53    struct loader_instance *ptr_instance = loader_get_instance(instance);
54    if (ptr_instance == NULL) return NULL;
55    // Return trampoline code for non-global entrypoints including any extensions.
56    // Device extensions are returned if a layer or ICD supports the extension.
57    // Instance extensions are returned if the extension is enabled and the
58    // loader or someone else supports the extension
59    return trampolineGetProcAddr(ptr_instance, pName);
60}
61
62// Get a device level or global level entry point address.
63// @param device
64// @param pName
65// @return
66//    If device is valid, returns a device relative entry point for device level
67//    entry points both core and extensions.
68//    Device relative means call down the device chain.
69LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName) {
70    void *addr;
71
72    // For entrypoints that loader must handle (ie non-dispatchable or create object)
73    // make sure the loader entrypoint is returned
74    addr = loader_non_passthrough_gdpa(pName);
75    if (addr) {
76        return addr;
77    }
78
79    // Although CreateDevice is on device chain it's dispatchable object isn't
80    // a VkDevice or child of VkDevice so return NULL.
81    if (!strcmp(pName, "CreateDevice")) return NULL;
82
83    // Return the dispatch table entrypoint for the fastest case
84    const VkLayerDispatchTable *disp_table = *(VkLayerDispatchTable **)device;
85    if (disp_table == NULL) return NULL;
86
87    addr = loader_lookup_device_dispatch_table(disp_table, pName);
88    if (addr) return addr;
89
90    if (disp_table->GetDeviceProcAddr == NULL) return NULL;
91    return disp_table->GetDeviceProcAddr(device, pName);
92}
93
94LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName,
95                                                                                    uint32_t *pPropertyCount,
96                                                                                    VkExtensionProperties *pProperties) {
97    tls_instance = NULL;
98    LOADER_PLATFORM_THREAD_ONCE(&once_init, loader_initialize);
99
100    // We know we need to call at least the terminator
101    VkResult res = VK_SUCCESS;
102    VkEnumerateInstanceExtensionPropertiesChain chain_tail = {
103        .header =
104            {
105                .type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES,
106                .version = VK_CURRENT_CHAIN_VERSION,
107                .size = sizeof(chain_tail),
108            },
109        .pfnNextLayer = &terminator_EnumerateInstanceExtensionProperties,
110        .pNextLink = NULL,
111    };
112    VkEnumerateInstanceExtensionPropertiesChain *chain_head = &chain_tail;
113
114    // Get the implicit layers
115    struct loader_layer_list layers;
116    memset(&layers, 0, sizeof(layers));
117    loader_implicit_layer_scan(NULL, &layers);
118
119    // We'll need to save the dl handles so we can close them later
120    loader_platform_dl_handle *libs = malloc(sizeof(loader_platform_dl_handle) * layers.count);
121    if (libs == NULL) {
122        return VK_ERROR_OUT_OF_HOST_MEMORY;
123    }
124    size_t lib_count = 0;
125
126    // Prepend layers onto the chain if they implment this entry point
127    for (uint32_t i = 0; i < layers.count; ++i) {
128        if (!loader_is_implicit_layer_enabled(NULL, layers.list + i) ||
129            layers.list[i].pre_instance_functions.enumerate_instance_extension_properties[0] == '\0') {
130            continue;
131        }
132
133        loader_platform_dl_handle layer_lib = loader_platform_open_library(layers.list[i].lib_name);
134        libs[lib_count++] = layer_lib;
135        void *pfn = loader_platform_get_proc_address(layer_lib,
136                                                     layers.list[i].pre_instance_functions.enumerate_instance_extension_properties);
137        if (pfn == NULL) {
138            loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
139                       "%s: Unable to resolve symbol \"%s\" in implicit layer library \"%s\"", __FUNCTION__,
140                       layers.list[i].pre_instance_functions.enumerate_instance_extension_properties, layers.list[i].lib_name);
141            continue;
142        }
143
144        VkEnumerateInstanceExtensionPropertiesChain *chain_link = malloc(sizeof(VkEnumerateInstanceExtensionPropertiesChain));
145        if (chain_link == NULL) {
146            res = VK_ERROR_OUT_OF_HOST_MEMORY;
147            break;
148        }
149
150        chain_link->header.type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES;
151        chain_link->header.version = VK_CURRENT_CHAIN_VERSION;
152        chain_link->header.size = sizeof(*chain_link);
153        chain_link->pfnNextLayer = pfn;
154        chain_link->pNextLink = chain_head;
155
156        chain_head = chain_link;
157    }
158
159    // Call down the chain
160    if (res == VK_SUCCESS) {
161        res = chain_head->pfnNextLayer(chain_head->pNextLink, pLayerName, pPropertyCount, pProperties);
162    }
163
164    // Free up the layers
165    loader_delete_layer_properties(NULL, &layers);
166
167    // Tear down the chain
168    while (chain_head != &chain_tail) {
169        VkEnumerateInstanceExtensionPropertiesChain *holder = chain_head;
170        chain_head = (VkEnumerateInstanceExtensionPropertiesChain *)chain_head->pNextLink;
171        free(holder);
172    }
173
174    // Close the dl handles
175    for (size_t i = 0; i < lib_count; ++i) {
176        loader_platform_close_library(libs[i]);
177    }
178    free(libs);
179
180    return res;
181}
182
183LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount,
184                                                                                VkLayerProperties *pProperties) {
185    tls_instance = NULL;
186    LOADER_PLATFORM_THREAD_ONCE(&once_init, loader_initialize);
187
188    // We know we need to call at least the terminator
189    VkResult res = VK_SUCCESS;
190    VkEnumerateInstanceLayerPropertiesChain chain_tail = {
191        .header =
192            {
193                .type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES,
194                .version = VK_CURRENT_CHAIN_VERSION,
195                .size = sizeof(chain_tail),
196            },
197        .pfnNextLayer = &terminator_EnumerateInstanceLayerProperties,
198        .pNextLink = NULL,
199    };
200    VkEnumerateInstanceLayerPropertiesChain *chain_head = &chain_tail;
201
202    // Get the implicit layers
203    struct loader_layer_list layers;
204    memset(&layers, 0, sizeof(layers));
205    loader_implicit_layer_scan(NULL, &layers);
206
207    // We'll need to save the dl handles so we can close them later
208    loader_platform_dl_handle *libs = malloc(sizeof(loader_platform_dl_handle) * layers.count);
209    if (libs == NULL) {
210        return VK_ERROR_OUT_OF_HOST_MEMORY;
211    }
212    size_t lib_count = 0;
213
214    // Prepend layers onto the chain if they implment this entry point
215    for (uint32_t i = 0; i < layers.count; ++i) {
216        if (!loader_is_implicit_layer_enabled(NULL, layers.list + i) ||
217            layers.list[i].pre_instance_functions.enumerate_instance_layer_properties[0] == '\0') {
218            continue;
219        }
220
221        loader_platform_dl_handle layer_lib = loader_platform_open_library(layers.list[i].lib_name);
222        libs[lib_count++] = layer_lib;
223        void *pfn =
224            loader_platform_get_proc_address(layer_lib, layers.list[i].pre_instance_functions.enumerate_instance_layer_properties);
225        if (pfn == NULL) {
226            loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
227                       "%s: Unable to resolve symbol \"%s\" in implicit layer library \"%s\"", __FUNCTION__,
228                       layers.list[i].pre_instance_functions.enumerate_instance_layer_properties, layers.list[i].lib_name);
229            continue;
230        }
231
232        VkEnumerateInstanceLayerPropertiesChain *chain_link = malloc(sizeof(VkEnumerateInstanceLayerPropertiesChain));
233        if (chain_link == NULL) {
234            res = VK_ERROR_OUT_OF_HOST_MEMORY;
235            break;
236        }
237
238        chain_link->header.type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES;
239        chain_link->header.version = VK_CURRENT_CHAIN_VERSION;
240        chain_link->header.size = sizeof(*chain_link);
241        chain_link->pfnNextLayer = pfn;
242        chain_link->pNextLink = chain_head;
243
244        chain_head = chain_link;
245    }
246
247    // Call down the chain
248    if (res == VK_SUCCESS) {
249        res = chain_head->pfnNextLayer(chain_head->pNextLink, pPropertyCount, pProperties);
250    }
251
252    // Free up the layers
253    loader_delete_layer_properties(NULL, &layers);
254
255    // Tear down the chain
256    while (chain_head != &chain_tail) {
257        VkEnumerateInstanceLayerPropertiesChain *holder = chain_head;
258        chain_head = (VkEnumerateInstanceLayerPropertiesChain *)chain_head->pNextLink;
259        free(holder);
260    }
261
262    // Close the dl handles
263    for (size_t i = 0; i < lib_count; ++i) {
264        loader_platform_close_library(libs[i]);
265    }
266    free(libs);
267
268    return res;
269}
270
271LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
272                                                              const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
273    struct loader_instance *ptr_instance = NULL;
274    VkInstance created_instance = VK_NULL_HANDLE;
275    bool loaderLocked = false;
276    VkResult res = VK_ERROR_INITIALIZATION_FAILED;
277
278    LOADER_PLATFORM_THREAD_ONCE(&once_init, loader_initialize);
279
280    // Fail if the requested Vulkan apiVersion is > 1.0 since the loader only supports 1.0.
281    // Having pCreateInfo == NULL, pCreateInfo->pApplication == NULL, or
282    // pCreateInfo->pApplicationInfo->apiVersion == 0 all indicate that the application is
283    // only requesting a 1.0 instance, which this loader will always support.
284    uint32_t loader_major_version = 1;
285    uint32_t loader_minor_version = 0;
286    if (NULL != pCreateInfo && NULL != pCreateInfo->pApplicationInfo &&
287        pCreateInfo->pApplicationInfo->apiVersion >= VK_MAKE_VERSION(loader_major_version, loader_minor_version + 1, 0)) {
288        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
289                   "vkCreateInstance:  Called with invalid API version %d.%d.  Loader only supports %d.%d",
290                   VK_VERSION_MAJOR(pCreateInfo->pApplicationInfo->apiVersion),
291                   VK_VERSION_MINOR(pCreateInfo->pApplicationInfo->apiVersion), loader_major_version, loader_minor_version);
292        res = VK_ERROR_INCOMPATIBLE_DRIVER;
293        goto out;
294    }
295
296#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
297    {
298#else
299    if (pAllocator) {
300        ptr_instance = (struct loader_instance *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(struct loader_instance),
301                                                                           sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
302    } else {
303#endif
304        ptr_instance = (struct loader_instance *)malloc(sizeof(struct loader_instance));
305    }
306
307    VkInstanceCreateInfo ici = *pCreateInfo;
308
309    if (ptr_instance == NULL) {
310        res = VK_ERROR_OUT_OF_HOST_MEMORY;
311        goto out;
312    }
313
314    tls_instance = ptr_instance;
315    loader_platform_thread_lock_mutex(&loader_lock);
316    loaderLocked = true;
317    memset(ptr_instance, 0, sizeof(struct loader_instance));
318    if (pAllocator) {
319        ptr_instance->alloc_callbacks = *pAllocator;
320    }
321
322    // Look for one or more debug report create info structures
323    // and setup a callback(s) for each one found.
324    ptr_instance->num_tmp_callbacks = 0;
325    ptr_instance->tmp_dbg_create_infos = NULL;
326    ptr_instance->tmp_callbacks = NULL;
327    if (util_CopyDebugReportCreateInfos(pCreateInfo->pNext, pAllocator, &ptr_instance->num_tmp_callbacks,
328                                        &ptr_instance->tmp_dbg_create_infos, &ptr_instance->tmp_callbacks)) {
329        // One or more were found, but allocation failed.  Therefore, clean up
330        // and fail this function:
331        res = VK_ERROR_OUT_OF_HOST_MEMORY;
332        goto out;
333    } else if (ptr_instance->num_tmp_callbacks > 0) {
334        // Setup the temporary callback(s) here to catch early issues:
335        if (util_CreateDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
336                                            ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks)) {
337            // Failure of setting up one or more of the callback.  Therefore,
338            // clean up and fail this function:
339            res = VK_ERROR_OUT_OF_HOST_MEMORY;
340            goto out;
341        }
342    }
343
344    // Due to implicit layers need to get layer list even if
345    // enabledLayerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
346    // get layer list via loader_layer_scan().
347    memset(&ptr_instance->instance_layer_list, 0, sizeof(ptr_instance->instance_layer_list));
348    loader_layer_scan(ptr_instance, &ptr_instance->instance_layer_list);
349
350    // Validate the app requested layers to be enabled
351    if (pCreateInfo->enabledLayerCount > 0) {
352        res = loader_validate_layers(ptr_instance, pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames,
353                                     &ptr_instance->instance_layer_list);
354        if (res != VK_SUCCESS) {
355            goto out;
356        }
357    }
358
359    // Scan/discover all ICD libraries
360    memset(&ptr_instance->icd_tramp_list, 0, sizeof(ptr_instance->icd_tramp_list));
361    res = loader_icd_scan(ptr_instance, &ptr_instance->icd_tramp_list);
362    if (res != VK_SUCCESS) {
363        goto out;
364    }
365
366    // Get extensions from all ICD's, merge so no duplicates, then validate
367    res = loader_get_icd_loader_instance_extensions(ptr_instance, &ptr_instance->icd_tramp_list, &ptr_instance->ext_list);
368    if (res != VK_SUCCESS) {
369        goto out;
370    }
371    res = loader_validate_instance_extensions(ptr_instance, &ptr_instance->ext_list, &ptr_instance->instance_layer_list, &ici);
372    if (res != VK_SUCCESS) {
373        goto out;
374    }
375
376    ptr_instance->disp = loader_instance_heap_alloc(ptr_instance, sizeof(struct loader_instance_dispatch_table),
377                                                    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
378    if (ptr_instance->disp == NULL) {
379        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
380                   "vkCreateInstance:  Failed to allocate Loader's full Instance dispatch table.");
381        res = VK_ERROR_OUT_OF_HOST_MEMORY;
382        goto out;
383    }
384    memcpy(&ptr_instance->disp->layer_inst_disp, &instance_disp, sizeof(instance_disp));
385
386    ptr_instance->next = loader.instances;
387    loader.instances = ptr_instance;
388
389    // Activate any layers on instance chain
390    res = loader_enable_instance_layers(ptr_instance, &ici, &ptr_instance->instance_layer_list);
391    if (res != VK_SUCCESS) {
392        goto out;
393    }
394
395    created_instance = (VkInstance)ptr_instance;
396    res = loader_create_instance_chain(&ici, pAllocator, ptr_instance, &created_instance);
397
398    if (res == VK_SUCCESS) {
399        memset(ptr_instance->enabled_known_extensions.padding, 0, sizeof(uint64_t) * 4);
400
401        wsi_create_instance(ptr_instance, &ici);
402        debug_report_create_instance(ptr_instance, &ici);
403        extensions_create_instance(ptr_instance, &ici);
404
405        *pInstance = created_instance;
406
407        // Finally have the layers in place and everyone has seen
408        // the CreateInstance command go by. This allows the layer's
409        // GetInstanceProcAddr functions to return valid extension functions
410        // if enabled.
411        loader_activate_instance_layer_extensions(ptr_instance, *pInstance);
412    }
413
414out:
415
416    if (NULL != ptr_instance) {
417        if (res != VK_SUCCESS) {
418            if (NULL != ptr_instance->next) {
419                loader.instances = ptr_instance->next;
420            }
421            if (NULL != ptr_instance->disp) {
422                loader_instance_heap_free(ptr_instance, ptr_instance->disp);
423            }
424            if (ptr_instance->num_tmp_callbacks > 0) {
425                util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
426                                                 ptr_instance->tmp_callbacks);
427                util_FreeDebugReportCreateInfos(pAllocator, ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks);
428            }
429
430            if (NULL != ptr_instance->expanded_activated_layer_list.list) {
431                loader_deactivate_layers(ptr_instance, NULL, &ptr_instance->expanded_activated_layer_list);
432            }
433            if (NULL != ptr_instance->app_activated_layer_list.list) {
434                loader_destroy_layer_list(ptr_instance, NULL, &ptr_instance->app_activated_layer_list);
435            }
436
437            loader_delete_layer_properties(ptr_instance, &ptr_instance->instance_layer_list);
438            loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_tramp_list);
439            loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&ptr_instance->ext_list);
440
441            loader_instance_heap_free(ptr_instance, ptr_instance);
442        } else {
443            // Remove temporary debug_report callback
444            util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
445                                             ptr_instance->tmp_callbacks);
446        }
447
448        if (loaderLocked) {
449            loader_platform_thread_unlock_mutex(&loader_lock);
450        }
451    }
452
453    return res;
454}
455
456LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
457    const VkLayerInstanceDispatchTable *disp;
458    struct loader_instance *ptr_instance = NULL;
459    bool callback_setup = false;
460
461    if (instance == VK_NULL_HANDLE) {
462        return;
463    }
464
465    disp = loader_get_instance_layer_dispatch(instance);
466
467    loader_platform_thread_lock_mutex(&loader_lock);
468
469    ptr_instance = loader_get_instance(instance);
470
471    if (pAllocator) {
472        ptr_instance->alloc_callbacks = *pAllocator;
473    }
474
475    if (ptr_instance->num_tmp_callbacks > 0) {
476        // Setup the temporary callback(s) here to catch cleanup issues:
477        if (!util_CreateDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
478                                             ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks)) {
479            callback_setup = true;
480        }
481    }
482
483    disp->DestroyInstance(instance, pAllocator);
484
485    if (NULL != ptr_instance->expanded_activated_layer_list.list) {
486        loader_deactivate_layers(ptr_instance, NULL, &ptr_instance->expanded_activated_layer_list);
487    }
488    if (NULL != ptr_instance->app_activated_layer_list.list) {
489        loader_destroy_layer_list(ptr_instance, NULL, &ptr_instance->app_activated_layer_list);
490    }
491
492    if (ptr_instance->phys_devs_tramp) {
493        for (uint32_t i = 0; i < ptr_instance->phys_dev_count_tramp; i++) {
494            loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_tramp[i]);
495        }
496        loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_tramp);
497    }
498
499    if (ptr_instance->phys_dev_groups_tramp) {
500        for (uint32_t i = 0; i < ptr_instance->phys_dev_group_count_tramp; i++) {
501            loader_instance_heap_free(ptr_instance, ptr_instance->phys_dev_groups_tramp[i]);
502        }
503        loader_instance_heap_free(ptr_instance, ptr_instance->phys_dev_groups_tramp);
504    }
505
506    if (callback_setup) {
507        util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks, ptr_instance->tmp_callbacks);
508        util_FreeDebugReportCreateInfos(pAllocator, ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks);
509    }
510    loader_instance_heap_free(ptr_instance, ptr_instance->disp);
511    loader_instance_heap_free(ptr_instance, ptr_instance);
512    loader_platform_thread_unlock_mutex(&loader_lock);
513}
514
515LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
516                                                                        VkPhysicalDevice *pPhysicalDevices) {
517    VkResult res = VK_SUCCESS;
518    uint32_t count;
519    uint32_t i;
520    struct loader_instance *inst;
521
522    loader_platform_thread_lock_mutex(&loader_lock);
523
524    inst = loader_get_instance(instance);
525    if (NULL == inst) {
526        res = VK_ERROR_INITIALIZATION_FAILED;
527        goto out;
528    }
529
530    if (NULL == pPhysicalDeviceCount) {
531        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
532                   "vkEnumeratePhysicalDevices: Received NULL pointer for physical device count return value.");
533        res = VK_ERROR_INITIALIZATION_FAILED;
534        goto out;
535    }
536
537    // Setup the trampoline loader physical devices.  This will actually
538    // call down and setup the terminator loader physical devices during the
539    // process.
540    VkResult setup_res = setupLoaderTrampPhysDevs(instance);
541    if (setup_res != VK_SUCCESS && setup_res != VK_INCOMPLETE) {
542        res = setup_res;
543        goto out;
544    }
545
546    count = inst->phys_dev_count_tramp;
547
548    // Wrap the PhysDev object for loader usage, return wrapped objects
549    if (NULL != pPhysicalDevices) {
550        if (inst->phys_dev_count_tramp > *pPhysicalDeviceCount) {
551            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
552                       "vkEnumeratePhysicalDevices: Trimming device count down"
553                       " by application request from %d to %d physical devices",
554                       inst->phys_dev_count_tramp, *pPhysicalDeviceCount);
555            count = *pPhysicalDeviceCount;
556            res = VK_INCOMPLETE;
557        }
558        for (i = 0; i < count; i++) {
559            pPhysicalDevices[i] = (VkPhysicalDevice)inst->phys_devs_tramp[i];
560        }
561    }
562
563    *pPhysicalDeviceCount = count;
564
565out:
566
567    loader_platform_thread_unlock_mutex(&loader_lock);
568    return res;
569}
570
571LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
572                                                                     VkPhysicalDeviceFeatures *pFeatures) {
573    const VkLayerInstanceDispatchTable *disp;
574    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
575    disp = loader_get_instance_layer_dispatch(physicalDevice);
576    disp->GetPhysicalDeviceFeatures(unwrapped_phys_dev, pFeatures);
577}
578
579LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
580                                                                             VkFormatProperties *pFormatInfo) {
581    const VkLayerInstanceDispatchTable *disp;
582    VkPhysicalDevice unwrapped_pd = loader_unwrap_physical_device(physicalDevice);
583    disp = loader_get_instance_layer_dispatch(physicalDevice);
584    disp->GetPhysicalDeviceFormatProperties(unwrapped_pd, format, pFormatInfo);
585}
586
587LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
588    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage,
589    VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties) {
590    const VkLayerInstanceDispatchTable *disp;
591    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
592    disp = loader_get_instance_layer_dispatch(physicalDevice);
593    return disp->GetPhysicalDeviceImageFormatProperties(unwrapped_phys_dev, format, type, tiling, usage, flags,
594                                                        pImageFormatProperties);
595}
596
597LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
598                                                                       VkPhysicalDeviceProperties *pProperties) {
599    const VkLayerInstanceDispatchTable *disp;
600    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
601    disp = loader_get_instance_layer_dispatch(physicalDevice);
602    disp->GetPhysicalDeviceProperties(unwrapped_phys_dev, pProperties);
603}
604
605LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
606                                                                                  uint32_t *pQueueFamilyPropertyCount,
607                                                                                  VkQueueFamilyProperties *pQueueProperties) {
608    const VkLayerInstanceDispatchTable *disp;
609    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
610    disp = loader_get_instance_layer_dispatch(physicalDevice);
611    disp->GetPhysicalDeviceQueueFamilyProperties(unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueProperties);
612}
613
614LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
615                                                                             VkPhysicalDeviceMemoryProperties *pMemoryProperties) {
616    const VkLayerInstanceDispatchTable *disp;
617    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
618    disp = loader_get_instance_layer_dispatch(physicalDevice);
619    disp->GetPhysicalDeviceMemoryProperties(unwrapped_phys_dev, pMemoryProperties);
620}
621
622LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
623                                                            const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
624    VkResult res;
625    struct loader_physical_device_tramp *phys_dev = NULL;
626    struct loader_device *dev = NULL;
627    struct loader_instance *inst = NULL;
628
629    assert(pCreateInfo->queueCreateInfoCount >= 1);
630
631    loader_platform_thread_lock_mutex(&loader_lock);
632
633    phys_dev = (struct loader_physical_device_tramp *)physicalDevice;
634    inst = (struct loader_instance *)phys_dev->this_instance;
635
636    // Get the physical device (ICD) extensions
637    struct loader_extension_list icd_exts;
638    icd_exts.list = NULL;
639    res = loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties));
640    if (VK_SUCCESS != res) {
641        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to create ICD extension list");
642        goto out;
643    }
644
645    res = loader_add_device_extensions(inst, inst->disp->layer_inst_disp.EnumerateDeviceExtensionProperties, phys_dev->phys_dev,
646                                       "Unknown", &icd_exts);
647    if (res != VK_SUCCESS) {
648        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to add extensions to list");
649        goto out;
650    }
651
652    // Make sure requested extensions to be enabled are supported
653    res = loader_validate_device_extensions(phys_dev, &inst->expanded_activated_layer_list, &icd_exts, pCreateInfo);
654    if (res != VK_SUCCESS) {
655        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to validate extensions in list");
656        goto out;
657    }
658
659    dev = loader_create_logical_device(inst, pAllocator);
660    if (dev == NULL) {
661        res = VK_ERROR_OUT_OF_HOST_MEMORY;
662        goto out;
663    }
664
665    // Copy the application enabled instance layer list into the device
666    if (NULL != inst->app_activated_layer_list.list) {
667        dev->app_activated_layer_list.capacity = inst->app_activated_layer_list.capacity;
668        dev->app_activated_layer_list.count = inst->app_activated_layer_list.count;
669        dev->app_activated_layer_list.list =
670            loader_device_heap_alloc(dev, inst->app_activated_layer_list.capacity, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
671        if (dev->app_activated_layer_list.list == NULL) {
672            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
673                       "vkCreateDevice:  Failed to allocate application activated layer list of size %d.",
674                       inst->app_activated_layer_list.capacity);
675            res = VK_ERROR_OUT_OF_HOST_MEMORY;
676            goto out;
677        }
678        memcpy(dev->app_activated_layer_list.list, inst->app_activated_layer_list.list,
679               sizeof(*dev->app_activated_layer_list.list) * dev->app_activated_layer_list.count);
680    } else {
681        dev->app_activated_layer_list.capacity = 0;
682        dev->app_activated_layer_list.count = 0;
683        dev->app_activated_layer_list.list = NULL;
684    }
685
686    // Copy the expanded enabled instance layer list into the device
687    if (NULL != inst->expanded_activated_layer_list.list) {
688        dev->expanded_activated_layer_list.capacity = inst->expanded_activated_layer_list.capacity;
689        dev->expanded_activated_layer_list.count = inst->expanded_activated_layer_list.count;
690        dev->expanded_activated_layer_list.list =
691            loader_device_heap_alloc(dev, inst->expanded_activated_layer_list.capacity, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
692        if (dev->expanded_activated_layer_list.list == NULL) {
693            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
694                       "vkCreateDevice:  Failed to allocate expanded activated layer list of size %d.",
695                       inst->expanded_activated_layer_list.capacity);
696            res = VK_ERROR_OUT_OF_HOST_MEMORY;
697            goto out;
698        }
699        memcpy(dev->expanded_activated_layer_list.list, inst->expanded_activated_layer_list.list,
700               sizeof(*dev->expanded_activated_layer_list.list) * dev->expanded_activated_layer_list.count);
701    } else {
702        dev->expanded_activated_layer_list.capacity = 0;
703        dev->expanded_activated_layer_list.count = 0;
704        dev->expanded_activated_layer_list.list = NULL;
705    }
706
707    res = loader_create_device_chain(phys_dev, pCreateInfo, pAllocator, inst, dev);
708    if (res != VK_SUCCESS) {
709        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to create device chain.");
710        goto out;
711    }
712
713    *pDevice = dev->chain_device;
714
715    // Initialize any device extension dispatch entry's from the instance list
716    loader_init_dispatch_dev_ext(inst, dev);
717
718    // Initialize WSI device extensions as part of core dispatch since loader
719    // has dedicated trampoline code for these*/
720    loader_init_device_extension_dispatch_table(&dev->loader_dispatch, dev->loader_dispatch.core_dispatch.GetDeviceProcAddr,
721                                                *pDevice);
722
723out:
724
725    // Failure cleanup
726    if (VK_SUCCESS != res) {
727        if (NULL != dev) {
728            loader_destroy_logical_device(inst, dev, pAllocator);
729        }
730    }
731
732    if (NULL != icd_exts.list) {
733        loader_destroy_generic_list(inst, (struct loader_generic_list *)&icd_exts);
734    }
735    loader_platform_thread_unlock_mutex(&loader_lock);
736    return res;
737}
738
739LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
740    const VkLayerDispatchTable *disp;
741    struct loader_device *dev;
742
743    if (device == VK_NULL_HANDLE) {
744        return;
745    }
746
747    loader_platform_thread_lock_mutex(&loader_lock);
748
749    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, NULL);
750    const struct loader_instance *inst = icd_term->this_instance;
751    disp = loader_get_dispatch(device);
752
753    disp->DestroyDevice(device, pAllocator);
754    dev->chain_device = NULL;
755    dev->icd_device = NULL;
756    loader_remove_logical_device(inst, icd_term, dev, pAllocator);
757
758    loader_platform_thread_unlock_mutex(&loader_lock);
759}
760
761LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
762                                                                                  const char *pLayerName, uint32_t *pPropertyCount,
763                                                                                  VkExtensionProperties *pProperties) {
764    VkResult res = VK_SUCCESS;
765    struct loader_physical_device_tramp *phys_dev;
766    phys_dev = (struct loader_physical_device_tramp *)physicalDevice;
767
768    loader_platform_thread_lock_mutex(&loader_lock);
769
770    // If pLayerName == NULL, then querying ICD extensions, pass this call
771    // down the instance chain which will terminate in the ICD. This allows
772    // layers to filter the extensions coming back up the chain.
773    // If pLayerName != NULL then get layer extensions from manifest file.
774    if (pLayerName == NULL || strlen(pLayerName) == 0) {
775        const VkLayerInstanceDispatchTable *disp;
776
777        disp = loader_get_instance_layer_dispatch(physicalDevice);
778        res = disp->EnumerateDeviceExtensionProperties(phys_dev->phys_dev, NULL, pPropertyCount, pProperties);
779    } else {
780        uint32_t count;
781        uint32_t copy_size;
782        const struct loader_instance *inst = phys_dev->this_instance;
783        struct loader_device_extension_list *dev_ext_list = NULL;
784        struct loader_device_extension_list local_ext_list;
785        memset(&local_ext_list, 0, sizeof(local_ext_list));
786        if (vk_string_validate(MaxLoaderStringLength, pLayerName) == VK_STRING_ERROR_NONE) {
787            for (uint32_t i = 0; i < inst->instance_layer_list.count; i++) {
788                struct loader_layer_properties *props = &inst->instance_layer_list.list[i];
789                if (strcmp(props->info.layerName, pLayerName) == 0) {
790                    dev_ext_list = &props->device_extension_list;
791                }
792            }
793
794            count = (dev_ext_list == NULL) ? 0 : dev_ext_list->count;
795            if (pProperties == NULL) {
796                *pPropertyCount = count;
797                loader_destroy_generic_list(inst, (struct loader_generic_list *)&local_ext_list);
798                loader_platform_thread_unlock_mutex(&loader_lock);
799                return VK_SUCCESS;
800            }
801
802            copy_size = *pPropertyCount < count ? *pPropertyCount : count;
803            for (uint32_t i = 0; i < copy_size; i++) {
804                memcpy(&pProperties[i], &dev_ext_list->list[i].props, sizeof(VkExtensionProperties));
805            }
806            *pPropertyCount = copy_size;
807
808            loader_destroy_generic_list(inst, (struct loader_generic_list *)&local_ext_list);
809            if (copy_size < count) {
810                loader_platform_thread_unlock_mutex(&loader_lock);
811                return VK_INCOMPLETE;
812            }
813        } else {
814            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
815                       "vkEnumerateDeviceExtensionProperties:  pLayerName "
816                       "is too long or is badly formed");
817            loader_platform_thread_unlock_mutex(&loader_lock);
818            return VK_ERROR_EXTENSION_NOT_PRESENT;
819        }
820    }
821
822    loader_platform_thread_unlock_mutex(&loader_lock);
823    return res;
824}
825
826LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
827                                                                              uint32_t *pPropertyCount,
828                                                                              VkLayerProperties *pProperties) {
829    uint32_t copy_size;
830    struct loader_physical_device_tramp *phys_dev;
831    struct loader_layer_list *enabled_layers, layers_list;
832    memset(&layers_list, 0, sizeof(layers_list));
833    loader_platform_thread_lock_mutex(&loader_lock);
834
835    // Don't dispatch this call down the instance chain, want all device layers
836    // enumerated and instance chain may not contain all device layers
837    // TODO re-evaluate the above statement we maybe able to start calling
838    // down the chain
839
840    phys_dev = (struct loader_physical_device_tramp *)physicalDevice;
841    const struct loader_instance *inst = phys_dev->this_instance;
842
843    uint32_t count = inst->app_activated_layer_list.count;
844    if (count == 0 || pProperties == NULL) {
845        *pPropertyCount = count;
846        loader_platform_thread_unlock_mutex(&loader_lock);
847        return VK_SUCCESS;
848    }
849    enabled_layers = (struct loader_layer_list *)&inst->app_activated_layer_list;
850
851    copy_size = (*pPropertyCount < count) ? *pPropertyCount : count;
852    for (uint32_t i = 0; i < copy_size; i++) {
853        memcpy(&pProperties[i], &(enabled_layers->list[i].info), sizeof(VkLayerProperties));
854    }
855    *pPropertyCount = copy_size;
856
857    if (copy_size < count) {
858        loader_platform_thread_unlock_mutex(&loader_lock);
859        return VK_INCOMPLETE;
860    }
861
862    loader_platform_thread_unlock_mutex(&loader_lock);
863    return VK_SUCCESS;
864}
865
866LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex,
867                                                          VkQueue *pQueue) {
868    const VkLayerDispatchTable *disp;
869
870    disp = loader_get_dispatch(device);
871
872    disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
873    loader_set_dispatch(*pQueue, disp);
874}
875
876LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits,
877                                                           VkFence fence) {
878    const VkLayerDispatchTable *disp;
879
880    disp = loader_get_dispatch(queue);
881
882    return disp->QueueSubmit(queue, submitCount, pSubmits, fence);
883}
884
885LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) {
886    const VkLayerDispatchTable *disp;
887
888    disp = loader_get_dispatch(queue);
889
890    return disp->QueueWaitIdle(queue);
891}
892
893LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) {
894    const VkLayerDispatchTable *disp;
895
896    disp = loader_get_dispatch(device);
897
898    return disp->DeviceWaitIdle(device);
899}
900
901LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
902                                                              const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) {
903    const VkLayerDispatchTable *disp;
904
905    disp = loader_get_dispatch(device);
906
907    return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
908}
909
910LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory mem,
911                                                      const VkAllocationCallbacks *pAllocator) {
912    const VkLayerDispatchTable *disp;
913
914    disp = loader_get_dispatch(device);
915
916    disp->FreeMemory(device, mem, pAllocator);
917}
918
919LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset,
920                                                         VkDeviceSize size, VkFlags flags, void **ppData) {
921    const VkLayerDispatchTable *disp;
922
923    disp = loader_get_dispatch(device);
924
925    return disp->MapMemory(device, mem, offset, size, flags, ppData);
926}
927
928LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory mem) {
929    const VkLayerDispatchTable *disp;
930
931    disp = loader_get_dispatch(device);
932
933    disp->UnmapMemory(device, mem);
934}
935
936LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
937                                                                       const VkMappedMemoryRange *pMemoryRanges) {
938    const VkLayerDispatchTable *disp;
939
940    disp = loader_get_dispatch(device);
941
942    return disp->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
943}
944
945LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
946                                                                            const VkMappedMemoryRange *pMemoryRanges) {
947    const VkLayerDispatchTable *disp;
948
949    disp = loader_get_dispatch(device);
950
951    return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
952}
953
954LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
955                                                                     VkDeviceSize *pCommittedMemoryInBytes) {
956    const VkLayerDispatchTable *disp;
957
958    disp = loader_get_dispatch(device);
959
960    disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
961}
962
963LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem,
964                                                                VkDeviceSize offset) {
965    const VkLayerDispatchTable *disp;
966
967    disp = loader_get_dispatch(device);
968
969    return disp->BindBufferMemory(device, buffer, mem, offset);
970}
971
972LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem,
973                                                               VkDeviceSize offset) {
974    const VkLayerDispatchTable *disp;
975
976    disp = loader_get_dispatch(device);
977
978    return disp->BindImageMemory(device, image, mem, offset);
979}
980
981LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
982                                                                       VkMemoryRequirements *pMemoryRequirements) {
983    const VkLayerDispatchTable *disp;
984
985    disp = loader_get_dispatch(device);
986
987    disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
988}
989
990LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image,
991                                                                      VkMemoryRequirements *pMemoryRequirements) {
992    const VkLayerDispatchTable *disp;
993
994    disp = loader_get_dispatch(device);
995
996    disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
997}
998
999LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1000vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
1001                                   VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
1002    const VkLayerDispatchTable *disp;
1003
1004    disp = loader_get_dispatch(device);
1005
1006    disp->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
1007}
1008
1009LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
1010    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage,
1011    VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties) {
1012    const VkLayerInstanceDispatchTable *disp;
1013    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
1014    disp = loader_get_instance_layer_dispatch(physicalDevice);
1015
1016    disp->GetPhysicalDeviceSparseImageFormatProperties(unwrapped_phys_dev, format, type, samples, usage, tiling, pPropertyCount,
1017                                                       pProperties);
1018}
1019
1020LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
1021                                                               const VkBindSparseInfo *pBindInfo, VkFence fence) {
1022    const VkLayerDispatchTable *disp;
1023
1024    disp = loader_get_dispatch(queue);
1025
1026    return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
1027}
1028
1029LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
1030                                                           const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
1031    const VkLayerDispatchTable *disp;
1032
1033    disp = loader_get_dispatch(device);
1034
1035    return disp->CreateFence(device, pCreateInfo, pAllocator, pFence);
1036}
1037
1038LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) {
1039    const VkLayerDispatchTable *disp;
1040
1041    disp = loader_get_dispatch(device);
1042
1043    disp->DestroyFence(device, fence, pAllocator);
1044}
1045
1046LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) {
1047    const VkLayerDispatchTable *disp;
1048
1049    disp = loader_get_dispatch(device);
1050
1051    return disp->ResetFences(device, fenceCount, pFences);
1052}
1053
1054LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) {
1055    const VkLayerDispatchTable *disp;
1056
1057    disp = loader_get_dispatch(device);
1058
1059    return disp->GetFenceStatus(device, fence);
1060}
1061
1062LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences,
1063                                                             VkBool32 waitAll, uint64_t timeout) {
1064    const VkLayerDispatchTable *disp;
1065
1066    disp = loader_get_dispatch(device);
1067
1068    return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
1069}
1070
1071LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
1072                                                               const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) {
1073    const VkLayerDispatchTable *disp;
1074
1075    disp = loader_get_dispatch(device);
1076
1077    return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
1078}
1079
1080LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
1081                                                            const VkAllocationCallbacks *pAllocator) {
1082    const VkLayerDispatchTable *disp;
1083
1084    disp = loader_get_dispatch(device);
1085
1086    disp->DestroySemaphore(device, semaphore, pAllocator);
1087}
1088
1089LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
1090                                                           const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
1091    const VkLayerDispatchTable *disp;
1092
1093    disp = loader_get_dispatch(device);
1094
1095    return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
1096}
1097
1098LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) {
1099    const VkLayerDispatchTable *disp;
1100
1101    disp = loader_get_dispatch(device);
1102
1103    disp->DestroyEvent(device, event, pAllocator);
1104}
1105
1106LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) {
1107    const VkLayerDispatchTable *disp;
1108
1109    disp = loader_get_dispatch(device);
1110
1111    return disp->GetEventStatus(device, event);
1112}
1113
1114LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) {
1115    const VkLayerDispatchTable *disp;
1116
1117    disp = loader_get_dispatch(device);
1118
1119    return disp->SetEvent(device, event);
1120}
1121
1122LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) {
1123    const VkLayerDispatchTable *disp;
1124
1125    disp = loader_get_dispatch(device);
1126
1127    return disp->ResetEvent(device, event);
1128}
1129
1130LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
1131                                                               const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) {
1132    const VkLayerDispatchTable *disp;
1133
1134    disp = loader_get_dispatch(device);
1135
1136    return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
1137}
1138
1139LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
1140                                                            const VkAllocationCallbacks *pAllocator) {
1141    const VkLayerDispatchTable *disp;
1142
1143    disp = loader_get_dispatch(device);
1144
1145    disp->DestroyQueryPool(device, queryPool, pAllocator);
1146}
1147
1148LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
1149                                                                   uint32_t queryCount, size_t dataSize, void *pData,
1150                                                                   VkDeviceSize stride, VkQueryResultFlags flags) {
1151    const VkLayerDispatchTable *disp;
1152
1153    disp = loader_get_dispatch(device);
1154
1155    return disp->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
1156}
1157
1158LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
1159                                                            const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
1160    const VkLayerDispatchTable *disp;
1161
1162    disp = loader_get_dispatch(device);
1163
1164    return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
1165}
1166
1167LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer,
1168                                                         const VkAllocationCallbacks *pAllocator) {
1169    const VkLayerDispatchTable *disp;
1170
1171    disp = loader_get_dispatch(device);
1172
1173    disp->DestroyBuffer(device, buffer, pAllocator);
1174}
1175
1176LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
1177                                                                const VkAllocationCallbacks *pAllocator, VkBufferView *pView) {
1178    const VkLayerDispatchTable *disp;
1179
1180    disp = loader_get_dispatch(device);
1181
1182    return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView);
1183}
1184
1185LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
1186                                                             const VkAllocationCallbacks *pAllocator) {
1187    const VkLayerDispatchTable *disp;
1188
1189    disp = loader_get_dispatch(device);
1190
1191    disp->DestroyBufferView(device, bufferView, pAllocator);
1192}
1193
1194LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
1195                                                           const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
1196    const VkLayerDispatchTable *disp;
1197
1198    disp = loader_get_dispatch(device);
1199
1200    return disp->CreateImage(device, pCreateInfo, pAllocator, pImage);
1201}
1202
1203LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
1204    const VkLayerDispatchTable *disp;
1205
1206    disp = loader_get_dispatch(device);
1207
1208    disp->DestroyImage(device, image, pAllocator);
1209}
1210
1211LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image,
1212                                                                     const VkImageSubresource *pSubresource,
1213                                                                     VkSubresourceLayout *pLayout) {
1214    const VkLayerDispatchTable *disp;
1215
1216    disp = loader_get_dispatch(device);
1217
1218    disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
1219}
1220
1221LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
1222                                                               const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
1223    const VkLayerDispatchTable *disp;
1224
1225    disp = loader_get_dispatch(device);
1226
1227    return disp->CreateImageView(device, pCreateInfo, pAllocator, pView);
1228}
1229
1230LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView,
1231                                                            const VkAllocationCallbacks *pAllocator) {
1232    const VkLayerDispatchTable *disp;
1233
1234    disp = loader_get_dispatch(device);
1235
1236    disp->DestroyImageView(device, imageView, pAllocator);
1237}
1238
1239LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo,
1240                                                                  const VkAllocationCallbacks *pAllocator,
1241                                                                  VkShaderModule *pShader) {
1242    const VkLayerDispatchTable *disp;
1243
1244    disp = loader_get_dispatch(device);
1245
1246    return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader);
1247}
1248
1249LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
1250                                                               const VkAllocationCallbacks *pAllocator) {
1251    const VkLayerDispatchTable *disp;
1252
1253    disp = loader_get_dispatch(device);
1254
1255    disp->DestroyShaderModule(device, shaderModule, pAllocator);
1256}
1257
1258LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo,
1259                                                                   const VkAllocationCallbacks *pAllocator,
1260                                                                   VkPipelineCache *pPipelineCache) {
1261    const VkLayerDispatchTable *disp;
1262
1263    disp = loader_get_dispatch(device);
1264
1265    return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
1266}
1267
1268LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
1269                                                                const VkAllocationCallbacks *pAllocator) {
1270    const VkLayerDispatchTable *disp;
1271
1272    disp = loader_get_dispatch(device);
1273
1274    disp->DestroyPipelineCache(device, pipelineCache, pAllocator);
1275}
1276
1277LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
1278                                                                    size_t *pDataSize, void *pData) {
1279    const VkLayerDispatchTable *disp;
1280
1281    disp = loader_get_dispatch(device);
1282
1283    return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
1284}
1285
1286LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
1287                                                                   uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches) {
1288    const VkLayerDispatchTable *disp;
1289
1290    disp = loader_get_dispatch(device);
1291
1292    return disp->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
1293}
1294
1295LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
1296                                                                       uint32_t createInfoCount,
1297                                                                       const VkGraphicsPipelineCreateInfo *pCreateInfos,
1298                                                                       const VkAllocationCallbacks *pAllocator,
1299                                                                       VkPipeline *pPipelines) {
1300    const VkLayerDispatchTable *disp;
1301
1302    disp = loader_get_dispatch(device);
1303
1304    return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
1305}
1306
1307LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
1308                                                                      uint32_t createInfoCount,
1309                                                                      const VkComputePipelineCreateInfo *pCreateInfos,
1310                                                                      const VkAllocationCallbacks *pAllocator,
1311                                                                      VkPipeline *pPipelines) {
1312    const VkLayerDispatchTable *disp;
1313
1314    disp = loader_get_dispatch(device);
1315
1316    return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
1317}
1318
1319LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
1320                                                           const VkAllocationCallbacks *pAllocator) {
1321    const VkLayerDispatchTable *disp;
1322
1323    disp = loader_get_dispatch(device);
1324
1325    disp->DestroyPipeline(device, pipeline, pAllocator);
1326}
1327
1328LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo,
1329                                                                    const VkAllocationCallbacks *pAllocator,
1330                                                                    VkPipelineLayout *pPipelineLayout) {
1331    const VkLayerDispatchTable *disp;
1332
1333    disp = loader_get_dispatch(device);
1334
1335    return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
1336}
1337
1338LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
1339                                                                 const VkAllocationCallbacks *pAllocator) {
1340    const VkLayerDispatchTable *disp;
1341
1342    disp = loader_get_dispatch(device);
1343
1344    disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
1345}
1346
1347LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
1348                                                             const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) {
1349    const VkLayerDispatchTable *disp;
1350
1351    disp = loader_get_dispatch(device);
1352
1353    return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
1354}
1355
1356LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler,
1357                                                          const VkAllocationCallbacks *pAllocator) {
1358    const VkLayerDispatchTable *disp;
1359
1360    disp = loader_get_dispatch(device);
1361
1362    disp->DestroySampler(device, sampler, pAllocator);
1363}
1364
1365LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device,
1366                                                                         const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
1367                                                                         const VkAllocationCallbacks *pAllocator,
1368                                                                         VkDescriptorSetLayout *pSetLayout) {
1369    const VkLayerDispatchTable *disp;
1370
1371    disp = loader_get_dispatch(device);
1372
1373    return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
1374}
1375
1376LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
1377                                                                      const VkAllocationCallbacks *pAllocator) {
1378    const VkLayerDispatchTable *disp;
1379
1380    disp = loader_get_dispatch(device);
1381
1382    disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
1383}
1384
1385LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo,
1386                                                                    const VkAllocationCallbacks *pAllocator,
1387                                                                    VkDescriptorPool *pDescriptorPool) {
1388    const VkLayerDispatchTable *disp;
1389
1390    disp = loader_get_dispatch(device);
1391
1392    return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
1393}
1394
1395LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
1396                                                                 const VkAllocationCallbacks *pAllocator) {
1397    const VkLayerDispatchTable *disp;
1398
1399    disp = loader_get_dispatch(device);
1400
1401    disp->DestroyDescriptorPool(device, descriptorPool, pAllocator);
1402}
1403
1404LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
1405                                                                   VkDescriptorPoolResetFlags flags) {
1406    const VkLayerDispatchTable *disp;
1407
1408    disp = loader_get_dispatch(device);
1409
1410    return disp->ResetDescriptorPool(device, descriptorPool, flags);
1411}
1412
1413LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device,
1414                                                                      const VkDescriptorSetAllocateInfo *pAllocateInfo,
1415                                                                      VkDescriptorSet *pDescriptorSets) {
1416    const VkLayerDispatchTable *disp;
1417
1418    disp = loader_get_dispatch(device);
1419
1420    return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
1421}
1422
1423LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
1424                                                                  uint32_t descriptorSetCount,
1425                                                                  const VkDescriptorSet *pDescriptorSets) {
1426    const VkLayerDispatchTable *disp;
1427
1428    disp = loader_get_dispatch(device);
1429
1430    return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
1431}
1432
1433LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
1434                                                                const VkWriteDescriptorSet *pDescriptorWrites,
1435                                                                uint32_t descriptorCopyCount,
1436                                                                const VkCopyDescriptorSet *pDescriptorCopies) {
1437    const VkLayerDispatchTable *disp;
1438
1439    disp = loader_get_dispatch(device);
1440
1441    disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
1442}
1443
1444LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
1445                                                                 const VkAllocationCallbacks *pAllocator,
1446                                                                 VkFramebuffer *pFramebuffer) {
1447    const VkLayerDispatchTable *disp;
1448
1449    disp = loader_get_dispatch(device);
1450
1451    return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
1452}
1453
1454LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
1455                                                              const VkAllocationCallbacks *pAllocator) {
1456    const VkLayerDispatchTable *disp;
1457
1458    disp = loader_get_dispatch(device);
1459
1460    disp->DestroyFramebuffer(device, framebuffer, pAllocator);
1461}
1462
1463LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
1464                                                                const VkAllocationCallbacks *pAllocator,
1465                                                                VkRenderPass *pRenderPass) {
1466    const VkLayerDispatchTable *disp;
1467
1468    disp = loader_get_dispatch(device);
1469
1470    return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
1471}
1472
1473LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
1474                                                             const VkAllocationCallbacks *pAllocator) {
1475    const VkLayerDispatchTable *disp;
1476
1477    disp = loader_get_dispatch(device);
1478
1479    disp->DestroyRenderPass(device, renderPass, pAllocator);
1480}
1481
1482LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
1483                                                                    VkExtent2D *pGranularity) {
1484    const VkLayerDispatchTable *disp;
1485
1486    disp = loader_get_dispatch(device);
1487
1488    disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
1489}
1490
1491LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
1492                                                                 const VkAllocationCallbacks *pAllocator,
1493                                                                 VkCommandPool *pCommandPool) {
1494    const VkLayerDispatchTable *disp;
1495
1496    disp = loader_get_dispatch(device);
1497
1498    return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
1499}
1500
1501LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
1502                                                              const VkAllocationCallbacks *pAllocator) {
1503    const VkLayerDispatchTable *disp;
1504
1505    disp = loader_get_dispatch(device);
1506
1507    disp->DestroyCommandPool(device, commandPool, pAllocator);
1508}
1509
1510LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
1511                                                                VkCommandPoolResetFlags flags) {
1512    const VkLayerDispatchTable *disp;
1513
1514    disp = loader_get_dispatch(device);
1515
1516    return disp->ResetCommandPool(device, commandPool, flags);
1517}
1518
1519LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device,
1520                                                                      const VkCommandBufferAllocateInfo *pAllocateInfo,
1521                                                                      VkCommandBuffer *pCommandBuffers) {
1522    const VkLayerDispatchTable *disp;
1523    VkResult res;
1524
1525    disp = loader_get_dispatch(device);
1526
1527    res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
1528    if (res == VK_SUCCESS) {
1529        for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) {
1530            if (pCommandBuffers[i]) {
1531                loader_init_dispatch(pCommandBuffers[i], disp);
1532            }
1533        }
1534    }
1535
1536    return res;
1537}
1538
1539LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
1540                                                              uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) {
1541    const VkLayerDispatchTable *disp;
1542
1543    disp = loader_get_dispatch(device);
1544
1545    disp->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
1546}
1547
1548LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
1549                                                                  const VkCommandBufferBeginInfo *pBeginInfo) {
1550    const VkLayerDispatchTable *disp;
1551
1552    disp = loader_get_dispatch(commandBuffer);
1553
1554    return disp->BeginCommandBuffer(commandBuffer, pBeginInfo);
1555}
1556
1557LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
1558    const VkLayerDispatchTable *disp;
1559
1560    disp = loader_get_dispatch(commandBuffer);
1561
1562    return disp->EndCommandBuffer(commandBuffer);
1563}
1564
1565LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
1566    const VkLayerDispatchTable *disp;
1567
1568    disp = loader_get_dispatch(commandBuffer);
1569
1570    return disp->ResetCommandBuffer(commandBuffer, flags);
1571}
1572
1573LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
1574                                                           VkPipeline pipeline) {
1575    const VkLayerDispatchTable *disp;
1576
1577    disp = loader_get_dispatch(commandBuffer);
1578
1579    disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
1580}
1581
1582LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
1583                                                          uint32_t viewportCount, const VkViewport *pViewports) {
1584    const VkLayerDispatchTable *disp;
1585
1586    disp = loader_get_dispatch(commandBuffer);
1587
1588    disp->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
1589}
1590
1591LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
1592                                                         uint32_t scissorCount, const VkRect2D *pScissors) {
1593    const VkLayerDispatchTable *disp;
1594
1595    disp = loader_get_dispatch(commandBuffer);
1596
1597    disp->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
1598}
1599
1600LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
1601    const VkLayerDispatchTable *disp;
1602
1603    disp = loader_get_dispatch(commandBuffer);
1604
1605    disp->CmdSetLineWidth(commandBuffer, lineWidth);
1606}
1607
1608LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
1609                                                           float depthBiasClamp, float depthBiasSlopeFactor) {
1610    const VkLayerDispatchTable *disp;
1611
1612    disp = loader_get_dispatch(commandBuffer);
1613
1614    disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
1615}
1616
1617LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
1618    const VkLayerDispatchTable *disp;
1619
1620    disp = loader_get_dispatch(commandBuffer);
1621
1622    disp->CmdSetBlendConstants(commandBuffer, blendConstants);
1623}
1624
1625LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
1626                                                             float maxDepthBounds) {
1627    const VkLayerDispatchTable *disp;
1628
1629    disp = loader_get_dispatch(commandBuffer);
1630
1631    disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
1632}
1633
1634LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
1635                                                                    uint32_t compareMask) {
1636    const VkLayerDispatchTable *disp;
1637
1638    disp = loader_get_dispatch(commandBuffer);
1639
1640    disp->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
1641}
1642
1643LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
1644                                                                  uint32_t writeMask) {
1645    const VkLayerDispatchTable *disp;
1646
1647    disp = loader_get_dispatch(commandBuffer);
1648
1649    disp->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
1650}
1651
1652LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
1653                                                                  uint32_t reference) {
1654    const VkLayerDispatchTable *disp;
1655
1656    disp = loader_get_dispatch(commandBuffer);
1657
1658    disp->CmdSetStencilReference(commandBuffer, faceMask, reference);
1659}
1660
1661LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer,
1662                                                                 VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
1663                                                                 uint32_t firstSet, uint32_t descriptorSetCount,
1664                                                                 const VkDescriptorSet *pDescriptorSets,
1665                                                                 uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) {
1666    const VkLayerDispatchTable *disp;
1667
1668    disp = loader_get_dispatch(commandBuffer);
1669
1670    disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets,
1671                                dynamicOffsetCount, pDynamicOffsets);
1672}
1673
1674LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
1675                                                              VkIndexType indexType) {
1676    const VkLayerDispatchTable *disp;
1677
1678    disp = loader_get_dispatch(commandBuffer);
1679
1680    disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
1681}
1682
1683LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
1684                                                                uint32_t bindingCount, const VkBuffer *pBuffers,
1685                                                                const VkDeviceSize *pOffsets) {
1686    const VkLayerDispatchTable *disp;
1687
1688    disp = loader_get_dispatch(commandBuffer);
1689
1690    disp->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
1691}
1692
1693LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
1694                                                   uint32_t firstVertex, uint32_t firstInstance) {
1695    const VkLayerDispatchTable *disp;
1696
1697    disp = loader_get_dispatch(commandBuffer);
1698
1699    disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
1700}
1701
1702LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
1703                                                          uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
1704                                                          uint32_t firstInstance) {
1705    const VkLayerDispatchTable *disp;
1706
1707    disp = loader_get_dispatch(commandBuffer);
1708
1709    disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
1710}
1711
1712LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
1713                                                           uint32_t drawCount, uint32_t stride) {
1714    const VkLayerDispatchTable *disp;
1715
1716    disp = loader_get_dispatch(commandBuffer);
1717
1718    disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
1719}
1720
1721LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
1722                                                                  VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
1723    const VkLayerDispatchTable *disp;
1724
1725    disp = loader_get_dispatch(commandBuffer);
1726
1727    disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
1728}
1729
1730LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
1731    const VkLayerDispatchTable *disp;
1732
1733    disp = loader_get_dispatch(commandBuffer);
1734
1735    disp->CmdDispatch(commandBuffer, x, y, z);
1736}
1737
1738LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
1739                                                               VkDeviceSize offset) {
1740    const VkLayerDispatchTable *disp;
1741
1742    disp = loader_get_dispatch(commandBuffer);
1743
1744    disp->CmdDispatchIndirect(commandBuffer, buffer, offset);
1745}
1746
1747LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
1748                                                         uint32_t regionCount, const VkBufferCopy *pRegions) {
1749    const VkLayerDispatchTable *disp;
1750
1751    disp = loader_get_dispatch(commandBuffer);
1752
1753    disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
1754}
1755
1756LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
1757                                                        VkImageLayout srcImageLayout, VkImage dstImage,
1758                                                        VkImageLayout dstImageLayout, uint32_t regionCount,
1759                                                        const VkImageCopy *pRegions) {
1760    const VkLayerDispatchTable *disp;
1761
1762    disp = loader_get_dispatch(commandBuffer);
1763
1764    disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
1765}
1766
1767LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
1768                                                        VkImageLayout srcImageLayout, VkImage dstImage,
1769                                                        VkImageLayout dstImageLayout, uint32_t regionCount,
1770                                                        const VkImageBlit *pRegions, VkFilter filter) {
1771    const VkLayerDispatchTable *disp;
1772
1773    disp = loader_get_dispatch(commandBuffer);
1774
1775    disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
1776}
1777
1778LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
1779                                                                VkImageLayout dstImageLayout, uint32_t regionCount,
1780                                                                const VkBufferImageCopy *pRegions) {
1781    const VkLayerDispatchTable *disp;
1782
1783    disp = loader_get_dispatch(commandBuffer);
1784
1785    disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
1786}
1787
1788LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
1789                                                                VkImageLayout srcImageLayout, VkBuffer dstBuffer,
1790                                                                uint32_t regionCount, const VkBufferImageCopy *pRegions) {
1791    const VkLayerDispatchTable *disp;
1792
1793    disp = loader_get_dispatch(commandBuffer);
1794
1795    disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
1796}
1797
1798LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
1799                                                           VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData) {
1800    const VkLayerDispatchTable *disp;
1801
1802    disp = loader_get_dispatch(commandBuffer);
1803
1804    disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
1805}
1806
1807LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
1808                                                         VkDeviceSize size, uint32_t data) {
1809    const VkLayerDispatchTable *disp;
1810
1811    disp = loader_get_dispatch(commandBuffer);
1812
1813    disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
1814}
1815
1816LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
1817                                                              VkImageLayout imageLayout, const VkClearColorValue *pColor,
1818                                                              uint32_t rangeCount, const VkImageSubresourceRange *pRanges) {
1819    const VkLayerDispatchTable *disp;
1820
1821    disp = loader_get_dispatch(commandBuffer);
1822
1823    disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
1824}
1825
1826LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
1827                                                                     VkImageLayout imageLayout,
1828                                                                     const VkClearDepthStencilValue *pDepthStencil,
1829                                                                     uint32_t rangeCount, const VkImageSubresourceRange *pRanges) {
1830    const VkLayerDispatchTable *disp;
1831
1832    disp = loader_get_dispatch(commandBuffer);
1833
1834    disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
1835}
1836
1837LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
1838                                                               const VkClearAttachment *pAttachments, uint32_t rectCount,
1839                                                               const VkClearRect *pRects) {
1840    const VkLayerDispatchTable *disp;
1841
1842    disp = loader_get_dispatch(commandBuffer);
1843
1844    disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
1845}
1846
1847LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
1848                                                           VkImageLayout srcImageLayout, VkImage dstImage,
1849                                                           VkImageLayout dstImageLayout, uint32_t regionCount,
1850                                                           const VkImageResolve *pRegions) {
1851    const VkLayerDispatchTable *disp;
1852
1853    disp = loader_get_dispatch(commandBuffer);
1854
1855    disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
1856}
1857
1858LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
1859                                                       VkPipelineStageFlags stageMask) {
1860    const VkLayerDispatchTable *disp;
1861
1862    disp = loader_get_dispatch(commandBuffer);
1863
1864    disp->CmdSetEvent(commandBuffer, event, stageMask);
1865}
1866
1867LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
1868                                                         VkPipelineStageFlags stageMask) {
1869    const VkLayerDispatchTable *disp;
1870
1871    disp = loader_get_dispatch(commandBuffer);
1872
1873    disp->CmdResetEvent(commandBuffer, event, stageMask);
1874}
1875
1876LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents,
1877                                                         VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags dstStageMask,
1878                                                         uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
1879                                                         uint32_t bufferMemoryBarrierCount,
1880                                                         const VkBufferMemoryBarrier *pBufferMemoryBarriers,
1881                                                         uint32_t imageMemoryBarrierCount,
1882                                                         const VkImageMemoryBarrier *pImageMemoryBarriers) {
1883    const VkLayerDispatchTable *disp;
1884
1885    disp = loader_get_dispatch(commandBuffer);
1886
1887    disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers,
1888                        bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1889}
1890
1891LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
1892                                                              VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
1893                                                              uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
1894                                                              uint32_t bufferMemoryBarrierCount,
1895                                                              const VkBufferMemoryBarrier *pBufferMemoryBarriers,
1896                                                              uint32_t imageMemoryBarrierCount,
1897                                                              const VkImageMemoryBarrier *pImageMemoryBarriers) {
1898    const VkLayerDispatchTable *disp;
1899
1900    disp = loader_get_dispatch(commandBuffer);
1901
1902    disp->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers,
1903                             bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1904}
1905
1906LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot,
1907                                                         VkFlags flags) {
1908    const VkLayerDispatchTable *disp;
1909
1910    disp = loader_get_dispatch(commandBuffer);
1911
1912    disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
1913}
1914
1915LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) {
1916    const VkLayerDispatchTable *disp;
1917
1918    disp = loader_get_dispatch(commandBuffer);
1919
1920    disp->CmdEndQuery(commandBuffer, queryPool, slot);
1921}
1922
1923LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
1924                                                             uint32_t firstQuery, uint32_t queryCount) {
1925    const VkLayerDispatchTable *disp;
1926
1927    disp = loader_get_dispatch(commandBuffer);
1928
1929    disp->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
1930}
1931
1932LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
1933                                                             VkQueryPool queryPool, uint32_t slot) {
1934    const VkLayerDispatchTable *disp;
1935
1936    disp = loader_get_dispatch(commandBuffer);
1937
1938    disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
1939}
1940
1941LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
1942                                                                   uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer,
1943                                                                   VkDeviceSize dstOffset, VkDeviceSize stride, VkFlags flags) {
1944    const VkLayerDispatchTable *disp;
1945
1946    disp = loader_get_dispatch(commandBuffer);
1947
1948    disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
1949}
1950
1951LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
1952                                                            VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
1953                                                            const void *pValues) {
1954    const VkLayerDispatchTable *disp;
1955
1956    disp = loader_get_dispatch(commandBuffer);
1957
1958    disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
1959}
1960
1961LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
1962                                                              const VkRenderPassBeginInfo *pRenderPassBegin,
1963                                                              VkSubpassContents contents) {
1964    const VkLayerDispatchTable *disp;
1965
1966    disp = loader_get_dispatch(commandBuffer);
1967
1968    disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
1969}
1970
1971LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
1972    const VkLayerDispatchTable *disp;
1973
1974    disp = loader_get_dispatch(commandBuffer);
1975
1976    disp->CmdNextSubpass(commandBuffer, contents);
1977}
1978
1979LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
1980    const VkLayerDispatchTable *disp;
1981
1982    disp = loader_get_dispatch(commandBuffer);
1983
1984    disp->CmdEndRenderPass(commandBuffer);
1985}
1986
1987LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount,
1988                                                              const VkCommandBuffer *pCommandBuffers) {
1989    const VkLayerDispatchTable *disp;
1990
1991    disp = loader_get_dispatch(commandBuffer);
1992
1993    disp->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
1994}
1995