1181 lines
35 KiB
Cheetah
1181 lines
35 KiB
Cheetah
{{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
|
|
VK_KHR_get_surface_capabilities2
|
|
{{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_KHR_external_memory_win32"}}true
|
|
{{else if eq $ext "VK_KHR_win32_keyed_mutex"}}true
|
|
{{else if eq $ext "VK_KHR_external_semaphore_win32"}}true
|
|
{{else if eq $ext "VK_KHR_external_fence_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}}
|