| {{define "Copyright"}} | |
| /* | |
| •* Copyright 2016 The Android Open Source Project | |
| •* | |
| •* Licensed under the Apache License, Version 2.0 (the "License"); | |
| •* you may not use this file except in compliance with the License. | |
| •* You may obtain a copy of the License at | |
| •* | |
| •* http://www.apache.org/licenses/LICENSE-2.0 | |
| •* | |
| •* Unless required by applicable law or agreed to in writing, software | |
| •* distributed under the License is distributed on an "AS IS" BASIS, | |
| •* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| •* See the License for the specific language governing permissions and | |
| •* limitations under the License. | |
| •*/ | |
| ¶{{end}} | |
| {{Include "../api/templates/vulkan_common.tmpl"}} | |
| {{Global "clang-format" (Strings "clang-format" "-style=file")}} | |
| {{Macro "DefineGlobals" $}} | |
| {{$ | Macro "api_gen.h" | Format (Global "clang-format") | Write "api_gen.h" }} | |
| {{$ | Macro "api_gen.cpp" | Format (Global "clang-format") | Write "api_gen.cpp"}} | |
| {{$ | Macro "driver_gen.h" | Format (Global "clang-format") | Write "driver_gen.h"}} | |
| {{$ | Macro "driver_gen.cpp" | Format (Global "clang-format") | Write "driver_gen.cpp"}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| api_gen.h | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "api_gen.h"}} | |
| {{Macro "Copyright"}} | |
| ¶ | |
| // WARNING: This file is generated. See ../README.md for instructions. | |
| ¶ | |
| #ifndef LIBVULKAN_API_GEN_H | |
| #define LIBVULKAN_API_GEN_H | |
| ¶ | |
| #include <bitset> | |
| #include <vulkan/vulkan.h> | |
| #include "driver_gen.h" | |
| ¶ | |
| namespace vulkan {« | |
| namespace api {« | |
| ¶ | |
| struct InstanceDispatchTable { | |
| // clang-format off | |
| {{range $f := AllCommands $}} | |
| {{if (Macro "api.IsInstanceDispatchTableEntry" $f)}} | |
| {{Macro "C++.DeclareTableEntry" $f}}; | |
| {{end}} | |
| {{end}} | |
| // clang-format on | |
| }; | |
| ¶ | |
| struct DeviceDispatchTable { | |
| // clang-format off | |
| {{range $f := AllCommands $}} | |
| {{if (Macro "api.IsDeviceDispatchTableEntry" $f)}} | |
| {{Macro "C++.DeclareTableEntry" $f}}; | |
| {{end}} | |
| {{end}} | |
| // clang-format on | |
| }; | |
| ¶ | |
| bool InitDispatchTable( | |
| VkInstance instance, | |
| PFN_vkGetInstanceProcAddr get_proc, | |
| const std::bitset<driver::ProcHook::EXTENSION_COUNT> &extensions); | |
| bool InitDispatchTable( | |
| VkDevice dev, | |
| PFN_vkGetDeviceProcAddr get_proc, | |
| const std::bitset<driver::ProcHook::EXTENSION_COUNT> &extensions); | |
| ¶ | |
| »} // namespace api | |
| »} // namespace vulkan | |
| ¶ | |
| #endif // LIBVULKAN_API_GEN_H | |
| ¶{{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| api_gen.cpp | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "api_gen.cpp"}} | |
| {{Macro "Copyright"}} | |
| ¶ | |
| // WARNING: This file is generated. See ../README.md for instructions. | |
| ¶ | |
| #include <string.h> | |
| ¶ | |
| #include <algorithm> | |
| ¶ | |
| #include <log/log.h> | |
| ¶ | |
| // to catch mismatches between vulkan.h and this file | |
| #undef VK_NO_PROTOTYPES | |
| #include "api.h" | |
| ¶ | |
| namespace vulkan {« | |
| namespace api {« | |
| ¶ | |
| {{Macro "C++.DefineInitProcMacro" "dispatch"}} | |
| ¶ | |
| {{Macro "api.C++.DefineInitProcExtMacro"}} | |
| ¶ | |
| namespace {« | |
| ¶ | |
| // clang-format off | |
| ¶ | |
| {{range $f := AllCommands $}} | |
| {{Macro "api.C++.DefineExtensionStub" $f}} | |
| {{end}} | |
| // clang-format on | |
| ¶ | |
| »} // anonymous | |
| ¶ | |
| bool InitDispatchTable( | |
| VkInstance instance, | |
| PFN_vkGetInstanceProcAddr get_proc, | |
| const std::bitset<driver::ProcHook::EXTENSION_COUNT> &extensions) { | |
| auto& data = GetData(instance); | |
| bool success = true; | |
| ¶ | |
| // clang-format off | |
| {{range $f := AllCommands $}} | |
| {{if (Macro "api.IsInstanceDispatchTableEntry" $f)}} | |
| {{Macro "C++.InitProc" $f}} | |
| {{end}} | |
| {{end}} | |
| // clang-format on | |
| ¶ | |
| return success; | |
| } | |
| ¶ | |
| bool InitDispatchTable( | |
| VkDevice dev, | |
| PFN_vkGetDeviceProcAddr get_proc, | |
| const std::bitset<driver::ProcHook::EXTENSION_COUNT> &extensions) { | |
| auto& data = GetData(dev); | |
| bool success = true; | |
| ¶ | |
| // clang-format off | |
| {{range $f := AllCommands $}} | |
| {{if (Macro "api.IsDeviceDispatchTableEntry" $f)}} | |
| {{Macro "C++.InitProc" $f}} | |
| {{end}} | |
| {{end}} | |
| // clang-format on | |
| ¶ | |
| return success; | |
| } | |
| ¶ | |
| // clang-format off | |
| ¶ | |
| namespace {« | |
| ¶ | |
| // forward declarations needed by GetInstanceProcAddr and GetDeviceProcAddr | |
| {{range $f := AllCommands $}} | |
| {{if and (Macro "IsFunctionExported" $f) (not (Macro "api.IsIntercepted" $f))}} | |
| VKAPI_ATTR {{Node "Type" $f.Return}} {{Macro "BaseName" $f}}({{Macro "Parameters" $f}}); | |
| {{end}} | |
| {{end}} | |
| ¶ | |
| {{range $f := AllCommands $}} | |
| {{if and (Macro "IsFunctionExported" $f) (not (Macro "api.IsIntercepted" $f))}} | |
| VKAPI_ATTR {{Node "Type" $f.Return}} {{Macro "BaseName" $f}}({{Macro "Parameters" $f}}) { | |
| {{ if eq $f.Name "vkGetInstanceProcAddr"}} | |
| {{Macro "api.C++.InterceptInstanceProcAddr" $}} | |
| {{else if eq $f.Name "vkGetDeviceProcAddr"}} | |
| {{Macro "api.C++.InterceptDeviceProcAddr" $}} | |
| {{end}} | |
| {{Macro "api.C++.Dispatch" $f}} | |
| } | |
| ¶ | |
| {{end}} | |
| {{end}} | |
| ¶ | |
| »} // anonymous namespace | |
| ¶ | |
| // clang-format on | |
| ¶ | |
| »} // namespace api | |
| »} // namespace vulkan | |
| ¶ | |
| // clang-format off | |
| ¶ | |
| {{range $f := AllCommands $}} | |
| {{if (Macro "IsFunctionExported" $f)}} | |
| __attribute__((visibility("default"))) | |
| VKAPI_ATTR {{Node "Type" $f.Return}} {{$f.Name}}({{Macro "Parameters" $f}}) { | |
| {{if not (IsVoid $f.Return.Type)}}return §{{end}} | |
| vulkan::api::{{Macro "BaseName" $f}}({{Macro "Arguments" $f}}); | |
| } | |
| ¶ | |
| {{end}} | |
| {{end}} | |
| ¶ | |
| // clang-format on | |
| ¶{{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| driver_gen.h | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "driver_gen.h"}} | |
| {{Macro "Copyright"}} | |
| ¶ | |
| // WARNING: This file is generated. See ../README.md for instructions. | |
| ¶ | |
| #ifndef LIBVULKAN_DRIVER_GEN_H | |
| #define LIBVULKAN_DRIVER_GEN_H | |
| ¶ | |
| #include <bitset> | |
| #include <vulkan/vulkan.h> | |
| #include <vulkan/vk_android_native_buffer.h> | |
| ¶ | |
| namespace vulkan {« | |
| namespace driver {« | |
| ¶ | |
| {{Macro "driver.C++.DefineProcHookType"}} | |
| ¶ | |
| struct InstanceDriverTable { | |
| // clang-format off | |
| {{range $f := AllCommands $}} | |
| {{if (Macro "driver.IsInstanceDriverTableEntry" $f)}} | |
| {{Macro "C++.DeclareTableEntry" $f}}; | |
| {{end}} | |
| {{end}} | |
| // clang-format on | |
| }; | |
| ¶ | |
| struct DeviceDriverTable { | |
| // clang-format off | |
| {{range $f := AllCommands $}} | |
| {{if (Macro "driver.IsDeviceDriverTableEntry" $f)}} | |
| {{Macro "C++.DeclareTableEntry" $f}}; | |
| {{end}} | |
| {{end}} | |
| // clang-format on | |
| }; | |
| ¶ | |
| const ProcHook* GetProcHook(const char* name); | |
| ProcHook::Extension GetProcHookExtension(const char* name); | |
| ¶ | |
| bool InitDriverTable(VkInstance instance, PFN_vkGetInstanceProcAddr get_proc, | |
| const std::bitset<ProcHook::EXTENSION_COUNT> &extensions); | |
| bool InitDriverTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc, | |
| const std::bitset<ProcHook::EXTENSION_COUNT> &extensions); | |
| ¶ | |
| »} // namespace driver | |
| »} // namespace vulkan | |
| ¶ | |
| #endif // LIBVULKAN_DRIVER_TABLE_H | |
| ¶{{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| driver_gen.cpp | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "driver_gen.cpp"}} | |
| {{Macro "Copyright"}} | |
| ¶ | |
| // WARNING: This file is generated. See ../README.md for instructions. | |
| ¶ | |
| #include <string.h> | |
| ¶ | |
| #include <algorithm> | |
| ¶ | |
| #include <log/log.h> | |
| ¶ | |
| #include "driver.h" | |
| ¶ | |
| namespace vulkan {« | |
| namespace driver {« | |
| ¶ | |
| namespace {« | |
| ¶ | |
| // clang-format off | |
| ¶ | |
| {{range $f := AllCommands $}} | |
| {{Macro "driver.C++.DefineProcHookStub" $f}} | |
| {{end}} | |
| // clang-format on | |
| ¶ | |
| const ProcHook g_proc_hooks[] = { | |
| // clang-format off | |
| {{range $f := SortBy (AllCommands $) "FunctionName"}} | |
| {{if (Macro "driver.IsIntercepted" $f)}} | |
| {{ if (Macro "IsGloballyDispatched" $f)}} | |
| {{Macro "driver.C++.DefineGlobalProcHook" $f}} | |
| {{else if (Macro "IsInstanceDispatched" $f)}} | |
| {{Macro "driver.C++.DefineInstanceProcHook" $f}} | |
| {{else if (Macro "IsDeviceDispatched" $f)}} | |
| {{Macro "driver.C++.DefineDeviceProcHook" $f}} | |
| {{end}} | |
| {{end}} | |
| {{end}} | |
| // clang-format on | |
| }; | |
| ¶ | |
| »} // anonymous | |
| ¶ | |
| const ProcHook* GetProcHook(const char* name) { | |
| const auto& begin = g_proc_hooks; | |
| const auto& end = g_proc_hooks + | |
| sizeof(g_proc_hooks) / sizeof(g_proc_hooks[0]); | |
| const auto hook = std::lower_bound(begin, end, name, | |
| [](const ProcHook& e, const char* n) { return strcmp(e.name, n) < 0; }); | |
| return (hook < end && strcmp(hook->name, name) == 0) ? hook : nullptr; | |
| } | |
| ¶ | |
| ProcHook::Extension GetProcHookExtension(const char* name) { | |
| {{$exts := Strings (Macro "driver.KnownExtensions") | SplitOn "\n"}} | |
| // clang-format off | |
| {{range $e := $exts}} | |
| if (strcmp(name, "{{$e}}") == 0) return ProcHook::{{TrimPrefix "VK_" $e}}; | |
| {{end}} | |
| // clang-format on | |
| return ProcHook::EXTENSION_UNKNOWN; | |
| } | |
| ¶ | |
| {{Macro "C++.DefineInitProcMacro" "driver"}} | |
| ¶ | |
| {{Macro "driver.C++.DefineInitProcExtMacro"}} | |
| ¶ | |
| bool InitDriverTable(VkInstance instance, PFN_vkGetInstanceProcAddr get_proc, | |
| const std::bitset<ProcHook::EXTENSION_COUNT> &extensions) | |
| { | |
| auto& data = GetData(instance); | |
| bool success = true; | |
| ¶ | |
| // clang-format off | |
| {{range $f := AllCommands $}} | |
| {{if (Macro "driver.IsInstanceDriverTableEntry" $f)}} | |
| {{Macro "C++.InitProc" $f}} | |
| {{end}} | |
| {{end}} | |
| // clang-format on | |
| ¶ | |
| return success; | |
| } | |
| ¶ | |
| bool InitDriverTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc, | |
| const std::bitset<ProcHook::EXTENSION_COUNT> &extensions) | |
| { | |
| auto& data = GetData(dev); | |
| bool success = true; | |
| ¶ | |
| // clang-format off | |
| {{range $f := AllCommands $}} | |
| {{if (Macro "driver.IsDeviceDriverTableEntry" $f)}} | |
| {{Macro "C++.InitProc" $f}} | |
| {{end}} | |
| {{end}} | |
| // clang-format on | |
| ¶ | |
| return success; | |
| } | |
| ¶ | |
| »} // namespace driver | |
| »} // namespace vulkan | |
| ¶ | |
| // clang-format on | |
| ¶{{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits a declaration of a dispatch/driver table entry. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "C++.DeclareTableEntry"}} | |
| {{AssertType $ "Function"}} | |
| {{Macro "FunctionPtrName" $}} {{Macro "BaseName" $}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits INIT_PROC macro. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "C++.DefineInitProcMacro"}} | |
| #define UNLIKELY(expr) __builtin_expect((expr), 0) | |
| ¶ | |
| #define INIT_PROC(required, obj, proc) do { \ | |
| data.{{$}}.proc = reinterpret_cast<PFN_vk ## proc>( \ | |
| get_proc(obj, "vk" # proc)); \ | |
| if (UNLIKELY(required && !data.{{$}}.proc)) { \ | |
| ALOGE("missing " # obj " proc: vk" # proc); \ | |
| success = false; \ | |
| } \ | |
| } while(0) | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits code to invoke INIT_PROC or INIT_PROC_EXT. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "C++.InitProc"}} | |
| {{AssertType $ "Function"}} | |
| {{$ext := GetAnnotation $ "extension"}} | |
| {{if $ext}} | |
| INIT_PROC_EXT({{Macro "BaseName" $ext}}, § | |
| {{else}} | |
| INIT_PROC(§ | |
| {{end}} | |
| {{if GetAnnotation $ "optional"}}false{{else}}true{{end}}, § | |
| {{if (Macro "IsInstanceDispatched" $)}} | |
| instance, § | |
| {{else}} | |
| dev, § | |
| {{end}} | |
| {{Macro "BaseName" $}}); | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits true if a function is exported and instance-dispatched. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "api.IsInstanceDispatchTableEntry"}} | |
| {{AssertType $ "Function"}} | |
| {{if and (Macro "IsFunctionExported" $) (Macro "IsInstanceDispatched" $)}} | |
| {{/* deprecated and unused internally */}} | |
| {{if not (eq $.Name "vkEnumerateDeviceLayerProperties")}} | |
| true | |
| {{end}} | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits true if a function is exported and device-dispatched. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "api.IsDeviceDispatchTableEntry"}} | |
| {{AssertType $ "Function"}} | |
| {{if and (Macro "IsFunctionExported" $) (Macro "IsDeviceDispatched" $)}} | |
| true | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits true if a function is intercepted by vulkan::api. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "api.IsIntercepted"}} | |
| {{AssertType $ "Function"}} | |
| {{if (Macro "IsFunctionSupported" $)}} | |
| {{/* Global functions cannot be dispatched at all */}} | |
| {{ if (Macro "IsGloballyDispatched" $)}}true | |
| {{/* VkPhysicalDevice functions that manage device layers */}} | |
| {{else if eq $.Name "vkCreateDevice"}}true | |
| {{else if eq $.Name "vkEnumerateDeviceLayerProperties"}}true | |
| {{else if eq $.Name "vkEnumerateDeviceExtensionProperties"}}true | |
| {{/* Destroy functions of dispatchable objects */}} | |
| {{else if eq $.Name "vkDestroyInstance"}}true | |
| {{else if eq $.Name "vkDestroyDevice"}}true | |
| {{end}} | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits INIT_PROC_EXT macro for vulkan::api. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "api.C++.DefineInitProcExtMacro"}} | |
| // Exported extension functions may be invoked even when their extensions | |
| // are disabled. Dispatch to stubs when that happens. | |
| #define INIT_PROC_EXT(ext, required, obj, proc) do { \ | |
| if (extensions[driver::ProcHook::ext]) \ | |
| INIT_PROC(required, obj, proc); \ | |
| else \ | |
| data.dispatch.proc = disabled ## proc; \ | |
| } while(0) | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits a stub for an exported extension function. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "api.C++.DefineExtensionStub"}} | |
| {{AssertType $ "Function"}} | |
| {{$ext := GetAnnotation $ "extension"}} | |
| {{if and $ext (Macro "IsFunctionExported" $)}} | |
| {{$ext_name := index $ext.Arguments 0}} | |
| {{$base := (Macro "BaseName" $)}} | |
| {{$p0 := (index $.CallParameters 0)}} | |
| {{$ptail := (Tail 1 $.CallParameters)}} | |
| {{$first_type := (Macro "Parameter" $p0)}} | |
| {{$tail_types := (ForEach $ptail "ParameterType" | JoinWith ", ")}} | |
| VKAPI_ATTR {{Node "Type" $.Return}} disabled{{$base}}({{$first_type}}, {{$tail_types}}) { | |
| driver::Logger({{$p0.Name}}).Err({{$p0.Name}}, § | |
| "{{$ext_name}} not enabled. Exported {{$.Name}} not executed."); | |
| {{if not (IsVoid $.Return.Type)}}return VK_SUCCESS;{{end}} | |
| } | |
| ¶ | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits code for vkGetInstanceProcAddr for function interception. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "api.C++.InterceptInstanceProcAddr"}} | |
| {{AssertType $ "API"}} | |
| // global functions | |
| if (instance == VK_NULL_HANDLE) { | |
| {{range $f := AllCommands $}} | |
| {{if (Macro "IsGloballyDispatched" $f)}} | |
| if (strcmp(pName, "{{$f.Name}}") == 0) return § | |
| reinterpret_cast<PFN_vkVoidFunction>({{Macro "BaseName" $f}}); | |
| {{end}} | |
| {{end}} | |
| ¶ | |
| ALOGE("invalid vkGetInstanceProcAddr(VK_NULL_HANDLE, \"%s\") call", pName); | |
| return nullptr; | |
| } | |
| ¶ | |
| static const struct Hook { | |
| const char* name; | |
| PFN_vkVoidFunction proc; | |
| } hooks[] = { | |
| {{range $f := SortBy (AllCommands $) "FunctionName"}} | |
| {{if (Macro "IsFunctionExported" $f)}} | |
| {{/* hide global functions */}} | |
| {{if (Macro "IsGloballyDispatched" $f)}} | |
| { "{{$f.Name}}", nullptr }, | |
| {{/* redirect intercepted functions */}} | |
| {{else if (Macro "api.IsIntercepted" $f)}} | |
| { "{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§ | |
| {{Macro "BaseName" $f}}) }, | |
| {{/* redirect vkGetInstanceProcAddr to itself */}} | |
| {{else if eq $f.Name "vkGetInstanceProcAddr"}} | |
| { "{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>({{Macro "BaseName" $f}}) }, | |
| {{/* redirect device functions to themselves as a workaround for | |
| layers that do not intercept in their vkGetInstanceProcAddr */}} | |
| {{else if (Macro "IsDeviceDispatched" $f)}} | |
| { "{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>({{Macro "BaseName" $f}}) }, | |
| {{end}} | |
| {{end}} | |
| {{end}} | |
| }; | |
| // clang-format on | |
| constexpr size_t count = sizeof(hooks) / sizeof(hooks[0]); | |
| auto hook = std::lower_bound( | |
| hooks, hooks + count, pName, | |
| [](const Hook& h, const char* n) { return strcmp(h.name, n) < 0; }); | |
| if (hook < hooks + count && strcmp(hook->name, pName) == 0) { | |
| if (!hook->proc) { | |
| vulkan::driver::Logger(instance).Err( | |
| instance, "invalid vkGetInstanceProcAddr(%p, \"%s\") call", | |
| instance, pName); | |
| } | |
| return hook->proc; | |
| } | |
| // clang-format off | |
| ¶ | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits code for vkGetDeviceProcAddr for function interception. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "api.C++.InterceptDeviceProcAddr"}} | |
| {{AssertType $ "API"}} | |
| if (device == VK_NULL_HANDLE) { | |
| ALOGE("invalid vkGetDeviceProcAddr(VK_NULL_HANDLE, ...) call"); | |
| return nullptr; | |
| } | |
| ¶ | |
| static const char* const known_non_device_names[] = { | |
| {{range $f := SortBy (AllCommands $) "FunctionName"}} | |
| {{if (Macro "IsFunctionSupported" $f)}} | |
| {{if not (Macro "IsDeviceDispatched" $f)}} | |
| "{{$f.Name}}", | |
| {{end}} | |
| {{end}} | |
| {{end}} | |
| }; | |
| // clang-format on | |
| constexpr size_t count = sizeof(known_non_device_names) / | |
| sizeof(known_non_device_names[0]); | |
| if (!pName || | |
| std::binary_search( | |
| known_non_device_names, known_non_device_names + count, pName, | |
| [](const char* a, const char* b) { return (strcmp(a, b) < 0); })) { | |
| vulkan::driver::Logger(device).Err(§ | |
| device, "invalid vkGetDeviceProcAddr(%p, \"%s\") call", device,§ | |
| (pName) ? pName : "(null)"); | |
| return nullptr; | |
| } | |
| // clang-format off | |
| ¶ | |
| {{range $f := AllCommands $}} | |
| {{if (Macro "IsDeviceDispatched" $f)}} | |
| {{ if (Macro "api.IsIntercepted" $f)}} | |
| if (strcmp(pName, "{{$f.Name}}") == 0) return § | |
| reinterpret_cast<PFN_vkVoidFunction>(§ | |
| {{Macro "BaseName" $f}}); | |
| {{else if eq $f.Name "vkGetDeviceProcAddr"}} | |
| if (strcmp(pName, "{{$f.Name}}") == 0) return § | |
| reinterpret_cast<PFN_vkVoidFunction>(§ | |
| {{Macro "BaseName" $f}}); | |
| {{end}} | |
| {{end}} | |
| {{end}} | |
| ¶ | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits code to dispatch a function. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "api.C++.Dispatch"}} | |
| {{AssertType $ "Function"}} | |
| {{if (Macro "api.IsIntercepted" $)}} | |
| {{Error "$.Name should not be generated"}} | |
| {{end}} | |
| {{if not (IsVoid $.Return.Type)}}return §{{end}} | |
| {{$p0 := index $.CallParameters 0}} | |
| GetData({{$p0.Name}}).dispatch.§ | |
| {{Macro "BaseName" $}}({{Macro "Arguments" $}}); | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits a list of extensions intercepted by vulkan::driver. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "driver.InterceptedExtensions"}} | |
| VK_ANDROID_native_buffer | |
| VK_EXT_debug_report | |
| VK_EXT_hdr_metadata | |
| VK_EXT_swapchain_colorspace | |
| VK_GOOGLE_display_timing | |
| VK_KHR_android_surface | |
| VK_KHR_incremental_present | |
| VK_KHR_shared_presentable_image | |
| VK_KHR_surface | |
| VK_KHR_swapchain | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits a list of extensions known to vulkan::driver. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "driver.KnownExtensions"}} | |
| {{Macro "driver.InterceptedExtensions"}} | |
| VK_KHR_get_physical_device_properties2 | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits true if an extension is intercepted by vulkan::driver. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "driver.IsExtensionIntercepted"}} | |
| {{$ext_name := index $.Arguments 0}} | |
| {{$filters := Strings (Macro "driver.InterceptedExtensions") | SplitOn "\n"}} | |
| {{range $f := $filters}} | |
| {{if eq $ext_name $f}}true{{end}} | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits true if a function is intercepted by vulkan::driver. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "driver.IsIntercepted"}} | |
| {{AssertType $ "Function"}} | |
| {{if (Macro "IsFunctionSupported" $)}} | |
| {{/* Create functions of dispatchable objects */}} | |
| {{ if eq $.Name "vkCreateInstance"}}true | |
| {{else if eq $.Name "vkCreateDevice"}}true | |
| {{else if eq $.Name "vkEnumeratePhysicalDevices"}}true | |
| {{else if eq $.Name "vkGetDeviceQueue"}}true | |
| {{else if eq $.Name "vkAllocateCommandBuffers"}}true | |
| {{/* Destroy functions of dispatchable objects */}} | |
| {{else if eq $.Name "vkDestroyInstance"}}true | |
| {{else if eq $.Name "vkDestroyDevice"}}true | |
| {{/* Enumeration of extensions */}} | |
| {{else if eq $.Name "vkEnumerateInstanceExtensionProperties"}}true | |
| {{else if eq $.Name "vkEnumerateDeviceExtensionProperties"}}true | |
| {{else if eq $.Name "vkGetInstanceProcAddr"}}true | |
| {{else if eq $.Name "vkGetDeviceProcAddr"}}true | |
| {{end}} | |
| {{$ext := GetAnnotation $ "extension"}} | |
| {{if $ext}} | |
| {{Macro "driver.IsExtensionIntercepted" $ext}} | |
| {{end}} | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits true if a function needs a ProcHook stub. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "driver.NeedProcHookStub"}} | |
| {{AssertType $ "Function"}} | |
| {{if and (Macro "driver.IsIntercepted" $) (Macro "IsDeviceDispatched" $)}} | |
| {{$ext := GetAnnotation $ "extension"}} | |
| {{if $ext}} | |
| {{if not (Macro "IsExtensionInternal" $ext)}}true{{end}} | |
| {{end}} | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits definition of struct ProcHook. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "driver.C++.DefineProcHookType"}} | |
| struct ProcHook { | |
| enum Type { | |
| GLOBAL, | |
| INSTANCE, | |
| DEVICE, | |
| }; | |
| enum Extension { | |
| {{$exts := Strings (Macro "driver.KnownExtensions") | SplitOn "\n"}} | |
| {{range $e := $exts}} | |
| {{TrimPrefix "VK_" $e}}, | |
| {{end}} | |
| ¶ | |
| EXTENSION_CORE, // valid bit | |
| EXTENSION_COUNT, | |
| EXTENSION_UNKNOWN, | |
| }; | |
| ¶ | |
| const char* name; | |
| Type type; | |
| Extension extension; | |
| ¶ | |
| PFN_vkVoidFunction proc; | |
| PFN_vkVoidFunction checked_proc; // always nullptr for non-device hooks | |
| }; | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits INIT_PROC_EXT macro for vulkan::driver. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "driver.C++.DefineInitProcExtMacro"}} | |
| #define INIT_PROC_EXT(ext, required, obj, proc) do { \ | |
| if (extensions[ProcHook::ext]) \ | |
| INIT_PROC(required, obj, proc); \ | |
| } while(0) | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits a stub for ProcHook::checked_proc. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "driver.C++.DefineProcHookStub"}} | |
| {{AssertType $ "Function"}} | |
| {{if (Macro "driver.NeedProcHookStub" $)}} | |
| {{$ext := GetAnnotation $ "extension"}} | |
| {{$ext_name := index $ext.Arguments 0}} | |
| {{$base := (Macro "BaseName" $)}} | |
| VKAPI_ATTR {{Node "Type" $.Return}} checked{{$base}}({{Macro "Parameters" $}}) { | |
| {{$p0 := index $.CallParameters 0}} | |
| {{$ext_hook := Strings ("ProcHook::") (Macro "BaseName" $ext)}} | |
| if (GetData({{$p0.Name}}).hook_extensions[{{$ext_hook}}]) { | |
| {{if not (IsVoid $.Return.Type)}}return §{{end}} | |
| {{$base}}({{Macro "Arguments" $}}); | |
| } else { | |
| Logger({{$p0.Name}}).Err({{$p0.Name}}, "{{$ext_name}} not enabled. {{$.Name}} not executed."); | |
| {{if not (IsVoid $.Return.Type)}}return VK_SUCCESS;{{end}} | |
| } | |
| } | |
| ¶ | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits definition of a global ProcHook. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "driver.C++.DefineGlobalProcHook"}} | |
| {{AssertType $ "Function"}} | |
| {{$base := (Macro "BaseName" $)}} | |
| {{$ext := GetAnnotation $ "extension"}} | |
| {{if $ext}} | |
| {{Error "invalid global extension"}} | |
| {{end}} | |
| { | |
| "{{$.Name}}", | |
| ProcHook::GLOBAL, | |
| ProcHook::EXTENSION_CORE, | |
| reinterpret_cast<PFN_vkVoidFunction>({{$base}}), | |
| nullptr, | |
| }, | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits definition of an instance ProcHook. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "driver.C++.DefineInstanceProcHook"}} | |
| {{AssertType $ "Function"}} | |
| {{$base := (Macro "BaseName" $)}} | |
| { | |
| "{{$.Name}}", | |
| ProcHook::INSTANCE, | |
| {{$ext := GetAnnotation $ "extension"}} | |
| {{if $ext}} | |
| ProcHook::{{Macro "BaseName" $ext}}, | |
| {{if (Macro "IsExtensionInternal" $ext)}} | |
| nullptr, | |
| nullptr, | |
| {{else}} | |
| reinterpret_cast<PFN_vkVoidFunction>({{$base}}), | |
| nullptr, | |
| {{end}} | |
| {{else}} | |
| ProcHook::EXTENSION_CORE, | |
| reinterpret_cast<PFN_vkVoidFunction>({{$base}}), | |
| nullptr, | |
| {{end}} | |
| }, | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits definition of a device ProcHook. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "driver.C++.DefineDeviceProcHook"}} | |
| {{AssertType $ "Function"}} | |
| {{$base := (Macro "BaseName" $)}} | |
| { | |
| "{{$.Name}}", | |
| ProcHook::DEVICE, | |
| {{$ext := GetAnnotation $ "extension"}} | |
| {{if $ext}} | |
| ProcHook::{{Macro "BaseName" $ext}}, | |
| {{if (Macro "IsExtensionInternal" $ext)}} | |
| nullptr, | |
| nullptr, | |
| {{else}} | |
| reinterpret_cast<PFN_vkVoidFunction>({{$base}}), | |
| reinterpret_cast<PFN_vkVoidFunction>(checked{{$base}}), | |
| {{end}} | |
| {{else}} | |
| ProcHook::EXTENSION_CORE, | |
| reinterpret_cast<PFN_vkVoidFunction>({{$base}}), | |
| nullptr, | |
| {{end}} | |
| }, | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits true if a function is needed by vulkan::driver. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "driver.IsDriverTableEntry"}} | |
| {{AssertType $ "Function"}} | |
| {{if (Macro "IsFunctionSupported" $)}} | |
| {{/* Create functions of dispatchable objects */}} | |
| {{ if eq $.Name "vkCreateDevice"}}true | |
| {{else if eq $.Name "vkGetDeviceQueue"}}true | |
| {{else if eq $.Name "vkAllocateCommandBuffers"}}true | |
| {{/* Destroy functions of dispatchable objects */}} | |
| {{else if eq $.Name "vkDestroyInstance"}}true | |
| {{else if eq $.Name "vkDestroyDevice"}}true | |
| {{/* Enumeration of extensions */}} | |
| {{else if eq $.Name "vkEnumerateDeviceExtensionProperties"}}true | |
| {{/* We cache physical devices in loader.cpp */}} | |
| {{else if eq $.Name "vkEnumeratePhysicalDevices"}}true | |
| {{else if eq $.Name "vkGetInstanceProcAddr"}}true | |
| {{else if eq $.Name "vkGetDeviceProcAddr"}}true | |
| {{/* VK_KHR_swapchain->VK_ANDROID_native_buffer translation */}} | |
| {{else if eq $.Name "vkCreateImage"}}true | |
| {{else if eq $.Name "vkDestroyImage"}}true | |
| {{else if eq $.Name "vkGetPhysicalDeviceProperties"}}true | |
| {{else if eq $.Name "vkGetPhysicalDeviceProperties2KHR"}}true | |
| {{end}} | |
| {{$ext := GetAnnotation $ "extension"}} | |
| {{if $ext}} | |
| {{$ext_name := index $ext.Arguments 0}} | |
| {{ if eq $ext_name "VK_ANDROID_native_buffer"}}true | |
| {{else if eq $ext_name "VK_EXT_debug_report"}}true | |
| {{end}} | |
| {{end}} | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits true if an instance-dispatched function is needed by vulkan::driver. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "driver.IsInstanceDriverTableEntry"}} | |
| {{AssertType $ "Function"}} | |
| {{if and (Macro "driver.IsDriverTableEntry" $) (Macro "IsInstanceDispatched" $)}} | |
| true | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emits true if a device-dispatched function is needed by vulkan::driver. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "driver.IsDeviceDriverTableEntry"}} | |
| {{AssertType $ "Function"}} | |
| {{if and (Macro "driver.IsDriverTableEntry" $) (Macro "IsDeviceDispatched" $)}} | |
| true | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits a function/extension name without the "vk"/"VK_" prefix. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "BaseName"}} | |
| {{ if IsFunction $}}{{TrimPrefix "vk" $.Name}} | |
| {{else if eq $.Name "extension"}}{{TrimPrefix "VK_" (index $.Arguments 0)}} | |
| {{else}}{{Error "invalid use of BaseName"}} | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------- | |
| Emits a comma-separated list of C parameter names for the given command. | |
| ------------------------------------------------------------------------------- | |
| */}} | |
| {{define "Arguments"}} | |
| {{AssertType $ "Function"}} | |
| {{ForEach $.CallParameters "ParameterName" | JoinWith ", "}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "IsGloballyDispatched"}} | |
| {{AssertType $ "Function"}} | |
| {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Global")}} | |
| true | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emit "true" for supported functions that undergo table dispatch. Only global | |
| functions and functions handled in the loader top without calling into | |
| lower layers are not dispatched. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "IsInstanceDispatched"}} | |
| {{AssertType $ "Function"}} | |
| {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Instance")}} | |
| true | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emit "true" for supported functions that can have device-specific dispatch. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "IsDeviceDispatched"}} | |
| {{AssertType $ "Function"}} | |
| {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Device")}} | |
| true | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emit "true" if a function is core or from a supportable extension. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "IsFunctionSupported"}} | |
| {{AssertType $ "Function"}} | |
| {{if not (GetAnnotation $ "pfn")}} | |
| {{$ext := GetAnnotation $ "extension"}} | |
| {{if not $ext}}true | |
| {{else if not (Macro "IsExtensionBlacklisted" $ext)}}true | |
| {{end}} | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Decides whether a function should be exported from the Android Vulkan | |
| library. Functions in the core API and in loader extensions are exported. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "IsFunctionExported"}} | |
| {{AssertType $ "Function"}} | |
| {{if (Macro "IsFunctionSupported" $)}} | |
| {{$ext := GetAnnotation $ "extension"}} | |
| {{if $ext}} | |
| {{Macro "IsExtensionExported" $ext}} | |
| {{else}} | |
| true | |
| {{end}} | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Emit "true" if an extension is unsupportable on Android. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "IsExtensionBlacklisted"}} | |
| {{$ext := index $.Arguments 0}} | |
| {{ if eq $ext "VK_KHR_display"}}true | |
| {{else if eq $ext "VK_KHR_display_swapchain"}}true | |
| {{else if eq $ext "VK_KHR_mir_surface"}}true | |
| {{else if eq $ext "VK_KHR_xcb_surface"}}true | |
| {{else if eq $ext "VK_KHR_xlib_surface"}}true | |
| {{else if eq $ext "VK_KHR_wayland_surface"}}true | |
| {{else if eq $ext "VK_KHR_win32_surface"}}true | |
| {{else if eq $ext "VK_KHX_external_memory_win32"}}true | |
| {{else if eq $ext "VK_KHX_win32_keyed_mutex"}}true | |
| {{else if eq $ext "VK_KHX_external_semaphore_win32"}}true | |
| {{else if eq $ext "VK_EXT_acquire_xlib_display"}}true | |
| {{else if eq $ext "VK_EXT_direct_mode_display"}}true | |
| {{else if eq $ext "VK_EXT_display_surface_counter"}}true | |
| {{else if eq $ext "VK_EXT_display_control"}}true | |
| {{else if eq $ext "VK_MVK_ios_surface"}}true | |
| {{else if eq $ext "VK_MVK_macos_surface"}}true | |
| {{else if eq $ext "VK_NN_vi_surface"}}true | |
| {{else if eq $ext "VK_NV_external_memory_win32"}}true | |
| {{else if eq $ext "VK_NV_win32_keyed_mutex"}}true | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Reports whether an extension has functions exported by the loader. | |
| E.g. applications can directly link to an extension function. | |
| Currently only support WSI extensions this way. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "IsExtensionExported"}} | |
| {{$ext := index $.Arguments 0}} | |
| {{ if eq $ext "VK_KHR_surface"}}true | |
| {{else if eq $ext "VK_KHR_swapchain"}}true | |
| {{else if eq $ext "VK_KHR_android_surface"}}true | |
| {{end}} | |
| {{end}} | |
| {{/* | |
| ------------------------------------------------------------------------------ | |
| Reports whether an extension is internal to the loader and drivers, | |
| so the loader should not enumerate it. | |
| ------------------------------------------------------------------------------ | |
| */}} | |
| {{define "IsExtensionInternal"}} | |
| {{$ext := index $.Arguments 0}} | |
| {{ if eq $ext "VK_ANDROID_native_buffer"}}true | |
| {{end}} | |
| {{end}} |