vulkan: clean up the framework generation script
1. Instead of mixing up all code formats, stick to pep8 and python style guide
2. Removed some redundant functions
3. Simplified seme code logic
4. Move constant codes back to main code gen blocks for readibility
5. Moved most of the hard-coded constants to the top
6. Removed a redundant clang format hint
7. Removed any mention of the legacy code gen stuff
Bug: 134185757
Test: ./scripts/code_generator.py && build
Change-Id: I1eca91fb0d181b7e8353c4c6a651d80ed1f2d1e0
diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py
index 4868ac0..5fff83e 100644
--- a/vulkan/scripts/driver_generator.py
+++ b/vulkan/scripts/driver_generator.py
@@ -17,41 +17,147 @@
# This script provides the functions for generating the
# vulkan driver framework directly from the vulkan registry (vk.xml).
-import generator_common as gencom
import os
+import generator_common as gencom
-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_get_surface_capabilities2',
- 'VK_KHR_incremental_present',
- 'VK_KHR_shared_presentable_image',
- 'VK_KHR_surface',
- 'VK_KHR_swapchain',
+_INTERCEPTED_EXTENSIONS = [
+ '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_get_surface_capabilities2',
+ 'VK_KHR_incremental_present',
+ 'VK_KHR_shared_presentable_image',
+ 'VK_KHR_surface',
+ 'VK_KHR_swapchain',
]
-knownExtensions = interceptedExtensions + [
- 'VK_ANDROID_external_memory_android_hardware_buffer',
- 'VK_KHR_bind_memory2',
- 'VK_KHR_get_physical_device_properties2',
+_KNOWN_EXTENSIONS = _INTERCEPTED_EXTENSIONS + [
+ 'VK_ANDROID_external_memory_android_hardware_buffer',
+ 'VK_KHR_bind_memory2',
+ 'VK_KHR_get_physical_device_properties2',
]
-def defineProcHookType(f):
- f.write ("""struct ProcHook {
+_NEEDED_COMMANDS = [
+ # Create functions of dispatchable objects
+ 'vkCreateDevice',
+ 'vkGetDeviceQueue',
+ 'vkGetDeviceQueue2',
+ 'vkAllocateCommandBuffers',
+
+ # Destroy functions of dispatchable objects
+ 'vkDestroyInstance',
+ 'vkDestroyDevice',
+
+ # Enumeration of extensions
+ 'vkEnumerateDeviceExtensionProperties',
+
+ # We cache physical devices in loader.cpp
+ 'vkEnumeratePhysicalDevices',
+ 'vkEnumeratePhysicalDeviceGroups',
+
+ 'vkGetInstanceProcAddr',
+ 'vkGetDeviceProcAddr',
+
+ 'vkQueueSubmit',
+
+ # VK_KHR_swapchain->VK_ANDROID_native_buffer translation
+ 'vkCreateImage',
+ 'vkDestroyImage',
+
+ 'vkGetPhysicalDeviceProperties',
+ 'vkGetPhysicalDeviceProperties2',
+ 'vkGetPhysicalDeviceProperties2KHR',
+
+ # VK_KHR_swapchain v69 requirement
+ 'vkBindImageMemory2',
+ 'vkBindImageMemory2KHR',
+]
+
+_INTERCEPTED_COMMANDS = [
+ # Create functions of dispatchable objects
+ 'vkCreateInstance',
+ 'vkCreateDevice',
+ 'vkEnumeratePhysicalDevices',
+ 'vkEnumeratePhysicalDeviceGroups',
+ 'vkGetDeviceQueue',
+ 'vkGetDeviceQueue2',
+ 'vkAllocateCommandBuffers',
+
+ # Destroy functions of dispatchable objects
+ 'vkDestroyInstance',
+ 'vkDestroyDevice',
+
+ # Enumeration of extensions
+ 'vkEnumerateInstanceExtensionProperties',
+ 'vkEnumerateDeviceExtensionProperties',
+
+ 'vkGetInstanceProcAddr',
+ 'vkGetDeviceProcAddr',
+
+ 'vkQueueSubmit',
+
+ # VK_KHR_swapchain v69 requirement
+ 'vkBindImageMemory2',
+ 'vkBindImageMemory2KHR',
+]
+
+
+def _is_driver_table_entry(cmd):
+ if gencom.is_function_supported(cmd):
+ if cmd in _NEEDED_COMMANDS:
+ return True
+ if cmd in gencom.extension_dict:
+ if (gencom.extension_dict[cmd] == 'VK_ANDROID_native_buffer' or
+ gencom.extension_dict[cmd] == 'VK_EXT_debug_report'):
+ return True
+ return False
+
+
+def _is_instance_driver_table_entry(cmd):
+ return (_is_driver_table_entry(cmd) and
+ gencom.is_instance_dispatched(cmd))
+
+
+def _is_device_driver_table_entry(cmd):
+ return (_is_driver_table_entry(cmd) and
+ gencom.is_device_dispatched(cmd))
+
+
+def gen_h():
+ genfile = os.path.join(os.path.dirname(__file__),
+ '..', 'libvulkan', 'driver_gen.h')
+
+ with open(genfile, 'w') as f:
+ f.write(gencom.copyright_and_warning(2016))
+
+ f.write("""\
+#ifndef LIBVULKAN_DRIVER_GEN_H
+#define LIBVULKAN_DRIVER_GEN_H
+
+#include <vulkan/vk_android_native_buffer.h>
+#include <vulkan/vulkan.h>
+
+#include <bitset>
+
+namespace vulkan {
+namespace driver {
+
+struct ProcHook {
enum Type {
GLOBAL,
INSTANCE,
DEVICE,
};
enum Extension {\n""")
- for exts in knownExtensions:
- f.write (gencom.clang_off_spaces*2 + exts[3:] + ',\n')
- f.write ('\n')
- f.write (gencom.clang_off_spaces*2 + """EXTENSION_CORE, // valid bit
+
+ for exts in _KNOWN_EXTENSIONS:
+ f.write(gencom.indent(2) + exts[3:] + ',\n')
+
+ f.write("""
+ EXTENSION_CORE, // valid bit
EXTENSION_COUNT,
EXTENSION_UNKNOWN,
};
@@ -62,99 +168,33 @@
PFN_vkVoidFunction proc;
PFN_vkVoidFunction checked_proc; // always nullptr for non-device hooks
-};\n\n""")
+};
-def isExtensionIntercepted(extensionName):
- if extensionName in interceptedExtensions:
- return True
- return False
+struct InstanceDriverTable {
+ // clang-format off\n""")
-def isDriverTableEntry(functionName):
- switchCase = {
- # Create functions of dispatchable objects
- 'vkCreateDevice' : True,
- 'vkGetDeviceQueue' : True,
- 'vkGetDeviceQueue2' : True,
- 'vkAllocateCommandBuffers' : True,
+ for cmd in gencom.command_list:
+ if _is_instance_driver_table_entry(cmd):
+ f.write(gencom.indent(1) + 'PFN_' + cmd + ' ' +
+ gencom.base_name(cmd) + ';\n')
- # Destroy functions of dispatchable objects
- 'vkDestroyInstance' : True,
- 'vkDestroyDevice' : True,
+ f.write("""\
+ // clang-format on
+};
- # Enumeration of extensions
- 'vkEnumerateDeviceExtensionProperties' : True,
+struct DeviceDriverTable {
+ // clang-format off\n""")
- # We cache physical devices in loader.cpp
- 'vkEnumeratePhysicalDevices' : True,
- 'vkEnumeratePhysicalDeviceGroups' : True,
+ for cmd in gencom.command_list:
+ if _is_device_driver_table_entry(cmd):
+ f.write(gencom.indent(1) + 'PFN_' + cmd + ' ' +
+ gencom.base_name(cmd) + ';\n')
- 'vkGetInstanceProcAddr' : True,
- 'vkGetDeviceProcAddr' : True,
+ f.write("""\
+ // clang-format on
+};
- 'vkQueueSubmit' : True,
-
- # VK_KHR_swapchain->VK_ANDROID_native_buffer translation
- 'vkCreateImage' : True,
- 'vkDestroyImage' : True,
-
- 'vkGetPhysicalDeviceProperties' : True,
- 'vkGetPhysicalDeviceProperties2' : True,
- 'vkGetPhysicalDeviceProperties2KHR' : True,
-
- # VK_KHR_swapchain v69 requirement
- 'vkBindImageMemory2' : True,
- 'vkBindImageMemory2KHR' : True
- }
- if gencom.isFunctionSupported(functionName):
- if functionName in switchCase:
- return True
- if functionName in gencom.extensionsDict:
- if gencom.extensionsDict[functionName] == 'VK_ANDROID_native_buffer' or gencom.extensionsDict[functionName] == 'VK_EXT_debug_report':
- return True
- return False
-
-def isInstanceDriverTableEntry(functionName):
- if isDriverTableEntry(functionName) and gencom.isInstanceDispatched(functionName):
- return True
- return False
-
-def isDeviceDriverTableEntry(functionName):
- if isDriverTableEntry(functionName) and gencom.isDeviceDispatched(functionName):
- return True
- return False
-
-def driver_genh():
- header = """#ifndef LIBVULKAN_DRIVER_GEN_H
-#define LIBVULKAN_DRIVER_GEN_H
-
-#include <vulkan/vk_android_native_buffer.h>
-#include <vulkan/vulkan.h>
-
-#include <bitset>
-
-namespace vulkan {
-namespace driver {\n\n"""
- genfile = os.path.join(os.path.dirname(__file__),'..','libvulkan','driver_gen.h')
- with open(genfile, 'w') as f:
- f.write (gencom.copyright)
- f.write (gencom.warning)
- f.write (header)
- defineProcHookType(f)
- f.write ('struct InstanceDriverTable {\n')
- gencom.clang_off(f, 1)
- for cmds in gencom.allCommandsList:
- if isInstanceDriverTableEntry(cmds):
- f.write (gencom.clang_off_spaces + 'PFN_' + cmds + ' ' + cmds[2:] + ';\n')
- gencom.clang_on(f, 1)
- f.write ('};\n\n')
- f.write ('struct DeviceDriverTable {\n')
- gencom.clang_off(f,1)
- for cmds in gencom.allCommandsList:
- if isDeviceDriverTableEntry(cmds):
- f.write (gencom.clang_off_spaces + 'PFN_' + cmds + ' ' + cmds[2:] + ';\n')
- gencom.clang_on(f,1)
- f.write ('};\n\n')
- f.write ("""const ProcHook* GetProcHook(const char* name);
+const ProcHook* GetProcHook(const char* name);
ProcHook::Extension GetProcHookExtension(const char* name);
bool InitDriverTable(VkInstance instance,
@@ -168,148 +208,131 @@
} // namespace vulkan
#endif // LIBVULKAN_DRIVER_TABLE_H\n""")
+
f.close()
- gencom.runClangFormat(genfile)
+ gencom.run_clang_format(genfile)
-def isIntercepted(functionName):
- switchCase = {
- # Create functions of dispatchable objects
- 'vkCreateInstance' : True,
- 'vkCreateDevice' : True,
- 'vkEnumeratePhysicalDevices' : True,
- 'vkEnumeratePhysicalDeviceGroups' : True,
- 'vkGetDeviceQueue' : True,
- 'vkGetDeviceQueue2' : True,
- 'vkAllocateCommandBuffers' : True,
- # Destroy functions of dispatchable objects
- 'vkDestroyInstance' : True,
- 'vkDestroyDevice' : True,
+def _is_intercepted(cmd):
+ if gencom.is_function_supported(cmd):
+ if cmd in _INTERCEPTED_COMMANDS:
+ return True
- # Enumeration of extensions
- 'vkEnumerateInstanceExtensionProperties' : True,
- 'vkEnumerateDeviceExtensionProperties' : True,
-
- 'vkGetInstanceProcAddr' : True,
- 'vkGetDeviceProcAddr' : True,
-
- 'vkQueueSubmit' : True,
-
- # VK_KHR_swapchain v69 requirement
- 'vkBindImageMemory2' : True,
- 'vkBindImageMemory2KHR' : True
- }
- if gencom.isFunctionSupported(functionName):
- if functionName in switchCase:
- return switchCase[functionName]
-
- if functionName in gencom.extensionsDict:
- return isExtensionIntercepted(gencom.extensionsDict[functionName])
+ if cmd in gencom.extension_dict:
+ return gencom.extension_dict[cmd] in _INTERCEPTED_EXTENSIONS
return False
-def needProcHookStub(functionName):
- if isIntercepted(functionName) and gencom.isDeviceDispatched(functionName):
- if functionName in gencom.extensionsDict:
- if not gencom.isExtensionInternal(gencom.extensionsDict[functionName]):
+
+def _need_proc_hook_stub(cmd):
+ if _is_intercepted(cmd) and gencom.is_device_dispatched(cmd):
+ if cmd in gencom.extension_dict:
+ if not gencom.is_extension_internal(gencom.extension_dict[cmd]):
return True
return False
-def defineInitProc(name, f):
- f.write ('#define UNLIKELY(expr) __builtin_expect((expr), 0)\n')
- f.write ('\n')
- f.write ("""#define INIT_PROC(required, obj, proc) \\
- do { \\
- data.""" + name + """.proc = \\
- reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \\
- if (UNLIKELY(required && !data.""" + name + """.proc)) { \\
- ALOGE("missing " #obj " proc: vk" #proc); \\
- success = false; \\
- } \\
- } while (0)\n\n""")
-def defineInitProcExt(f):
- f.write ("""#define INIT_PROC_EXT(ext, required, obj, proc) \\
- do { \\
- if (extensions[ProcHook::ext]) \\
- INIT_PROC(required, obj, proc); \\
- } while (0)\n\n""")
-
-def defineProcHookStub(functionName, f):
- if needProcHookStub(functionName):
- ext_name = gencom.extensionsDict[functionName]
- base_name = functionName[2:]
- paramList = [''.join(i) for i in gencom.paramDict[functionName]]
- p0 = gencom.paramDict[functionName][0][1]
- f.write ('VKAPI_ATTR ' + gencom.returnTypeDict[functionName] + ' checked' + base_name + '(' + ', '.join(paramList) + ') {\n')
+def _define_proc_hook_stub(cmd, f):
+ if _need_proc_hook_stub(cmd):
+ return_type = gencom.return_type_dict[cmd]
+ ext_name = gencom.extension_dict[cmd]
ext_hook = 'ProcHook::' + ext_name[3:]
+ handle = gencom.param_dict[cmd][0][1]
+ param_types = ', '.join([''.join(i) for i in gencom.param_dict[cmd]])
+ param_names = ', '.join([''.join(i[1]) for i in gencom.param_dict[cmd]])
- f.write (gencom.clang_off_spaces + 'if (GetData(' + p0 + ').hook_extensions[' + ext_hook + ']) {\n')
- f.write (gencom.clang_off_spaces *2)
- if gencom.returnTypeDict[functionName] != 'void':
- f.write ('return ')
- paramNames = [''.join(i[1]) for i in gencom.paramDict[functionName]]
- f.write (base_name + '(' + ', '.join(paramNames) + ');\n')
- f.write (gencom.clang_off_spaces + '} else {\n')
- f.write (gencom.clang_off_spaces*2 + 'Logger(' + p0 + ').Err(' + p0 + ', \"' + ext_name + ' not enabled. ' + functionName + ' not executed.\");\n')
- if gencom.returnTypeDict[functionName] != 'void':
- f.write (gencom.clang_off_spaces*2 + 'return VK_SUCCESS;\n')
- f.write (gencom.clang_off_spaces + '}\n')
- f.write ('}\n\n')
+ f.write('VKAPI_ATTR ' + return_type + ' checked' + gencom.base_name(cmd) +
+ '(' + param_types + ') {\n')
+ f.write(gencom.indent(1) + 'if (GetData(' + handle + ').hook_extensions[' +
+ ext_hook + ']) {\n')
-def defineGlobalProcHook(functionName, f):
- base_name = functionName[2:]
- assert (functionName not in gencom.extensionsDict)
- f.write (gencom.clang_off_spaces + '{\n' + gencom.clang_off_spaces*2 + '\"' + functionName + '\",\n' + gencom.clang_off_spaces*2)
- f.write ("""ProcHook::GLOBAL,
+ f.write(gencom.indent(2))
+ if gencom.return_type_dict[cmd] != 'void':
+ f.write('return ')
+ f.write(gencom.base_name(cmd) + '(' + param_names + ');\n')
+
+ f.write(gencom.indent(1) + '} else {\n')
+ f.write(gencom.indent(2) + 'Logger(' + handle + ').Err(' + handle + ', \"' +
+ ext_name + ' not enabled. ' + cmd + ' not executed.\");\n')
+ if gencom.return_type_dict[cmd] != 'void':
+ f.write(gencom.indent(2) + 'return VK_SUCCESS;\n')
+ f.write(gencom.indent(1) + '}\n}\n\n')
+
+
+def _define_global_proc_hook(cmd, f):
+ assert cmd not in gencom.extension_dict
+
+ f.write(gencom.indent(1) + '{\n')
+ f.write(gencom.indent(2) + '\"' + cmd + '\",\n')
+ f.write("""\
+ ProcHook::GLOBAL,
ProcHook::EXTENSION_CORE,
- reinterpret_cast<PFN_vkVoidFunction>(""" + base_name + """),
+ reinterpret_cast<PFN_vkVoidFunction>(""" + gencom.base_name(cmd) + """),
nullptr,
},\n""")
-def defineInstanceProcHook(functionName, f):
- base_name = functionName[2:]
- f.write (gencom.clang_off_spaces + '{\n')
- f.write (gencom.clang_off_spaces*2 + '\"' + functionName + '\",\n')
- f.write (gencom.clang_off_spaces*2 + 'ProcHook::INSTANCE,\n')
- if functionName in gencom.extensionsDict:
- ext_name = gencom.extensionsDict[functionName]
- f.write (gencom.clang_off_spaces*2 + 'ProcHook::' + ext_name[3:] + ',\n')
- if gencom.isExtensionInternal(ext_name):
- f.write (gencom.clang_off_spaces*2 + 'nullptr,\n' + gencom.clang_off_spaces*2 + 'nullptr,\n')
+def _define_instance_proc_hook(cmd, f):
+ f.write(gencom.indent(1) + '{\n')
+ f.write(gencom.indent(2) + '\"' + cmd + '\",\n')
+ f.write(gencom.indent(2) + 'ProcHook::INSTANCE,\n')
+
+ if cmd in gencom.extension_dict:
+ ext_name = gencom.extension_dict[cmd]
+ f.write(gencom.indent(2) + 'ProcHook::' + ext_name[3:] + ',\n')
+
+ if gencom.is_extension_internal(ext_name):
+ f.write("""\
+ nullptr,
+ nullptr,\n""")
else:
- f.write (gencom.clang_off_spaces*2 + 'reinterpret_cast<PFN_vkVoidFunction>(' + base_name + '),\n' + gencom.clang_off_spaces*2 + 'nullptr,\n')
-
+ f.write("""\
+ reinterpret_cast<PFN_vkVoidFunction>(""" + gencom.base_name(cmd) + """),
+ nullptr,\n""")
else:
- f.write (gencom.clang_off_spaces*2 + """ProcHook::EXTENSION_CORE,
- reinterpret_cast<PFN_vkVoidFunction>(""" + base_name + """),
+ f.write("""\
+ ProcHook::EXTENSION_CORE,
+ reinterpret_cast<PFN_vkVoidFunction>(""" + gencom.base_name(cmd) + """),
nullptr,\n""")
- f.write (gencom.clang_off_spaces + '},\n')
+ f.write(gencom.indent(1) + '},\n')
-def defineDeviceProcHook(functionName, f):
- base_name = functionName[2:]
- f.write (gencom.clang_off_spaces + '{\n')
- f.write (gencom.clang_off_spaces*2 + '\"' + functionName + '\",\n')
- f.write (gencom.clang_off_spaces*2 + 'ProcHook::DEVICE,\n')
- if functionName in gencom.extensionsDict:
- ext_name = gencom.extensionsDict[functionName]
- f.write (gencom.clang_off_spaces*2 + 'ProcHook::' + ext_name[3:] + ',\n')
- if gencom.isExtensionInternal(ext_name):
- f.write (gencom.clang_off_spaces*2 + 'nullptr,\n' + gencom.clang_off_spaces*2 + 'nullptr,\n')
+def _define_device_proc_hook(cmd, f):
+ f.write(gencom.indent(1) + '{\n')
+ f.write(gencom.indent(2) + '\"' + cmd + '\",\n')
+ f.write(gencom.indent(2) + 'ProcHook::DEVICE,\n')
+
+ if cmd in gencom.extension_dict:
+ ext_name = gencom.extension_dict[cmd]
+ f.write(gencom.indent(2) + 'ProcHook::' + ext_name[3:] + ',\n')
+
+ if gencom.is_extension_internal(ext_name):
+ f.write("""\
+ nullptr,
+ nullptr,\n""")
else:
- f.write (gencom.clang_off_spaces*2 + 'reinterpret_cast<PFN_vkVoidFunction>(' + base_name + '),\n' + gencom.clang_off_spaces*2 + 'reinterpret_cast<PFN_vkVoidFunction>(checked' + base_name + '),\n')
+ f.write("""\
+ reinterpret_cast<PFN_vkVoidFunction>(""" + gencom.base_name(cmd) + """),
+ reinterpret_cast<PFN_vkVoidFunction>(checked""" +
+ gencom.base_name(cmd) + '),\n')
else:
- f.write (gencom.clang_off_spaces*2 + """ProcHook::EXTENSION_CORE,
- reinterpret_cast<PFN_vkVoidFunction>(""" + base_name + """),
+ f.write("""\
+ ProcHook::EXTENSION_CORE,
+ reinterpret_cast<PFN_vkVoidFunction>(""" + gencom.base_name(cmd) + """),
nullptr,\n""")
- f.write (gencom.clang_off_spaces + '},\n')
+ f.write(gencom.indent(1) + '},\n')
-def driver_gencpp():
- header = """#include <log/log.h>
+
+def gen_cpp():
+ genfile = os.path.join(os.path.dirname(__file__),
+ '..', 'libvulkan', 'driver_gen.cpp')
+
+ with open(genfile, 'w') as f:
+ f.write(gencom.copyright_and_warning(2016))
+ f.write("""\
+#include <log/log.h>
#include <string.h>
#include <algorithm>
@@ -321,35 +344,34 @@
namespace {
-// clang-format off\n\n"""
+// clang-format off\n\n""")
- genfile = os.path.join(os.path.dirname(__file__),'..','libvulkan','driver_gen.cpp')
+ for cmd in gencom.command_list:
+ _define_proc_hook_stub(cmd, f)
- with open(genfile, 'w') as f:
- f.write (gencom.copyright)
- f.write (gencom.warning)
- f.write (header)
+ f.write("""\
+// clang-format on
- for cmds in gencom.allCommandsList:
- defineProcHookStub(cmds, f)
- gencom.clang_on(f, 0)
- f.write ('\n')
+const ProcHook g_proc_hooks[] = {
+ // clang-format off\n""")
- f.write ('const ProcHook g_proc_hooks[] = {\n')
- gencom.clang_off(f, 1)
- sortedCommandsList = sorted(gencom.allCommandsList)
- for cmds in sortedCommandsList:
- if isIntercepted(cmds):
- if gencom.isGloballyDispatched(cmds):
- defineGlobalProcHook(cmds, f)
- elif gencom.isInstanceDispatched(cmds):
- defineInstanceProcHook(cmds, f)
- elif gencom.isDeviceDispatched(cmds):
- defineDeviceProcHook(cmds, f)
- gencom.clang_on(f, 1)
- f.write ('};\n\n} // namespace\n\n')
+ sorted_command_list = sorted(gencom.command_list)
+ for cmd in sorted_command_list:
+ if _is_intercepted(cmd):
+ if gencom.is_globally_dispatched(cmd):
+ _define_global_proc_hook(cmd, f)
+ elif gencom.is_instance_dispatched(cmd):
+ _define_instance_proc_hook(cmd, f)
+ elif gencom.is_device_dispatched(cmd):
+ _define_device_proc_hook(cmd, f)
- f.write ("""const ProcHook* GetProcHook(const char* name) {
+ f.write("""\
+ // clang-format on
+};
+
+} // namespace
+
+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]);
@@ -357,44 +379,76 @@
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;
-}\n\n""")
+}
- f.write ('ProcHook::Extension GetProcHookExtension(const char* name) {\n')
- gencom.clang_off(f, 1)
- for exts in knownExtensions:
- f.write (gencom.clang_off_spaces + 'if (strcmp(name, \"' + exts + '\") == 0) return ProcHook::' + exts[3:] + ';\n')
- gencom.clang_on(f, 1)
- f.write (gencom.clang_off_spaces + 'return ProcHook::EXTENSION_UNKNOWN;\n')
- f.write ('}\n\n')
+ProcHook::Extension GetProcHookExtension(const char* name) {
+ // clang-format off\n""")
- defineInitProc('driver', f)
- defineInitProcExt(f)
+ for exts in _KNOWN_EXTENSIONS:
+ f.write(gencom.indent(1) + 'if (strcmp(name, \"' + exts +
+ '\") == 0) return ProcHook::' + exts[3:] + ';\n')
- f.write ("""bool InitDriverTable(VkInstance instance,
+ f.write("""\
+ // clang-format on
+ return ProcHook::EXTENSION_UNKNOWN;
+}
+
+#define UNLIKELY(expr) __builtin_expect((expr), 0)
+
+#define INIT_PROC(required, obj, proc) \\
+ do { \\
+ data.driver.proc = \\
+ reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \\
+ if (UNLIKELY(required && !data.driver.proc)) { \\
+ ALOGE("missing " #obj " proc: vk" #proc); \\
+ success = false; \\
+ } \\
+ } while (0)
+
+#define INIT_PROC_EXT(ext, required, obj, proc) \\
+ do { \\
+ if (extensions[ProcHook::ext]) \\
+ INIT_PROC(required, obj, proc); \\
+ } while (0)
+
+bool InitDriverTable(VkInstance instance,
PFN_vkGetInstanceProcAddr get_proc,
const std::bitset<ProcHook::EXTENSION_COUNT>& extensions) {
auto& data = GetData(instance);
- bool success = true;\n\n""")
- gencom.clang_off(f, 1)
- for cmds in gencom.allCommandsList:
- if isInstanceDriverTableEntry(cmds):
- gencom.initProc(cmds, f)
- gencom.clang_on(f, 1)
- f.write ('\n' + gencom.clang_off_spaces + 'return success;\n')
- f.write ('}\n\n')
+ bool success = true;
- f.write ("""bool InitDriverTable(VkDevice dev,
+ // clang-format off\n""")
+
+ for cmd in gencom.command_list:
+ if _is_instance_driver_table_entry(cmd):
+ gencom.init_proc(cmd, f)
+
+ f.write("""\
+ // 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;\n\n""")
- gencom.clang_off(f, 1)
- for cmds in gencom.allCommandsList:
- if isDeviceDriverTableEntry(cmds):
- gencom.initProc(cmds, f)
- gencom.clang_on(f, 1)
- f.write ('\n' + gencom.clang_off_spaces + 'return success;\n')
- f.write ('}\n\n} // namespace driver\n} // namespace vulkan\n\n')
- gencom.clang_on(f, 0)
+ bool success = true;
+
+ // clang-format off\n""")
+
+ for cmd in gencom.command_list:
+ if _is_device_driver_table_entry(cmd):
+ gencom.init_proc(cmd, f)
+
+ f.write("""\
+ // clang-format on
+
+ return success;
+}
+
+} // namespace driver
+} // namespace vulkan\n""")
+
f.close()
- gencom.runClangFormat(genfile)
+ gencom.run_clang_format(genfile)