vulkan/scripts/api_generator.py

#!/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.
#
# This script provides the functions required for generating the
# vulkan api framework directly from the vulkan registry (vk.xml)

import os
import generator_common as gencom

_INTERCEPTED_COMMANDS = [
    'vkCreateDevice',
    'vkDestroyDevice',
    'vkDestroyInstance',
    'vkEnumerateDeviceExtensionProperties',
    'vkEnumerateDeviceLayerProperties',
]


def gen_h():
  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):
  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):
  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):
  f.write("""\
    // global functions
    if (instance == VK_NULL_HANDLE) {\n""")

  for cmd in gencom.command_list:
    if gencom.is_globally_dispatched(cmd):
      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):
  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):
  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():
  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)