vulkan/scripts/api_generator.py - LeafOS-Project/android_frameworks_native - Gitiles

 #!/usr/bin/env python3
 #
 # Copyright 2019 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.

 """Generates the api_gen.h and api_gen.cpp.
 """

 import os
 import generator_common as gencom

 # Functions intercepted at vulkan::api level.
 _INTERCEPTED_COMMANDS = [
     'vkCreateDevice',
     'vkDestroyDevice',
     'vkDestroyInstance',
     'vkEnumerateDeviceExtensionProperties',
     'vkEnumerateDeviceLayerProperties',
 ]


 def gen_h():
   """Generates the api_gen.h file.
   """
   genfile = os.path.join(os.path.dirname(__file__),
                          '..', 'libvulkan', 'api_gen.h')

   with open(genfile, 'w') as f:
     instance_dispatch_table_entries = []
     device_dispatch_table_entries = []

     for cmd in gencom.command_list:
       if cmd not in gencom.alias_dict:
         if gencom.is_instance_dispatch_table_entry(cmd):
           instance_dispatch_table_entries.append(
               'PFN_' + cmd + ' ' + gencom.base_name(cmd) + ';')
         elif gencom.is_device_dispatch_table_entry(cmd):
           device_dispatch_table_entries.append(
               'PFN_' + cmd + ' ' + gencom.base_name(cmd) + ';')

     f.write(gencom.copyright_and_warning(2016))

     f.write("""\
 #ifndef LIBVULKAN_API_GEN_H
 #define LIBVULKAN_API_GEN_H

 #include <vulkan/vulkan.h>

 #include <bitset>

 #include "driver_gen.h"

 namespace vulkan {
 namespace api {

 struct InstanceDispatchTable {
     // clang-format off\n""")

     for entry in instance_dispatch_table_entries:
       f.write(gencom.indent(1) + entry + '\n')

     f.write("""\
     // clang-format on
 };

 struct DeviceDispatchTable {
     // clang-format off\n""")

     for entry in device_dispatch_table_entries:
       f.write(gencom.indent(1) + entry + '\n')

     f.write("""\
     // 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\n""")

     f.close()
   gencom.run_clang_format(genfile)


 def _define_extension_stub(cmd, f):
   """Emits a stub for an exported extension function.

   Args:
     cmd: Vulkan function name.
     f: Output file handle.
   """
   if (cmd in gencom.extension_dict and gencom.is_function_exported(cmd)):
     ext_name = gencom.extension_dict[cmd]
     ret = gencom.return_type_dict[cmd]
     params = gencom.param_dict[cmd]
     first_param = params[0][0] + params[0][1]
     tail_params = ', '.join([i[0][:-1] for i in params[1:]])

     f.write('VKAPI_ATTR ' + ret + ' disabled' + gencom.base_name(cmd) +
             '(' + first_param + ', ' + tail_params + ') {\n')

     f.write(gencom.indent(1) + 'driver::Logger(' + params[0][1] +
             ').Err(' + params[0][1] + ', \"' + ext_name +
             ' not enabled. Exported ' + cmd + ' not executed.\");\n')

     if gencom.return_type_dict[cmd] != 'void':
       f.write(gencom.indent(1) + 'return VK_SUCCESS;\n')

     f.write('}\n\n')


 def _is_intercepted(cmd):
   """Returns true if a function is intercepted by vulkan::api.

   Args:
     cmd: Vulkan function name.
   """
   if gencom.is_function_supported(cmd):
     if gencom.is_globally_dispatched(cmd) or cmd in _INTERCEPTED_COMMANDS:
       return True
   return False


 def _intercept_instance_proc_addr(f):
   """Emits code for vkGetInstanceProcAddr for function interception.

   Args:
     f: Output file handle.
   """
   f.write("""\
     // global functions
     if (instance == VK_NULL_HANDLE) {\n""")

   for cmd in gencom.command_list:
     # vkGetInstanceProcAddr(nullptr, "vkGetInstanceProcAddr") is effectively
     # globally dispatched
     if gencom.is_globally_dispatched(cmd) or cmd == 'vkGetInstanceProcAddr':
       f.write(gencom.indent(2) +
               'if (strcmp(pName, \"' + cmd +
               '\") == 0) return reinterpret_cast<PFN_vkVoidFunction>(' +
               gencom.base_name(cmd) + ');\n')

   f.write("""
         ALOGE("invalid vkGetInstanceProcAddr(VK_NULL_HANDLE, \\\"%s\\\") call", pName);
         return nullptr;
     }

     static const struct Hook {
         const char* name;
         PFN_vkVoidFunction proc;
     } hooks[] = {\n""")

   sorted_command_list = sorted(gencom.command_list)
   for cmd in sorted_command_list:
     if gencom.is_function_exported(cmd):
       if gencom.is_globally_dispatched(cmd):
         f.write(gencom.indent(2) + '{ \"' + cmd + '\", nullptr },\n')
       elif (_is_intercepted(cmd) or
             cmd == 'vkGetInstanceProcAddr' or
             gencom.is_device_dispatched(cmd)):
         f.write(gencom.indent(2) + '{ \"' + cmd +
                 '\", reinterpret_cast<PFN_vkVoidFunction>(' +
                 gencom.base_name(cmd) + ') },\n')

   f.write("""\
     };
     // 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\n\n""")


 def _intercept_device_proc_addr(f):
   """Emits code for vkGetDeviceProcAddr for function interception.

   Args:
     f: Output file handle.
   """
   f.write("""\
     if (device == VK_NULL_HANDLE) {
         ALOGE("invalid vkGetDeviceProcAddr(VK_NULL_HANDLE, ...) call");
         return nullptr;
     }

     static const char* const known_non_device_names[] = {\n""")

   sorted_command_list = sorted(gencom.command_list)
   for cmd in sorted_command_list:
     if gencom.is_function_supported(cmd):
       if not gencom.is_device_dispatched(cmd):
         f.write(gencom.indent(2) + '\"' + cmd + '\",\n')

   f.write("""\
     };
     // 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\n\n""")

   for cmd in gencom.command_list:
     if gencom.is_device_dispatched(cmd):
       if _is_intercepted(cmd) or cmd == 'vkGetDeviceProcAddr':
         f.write(gencom.indent(1) + 'if (strcmp(pName, "' + cmd +
                 '") == 0) return reinterpret_cast<PFN_vkVoidFunction>(' +
                 gencom.base_name(cmd) + ');\n')
   f.write('\n')


 def _api_dispatch(cmd, f):
   """Emits code to dispatch a function.

   Args:
     cmd: Vulkan function name.
     f: Output file handle.
   """
   assert not _is_intercepted(cmd)

   f.write(gencom.indent(1))
   if gencom.return_type_dict[cmd] != 'void':
     f.write('return ')

   param_list = gencom.param_dict[cmd]
   handle = param_list[0][1]
   f.write('GetData(' + handle + ').dispatch.' + gencom.base_name(cmd) +
           '(' + ', '.join(i[1] for i in param_list) + ');\n')


 def gen_cpp():
   """Generates the api_gen.cpp file.
   """
   genfile = os.path.join(os.path.dirname(__file__),
                          '..', 'libvulkan', 'api_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>

 // to catch mismatches between vulkan.h and this file
 #undef VK_NO_PROTOTYPES
 #include "api.h"

 namespace vulkan {
 namespace api {

 #define UNLIKELY(expr) __builtin_expect((expr), 0)

 #define INIT_PROC(required, obj, proc)                                 \\
     do {                                                               \\
         data.dispatch.proc =                                           \\
             reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \\
         if (UNLIKELY(required && !data.dispatch.proc)) {               \\
             ALOGE("missing " #obj " proc: vk" #proc);                  \\
             success = false;                                           \\
         }                                                              \\
     } while (0)

 // 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)

 namespace {

 // clang-format off\n\n""")

     for cmd in gencom.command_list:
       _define_extension_stub(cmd, f)

     f.write("""\
 // clang-format on

 }  // namespace

 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\n""")

     for cmd in gencom.command_list:
       if gencom.is_instance_dispatch_table_entry(cmd):
         gencom.init_proc(cmd, f)

     f.write("""\
     // 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\n""")

     for cmd in gencom.command_list:
       if gencom.is_device_dispatch_table_entry(cmd):
         gencom.init_proc(cmd, f)

     f.write("""\
     // clang-format on

     return success;
 }

 // clang-format off

 namespace {

 // forward declarations needed by GetInstanceProcAddr and GetDeviceProcAddr
 """)

     for cmd in gencom.command_list:
       if gencom.is_function_exported(cmd) and not _is_intercepted(cmd):
         param_list = [''.join(i) for i in gencom.param_dict[cmd]]
         f.write('VKAPI_ATTR ' + gencom.return_type_dict[cmd] + ' ' +
                 gencom.base_name(cmd) + '(' + ', '.join(param_list) + ');\n')

     f.write('\n')
     for cmd in gencom.command_list:
       if gencom.is_function_exported(cmd) and not _is_intercepted(cmd):
         param_list = [''.join(i) for i in gencom.param_dict[cmd]]
         f.write('VKAPI_ATTR ' + gencom.return_type_dict[cmd] + ' ' +
                 gencom.base_name(cmd) + '(' + ', '.join(param_list) + ') {\n')
         if cmd == 'vkGetInstanceProcAddr':
           _intercept_instance_proc_addr(f)
         elif cmd == 'vkGetDeviceProcAddr':
           _intercept_device_proc_addr(f)
         _api_dispatch(cmd, f)
         f.write('}\n\n')

     f.write("""
 }  // anonymous namespace

 // clang-format on

 }  // namespace api
 }  // namespace vulkan

 // clang-format off\n\n""")

     for cmd in gencom.command_list:
       if gencom.is_function_exported(cmd):
         param_list = [''.join(i) for i in gencom.param_dict[cmd]]
         f.write('__attribute__((visibility("default")))\n')
         f.write('VKAPI_ATTR ' + gencom.return_type_dict[cmd] + ' ' +
                 cmd + '(' + ', '.join(param_list) + ') {\n')
         f.write(gencom.indent(1))
         if gencom.return_type_dict[cmd] != 'void':
           f.write('return ')
         param_list = gencom.param_dict[cmd]
         f.write('vulkan::api::' + gencom.base_name(cmd) +
                 '(' + ', '.join(i[1] for i in param_list) + ');\n}\n\n')

     f.write('// clang-format on\n')
     f.close()
   gencom.run_clang_format(genfile)
	#!/usr/bin/env python3
	#
	# Copyright 2019 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.

	"""Generates the api_gen.h and api_gen.cpp.
	"""

	import os
	import generator_common as gencom

	# Functions intercepted at vulkan::api level.
	_INTERCEPTED_COMMANDS = [
	'vkCreateDevice',
	'vkDestroyDevice',
	'vkDestroyInstance',
	'vkEnumerateDeviceExtensionProperties',
	'vkEnumerateDeviceLayerProperties',
	]


	def gen_h():
	"""Generates the api_gen.h file.
	"""
	genfile = os.path.join(os.path.dirname(__file__),
	'..', 'libvulkan', 'api_gen.h')

	with open(genfile, 'w') as f:
	instance_dispatch_table_entries = []
	device_dispatch_table_entries = []

	for cmd in gencom.command_list:
	if cmd not in gencom.alias_dict:
	if gencom.is_instance_dispatch_table_entry(cmd):
	instance_dispatch_table_entries.append(
	'PFN_' + cmd + ' ' + gencom.base_name(cmd) + ';')
	elif gencom.is_device_dispatch_table_entry(cmd):
	device_dispatch_table_entries.append(
	'PFN_' + cmd + ' ' + gencom.base_name(cmd) + ';')

	f.write(gencom.copyright_and_warning(2016))

	f.write("""\
	#ifndef LIBVULKAN_API_GEN_H
	#define LIBVULKAN_API_GEN_H

	#include <vulkan/vulkan.h>

	#include <bitset>

	#include "driver_gen.h"

	namespace vulkan {
	namespace api {

	struct InstanceDispatchTable {
	// clang-format off\n""")

	for entry in instance_dispatch_table_entries:
	f.write(gencom.indent(1) + entry + '\n')

	f.write("""\
	// clang-format on
	};

	struct DeviceDispatchTable {
	// clang-format off\n""")

	for entry in device_dispatch_table_entries:
	f.write(gencom.indent(1) + entry + '\n')

	f.write("""\
	// 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\n""")

	f.close()
	gencom.run_clang_format(genfile)


	def _define_extension_stub(cmd, f):
	"""Emits a stub for an exported extension function.

	Args:
	cmd: Vulkan function name.
	f: Output file handle.
	"""
	if (cmd in gencom.extension_dict and gencom.is_function_exported(cmd)):
	ext_name = gencom.extension_dict[cmd]
	ret = gencom.return_type_dict[cmd]
	params = gencom.param_dict[cmd]
	first_param = params[0][0] + params[0][1]
	tail_params = ', '.join([i[0][:-1] for i in params[1:]])

	f.write('VKAPI_ATTR ' + ret + ' disabled' + gencom.base_name(cmd) +
	'(' + first_param + ', ' + tail_params + ') {\n')

	f.write(gencom.indent(1) + 'driver::Logger(' + params[0][1] +
	').Err(' + params[0][1] + ', \"' + ext_name +
	' not enabled. Exported ' + cmd + ' not executed.\");\n')

	if gencom.return_type_dict[cmd] != 'void':
	f.write(gencom.indent(1) + 'return VK_SUCCESS;\n')

	f.write('}\n\n')


	def _is_intercepted(cmd):
	"""Returns true if a function is intercepted by vulkan::api.

	Args:
	cmd: Vulkan function name.
	"""
	if gencom.is_function_supported(cmd):
	if gencom.is_globally_dispatched(cmd) or cmd in _INTERCEPTED_COMMANDS:
	return True
	return False


	def _intercept_instance_proc_addr(f):
	"""Emits code for vkGetInstanceProcAddr for function interception.

	Args:
	f: Output file handle.
	"""
	f.write("""\
	// global functions
	if (instance == VK_NULL_HANDLE) {\n""")

	for cmd in gencom.command_list:
	# vkGetInstanceProcAddr(nullptr, "vkGetInstanceProcAddr") is effectively
	# globally dispatched
	if gencom.is_globally_dispatched(cmd) or cmd == 'vkGetInstanceProcAddr':
	f.write(gencom.indent(2) +
	'if (strcmp(pName, \"' + cmd +
	'\") == 0) return reinterpret_cast<PFN_vkVoidFunction>(' +
	gencom.base_name(cmd) + ');\n')

	f.write("""
	ALOGE("invalid vkGetInstanceProcAddr(VK_NULL_HANDLE, \\\"%s\\\") call", pName);
	return nullptr;
	}

	static const struct Hook {
	const char* name;
	PFN_vkVoidFunction proc;
	} hooks[] = {\n""")

	sorted_command_list = sorted(gencom.command_list)
	for cmd in sorted_command_list:
	if gencom.is_function_exported(cmd):
	if gencom.is_globally_dispatched(cmd):
	f.write(gencom.indent(2) + '{ \"' + cmd + '\", nullptr },\n')
	elif (_is_intercepted(cmd) or
	cmd == 'vkGetInstanceProcAddr' or
	gencom.is_device_dispatched(cmd)):
	f.write(gencom.indent(2) + '{ \"' + cmd +
	'\", reinterpret_cast<PFN_vkVoidFunction>(' +
	gencom.base_name(cmd) + ') },\n')

	f.write("""\
	};
	// 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\n\n""")


	def _intercept_device_proc_addr(f):
	"""Emits code for vkGetDeviceProcAddr for function interception.

	Args:
	f: Output file handle.
	"""
	f.write("""\
	if (device == VK_NULL_HANDLE) {
	ALOGE("invalid vkGetDeviceProcAddr(VK_NULL_HANDLE, ...) call");
	return nullptr;
	}

	static const char* const known_non_device_names[] = {\n""")

	sorted_command_list = sorted(gencom.command_list)
	for cmd in sorted_command_list:
	if gencom.is_function_supported(cmd):
	if not gencom.is_device_dispatched(cmd):
	f.write(gencom.indent(2) + '\"' + cmd + '\",\n')

	f.write("""\
	};
	// 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\n\n""")

	for cmd in gencom.command_list:
	if gencom.is_device_dispatched(cmd):
	if _is_intercepted(cmd) or cmd == 'vkGetDeviceProcAddr':
	f.write(gencom.indent(1) + 'if (strcmp(pName, "' + cmd +
	'") == 0) return reinterpret_cast<PFN_vkVoidFunction>(' +
	gencom.base_name(cmd) + ');\n')
	f.write('\n')


	def _api_dispatch(cmd, f):
	"""Emits code to dispatch a function.

	Args:
	cmd: Vulkan function name.
	f: Output file handle.
	"""
	assert not _is_intercepted(cmd)

	f.write(gencom.indent(1))
	if gencom.return_type_dict[cmd] != 'void':
	f.write('return ')

	param_list = gencom.param_dict[cmd]
	handle = param_list[0][1]
	f.write('GetData(' + handle + ').dispatch.' + gencom.base_name(cmd) +
	'(' + ', '.join(i[1] for i in param_list) + ');\n')


	def gen_cpp():
	"""Generates the api_gen.cpp file.
	"""
	genfile = os.path.join(os.path.dirname(__file__),
	'..', 'libvulkan', 'api_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>

	// to catch mismatches between vulkan.h and this file
	#undef VK_NO_PROTOTYPES
	#include "api.h"

	namespace vulkan {
	namespace api {

	#define UNLIKELY(expr) __builtin_expect((expr), 0)

	#define INIT_PROC(required, obj, proc) \\
	do { \\
	data.dispatch.proc = \\
	reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \\
	if (UNLIKELY(required && !data.dispatch.proc)) { \\
	ALOGE("missing " #obj " proc: vk" #proc); \\
	success = false; \\
	} \\
	} while (0)

	// 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)

	namespace {

	// clang-format off\n\n""")

	for cmd in gencom.command_list:
	_define_extension_stub(cmd, f)

	f.write("""\
	// clang-format on

	} // namespace

	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\n""")

	for cmd in gencom.command_list:
	if gencom.is_instance_dispatch_table_entry(cmd):
	gencom.init_proc(cmd, f)

	f.write("""\
	// 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\n""")

	for cmd in gencom.command_list:
	if gencom.is_device_dispatch_table_entry(cmd):
	gencom.init_proc(cmd, f)

	f.write("""\
	// clang-format on

	return success;
	}

	// clang-format off

	namespace {

	// forward declarations needed by GetInstanceProcAddr and GetDeviceProcAddr
	""")

	for cmd in gencom.command_list:
	if gencom.is_function_exported(cmd) and not _is_intercepted(cmd):
	param_list = [''.join(i) for i in gencom.param_dict[cmd]]
	f.write('VKAPI_ATTR ' + gencom.return_type_dict[cmd] + ' ' +
	gencom.base_name(cmd) + '(' + ', '.join(param_list) + ');\n')

	f.write('\n')
	for cmd in gencom.command_list:
	if gencom.is_function_exported(cmd) and not _is_intercepted(cmd):
	param_list = [''.join(i) for i in gencom.param_dict[cmd]]
	f.write('VKAPI_ATTR ' + gencom.return_type_dict[cmd] + ' ' +
	gencom.base_name(cmd) + '(' + ', '.join(param_list) + ') {\n')
	if cmd == 'vkGetInstanceProcAddr':
	_intercept_instance_proc_addr(f)
	elif cmd == 'vkGetDeviceProcAddr':
	_intercept_device_proc_addr(f)
	_api_dispatch(cmd, f)
	f.write('}\n\n')

	f.write("""
	} // anonymous namespace

	// clang-format on

	} // namespace api
	} // namespace vulkan

	// clang-format off\n\n""")

	for cmd in gencom.command_list:
	if gencom.is_function_exported(cmd):
	param_list = [''.join(i) for i in gencom.param_dict[cmd]]
	f.write('__attribute__((visibility("default")))\n')
	f.write('VKAPI_ATTR ' + gencom.return_type_dict[cmd] + ' ' +
	cmd + '(' + ', '.join(param_list) + ') {\n')
	f.write(gencom.indent(1))
	if gencom.return_type_dict[cmd] != 'void':
	f.write('return ')
	param_list = gencom.param_dict[cmd]
	f.write('vulkan::api::' + gencom.base_name(cmd) +
	'(' + ', '.join(i[1] for i in param_list) + ');\n}\n\n')

	f.write('// clang-format on\n')
	f.close()
	gencom.run_clang_format(genfile)