aboutsummaryrefslogtreecommitdiff
path: root/loader
diff options
context:
space:
mode:
authorJon Ashburn <jon@lunarg.com>2015-11-17 15:31:02 -0700
committerJon Ashburn <jon@lunarg.com>2015-11-18 17:05:38 -0700
commit01261e73d94be281a6b8bc73e088333841fb83d6 (patch)
tree422905de73cc57fc3340522c598c5304187fa7de /loader
parente716d2ed830a7080604a7d6b66224ff88c0f14b6 (diff)
downloadusermoji-01261e73d94be281a6b8bc73e088333841fb83d6.tar.xz
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.
Diffstat (limited to 'loader')
-rw-r--r--loader/CMakeLists.txt3
-rw-r--r--loader/dev_ext_trampoline.c2291
-rw-r--r--loader/gpa_helper.h4
-rw-r--r--loader/loader.c231
-rw-r--r--loader/loader.h38
-rw-r--r--loader/murmurhash.c74
-rw-r--r--loader/murmurhash.h31
-rw-r--r--loader/table_ops.h10
-rwxr-xr-xloader/vk-loader-generate.py35
-rw-r--r--loader/vk_loader_platform.h2
10 files changed, 2708 insertions, 11 deletions
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 <jon@lunarg.com>
+ */
+
+#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 <joseph.werle@gmail.com>
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#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 <joseph.werle@gmail.com>
+ */
+
+#ifndef MURMURHASH_H
+#define MURMURHASH_H 1
+
+#include <stdint.h>
+
+#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 <jon@lunarg.com>
+ * Author: Chia-I Wu <olv@lunarg.com>
+ * Author: Courtney Goeltzenleuchter <courtney@lunarg.com>
*/"""
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 <dlfcn.h>
#include <pthread.h>
#include <assert.h>
+#include <string.h>
#include <stdbool.h>
#include <stdlib.h>
#include <libgen.h>
@@ -207,6 +208,7 @@ static inline void loader_platform_thread_cond_broadcast(loader_platform_thread_
#endif
#include <assert.h>
#include <stdio.h>
+#include <string.h>
#include <io.h>
#include <stdbool.h>
#include <shlwapi.h>
generated by cgit v1.2.3 (git 2.39.1) at 2026-08-05 01:19:43 +0000