From 01261e73d94be281a6b8bc73e088333841fb83d6 Mon Sep 17 00:00:00 2001 From: Jon Ashburn Date: Tue, 17 Nov 2015 15:31:02 -0700 Subject: loader: Add dynamic dispatch for unknown device extension entrypoints GetInstancePorcAddr() is specified to return trampoline entrypoints for all Vulkan core and extension entrypoints that are dispatched on an instance object or a child of that instance object. However, typically, device extensions would be unknown to the loader (don't want to rev the loader everytime an IHV creates a new device extension). This patch allows loader to dynamically discover device extension entrypoints and configure generic trampoline code for these discovered device extensions. --- loader/CMakeLists.txt | 3 + loader/dev_ext_trampoline.c | 2291 ++++++++++++++++++++++++++++++++++++++++++ loader/gpa_helper.h | 4 +- loader/loader.c | 231 ++++- loader/loader.h | 38 +- loader/murmurhash.c | 74 ++ loader/murmurhash.h | 31 + loader/table_ops.h | 10 +- loader/vk-loader-generate.py | 35 + loader/vk_loader_platform.h | 2 + 10 files changed, 2708 insertions(+), 11 deletions(-) create mode 100644 loader/dev_ext_trampoline.c create mode 100644 loader/murmurhash.c create mode 100644 loader/murmurhash.h (limited to 'loader') diff --git a/loader/CMakeLists.txt b/loader/CMakeLists.txt index 5dd180d6..c523d3da 100644 --- a/loader/CMakeLists.txt +++ b/loader/CMakeLists.txt @@ -26,6 +26,9 @@ set(LOADER_SRCS gpa_helper.h cJSON.c cJSON.h + dev_ext_trampoline.c + murmurhash.c + murmurhash.h ) diff --git a/loader/dev_ext_trampoline.c b/loader/dev_ext_trampoline.c new file mode 100644 index 00000000..f233340e --- /dev/null +++ b/loader/dev_ext_trampoline.c @@ -0,0 +1,2291 @@ +/* THIS FILE IS GENERATED. DO NOT EDIT. */ + +/* + * + * Copyright (C) 2015 Valve Corporation + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Author: Jon Ashburn + */ + +#include "vk_loader_platform.h" +#include "loader.h" +#if defined(__linux__) +#pragma GCC optimize(3) // force gcc to use tail-calls +#endif + + +VKAPI_ATTR void VKAPI_CALL vkDevExt0(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[0](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt1(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[1](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt2(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[2](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt3(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[3](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt4(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[4](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt5(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[5](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt6(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[6](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt7(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[7](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt8(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[8](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt9(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[9](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt10(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[10](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt11(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[11](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt12(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[12](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt13(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[13](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt14(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[14](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt15(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[15](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt16(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[16](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt17(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[17](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt18(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[18](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt19(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[19](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt20(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[20](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt21(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[21](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt22(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[22](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt23(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[23](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt24(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[24](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt25(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[25](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt26(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[26](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt27(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[27](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt28(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[28](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt29(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[29](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt30(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[30](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt31(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[31](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt32(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[32](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt33(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[33](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt34(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[34](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt35(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[35](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt36(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[36](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt37(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[37](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt38(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[38](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt39(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[39](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt40(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[40](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt41(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[41](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt42(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[42](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt43(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[43](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt44(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[44](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt45(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[45](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt46(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[46](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt47(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[47](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt48(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[48](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt49(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[49](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt50(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[50](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt51(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[51](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt52(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[52](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt53(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[53](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt54(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[54](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt55(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[55](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt56(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[56](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt57(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[57](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt58(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[58](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt59(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[59](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt60(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[60](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt61(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[61](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt62(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[62](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt63(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[63](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt64(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[64](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt65(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[65](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt66(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[66](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt67(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[67](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt68(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[68](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt69(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[69](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt70(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[70](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt71(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[71](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt72(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[72](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt73(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[73](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt74(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[74](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt75(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[75](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt76(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[76](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt77(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[77](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt78(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[78](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt79(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[79](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt80(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[80](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt81(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[81](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt82(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[82](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt83(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[83](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt84(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[84](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt85(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[85](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt86(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[86](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt87(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[87](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt88(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[88](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt89(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[89](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt90(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[90](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt91(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[91](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt92(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[92](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt93(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[93](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt94(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[94](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt95(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[95](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt96(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[96](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt97(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[97](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt98(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[98](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt99(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[99](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt100(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[100](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt101(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[101](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt102(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[102](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt103(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[103](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt104(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[104](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt105(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[105](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt106(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[106](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt107(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[107](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt108(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[108](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt109(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[109](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt110(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[110](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt111(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[111](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt112(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[112](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt113(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[113](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt114(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[114](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt115(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[115](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt116(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[116](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt117(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[117](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt118(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[118](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt119(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[119](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt120(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[120](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt121(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[121](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt122(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[122](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt123(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[123](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt124(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[124](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt125(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[125](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt126(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[126](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt127(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[127](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt128(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[128](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt129(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[129](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt130(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[130](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt131(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[131](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt132(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[132](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt133(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[133](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt134(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[134](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt135(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[135](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt136(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[136](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt137(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[137](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt138(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[138](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt139(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[139](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt140(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[140](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt141(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[141](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt142(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[142](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt143(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[143](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt144(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[144](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt145(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[145](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt146(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[146](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt147(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[147](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt148(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[148](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt149(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[149](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt150(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[150](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt151(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[151](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt152(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[152](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt153(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[153](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt154(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[154](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt155(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[155](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt156(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[156](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt157(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[157](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt158(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[158](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt159(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[159](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt160(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[160](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt161(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[161](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt162(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[162](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt163(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[163](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt164(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[164](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt165(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[165](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt166(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[166](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt167(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[167](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt168(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[168](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt169(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[169](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt170(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[170](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt171(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[171](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt172(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[172](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt173(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[173](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt174(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[174](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt175(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[175](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt176(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[176](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt177(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[177](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt178(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[178](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt179(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[179](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt180(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[180](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt181(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[181](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt182(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[182](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt183(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[183](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt184(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[184](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt185(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[185](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt186(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[186](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt187(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[187](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt188(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[188](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt189(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[189](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt190(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[190](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt191(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[191](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt192(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[192](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt193(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[193](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt194(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[194](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt195(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[195](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt196(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[196](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt197(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[197](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt198(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[198](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt199(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[199](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt200(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[200](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt201(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[201](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt202(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[202](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt203(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[203](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt204(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[204](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt205(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[205](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt206(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[206](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt207(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[207](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt208(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[208](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt209(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[209](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt210(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[210](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt211(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[211](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt212(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[212](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt213(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[213](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt214(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[214](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt215(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[215](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt216(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[216](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt217(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[217](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt218(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[218](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt219(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[219](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt220(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[220](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt221(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[221](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt222(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[222](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt223(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[223](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt224(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[224](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt225(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[225](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt226(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[226](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt227(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[227](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt228(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[228](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt229(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[229](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt230(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[230](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt231(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[231](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt232(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[232](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt233(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[233](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt234(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[234](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt235(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[235](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt236(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[236](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt237(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[237](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt238(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[238](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt239(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[239](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt240(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[240](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt241(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[241](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt242(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[242](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt243(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[243](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt244(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[244](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt245(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[245](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt246(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[246](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt247(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[247](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt248(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[248](device); +} + +VKAPI_ATTR void VKAPI_CALL vkDevExt249(VkDevice device) +{ + const struct loader_dev_dispatch_table *disp; + disp = loader_get_dev_dispatch(device); + disp->ext_dispatch.DevExt[249](device); +} + +void *loader_get_dev_ext_trampoline(uint32_t index) +{ + switch (index) { + case 0: + return vkDevExt0; + case 1: + return vkDevExt1; + case 2: + return vkDevExt2; + case 3: + return vkDevExt3; + case 4: + return vkDevExt4; + case 5: + return vkDevExt5; + case 6: + return vkDevExt6; + case 7: + return vkDevExt7; + case 8: + return vkDevExt8; + case 9: + return vkDevExt9; + case 10: + return vkDevExt10; + case 11: + return vkDevExt11; + case 12: + return vkDevExt12; + case 13: + return vkDevExt13; + case 14: + return vkDevExt14; + case 15: + return vkDevExt15; + case 16: + return vkDevExt16; + case 17: + return vkDevExt17; + case 18: + return vkDevExt18; + case 19: + return vkDevExt19; + case 20: + return vkDevExt20; + case 21: + return vkDevExt21; + case 22: + return vkDevExt22; + case 23: + return vkDevExt23; + case 24: + return vkDevExt24; + case 25: + return vkDevExt25; + case 26: + return vkDevExt26; + case 27: + return vkDevExt27; + case 28: + return vkDevExt28; + case 29: + return vkDevExt29; + case 30: + return vkDevExt30; + case 31: + return vkDevExt31; + case 32: + return vkDevExt32; + case 33: + return vkDevExt33; + case 34: + return vkDevExt34; + case 35: + return vkDevExt35; + case 36: + return vkDevExt36; + case 37: + return vkDevExt37; + case 38: + return vkDevExt38; + case 39: + return vkDevExt39; + case 40: + return vkDevExt40; + case 41: + return vkDevExt41; + case 42: + return vkDevExt42; + case 43: + return vkDevExt43; + case 44: + return vkDevExt44; + case 45: + return vkDevExt45; + case 46: + return vkDevExt46; + case 47: + return vkDevExt47; + case 48: + return vkDevExt48; + case 49: + return vkDevExt49; + case 50: + return vkDevExt50; + case 51: + return vkDevExt51; + case 52: + return vkDevExt52; + case 53: + return vkDevExt53; + case 54: + return vkDevExt54; + case 55: + return vkDevExt55; + case 56: + return vkDevExt56; + case 57: + return vkDevExt57; + case 58: + return vkDevExt58; + case 59: + return vkDevExt59; + case 60: + return vkDevExt60; + case 61: + return vkDevExt61; + case 62: + return vkDevExt62; + case 63: + return vkDevExt63; + case 64: + return vkDevExt64; + case 65: + return vkDevExt65; + case 66: + return vkDevExt66; + case 67: + return vkDevExt67; + case 68: + return vkDevExt68; + case 69: + return vkDevExt69; + case 70: + return vkDevExt70; + case 71: + return vkDevExt71; + case 72: + return vkDevExt72; + case 73: + return vkDevExt73; + case 74: + return vkDevExt74; + case 75: + return vkDevExt75; + case 76: + return vkDevExt76; + case 77: + return vkDevExt77; + case 78: + return vkDevExt78; + case 79: + return vkDevExt79; + case 80: + return vkDevExt80; + case 81: + return vkDevExt81; + case 82: + return vkDevExt82; + case 83: + return vkDevExt83; + case 84: + return vkDevExt84; + case 85: + return vkDevExt85; + case 86: + return vkDevExt86; + case 87: + return vkDevExt87; + case 88: + return vkDevExt88; + case 89: + return vkDevExt89; + case 90: + return vkDevExt90; + case 91: + return vkDevExt91; + case 92: + return vkDevExt92; + case 93: + return vkDevExt93; + case 94: + return vkDevExt94; + case 95: + return vkDevExt95; + case 96: + return vkDevExt96; + case 97: + return vkDevExt97; + case 98: + return vkDevExt98; + case 99: + return vkDevExt99; + case 100: + return vkDevExt100; + case 101: + return vkDevExt101; + case 102: + return vkDevExt102; + case 103: + return vkDevExt103; + case 104: + return vkDevExt104; + case 105: + return vkDevExt105; + case 106: + return vkDevExt106; + case 107: + return vkDevExt107; + case 108: + return vkDevExt108; + case 109: + return vkDevExt109; + case 110: + return vkDevExt110; + case 111: + return vkDevExt111; + case 112: + return vkDevExt112; + case 113: + return vkDevExt113; + case 114: + return vkDevExt114; + case 115: + return vkDevExt115; + case 116: + return vkDevExt116; + case 117: + return vkDevExt117; + case 118: + return vkDevExt118; + case 119: + return vkDevExt119; + case 120: + return vkDevExt120; + case 121: + return vkDevExt121; + case 122: + return vkDevExt122; + case 123: + return vkDevExt123; + case 124: + return vkDevExt124; + case 125: + return vkDevExt125; + case 126: + return vkDevExt126; + case 127: + return vkDevExt127; + case 128: + return vkDevExt128; + case 129: + return vkDevExt129; + case 130: + return vkDevExt130; + case 131: + return vkDevExt131; + case 132: + return vkDevExt132; + case 133: + return vkDevExt133; + case 134: + return vkDevExt134; + case 135: + return vkDevExt135; + case 136: + return vkDevExt136; + case 137: + return vkDevExt137; + case 138: + return vkDevExt138; + case 139: + return vkDevExt139; + case 140: + return vkDevExt140; + case 141: + return vkDevExt141; + case 142: + return vkDevExt142; + case 143: + return vkDevExt143; + case 144: + return vkDevExt144; + case 145: + return vkDevExt145; + case 146: + return vkDevExt146; + case 147: + return vkDevExt147; + case 148: + return vkDevExt148; + case 149: + return vkDevExt149; + case 150: + return vkDevExt150; + case 151: + return vkDevExt151; + case 152: + return vkDevExt152; + case 153: + return vkDevExt153; + case 154: + return vkDevExt154; + case 155: + return vkDevExt155; + case 156: + return vkDevExt156; + case 157: + return vkDevExt157; + case 158: + return vkDevExt158; + case 159: + return vkDevExt159; + case 160: + return vkDevExt160; + case 161: + return vkDevExt161; + case 162: + return vkDevExt162; + case 163: + return vkDevExt163; + case 164: + return vkDevExt164; + case 165: + return vkDevExt165; + case 166: + return vkDevExt166; + case 167: + return vkDevExt167; + case 168: + return vkDevExt168; + case 169: + return vkDevExt169; + case 170: + return vkDevExt170; + case 171: + return vkDevExt171; + case 172: + return vkDevExt172; + case 173: + return vkDevExt173; + case 174: + return vkDevExt174; + case 175: + return vkDevExt175; + case 176: + return vkDevExt176; + case 177: + return vkDevExt177; + case 178: + return vkDevExt178; + case 179: + return vkDevExt179; + case 180: + return vkDevExt180; + case 181: + return vkDevExt181; + case 182: + return vkDevExt182; + case 183: + return vkDevExt183; + case 184: + return vkDevExt184; + case 185: + return vkDevExt185; + case 186: + return vkDevExt186; + case 187: + return vkDevExt187; + case 188: + return vkDevExt188; + case 189: + return vkDevExt189; + case 190: + return vkDevExt190; + case 191: + return vkDevExt191; + case 192: + return vkDevExt192; + case 193: + return vkDevExt193; + case 194: + return vkDevExt194; + case 195: + return vkDevExt195; + case 196: + return vkDevExt196; + case 197: + return vkDevExt197; + case 198: + return vkDevExt198; + case 199: + return vkDevExt199; + case 200: + return vkDevExt200; + case 201: + return vkDevExt201; + case 202: + return vkDevExt202; + case 203: + return vkDevExt203; + case 204: + return vkDevExt204; + case 205: + return vkDevExt205; + case 206: + return vkDevExt206; + case 207: + return vkDevExt207; + case 208: + return vkDevExt208; + case 209: + return vkDevExt209; + case 210: + return vkDevExt210; + case 211: + return vkDevExt211; + case 212: + return vkDevExt212; + case 213: + return vkDevExt213; + case 214: + return vkDevExt214; + case 215: + return vkDevExt215; + case 216: + return vkDevExt216; + case 217: + return vkDevExt217; + case 218: + return vkDevExt218; + case 219: + return vkDevExt219; + case 220: + return vkDevExt220; + case 221: + return vkDevExt221; + case 222: + return vkDevExt222; + case 223: + return vkDevExt223; + case 224: + return vkDevExt224; + case 225: + return vkDevExt225; + case 226: + return vkDevExt226; + case 227: + return vkDevExt227; + case 228: + return vkDevExt228; + case 229: + return vkDevExt229; + case 230: + return vkDevExt230; + case 231: + return vkDevExt231; + case 232: + return vkDevExt232; + case 233: + return vkDevExt233; + case 234: + return vkDevExt234; + case 235: + return vkDevExt235; + case 236: + return vkDevExt236; + case 237: + return vkDevExt237; + case 238: + return vkDevExt238; + case 239: + return vkDevExt239; + case 240: + return vkDevExt240; + case 241: + return vkDevExt241; + case 242: + return vkDevExt242; + case 243: + return vkDevExt243; + case 244: + return vkDevExt244; + case 245: + return vkDevExt245; + case 246: + return vkDevExt246; + case 247: + return vkDevExt247; + case 248: + return vkDevExt248; + case 249: + return vkDevExt249; + } + return NULL; +} diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h index 5fb12324..1c0c84e6 100644 --- a/loader/gpa_helper.h +++ b/loader/gpa_helper.h @@ -310,8 +310,8 @@ static inline void* trampolineGetProcAddr(struct loader_instance *inst, if (wsi_swapchain_instance_gpa(inst, funcName, &addr)) return addr; - //TODO device extensions - return NULL; + addr = loader_dev_ext_gpa(inst, funcName); + return addr; } static inline void* globalGetProcAddr(const char *name) diff --git a/loader/loader.c b/loader/loader.c index 4f910111..f1a8556a 100644 --- a/loader/loader.c +++ b/loader/loader.c @@ -47,6 +47,7 @@ #include "wsi_swapchain.h" #include "vulkan/vk_icd.h" #include "cJSON.h" +#include "murmurhash.h" static loader_platform_dl_handle loader_add_layer_lib( const struct loader_instance *inst, @@ -2048,6 +2049,221 @@ static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpa_instance_internal(VkI return disp_table->GetInstanceProcAddr(inst, pName); } +/** + * Initialize device_ext dispatch table entry as follows: + * If dev == NULL find all logical devices created within this instance and + * init the entry (given by idx) in the ext dispatch table. + * If dev != NULL only initialize the entry in the given dev's dispatch table. + * The initialization value is gotten by calling down the device chain with GDPA. + * If GDPA returns NULL then don't initialize the dispatch table entry. + */ +static void loader_init_dispatch_dev_ext_entry(struct loader_instance *inst, + struct loader_device *dev, + uint32_t idx, + const char *funcName) + + { + void *gdpa_value; + if (dev != NULL) { + gdpa_value = dev->loader_dispatch.core_dispatch.GetDeviceProcAddr( + dev->device, funcName); + if (gdpa_value != NULL) + dev->loader_dispatch.ext_dispatch.DevExt[idx] = (PFN_vkDevExt) gdpa_value; + } else { + for (uint32_t i = 0; i < inst->total_icd_count; i++) { + struct loader_icd *icd = &inst->icds[i]; + struct loader_device *dev = icd->logical_device_list; + while (dev) { + gdpa_value = dev->loader_dispatch.core_dispatch.GetDeviceProcAddr( + dev->device, funcName); + if (gdpa_value != NULL) + dev->loader_dispatch.ext_dispatch.DevExt[idx] = + (PFN_vkDevExt) gdpa_value; + dev = dev->next; + } + } + } + +} + +/** + * Find all dev extension in the hash table and initialize the dispatch table + * for dev for each of those extension entrypoints found in hash table. + + */ +static void loader_init_dispatch_dev_ext(struct loader_instance *inst, + struct loader_device *dev) +{ + for (uint32_t i = 0; i < MAX_NUM_DEV_EXTS; i++) { + if (inst->disp_hash[i].func_name != NULL) + loader_init_dispatch_dev_ext_entry(inst, dev, i, + inst->disp_hash[i].func_name); + } +} + +static bool loader_check_icds_for_address(struct loader_instance *inst, + const char *funcName) +{ + struct loader_icd *icd; + icd = inst->icds; + while (icd) { + if (icd->this_icd_lib->GetInstanceProcAddr(icd->instance, funcName)) + // this icd supports funcName + return true; + icd = icd->next; + } + + return false; +} + +static void loader_free_dev_ext_table(struct loader_instance *inst) +{ + for (uint32_t i = 0; i < MAX_NUM_DEV_EXTS; i++) { + loader_heap_free(inst, inst->disp_hash[i].func_name); + loader_heap_free(inst, inst->disp_hash[i].list.index); + + } + memset(inst->disp_hash, 0, sizeof(inst->disp_hash)); +} + +static bool loader_add_dev_ext_table(struct loader_instance *inst, + uint32_t *ptr_idx, + const char *funcName) +{ + uint32_t i; + uint32_t idx = *ptr_idx; + struct loader_dispatch_hash_list *list = &inst->disp_hash[idx].list; + + if (!inst->disp_hash[idx].func_name) { + // no entry here at this idx, so use it + assert(list->capacity == 0); + inst->disp_hash[idx].func_name = (char *) loader_heap_alloc(inst, + strlen(funcName) + 1, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (inst->disp_hash[idx].func_name == NULL) { + loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + "loader_add_dev_ext_table() can't allocate memory for func_name"); + return false; + } + strncpy(inst->disp_hash[idx].func_name, funcName, strlen(funcName) + 1); + return true; + } + + // check for enough capacity + if (list->capacity == 0) { + list->index = loader_heap_alloc(inst, 8 * sizeof(*(list->index)), + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (list->index == NULL) { + loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + "loader_add_dev_ext_table() can't allocate list memory"); + return false; + } + list->capacity = 8 * sizeof(*(list->index)); + } else if (list->capacity < (list->count + 1) * sizeof(*(list->index))) { + list->index = loader_heap_realloc(inst, list->index, list->capacity, + list->capacity * 2, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (list->index == NULL) { + loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + "loader_add_dev_ext_table() can't reallocate list memory"); + return false; + } + list->capacity *= 2; + } + + //find an unused index in the hash table and use it + i = (idx + 1) % MAX_NUM_DEV_EXTS; + do { + if (!inst->disp_hash[i].func_name) { + assert(inst->disp_hash[i].list.capacity == 0); + inst->disp_hash[i].func_name = (char *) loader_heap_alloc(inst, + strlen(funcName) + 1, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (inst->disp_hash[i].func_name == NULL) { + loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + "loader_add_dev_ext_table() can't rallocate func_name memory"); + return false; + } + strncpy(inst->disp_hash[i].func_name, funcName, strlen(funcName) + 1); + list->index[list->count] = i; + list->count++; + *ptr_idx = i; + return true; + } + i = (i + 1) % MAX_NUM_DEV_EXTS; + } while (i != idx); + + loader_log(VK_DBG_REPORT_ERROR_BIT, 0, + "loader_add_dev_ext_table() couldn't insert into hash table; is it full?"); + return false; +} + +static bool loader_name_in_dev_ext_table(struct loader_instance *inst, + uint32_t *idx, + const char *funcName) +{ + uint32_t alt_idx; + if (inst->disp_hash[*idx].func_name && !strcmp( + inst->disp_hash[*idx].func_name, + funcName)) + return true; + + // funcName wasn't at the primary spot in the hash table + // search the list of secondary locations (shallow search, not deep search) + for (uint32_t i = 0; i < inst->disp_hash[*idx].list.count; i++) { + alt_idx = inst->disp_hash[*idx].list.index[i]; + if (!strcmp(inst->disp_hash[*idx].func_name, funcName)) { + *idx = alt_idx; + return true; + } + } + + return false; +} + +/** + * This function returns generic trampoline code address for unknown entry points. + * Presumably, these unknown entry points (as given by funcName) are device + * extension entrypoints. A hash table is used to keep a list of unknown entry + * points and their mapping to the device extension dispatch table + * (struct loader_dev_ext_dispatch_table). + * \returns + * For a given entry point string (funcName), if an existing mapping is found the + * trampoline address for that mapping is returned. Otherwise, this unknown entry point + * has not been seen yet. Next check if a layer or ICD supports it. If so then a + * new entry in the hash table is initialized and that trampoline address for + * the new entry is returned. Null is returned if the hash table is full or + * if no discovered layer or ICD returns a non-NULL GetProcAddr for it. + */ +void *loader_dev_ext_gpa(struct loader_instance *inst, + const char *funcName) +{ + uint32_t idx; + uint32_t seed = 0; + + idx = murmurhash(funcName, strlen(funcName), seed) % MAX_NUM_DEV_EXTS; + + if (loader_name_in_dev_ext_table(inst, &idx, funcName)) + // found funcName already in hash + return loader_get_dev_ext_trampoline(idx); + + // Check if funcName is supported in either ICDs or a layer library + if (!loader_check_icds_for_address(inst, funcName)) { + // TODO Add check in layer libraries for support of address + // if support found in layers continue on + return NULL; + } + + if (loader_add_dev_ext_table(inst, &idx, funcName)) { + // successfully added new table entry + // init any dev dispatch table entrys as needed + loader_init_dispatch_dev_ext_entry(inst, NULL, idx, funcName); + return loader_get_dev_ext_trampoline(idx); + } + + return NULL; +} + struct loader_instance *loader_get_instance(const VkInstance instance) { /* look up the loader_instance in our list by comparing dispatch tables, as @@ -2759,6 +2975,7 @@ VKAPI_ATTR void VKAPI_CALL loader_DestroyInstance( for (uint32_t i = 0; i < ptr_instance->total_gpu_count; i++) loader_destroy_ext_list(ptr_instance, &ptr_instance->phys_devs[i].device_extension_cache); loader_heap_free(ptr_instance, ptr_instance->phys_devs); + loader_free_dev_ext_table(ptr_instance); } VkResult loader_init_physical_device_info(struct loader_instance *ptr_instance) @@ -2962,7 +3179,7 @@ VKAPI_ATTR VkResult VKAPI_CALL loader_CreateDevice( struct loader_physical_device *phys_dev = (struct loader_physical_device *) physicalDevice; struct loader_icd *icd = phys_dev->this_icd; struct loader_device *dev; - const struct loader_instance *inst; + struct loader_instance *inst; VkDeviceCreateInfo device_create_info; char **filtered_extension_names = NULL; VkResult res; @@ -3050,11 +3267,7 @@ VKAPI_ATTR VkResult VKAPI_CALL loader_CreateDevice( if (dev == NULL) { return VK_ERROR_OUT_OF_HOST_MEMORY; } - PFN_vkGetDeviceProcAddr get_proc_addr = icd->GetDeviceProcAddr; - loader_init_device_dispatch_table(&dev->loader_dispatch, get_proc_addr, - *pDevice, *pDevice); - dev->loader_dispatch.CreateDevice = scratch_vkCreateDevice; loader_init_dispatch(*pDevice, &dev->loader_dispatch); /* activate any layers on device chain which terminates with device*/ @@ -3065,9 +3278,13 @@ VKAPI_ATTR VkResult VKAPI_CALL loader_CreateDevice( } loader_activate_device_layers(inst, dev, *pDevice); - res = dev->loader_dispatch.CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); + /* initialize any device extension dispatch entry's from the instance list*/ + loader_init_dispatch_dev_ext(inst, dev); + + /* finally can call down the chain */ + res = dev->loader_dispatch.core_dispatch.CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); - dev->loader_dispatch.CreateDevice = icd->CreateDevice; + dev->loader_dispatch.core_dispatch.CreateDevice = icd->CreateDevice; return res; } diff --git a/loader/loader.h b/loader/loader.h index 3b9ee47d..c9cf11a2 100644 --- a/loader/loader.h +++ b/loader/loader.h @@ -109,9 +109,34 @@ struct loader_layer_library_list { struct loader_lib_info *list; }; +struct loader_dispatch_hash_list { + size_t capacity; + uint32_t count; + uint32_t *index; // index into the dev_ext dispatch table +}; + +#define MAX_NUM_DEV_EXTS 250 +// loader_dispatch_hash_entry and loader_dev_ext_dispatch_table.DevExt have one to one +// correspondence; one loader_dispatch_hash_entry for one DevExt dispatch entry. +// Also have a one to one correspondence with functions in dev_ext_trampoline.c +struct loader_dispatch_hash_entry { + char *func_name; + struct loader_dispatch_hash_list list; // to handle hashing collisions +}; + +typedef void (VKAPI_PTR *PFN_vkDevExt)(VkDevice device); +struct loader_dev_ext_dispatch_table { + PFN_vkDevExt DevExt[MAX_NUM_DEV_EXTS]; +}; + +struct loader_dev_dispatch_table { + VkLayerDispatchTable core_dispatch; + struct loader_dev_ext_dispatch_table ext_dispatch; +}; + /* per CreateDevice structure */ struct loader_device { - VkLayerDispatchTable loader_dispatch; + struct loader_dev_dispatch_table loader_dispatch; VkDevice device; // device object from the icd uint32_t app_extension_count; @@ -169,6 +194,7 @@ struct loader_instance { struct loader_icd_libs icd_libs; struct loader_layer_list instance_layer_list; struct loader_layer_list device_layer_list; + struct loader_dispatch_hash_entry disp_hash[MAX_NUM_DEV_EXTS]; struct loader_msg_callback_map_entry *icd_msg_callback_map; @@ -229,6 +255,11 @@ static inline VkLayerDispatchTable *loader_get_dispatch(const void* obj) return *((VkLayerDispatchTable **) obj); } +static inline struct loader_dev_dispatch_table *loader_get_dev_dispatch(const void* obj) +{ + return *((struct loader_dev_dispatch_table **) obj); +} + static inline VkLayerInstanceDispatchTable *loader_get_instance_dispatch(const void* obj) { return *((VkLayerInstanceDispatchTable **) obj); @@ -384,6 +415,11 @@ void loader_get_icd_loader_instance_extensions( struct loader_icd *loader_get_icd_and_device( const VkDevice device, struct loader_device **found_dev); +void *loader_dev_ext_gpa( + struct loader_instance *inst, + const char *funcName); +void *loader_get_dev_ext_trampoline( + uint32_t index); struct loader_instance *loader_get_instance( const VkInstance instance); void loader_remove_logical_device( diff --git a/loader/murmurhash.c b/loader/murmurhash.c new file mode 100644 index 00000000..4f1dc4b2 --- /dev/null +++ b/loader/murmurhash.c @@ -0,0 +1,74 @@ + +/** + * `murmurhash.h' - murmurhash + * + * copyright (c) 2014 joseph werle + */ + +#include +#include +#include +#include "murmurhash.h" + +uint32_t +murmurhash (const char *key, uint32_t len, uint32_t seed) { + uint32_t c1 = 0xcc9e2d51; + uint32_t c2 = 0x1b873593; + uint32_t r1 = 15; + uint32_t r2 = 13; + uint32_t m = 5; + uint32_t n = 0xe6546b64; + uint32_t h = 0; + uint32_t k = 0; + uint8_t *d = (uint8_t *) key; // 32 bit extract from `key' + const uint32_t *chunks = NULL; + const uint8_t *tail = NULL; // tail - last 8 bytes + int i = 0; + int l = len / 4; // chunk length + + h = seed; + + chunks = (const uint32_t *) (d + l * 4); // body + tail = (const uint8_t *) (d + l * 4); // last 8 byte chunk of `key' + + // for each 4 byte chunk of `key' + for (i = -l; i != 0; ++i) { + // next 4 byte chunk of `key' + k = chunks[i]; + + // encode next 4 byte chunk of `key' + k *= c1; + k = (k << r1) | (k >> (32 - r1)); + k *= c2; + + // append to hash + h ^= k; + h = (h << r2) | (h >> (32 - r2)); + h = h * m + n; + } + + k = 0; + + // remainder + switch (len & 3) { // `len % 4' + case 3: k ^= (tail[2] << 16); + case 2: k ^= (tail[1] << 8); + + case 1: + k ^= tail[0]; + k *= c1; + k = (k << r1) | (k >> (32 - r1)); + k *= c2; + h ^= k; + } + + h ^= len; + + h ^= (h >> 16); + h *= 0x85ebca6b; + h ^= (h >> 13); + h *= 0xc2b2ae35; + h ^= (h >> 16); + + return h; +} diff --git a/loader/murmurhash.h b/loader/murmurhash.h new file mode 100644 index 00000000..3fa072c1 --- /dev/null +++ b/loader/murmurhash.h @@ -0,0 +1,31 @@ + +/** + * `murmurhash.h' - murmurhash + * + * copyright (c) 2014 joseph werle + */ + +#ifndef MURMURHASH_H +#define MURMURHASH_H 1 + +#include + +#define MURMURHASH_VERSION "0.0.3" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Returns a murmur hash of `key' based on `seed' + * using the MurmurHash3 algorithm + */ + +uint32_t +murmurhash (const char *key, uint32_t len, uint32_t seed); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/loader/table_ops.h b/loader/table_ops.h index 2b113e36..e468b0d9 100644 --- a/loader/table_ops.h +++ b/loader/table_ops.h @@ -31,11 +31,19 @@ #include "loader.h" #include "vk_loader_platform.h" -static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table, +static VkResult vkDevExtError(VkDevice dev) +{ + return VK_ERROR_INITIALIZATION_FAILED; +} + +static inline void loader_init_device_dispatch_table(struct loader_dev_dispatch_table *dev_table, PFN_vkGetDeviceProcAddr gpa, VkDevice dev_next, VkDevice dev) { + VkLayerDispatchTable *table = &dev_table->core_dispatch; + for (uint32_t i = 0; i < MAX_NUM_DEV_EXTS; i++) + dev_table->ext_dispatch.DevExt[i] = (PFN_vkDevExt) vkDevExtError; // If layer is next, this will trigger layers to initialize their dispatch tables //then use the gpa in their dispatch for subsequent layers in the chain table->GetDeviceProcAddr = (PFN_vkGetDeviceProcAddr) gpa(dev_next, "vkGetDeviceProcAddr"); diff --git a/loader/vk-loader-generate.py b/loader/vk-loader-generate.py index 143af61f..e2c794dd 100755 --- a/loader/vk-loader-generate.py +++ b/loader/vk-loader-generate.py @@ -91,6 +91,7 @@ class Subcommand(object): /* * * Copyright (C) 2015 Valve Corporation + * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -111,6 +112,8 @@ class Subcommand(object): * DEALINGS IN THE SOFTWARE. * * Author: Jon Ashburn + * Author: Chia-I Wu + * Author: Courtney Goeltzenleuchter */""" def generate_header(self): @@ -122,6 +125,37 @@ class Subcommand(object): def generate_footer(self): pass +class DevExtTrampolineSubcommand(Subcommand): + def generate_header(self): + lines = [] + lines.append("#include \"vk_loader_platform.h\"") + lines.append("#include \"loader.h\"") + lines.append("#if defined(__linux__)") + lines.append("#pragma GCC optimize(3) // force gcc to use tail-calls") + lines.append("#endif") + return "\n".join(lines) + + def generate_body(self): + lines = [] + for i in range(250): + lines.append('\nVKAPI_ATTR void VKAPI_CALL vkDevExt%s(VkDevice device)' % i) + lines.append('{') + lines.append(' const struct loader_dev_dispatch_table *disp;') + lines.append(' disp = loader_get_dev_dispatch(device);') + lines.append(' disp->ext_dispatch.DevExt[%s](device);' % i) + lines.append('}') + lines.append('') + lines.append('void *loader_get_dev_ext_trampoline(uint32_t index)') + lines.append('{') + lines.append(' switch (index) {') + for i in range(250): + lines.append(' case %s:' % i) + lines.append(' return vkDevExt%s;' % i) + lines.append(' }') + lines.append(' return NULL;') + lines.append('}') + return "\n".join(lines) + class LoaderEntrypointsSubcommand(Subcommand): def generate_header(self): return "#include \"loader.h\"" @@ -412,6 +446,7 @@ class LoaderGetProcAddrSubcommand(Subcommand): def main(): subcommands = { + "dev-ext-trampoline": DevExtTrampolineSubcommand, "loader-entrypoints": LoaderEntrypointsSubcommand, "dispatch-table-ops": DispatchTableOpsSubcommand, "win-def-file": WinDefFileSubcommand, diff --git a/loader/vk_loader_platform.h b/loader/vk_loader_platform.h index 530546d9..1688e5eb 100644 --- a/loader/vk_loader_platform.h +++ b/loader/vk_loader_platform.h @@ -43,6 +43,7 @@ #include #include #include +#include #include #include #include @@ -207,6 +208,7 @@ static inline void loader_platform_thread_cond_broadcast(loader_platform_thread_ #endif #include #include +#include #include #include #include -- cgit v1.2.3