trampoline.c revision 7ec85cdb9e8526f0eea01e1782c4c03bfbd9677c 
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 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and/or associated documentation files (the "Materials"), to
10 * deal in the Materials without restriction, including without limitation the
11 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
12 * sell copies of the Materials, and to permit persons to whom the Materials are
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice(s) and this permission notice shall be included in
16 * all copies or substantial portions of the Materials.
17 *
18 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 *
22 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
23 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
24 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
25 * USE OR OTHER DEALINGS IN THE MATERIALS.
26 *
27 * Author: Courtney Goeltzenleuchter <courtney@lunarg.com>
28 * Author: Jon Ashburn <jon@lunarg.com>
29 * Author: Tony Barbour <tony@LunarG.com>
30 * Author: Chia-I Wu <olv@lunarg.com>
31 */
32#define _GNU_SOURCE
33#include <stdlib.h>
34#include <string.h>
35
36#include "vk_loader_platform.h"
37#include "loader.h"
38#include "debug_report.h"
39#include "wsi.h"
40
41/* Trampoline entrypoints */
42LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
43vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
44                 const VkAllocationCallbacks *pAllocator,
45                 VkInstance *pInstance) {
46    struct loader_instance *ptr_instance = NULL;
47    VkInstance created_instance = VK_NULL_HANDLE;
48    VkResult res = VK_ERROR_INITIALIZATION_FAILED;
49    VkDebugReportCallbackEXT instance_callback = VK_NULL_HANDLE;
50    void *pNext = (void *)pCreateInfo->pNext;
51
52    loader_platform_thread_once(&once_init, loader_initialize);
53
54#if 0
55	if (pAllocator) {
56        ptr_instance = (struct loader_instance *) pAllocator->pfnAllocation(
57                           pAllocator->pUserData,
58                           sizeof(struct loader_instance),
59                           sizeof(int *),
60                           VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
61    } else {
62#endif
63    ptr_instance =
64        (struct loader_instance *)malloc(sizeof(struct loader_instance));
65    //}
66    if (ptr_instance == NULL) {
67        return VK_ERROR_OUT_OF_HOST_MEMORY;
68    }
69
70    tls_instance = ptr_instance;
71    loader_platform_thread_lock_mutex(&loader_lock);
72    memset(ptr_instance, 0, sizeof(struct loader_instance));
73#if 0
74    if (pAllocator) {
75        ptr_instance->alloc_callbacks = *pAllocator;
76    }
77#endif
78
79    /*
80     * Look for a debug report create info structure
81     * and setup a callback if found.
82     */
83    while (pNext) {
84        if (((VkInstanceCreateInfo *)pNext)->sType ==
85            VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) {
86            instance_callback = (VkDebugReportCallbackEXT)ptr_instance;
87            if (util_CreateDebugReportCallback(ptr_instance, pNext, NULL,
88                                               instance_callback)) {
89                loader_heap_free(ptr_instance, ptr_instance);
90                loader_platform_thread_unlock_mutex(&loader_lock);
91                return VK_ERROR_OUT_OF_HOST_MEMORY;
92            }
93        }
94        pNext = (void *)((VkInstanceCreateInfo *)pNext)->pNext;
95    }
96
97    /* Due to implicit layers need to get layer list even if
98     * enabledLayerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
99     * get layer list (both instance and device) via loader_layer_scan(). */
100    memset(&ptr_instance->instance_layer_list, 0,
101           sizeof(ptr_instance->instance_layer_list));
102    memset(&ptr_instance->device_layer_list, 0,
103           sizeof(ptr_instance->device_layer_list));
104    loader_layer_scan(ptr_instance, &ptr_instance->instance_layer_list,
105                      &ptr_instance->device_layer_list);
106
107    /* validate the app requested layers to be enabled */
108    if (pCreateInfo->enabledLayerCount > 0) {
109        res =
110            loader_validate_layers(ptr_instance, pCreateInfo->enabledLayerCount,
111                                   pCreateInfo->ppEnabledLayerNames,
112                                   &ptr_instance->instance_layer_list);
113        if (res != VK_SUCCESS) {
114            util_DestroyDebugReportCallback(ptr_instance, instance_callback,
115                                            NULL);
116            loader_heap_free(ptr_instance, ptr_instance);
117            loader_platform_thread_unlock_mutex(&loader_lock);
118            return res;
119        }
120    }
121
122    /* Scan/discover all ICD libraries */
123    memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs));
124    loader_icd_scan(ptr_instance, &ptr_instance->icd_libs);
125
126    /* get extensions from all ICD's, merge so no duplicates, then validate */
127    loader_get_icd_loader_instance_extensions(
128        ptr_instance, &ptr_instance->icd_libs, &ptr_instance->ext_list);
129    res = loader_validate_instance_extensions(
130        ptr_instance, &ptr_instance->ext_list,
131        &ptr_instance->instance_layer_list, pCreateInfo);
132    if (res != VK_SUCCESS) {
133        loader_delete_layer_properties(ptr_instance,
134                                       &ptr_instance->device_layer_list);
135        loader_delete_layer_properties(ptr_instance,
136                                       &ptr_instance->instance_layer_list);
137        loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
138        loader_destroy_generic_list(
139            ptr_instance,
140            (struct loader_generic_list *)&ptr_instance->ext_list);
141        util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL);
142        loader_platform_thread_unlock_mutex(&loader_lock);
143        loader_heap_free(ptr_instance, ptr_instance);
144        return res;
145    }
146
147    ptr_instance->disp =
148        loader_heap_alloc(ptr_instance, sizeof(VkLayerInstanceDispatchTable),
149                          VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
150    if (ptr_instance->disp == NULL) {
151        loader_delete_layer_properties(ptr_instance,
152                                       &ptr_instance->device_layer_list);
153        loader_delete_layer_properties(ptr_instance,
154                                       &ptr_instance->instance_layer_list);
155        loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
156        loader_destroy_generic_list(
157            ptr_instance,
158            (struct loader_generic_list *)&ptr_instance->ext_list);
159        util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL);
160        loader_platform_thread_unlock_mutex(&loader_lock);
161        loader_heap_free(ptr_instance, ptr_instance);
162        return VK_ERROR_OUT_OF_HOST_MEMORY;
163    }
164    memcpy(ptr_instance->disp, &instance_disp, sizeof(instance_disp));
165    ptr_instance->next = loader.instances;
166    loader.instances = ptr_instance;
167
168    /* activate any layers on instance chain */
169    res = loader_enable_instance_layers(ptr_instance, pCreateInfo,
170                                        &ptr_instance->instance_layer_list);
171    if (res != VK_SUCCESS) {
172        loader_delete_layer_properties(ptr_instance,
173                                       &ptr_instance->device_layer_list);
174        loader_delete_layer_properties(ptr_instance,
175                                       &ptr_instance->instance_layer_list);
176        loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
177        loader_destroy_generic_list(
178            ptr_instance,
179            (struct loader_generic_list *)&ptr_instance->ext_list);
180        loader.instances = ptr_instance->next;
181        util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL);
182        loader_platform_thread_unlock_mutex(&loader_lock);
183        loader_heap_free(ptr_instance, ptr_instance->disp);
184        loader_heap_free(ptr_instance, ptr_instance);
185        return res;
186    }
187
188    created_instance = (VkInstance)ptr_instance;
189    res = loader_create_instance_chain(pCreateInfo, pAllocator, ptr_instance,
190                                       &created_instance);
191
192    if (res == VK_SUCCESS) {
193        wsi_create_instance(ptr_instance, pCreateInfo);
194        debug_report_create_instance(ptr_instance, pCreateInfo);
195
196        *pInstance = created_instance;
197
198        /*
199         * Finally have the layers in place and everyone has seen
200         * the CreateInstance command go by. This allows the layer's
201         * GetInstanceProcAddr functions to return valid extension functions
202         * if enabled.
203         */
204        loader_activate_instance_layer_extensions(ptr_instance, *pInstance);
205    } else {
206        // TODO: cleanup here.
207    }
208
209    /* Remove temporary debug_report callback */
210    util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL);
211
212    loader_platform_thread_unlock_mutex(&loader_lock);
213    return res;
214}
215
216LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
217vkDestroyInstance(VkInstance instance,
218                  const VkAllocationCallbacks *pAllocator) {
219    const VkLayerInstanceDispatchTable *disp;
220    struct loader_instance *ptr_instance = NULL;
221    disp = loader_get_instance_dispatch(instance);
222
223    loader_platform_thread_lock_mutex(&loader_lock);
224
225    /* TODO: Do we need a temporary callback here to catch cleanup issues? */
226
227    ptr_instance = loader_get_instance(instance);
228    disp->DestroyInstance(instance, pAllocator);
229
230    loader_deactivate_instance_layers(ptr_instance);
231    loader_heap_free(ptr_instance, ptr_instance->disp);
232    loader_heap_free(ptr_instance, ptr_instance);
233    loader_platform_thread_unlock_mutex(&loader_lock);
234}
235
236LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
237vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
238                           VkPhysicalDevice *pPhysicalDevices) {
239    const VkLayerInstanceDispatchTable *disp;
240    VkResult res;
241    disp = loader_get_instance_dispatch(instance);
242
243    loader_platform_thread_lock_mutex(&loader_lock);
244    res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount,
245                                         pPhysicalDevices);
246    loader_platform_thread_unlock_mutex(&loader_lock);
247    return res;
248}
249
250LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
251vkGetPhysicalDeviceFeatures(VkPhysicalDevice gpu,
252                            VkPhysicalDeviceFeatures *pFeatures) {
253    const VkLayerInstanceDispatchTable *disp;
254
255    disp = loader_get_instance_dispatch(gpu);
256    disp->GetPhysicalDeviceFeatures(gpu, pFeatures);
257}
258
259LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
260vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice gpu, VkFormat format,
261                                    VkFormatProperties *pFormatInfo) {
262    const VkLayerInstanceDispatchTable *disp;
263
264    disp = loader_get_instance_dispatch(gpu);
265    disp->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo);
266}
267
268LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
269vkGetPhysicalDeviceImageFormatProperties(
270    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
271    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
272    VkImageFormatProperties *pImageFormatProperties) {
273    const VkLayerInstanceDispatchTable *disp;
274
275    disp = loader_get_instance_dispatch(physicalDevice);
276    return disp->GetPhysicalDeviceImageFormatProperties(
277        physicalDevice, format, type, tiling, usage, flags,
278        pImageFormatProperties);
279}
280
281LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
282vkGetPhysicalDeviceProperties(VkPhysicalDevice gpu,
283                              VkPhysicalDeviceProperties *pProperties) {
284    const VkLayerInstanceDispatchTable *disp;
285
286    disp = loader_get_instance_dispatch(gpu);
287    disp->GetPhysicalDeviceProperties(gpu, pProperties);
288}
289
290LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
291vkGetPhysicalDeviceQueueFamilyProperties(
292    VkPhysicalDevice gpu, uint32_t *pQueueFamilyPropertyCount,
293    VkQueueFamilyProperties *pQueueProperties) {
294    const VkLayerInstanceDispatchTable *disp;
295
296    disp = loader_get_instance_dispatch(gpu);
297    disp->GetPhysicalDeviceQueueFamilyProperties(gpu, pQueueFamilyPropertyCount,
298                                                 pQueueProperties);
299}
300
301LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
302    VkPhysicalDevice gpu, VkPhysicalDeviceMemoryProperties *pMemoryProperties) {
303    const VkLayerInstanceDispatchTable *disp;
304
305    disp = loader_get_instance_dispatch(gpu);
306    disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties);
307}
308
309LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
310vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
311               const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
312    VkResult res;
313
314    loader_platform_thread_lock_mutex(&loader_lock);
315
316    res = loader_CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
317
318    loader_platform_thread_unlock_mutex(&loader_lock);
319    return res;
320}
321
322LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
323vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
324    const VkLayerDispatchTable *disp;
325    struct loader_device *dev;
326
327    loader_platform_thread_lock_mutex(&loader_lock);
328
329    struct loader_icd *icd = loader_get_icd_and_device(device, &dev);
330    const struct loader_instance *inst = icd->this_instance;
331    disp = loader_get_dispatch(device);
332
333    disp->DestroyDevice(device, pAllocator);
334    dev->device = NULL;
335    loader_remove_logical_device(inst, icd, dev);
336
337    loader_platform_thread_unlock_mutex(&loader_lock);
338}
339
340LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
341vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
342                                     const char *pLayerName,
343                                     uint32_t *pPropertyCount,
344                                     VkExtensionProperties *pProperties) {
345    VkResult res;
346
347    loader_platform_thread_lock_mutex(&loader_lock);
348
349    /* If pLayerName == NULL, then querying ICD extensions, pass this call
350       down the instance chain which will terminate in the ICD. This allows
351       layers to filter the extensions coming back up the chain.
352       If pLayerName != NULL then get layer extensions from manifest file.  */
353    if (pLayerName == NULL || strlen(pLayerName) == 0) {
354        const VkLayerInstanceDispatchTable *disp;
355
356        disp = loader_get_instance_dispatch(physicalDevice);
357        res = disp->EnumerateDeviceExtensionProperties(
358            physicalDevice, NULL, pPropertyCount, pProperties);
359    } else {
360        res = loader_EnumerateDeviceExtensionProperties(
361            physicalDevice, pLayerName, pPropertyCount, pProperties);
362    }
363
364    loader_platform_thread_unlock_mutex(&loader_lock);
365    return res;
366}
367
368LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
369vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
370                                 uint32_t *pPropertyCount,
371                                 VkLayerProperties *pProperties) {
372    VkResult res;
373
374    loader_platform_thread_lock_mutex(&loader_lock);
375
376    /* Don't dispatch this call down the instance chain, want all device layers
377       enumerated and instance chain may not contain all device layers */
378    res = loader_EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount,
379                                                pProperties);
380    loader_platform_thread_unlock_mutex(&loader_lock);
381    return res;
382}
383
384LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
385vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex,
386                 VkQueue *pQueue) {
387    const VkLayerDispatchTable *disp;
388
389    disp = loader_get_dispatch(device);
390
391    disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
392    loader_set_dispatch(*pQueue, disp);
393}
394
395LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
396vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits,
397              VkFence fence) {
398    const VkLayerDispatchTable *disp;
399
400    disp = loader_get_dispatch(queue);
401
402    return disp->QueueSubmit(queue, submitCount, pSubmits, fence);
403}
404
405LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) {
406    const VkLayerDispatchTable *disp;
407
408    disp = loader_get_dispatch(queue);
409
410    return disp->QueueWaitIdle(queue);
411}
412
413LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) {
414    const VkLayerDispatchTable *disp;
415
416    disp = loader_get_dispatch(device);
417
418    return disp->DeviceWaitIdle(device);
419}
420
421LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
422vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
423                 const VkAllocationCallbacks *pAllocator,
424                 VkDeviceMemory *pMemory) {
425    const VkLayerDispatchTable *disp;
426
427    disp = loader_get_dispatch(device);
428
429    return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
430}
431
432LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
433vkFreeMemory(VkDevice device, VkDeviceMemory mem,
434             const VkAllocationCallbacks *pAllocator) {
435    const VkLayerDispatchTable *disp;
436
437    disp = loader_get_dispatch(device);
438
439    disp->FreeMemory(device, mem, pAllocator);
440}
441
442LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
443vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset,
444            VkDeviceSize size, VkFlags flags, void **ppData) {
445    const VkLayerDispatchTable *disp;
446
447    disp = loader_get_dispatch(device);
448
449    return disp->MapMemory(device, mem, offset, size, flags, ppData);
450}
451
452LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
453vkUnmapMemory(VkDevice device, VkDeviceMemory mem) {
454    const VkLayerDispatchTable *disp;
455
456    disp = loader_get_dispatch(device);
457
458    disp->UnmapMemory(device, mem);
459}
460
461LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
462vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
463                          const VkMappedMemoryRange *pMemoryRanges) {
464    const VkLayerDispatchTable *disp;
465
466    disp = loader_get_dispatch(device);
467
468    return disp->FlushMappedMemoryRanges(device, memoryRangeCount,
469                                         pMemoryRanges);
470}
471
472LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
473vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
474                               const VkMappedMemoryRange *pMemoryRanges) {
475    const VkLayerDispatchTable *disp;
476
477    disp = loader_get_dispatch(device);
478
479    return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount,
480                                              pMemoryRanges);
481}
482
483LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
484vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
485                            VkDeviceSize *pCommittedMemoryInBytes) {
486    const VkLayerDispatchTable *disp;
487
488    disp = loader_get_dispatch(device);
489
490    disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
491}
492
493LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
494vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem,
495                   VkDeviceSize offset) {
496    const VkLayerDispatchTable *disp;
497
498    disp = loader_get_dispatch(device);
499
500    return disp->BindBufferMemory(device, buffer, mem, offset);
501}
502
503LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
504vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem,
505                  VkDeviceSize offset) {
506    const VkLayerDispatchTable *disp;
507
508    disp = loader_get_dispatch(device);
509
510    return disp->BindImageMemory(device, image, mem, offset);
511}
512
513LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
514vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
515                              VkMemoryRequirements *pMemoryRequirements) {
516    const VkLayerDispatchTable *disp;
517
518    disp = loader_get_dispatch(device);
519
520    disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
521}
522
523LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
524vkGetImageMemoryRequirements(VkDevice device, VkImage image,
525                             VkMemoryRequirements *pMemoryRequirements) {
526    const VkLayerDispatchTable *disp;
527
528    disp = loader_get_dispatch(device);
529
530    disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
531}
532
533LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
534    VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
535    VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
536    const VkLayerDispatchTable *disp;
537
538    disp = loader_get_dispatch(device);
539
540    disp->GetImageSparseMemoryRequirements(device, image,
541                                           pSparseMemoryRequirementCount,
542                                           pSparseMemoryRequirements);
543}
544
545LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
546vkGetPhysicalDeviceSparseImageFormatProperties(
547    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
548    VkSampleCountFlagBits samples, VkImageUsageFlags usage,
549    VkImageTiling tiling, uint32_t *pPropertyCount,
550    VkSparseImageFormatProperties *pProperties) {
551    const VkLayerInstanceDispatchTable *disp;
552
553    disp = loader_get_instance_dispatch(physicalDevice);
554
555    disp->GetPhysicalDeviceSparseImageFormatProperties(
556        physicalDevice, format, type, samples, usage, tiling, pPropertyCount,
557        pProperties);
558}
559
560LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
561vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
562                  const VkBindSparseInfo *pBindInfo, VkFence fence) {
563    const VkLayerDispatchTable *disp;
564
565    disp = loader_get_dispatch(queue);
566
567    return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
568}
569
570LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
571vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
572              const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
573    const VkLayerDispatchTable *disp;
574
575    disp = loader_get_dispatch(device);
576
577    return disp->CreateFence(device, pCreateInfo, pAllocator, pFence);
578}
579
580LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
581vkDestroyFence(VkDevice device, VkFence fence,
582               const VkAllocationCallbacks *pAllocator) {
583    const VkLayerDispatchTable *disp;
584
585    disp = loader_get_dispatch(device);
586
587    disp->DestroyFence(device, fence, pAllocator);
588}
589
590LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
591vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) {
592    const VkLayerDispatchTable *disp;
593
594    disp = loader_get_dispatch(device);
595
596    return disp->ResetFences(device, fenceCount, pFences);
597}
598
599LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
600vkGetFenceStatus(VkDevice device, VkFence fence) {
601    const VkLayerDispatchTable *disp;
602
603    disp = loader_get_dispatch(device);
604
605    return disp->GetFenceStatus(device, fence);
606}
607
608LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
609vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences,
610                VkBool32 waitAll, uint64_t timeout) {
611    const VkLayerDispatchTable *disp;
612
613    disp = loader_get_dispatch(device);
614
615    return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
616}
617
618LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
619vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
620                  const VkAllocationCallbacks *pAllocator,
621                  VkSemaphore *pSemaphore) {
622    const VkLayerDispatchTable *disp;
623
624    disp = loader_get_dispatch(device);
625
626    return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
627}
628
629LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
630vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
631                   const VkAllocationCallbacks *pAllocator) {
632    const VkLayerDispatchTable *disp;
633
634    disp = loader_get_dispatch(device);
635
636    disp->DestroySemaphore(device, semaphore, pAllocator);
637}
638
639LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
640vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
641              const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
642    const VkLayerDispatchTable *disp;
643
644    disp = loader_get_dispatch(device);
645
646    return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
647}
648
649LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
650vkDestroyEvent(VkDevice device, VkEvent event,
651               const VkAllocationCallbacks *pAllocator) {
652    const VkLayerDispatchTable *disp;
653
654    disp = loader_get_dispatch(device);
655
656    disp->DestroyEvent(device, event, pAllocator);
657}
658
659LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
660vkGetEventStatus(VkDevice device, VkEvent event) {
661    const VkLayerDispatchTable *disp;
662
663    disp = loader_get_dispatch(device);
664
665    return disp->GetEventStatus(device, event);
666}
667
668LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
669vkSetEvent(VkDevice device, VkEvent event) {
670    const VkLayerDispatchTable *disp;
671
672    disp = loader_get_dispatch(device);
673
674    return disp->SetEvent(device, event);
675}
676
677LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
678vkResetEvent(VkDevice device, VkEvent event) {
679    const VkLayerDispatchTable *disp;
680
681    disp = loader_get_dispatch(device);
682
683    return disp->ResetEvent(device, event);
684}
685
686LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
687vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
688                  const VkAllocationCallbacks *pAllocator,
689                  VkQueryPool *pQueryPool) {
690    const VkLayerDispatchTable *disp;
691
692    disp = loader_get_dispatch(device);
693
694    return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
695}
696
697LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
698vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
699                   const VkAllocationCallbacks *pAllocator) {
700    const VkLayerDispatchTable *disp;
701
702    disp = loader_get_dispatch(device);
703
704    disp->DestroyQueryPool(device, queryPool, pAllocator);
705}
706
707LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
708vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
709                      uint32_t firstQuery, uint32_t queryCount, size_t dataSize,
710                      void *pData, VkDeviceSize stride,
711                      VkQueryResultFlags flags) {
712    const VkLayerDispatchTable *disp;
713
714    disp = loader_get_dispatch(device);
715
716    return disp->GetQueryPoolResults(device, queryPool, firstQuery, queryCount,
717                                     dataSize, pData, stride, flags);
718}
719
720LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
721vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
722               const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
723    const VkLayerDispatchTable *disp;
724
725    disp = loader_get_dispatch(device);
726
727    return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
728}
729
730LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
731vkDestroyBuffer(VkDevice device, VkBuffer buffer,
732                const VkAllocationCallbacks *pAllocator) {
733    const VkLayerDispatchTable *disp;
734
735    disp = loader_get_dispatch(device);
736
737    disp->DestroyBuffer(device, buffer, pAllocator);
738}
739
740LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
741vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
742                   const VkAllocationCallbacks *pAllocator,
743                   VkBufferView *pView) {
744    const VkLayerDispatchTable *disp;
745
746    disp = loader_get_dispatch(device);
747
748    return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView);
749}
750
751LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
752vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
753                    const VkAllocationCallbacks *pAllocator) {
754    const VkLayerDispatchTable *disp;
755
756    disp = loader_get_dispatch(device);
757
758    disp->DestroyBufferView(device, bufferView, pAllocator);
759}
760
761LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
762vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
763              const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
764    const VkLayerDispatchTable *disp;
765
766    disp = loader_get_dispatch(device);
767
768    return disp->CreateImage(device, pCreateInfo, pAllocator, pImage);
769}
770
771LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
772vkDestroyImage(VkDevice device, VkImage image,
773               const VkAllocationCallbacks *pAllocator) {
774    const VkLayerDispatchTable *disp;
775
776    disp = loader_get_dispatch(device);
777
778    disp->DestroyImage(device, image, pAllocator);
779}
780
781LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
782vkGetImageSubresourceLayout(VkDevice device, VkImage image,
783                            const VkImageSubresource *pSubresource,
784                            VkSubresourceLayout *pLayout) {
785    const VkLayerDispatchTable *disp;
786
787    disp = loader_get_dispatch(device);
788
789    disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
790}
791
792LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
793vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
794                  const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
795    const VkLayerDispatchTable *disp;
796
797    disp = loader_get_dispatch(device);
798
799    return disp->CreateImageView(device, pCreateInfo, pAllocator, pView);
800}
801
802LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
803vkDestroyImageView(VkDevice device, VkImageView imageView,
804                   const VkAllocationCallbacks *pAllocator) {
805    const VkLayerDispatchTable *disp;
806
807    disp = loader_get_dispatch(device);
808
809    disp->DestroyImageView(device, imageView, pAllocator);
810}
811
812LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
813vkCreateShaderModule(VkDevice device,
814                     const VkShaderModuleCreateInfo *pCreateInfo,
815                     const VkAllocationCallbacks *pAllocator,
816                     VkShaderModule *pShader) {
817    const VkLayerDispatchTable *disp;
818
819    disp = loader_get_dispatch(device);
820
821    return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader);
822}
823
824LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
825vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
826                      const VkAllocationCallbacks *pAllocator) {
827    const VkLayerDispatchTable *disp;
828
829    disp = loader_get_dispatch(device);
830
831    disp->DestroyShaderModule(device, shaderModule, pAllocator);
832}
833
834LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
835vkCreatePipelineCache(VkDevice device,
836                      const VkPipelineCacheCreateInfo *pCreateInfo,
837                      const VkAllocationCallbacks *pAllocator,
838                      VkPipelineCache *pPipelineCache) {
839    const VkLayerDispatchTable *disp;
840
841    disp = loader_get_dispatch(device);
842
843    return disp->CreatePipelineCache(device, pCreateInfo, pAllocator,
844                                     pPipelineCache);
845}
846
847LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
848vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
849                       const VkAllocationCallbacks *pAllocator) {
850    const VkLayerDispatchTable *disp;
851
852    disp = loader_get_dispatch(device);
853
854    disp->DestroyPipelineCache(device, pipelineCache, pAllocator);
855}
856
857LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
858vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
859                       size_t *pDataSize, void *pData) {
860    const VkLayerDispatchTable *disp;
861
862    disp = loader_get_dispatch(device);
863
864    return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
865}
866
867LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
868vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
869                      uint32_t srcCacheCount,
870                      const VkPipelineCache *pSrcCaches) {
871    const VkLayerDispatchTable *disp;
872
873    disp = loader_get_dispatch(device);
874
875    return disp->MergePipelineCaches(device, dstCache, srcCacheCount,
876                                     pSrcCaches);
877}
878
879LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
880vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
881                          uint32_t createInfoCount,
882                          const VkGraphicsPipelineCreateInfo *pCreateInfos,
883                          const VkAllocationCallbacks *pAllocator,
884                          VkPipeline *pPipelines) {
885    const VkLayerDispatchTable *disp;
886
887    disp = loader_get_dispatch(device);
888
889    return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount,
890                                         pCreateInfos, pAllocator, pPipelines);
891}
892
893LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
894vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
895                         uint32_t createInfoCount,
896                         const VkComputePipelineCreateInfo *pCreateInfos,
897                         const VkAllocationCallbacks *pAllocator,
898                         VkPipeline *pPipelines) {
899    const VkLayerDispatchTable *disp;
900
901    disp = loader_get_dispatch(device);
902
903    return disp->CreateComputePipelines(device, pipelineCache, createInfoCount,
904                                        pCreateInfos, pAllocator, pPipelines);
905}
906
907LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
908vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
909                  const VkAllocationCallbacks *pAllocator) {
910    const VkLayerDispatchTable *disp;
911
912    disp = loader_get_dispatch(device);
913
914    disp->DestroyPipeline(device, pipeline, pAllocator);
915}
916
917LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
918vkCreatePipelineLayout(VkDevice device,
919                       const VkPipelineLayoutCreateInfo *pCreateInfo,
920                       const VkAllocationCallbacks *pAllocator,
921                       VkPipelineLayout *pPipelineLayout) {
922    const VkLayerDispatchTable *disp;
923
924    disp = loader_get_dispatch(device);
925
926    return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator,
927                                      pPipelineLayout);
928}
929
930LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
931vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
932                        const VkAllocationCallbacks *pAllocator) {
933    const VkLayerDispatchTable *disp;
934
935    disp = loader_get_dispatch(device);
936
937    disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
938}
939
940LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
941vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
942                const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) {
943    const VkLayerDispatchTable *disp;
944
945    disp = loader_get_dispatch(device);
946
947    return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
948}
949
950LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
951vkDestroySampler(VkDevice device, VkSampler sampler,
952                 const VkAllocationCallbacks *pAllocator) {
953    const VkLayerDispatchTable *disp;
954
955    disp = loader_get_dispatch(device);
956
957    disp->DestroySampler(device, sampler, pAllocator);
958}
959
960LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
961vkCreateDescriptorSetLayout(VkDevice device,
962                            const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
963                            const VkAllocationCallbacks *pAllocator,
964                            VkDescriptorSetLayout *pSetLayout) {
965    const VkLayerDispatchTable *disp;
966
967    disp = loader_get_dispatch(device);
968
969    return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator,
970                                           pSetLayout);
971}
972
973LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
974vkDestroyDescriptorSetLayout(VkDevice device,
975                             VkDescriptorSetLayout descriptorSetLayout,
976                             const VkAllocationCallbacks *pAllocator) {
977    const VkLayerDispatchTable *disp;
978
979    disp = loader_get_dispatch(device);
980
981    disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
982}
983
984LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
985vkCreateDescriptorPool(VkDevice device,
986                       const VkDescriptorPoolCreateInfo *pCreateInfo,
987                       const VkAllocationCallbacks *pAllocator,
988                       VkDescriptorPool *pDescriptorPool) {
989    const VkLayerDispatchTable *disp;
990
991    disp = loader_get_dispatch(device);
992
993    return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator,
994                                      pDescriptorPool);
995}
996
997LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
998vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
999                        const VkAllocationCallbacks *pAllocator) {
1000    const VkLayerDispatchTable *disp;
1001
1002    disp = loader_get_dispatch(device);
1003
1004    disp->DestroyDescriptorPool(device, descriptorPool, pAllocator);
1005}
1006
1007LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1008vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
1009                      VkDescriptorPoolResetFlags flags) {
1010    const VkLayerDispatchTable *disp;
1011
1012    disp = loader_get_dispatch(device);
1013
1014    return disp->ResetDescriptorPool(device, descriptorPool, flags);
1015}
1016
1017LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1018vkAllocateDescriptorSets(VkDevice device,
1019                         const VkDescriptorSetAllocateInfo *pAllocateInfo,
1020                         VkDescriptorSet *pDescriptorSets) {
1021    const VkLayerDispatchTable *disp;
1022
1023    disp = loader_get_dispatch(device);
1024
1025    return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
1026}
1027
1028LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1029vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
1030                     uint32_t descriptorSetCount,
1031                     const VkDescriptorSet *pDescriptorSets) {
1032    const VkLayerDispatchTable *disp;
1033
1034    disp = loader_get_dispatch(device);
1035
1036    return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount,
1037                                    pDescriptorSets);
1038}
1039
1040LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1041vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
1042                       const VkWriteDescriptorSet *pDescriptorWrites,
1043                       uint32_t descriptorCopyCount,
1044                       const VkCopyDescriptorSet *pDescriptorCopies) {
1045    const VkLayerDispatchTable *disp;
1046
1047    disp = loader_get_dispatch(device);
1048
1049    disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites,
1050                               descriptorCopyCount, pDescriptorCopies);
1051}
1052
1053LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1054vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
1055                    const VkAllocationCallbacks *pAllocator,
1056                    VkFramebuffer *pFramebuffer) {
1057    const VkLayerDispatchTable *disp;
1058
1059    disp = loader_get_dispatch(device);
1060
1061    return disp->CreateFramebuffer(device, pCreateInfo, pAllocator,
1062                                   pFramebuffer);
1063}
1064
1065LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1066vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
1067                     const VkAllocationCallbacks *pAllocator) {
1068    const VkLayerDispatchTable *disp;
1069
1070    disp = loader_get_dispatch(device);
1071
1072    disp->DestroyFramebuffer(device, framebuffer, pAllocator);
1073}
1074
1075LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1076vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
1077                   const VkAllocationCallbacks *pAllocator,
1078                   VkRenderPass *pRenderPass) {
1079    const VkLayerDispatchTable *disp;
1080
1081    disp = loader_get_dispatch(device);
1082
1083    return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
1084}
1085
1086LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1087vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
1088                    const VkAllocationCallbacks *pAllocator) {
1089    const VkLayerDispatchTable *disp;
1090
1091    disp = loader_get_dispatch(device);
1092
1093    disp->DestroyRenderPass(device, renderPass, pAllocator);
1094}
1095
1096LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1097vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
1098                           VkExtent2D *pGranularity) {
1099    const VkLayerDispatchTable *disp;
1100
1101    disp = loader_get_dispatch(device);
1102
1103    disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
1104}
1105
1106LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1107vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
1108                    const VkAllocationCallbacks *pAllocator,
1109                    VkCommandPool *pCommandPool) {
1110    const VkLayerDispatchTable *disp;
1111
1112    disp = loader_get_dispatch(device);
1113
1114    return disp->CreateCommandPool(device, pCreateInfo, pAllocator,
1115                                   pCommandPool);
1116}
1117
1118LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1119vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
1120                     const VkAllocationCallbacks *pAllocator) {
1121    const VkLayerDispatchTable *disp;
1122
1123    disp = loader_get_dispatch(device);
1124
1125    disp->DestroyCommandPool(device, commandPool, pAllocator);
1126}
1127
1128LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1129vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
1130                   VkCommandPoolResetFlags flags) {
1131    const VkLayerDispatchTable *disp;
1132
1133    disp = loader_get_dispatch(device);
1134
1135    return disp->ResetCommandPool(device, commandPool, flags);
1136}
1137
1138LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1139vkAllocateCommandBuffers(VkDevice device,
1140                         const VkCommandBufferAllocateInfo *pAllocateInfo,
1141                         VkCommandBuffer *pCommandBuffers) {
1142    const VkLayerDispatchTable *disp;
1143    VkResult res;
1144
1145    disp = loader_get_dispatch(device);
1146
1147    res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
1148    if (res == VK_SUCCESS) {
1149        for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) {
1150            if (pCommandBuffers[i]) {
1151                loader_init_dispatch(pCommandBuffers[i], disp);
1152            }
1153        }
1154    }
1155
1156    return res;
1157}
1158
1159LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1160vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
1161                     uint32_t commandBufferCount,
1162                     const VkCommandBuffer *pCommandBuffers) {
1163    const VkLayerDispatchTable *disp;
1164
1165    disp = loader_get_dispatch(device);
1166
1167    disp->FreeCommandBuffers(device, commandPool, commandBufferCount,
1168                             pCommandBuffers);
1169}
1170
1171LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1172vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
1173                     const VkCommandBufferBeginInfo *pBeginInfo) {
1174    const VkLayerDispatchTable *disp;
1175
1176    disp = loader_get_dispatch(commandBuffer);
1177
1178    return disp->BeginCommandBuffer(commandBuffer, pBeginInfo);
1179}
1180
1181LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1182vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
1183    const VkLayerDispatchTable *disp;
1184
1185    disp = loader_get_dispatch(commandBuffer);
1186
1187    return disp->EndCommandBuffer(commandBuffer);
1188}
1189
1190LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1191vkResetCommandBuffer(VkCommandBuffer commandBuffer,
1192                     VkCommandBufferResetFlags flags) {
1193    const VkLayerDispatchTable *disp;
1194
1195    disp = loader_get_dispatch(commandBuffer);
1196
1197    return disp->ResetCommandBuffer(commandBuffer, flags);
1198}
1199
1200LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1201vkCmdBindPipeline(VkCommandBuffer commandBuffer,
1202                  VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
1203    const VkLayerDispatchTable *disp;
1204
1205    disp = loader_get_dispatch(commandBuffer);
1206
1207    disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
1208}
1209
1210LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1211vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
1212                 uint32_t viewportCount, const VkViewport *pViewports) {
1213    const VkLayerDispatchTable *disp;
1214
1215    disp = loader_get_dispatch(commandBuffer);
1216
1217    disp->CmdSetViewport(commandBuffer, firstViewport, viewportCount,
1218                         pViewports);
1219}
1220
1221LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1222vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
1223                uint32_t scissorCount, const VkRect2D *pScissors) {
1224    const VkLayerDispatchTable *disp;
1225
1226    disp = loader_get_dispatch(commandBuffer);
1227
1228    disp->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
1229}
1230
1231LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1232vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
1233    const VkLayerDispatchTable *disp;
1234
1235    disp = loader_get_dispatch(commandBuffer);
1236
1237    disp->CmdSetLineWidth(commandBuffer, lineWidth);
1238}
1239
1240LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1241vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
1242                  float depthBiasClamp, float depthBiasSlopeFactor) {
1243    const VkLayerDispatchTable *disp;
1244
1245    disp = loader_get_dispatch(commandBuffer);
1246
1247    disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor,
1248                          depthBiasClamp, depthBiasSlopeFactor);
1249}
1250
1251LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1252vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
1253                       const float blendConstants[4]) {
1254    const VkLayerDispatchTable *disp;
1255
1256    disp = loader_get_dispatch(commandBuffer);
1257
1258    disp->CmdSetBlendConstants(commandBuffer, blendConstants);
1259}
1260
1261LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1262vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
1263                    float maxDepthBounds) {
1264    const VkLayerDispatchTable *disp;
1265
1266    disp = loader_get_dispatch(commandBuffer);
1267
1268    disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
1269}
1270
1271LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1272vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
1273                           VkStencilFaceFlags faceMask, uint32_t compareMask) {
1274    const VkLayerDispatchTable *disp;
1275
1276    disp = loader_get_dispatch(commandBuffer);
1277
1278    disp->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
1279}
1280
1281LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1282vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
1283                         VkStencilFaceFlags faceMask, uint32_t writeMask) {
1284    const VkLayerDispatchTable *disp;
1285
1286    disp = loader_get_dispatch(commandBuffer);
1287
1288    disp->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
1289}
1290
1291LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1292vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
1293                         VkStencilFaceFlags faceMask, uint32_t reference) {
1294    const VkLayerDispatchTable *disp;
1295
1296    disp = loader_get_dispatch(commandBuffer);
1297
1298    disp->CmdSetStencilReference(commandBuffer, faceMask, reference);
1299}
1300
1301LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
1302    VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
1303    VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount,
1304    const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount,
1305    const uint32_t *pDynamicOffsets) {
1306    const VkLayerDispatchTable *disp;
1307
1308    disp = loader_get_dispatch(commandBuffer);
1309
1310    disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout,
1311                                firstSet, descriptorSetCount, pDescriptorSets,
1312                                dynamicOffsetCount, pDynamicOffsets);
1313}
1314
1315LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1316vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
1317                     VkDeviceSize offset, VkIndexType indexType) {
1318    const VkLayerDispatchTable *disp;
1319
1320    disp = loader_get_dispatch(commandBuffer);
1321
1322    disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
1323}
1324
1325LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1326vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
1327                       uint32_t bindingCount, const VkBuffer *pBuffers,
1328                       const VkDeviceSize *pOffsets) {
1329    const VkLayerDispatchTable *disp;
1330
1331    disp = loader_get_dispatch(commandBuffer);
1332
1333    disp->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount,
1334                               pBuffers, pOffsets);
1335}
1336
1337LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1338vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
1339          uint32_t instanceCount, uint32_t firstVertex,
1340          uint32_t firstInstance) {
1341    const VkLayerDispatchTable *disp;
1342
1343    disp = loader_get_dispatch(commandBuffer);
1344
1345    disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex,
1346                  firstInstance);
1347}
1348
1349LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1350vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
1351                 uint32_t instanceCount, uint32_t firstIndex,
1352                 int32_t vertexOffset, uint32_t firstInstance) {
1353    const VkLayerDispatchTable *disp;
1354
1355    disp = loader_get_dispatch(commandBuffer);
1356
1357    disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex,
1358                         vertexOffset, firstInstance);
1359}
1360
1361LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1362vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
1363                  VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
1364    const VkLayerDispatchTable *disp;
1365
1366    disp = loader_get_dispatch(commandBuffer);
1367
1368    disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
1369}
1370
1371LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1372vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
1373                         VkDeviceSize offset, uint32_t drawCount,
1374                         uint32_t stride) {
1375    const VkLayerDispatchTable *disp;
1376
1377    disp = loader_get_dispatch(commandBuffer);
1378
1379    disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount,
1380                                 stride);
1381}
1382
1383LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1384vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y,
1385              uint32_t z) {
1386    const VkLayerDispatchTable *disp;
1387
1388    disp = loader_get_dispatch(commandBuffer);
1389
1390    disp->CmdDispatch(commandBuffer, x, y, z);
1391}
1392
1393LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1394vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
1395                      VkDeviceSize offset) {
1396    const VkLayerDispatchTable *disp;
1397
1398    disp = loader_get_dispatch(commandBuffer);
1399
1400    disp->CmdDispatchIndirect(commandBuffer, buffer, offset);
1401}
1402
1403LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1404vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
1405                VkBuffer dstBuffer, uint32_t regionCount,
1406                const VkBufferCopy *pRegions) {
1407    const VkLayerDispatchTable *disp;
1408
1409    disp = loader_get_dispatch(commandBuffer);
1410
1411    disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount,
1412                        pRegions);
1413}
1414
1415LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1416vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
1417               VkImageLayout srcImageLayout, VkImage dstImage,
1418               VkImageLayout dstImageLayout, uint32_t regionCount,
1419               const VkImageCopy *pRegions) {
1420    const VkLayerDispatchTable *disp;
1421
1422    disp = loader_get_dispatch(commandBuffer);
1423
1424    disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage,
1425                       dstImageLayout, regionCount, pRegions);
1426}
1427
1428LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1429vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
1430               VkImageLayout srcImageLayout, VkImage dstImage,
1431               VkImageLayout dstImageLayout, uint32_t regionCount,
1432               const VkImageBlit *pRegions, VkFilter filter) {
1433    const VkLayerDispatchTable *disp;
1434
1435    disp = loader_get_dispatch(commandBuffer);
1436
1437    disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage,
1438                       dstImageLayout, regionCount, pRegions, filter);
1439}
1440
1441LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1442vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
1443                       VkImage dstImage, VkImageLayout dstImageLayout,
1444                       uint32_t regionCount,
1445                       const VkBufferImageCopy *pRegions) {
1446    const VkLayerDispatchTable *disp;
1447
1448    disp = loader_get_dispatch(commandBuffer);
1449
1450    disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage,
1451                               dstImageLayout, regionCount, pRegions);
1452}
1453
1454LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1455vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
1456                       VkImageLayout srcImageLayout, VkBuffer dstBuffer,
1457                       uint32_t regionCount,
1458                       const VkBufferImageCopy *pRegions) {
1459    const VkLayerDispatchTable *disp;
1460
1461    disp = loader_get_dispatch(commandBuffer);
1462
1463    disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout,
1464                               dstBuffer, regionCount, pRegions);
1465}
1466
1467LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1468vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
1469                  VkDeviceSize dstOffset, VkDeviceSize dataSize,
1470                  const uint32_t *pData) {
1471    const VkLayerDispatchTable *disp;
1472
1473    disp = loader_get_dispatch(commandBuffer);
1474
1475    disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
1476}
1477
1478LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1479vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
1480                VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
1481    const VkLayerDispatchTable *disp;
1482
1483    disp = loader_get_dispatch(commandBuffer);
1484
1485    disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
1486}
1487
1488LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1489vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
1490                     VkImageLayout imageLayout, const VkClearColorValue *pColor,
1491                     uint32_t rangeCount,
1492                     const VkImageSubresourceRange *pRanges) {
1493    const VkLayerDispatchTable *disp;
1494
1495    disp = loader_get_dispatch(commandBuffer);
1496
1497    disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor,
1498                             rangeCount, pRanges);
1499}
1500
1501LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1502vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
1503                            VkImageLayout imageLayout,
1504                            const VkClearDepthStencilValue *pDepthStencil,
1505                            uint32_t rangeCount,
1506                            const VkImageSubresourceRange *pRanges) {
1507    const VkLayerDispatchTable *disp;
1508
1509    disp = loader_get_dispatch(commandBuffer);
1510
1511    disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout,
1512                                    pDepthStencil, rangeCount, pRanges);
1513}
1514
1515LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1516vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
1517                      const VkClearAttachment *pAttachments, uint32_t rectCount,
1518                      const VkClearRect *pRects) {
1519    const VkLayerDispatchTable *disp;
1520
1521    disp = loader_get_dispatch(commandBuffer);
1522
1523    disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments,
1524                              rectCount, pRects);
1525}
1526
1527LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1528vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
1529                  VkImageLayout srcImageLayout, VkImage dstImage,
1530                  VkImageLayout dstImageLayout, uint32_t regionCount,
1531                  const VkImageResolve *pRegions) {
1532    const VkLayerDispatchTable *disp;
1533
1534    disp = loader_get_dispatch(commandBuffer);
1535
1536    disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage,
1537                          dstImageLayout, regionCount, pRegions);
1538}
1539
1540LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1541vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
1542              VkPipelineStageFlags stageMask) {
1543    const VkLayerDispatchTable *disp;
1544
1545    disp = loader_get_dispatch(commandBuffer);
1546
1547    disp->CmdSetEvent(commandBuffer, event, stageMask);
1548}
1549
1550LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1551vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
1552                VkPipelineStageFlags stageMask) {
1553    const VkLayerDispatchTable *disp;
1554
1555    disp = loader_get_dispatch(commandBuffer);
1556
1557    disp->CmdResetEvent(commandBuffer, event, stageMask);
1558}
1559
1560LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1561vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
1562                const VkEvent *pEvents, VkPipelineStageFlags sourceStageMask,
1563                VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount,
1564                const VkMemoryBarrier *pMemoryBarriers,
1565                uint32_t bufferMemoryBarrierCount,
1566                const VkBufferMemoryBarrier *pBufferMemoryBarriers,
1567                uint32_t imageMemoryBarrierCount,
1568                const VkImageMemoryBarrier *pImageMemoryBarriers) {
1569    const VkLayerDispatchTable *disp;
1570
1571    disp = loader_get_dispatch(commandBuffer);
1572
1573    disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask,
1574                        dstStageMask, memoryBarrierCount, pMemoryBarriers,
1575                        bufferMemoryBarrierCount, pBufferMemoryBarriers,
1576                        imageMemoryBarrierCount, pImageMemoryBarriers);
1577}
1578
1579LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
1580    VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
1581    VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
1582    uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
1583    uint32_t bufferMemoryBarrierCount,
1584    const VkBufferMemoryBarrier *pBufferMemoryBarriers,
1585    uint32_t imageMemoryBarrierCount,
1586    const VkImageMemoryBarrier *pImageMemoryBarriers) {
1587    const VkLayerDispatchTable *disp;
1588
1589    disp = loader_get_dispatch(commandBuffer);
1590
1591    disp->CmdPipelineBarrier(
1592        commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
1593        memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
1594        pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1595}
1596
1597LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1598vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
1599                uint32_t slot, VkFlags flags) {
1600    const VkLayerDispatchTable *disp;
1601
1602    disp = loader_get_dispatch(commandBuffer);
1603
1604    disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
1605}
1606
1607LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1608vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
1609              uint32_t slot) {
1610    const VkLayerDispatchTable *disp;
1611
1612    disp = loader_get_dispatch(commandBuffer);
1613
1614    disp->CmdEndQuery(commandBuffer, queryPool, slot);
1615}
1616
1617LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1618vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
1619                    uint32_t firstQuery, uint32_t queryCount) {
1620    const VkLayerDispatchTable *disp;
1621
1622    disp = loader_get_dispatch(commandBuffer);
1623
1624    disp->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
1625}
1626
1627LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1628vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
1629                    VkPipelineStageFlagBits pipelineStage,
1630                    VkQueryPool queryPool, uint32_t slot) {
1631    const VkLayerDispatchTable *disp;
1632
1633    disp = loader_get_dispatch(commandBuffer);
1634
1635    disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
1636}
1637
1638LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1639vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
1640                          uint32_t firstQuery, uint32_t queryCount,
1641                          VkBuffer dstBuffer, VkDeviceSize dstOffset,
1642                          VkDeviceSize stride, VkFlags flags) {
1643    const VkLayerDispatchTable *disp;
1644
1645    disp = loader_get_dispatch(commandBuffer);
1646
1647    disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery,
1648                                  queryCount, dstBuffer, dstOffset, stride,
1649                                  flags);
1650}
1651
1652LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1653vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
1654                   VkShaderStageFlags stageFlags, uint32_t offset,
1655                   uint32_t size, const void *pValues) {
1656    const VkLayerDispatchTable *disp;
1657
1658    disp = loader_get_dispatch(commandBuffer);
1659
1660    disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size,
1661                           pValues);
1662}
1663
1664LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1665vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
1666                     const VkRenderPassBeginInfo *pRenderPassBegin,
1667                     VkSubpassContents contents) {
1668    const VkLayerDispatchTable *disp;
1669
1670    disp = loader_get_dispatch(commandBuffer);
1671
1672    disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
1673}
1674
1675LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1676vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
1677    const VkLayerDispatchTable *disp;
1678
1679    disp = loader_get_dispatch(commandBuffer);
1680
1681    disp->CmdNextSubpass(commandBuffer, contents);
1682}
1683
1684LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1685vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
1686    const VkLayerDispatchTable *disp;
1687
1688    disp = loader_get_dispatch(commandBuffer);
1689
1690    disp->CmdEndRenderPass(commandBuffer);
1691}
1692
1693LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1694vkCmdExecuteCommands(VkCommandBuffer commandBuffer,
1695                     uint32_t commandBuffersCount,
1696                     const VkCommandBuffer *pCommandBuffers) {
1697    const VkLayerDispatchTable *disp;
1698
1699    disp = loader_get_dispatch(commandBuffer);
1700
1701    disp->CmdExecuteCommands(commandBuffer, commandBuffersCount,
1702                             pCommandBuffers);
1703}
1704