turnip: Use the common dispatch framework

Acked-by: Jonathan Marek <jonathan@marek.ca>
Reviewed-by: Bas Nieuwenhuizen <bas@basnieuwenhuizen.nl>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/8676>

11 files changed, 77 insertions, 673 deletions

diff --git a/src/freedreno/vulkan/meson.build b/src/freedreno/vulkan/meson.build
index 6a9035ff3f4..fa537019bcb 100644
--- a/src/freedreno/vulkan/meson.build
+++ b/src/freedreno/vulkan/meson.build
@@ -19,14 +19,13 @@
 # SOFTWARE.
 
 tu_entrypoints = custom_target(
-  'tu_entrypoints.[ch]',
-  input : ['tu_entrypoints_gen.py', vk_api_xml],
+  'tu_entrypoints',
+  input : [vk_entrypoints_gen, vk_api_xml],
   output : ['tu_entrypoints.h', 'tu_entrypoints.c'],
   command : [
-    prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--outdir',
-    meson.current_build_dir()
+    prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--proto', '--weak',
+    '--out-h', '@OUTPUT0@', '--out-c', '@OUTPUT1@', '--prefix', 'tu',
   ],
-  depend_files : files('tu_extensions.py'),
 )
 
 tu_extensions_c = custom_target(
diff --git a/src/freedreno/vulkan/tu_device.c b/src/freedreno/vulkan/tu_device.c
index e7a21a8838d..6d3b65d5e68 100644
--- a/src/freedreno/vulkan/tu_device.c
+++ b/src/freedreno/vulkan/tu_device.c
@@ -87,12 +87,12 @@ tu_physical_device_init(struct tu_physical_device *device,
    default:
       result = vk_startup_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
                                  "device %s is unsupported", device->name);
-      goto fail;
+      goto fail_fds;
    }
    if (tu_device_get_cache_uuid(device->gpu_id, device->cache_uuid)) {
       result = vk_startup_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
                                  "cannot generate UUID");
-      goto fail;
+      goto fail_fds;
    }
 
    /* The gpu id is already embedded in the uuid so we just pass "tu"
@@ -108,19 +108,32 @@ tu_physical_device_init(struct tu_physical_device *device,
    fd_get_driver_uuid(device->driver_uuid);
    fd_get_device_uuid(device->device_uuid, device->gpu_id);
 
-   tu_physical_device_get_supported_extensions(device, &device->supported_extensions);
+   struct vk_device_extension_table supported_extensions;
+   tu_physical_device_get_supported_extensions(device, &supported_extensions);
+
+   struct vk_physical_device_dispatch_table dispatch_table;
+   vk_physical_device_dispatch_table_from_entrypoints(
+      &dispatch_table, &tu_physical_device_entrypoints, true);
+
+   result = vk_physical_device_init(&device->vk, &instance->vk,
+                                    &supported_extensions,
+                                    &dispatch_table);
+   if (result != VK_SUCCESS)
+      goto fail_fds;
 
 #if TU_HAS_SURFACE
    result = tu_wsi_init(device);
    if (result != VK_SUCCESS) {
       vk_startup_errorf(instance, result, "WSI init failure");
-      goto fail;
+      goto fail_vk_pd_init;
    }
 #endif
 
    return VK_SUCCESS;
 
-fail:
+fail_vk_pd_init:
+   vk_physical_device_finish(&device->vk);
+fail_fds:
    close(device->local_fd);
    if (device->master_fd != -1)
       close(device->master_fd);
@@ -139,7 +152,7 @@ tu_physical_device_finish(struct tu_physical_device *device)
    if (device->master_fd != -1)
       close(device->master_fd);
 
-   vk_object_base_finish(&device->base);
+   vk_physical_device_finish(&device->vk);
 }
 
 static VKAPI_ATTR void *
@@ -195,16 +208,6 @@ tu_get_debug_option_name(int id)
    return tu_debug_options[id].string;
 }
 
-static int
-tu_get_instance_extension_index(const char *name)
-{
-   for (unsigned i = 0; i < TU_INSTANCE_EXTENSION_COUNT; ++i) {
-      if (strcmp(name, tu_instance_extensions[i].extensionName) == 0)
-         return i;
-   }
-   return -1;
-}
-
 VkResult
 tu_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
                   const VkAllocationCallbacks *pAllocator,
@@ -215,28 +218,28 @@ tu_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
 
    assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);
 
-   uint32_t client_version;
-   if (pCreateInfo->pApplicationInfo &&
-       pCreateInfo->pApplicationInfo->apiVersion != 0) {
-      client_version = pCreateInfo->pApplicationInfo->apiVersion;
-   } else {
-      tu_EnumerateInstanceVersion(&client_version);
-   }
+   if (pAllocator == NULL)
+      pAllocator = &default_alloc;
 
-   instance = vk_zalloc2(&default_alloc, pAllocator, sizeof(*instance), 8,
-                         VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+   instance = vk_zalloc(pAllocator, sizeof(*instance), 8,
+                        VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
 
    if (!instance)
       return vk_error(NULL, VK_ERROR_OUT_OF_HOST_MEMORY);
 
-   vk_object_base_init(NULL, &instance->base, VK_OBJECT_TYPE_INSTANCE);
+   struct vk_instance_dispatch_table dispatch_table;
+   vk_instance_dispatch_table_from_entrypoints(
+      &dispatch_table, &tu_instance_entrypoints, true);
 
-   if (pAllocator)
-      instance->alloc = *pAllocator;
-   else
-      instance->alloc = default_alloc;
+   result = vk_instance_init(&instance->vk,
+                             &tu_instance_extensions_supported,
+                             &dispatch_table,
+                             pCreateInfo, pAllocator);
+   if (result != VK_SUCCESS) {
+      vk_free(pAllocator, instance);
+      return vk_error(NULL, result);
+   }
 
-   instance->api_version = client_version;
    instance->physical_device_count = -1;
 
    instance->debug_flags =
@@ -253,24 +256,10 @@ tu_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
    if (instance->debug_flags & TU_DEBUG_STARTUP)
       mesa_logi("Created an instance");
 
-   for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-      const char *ext_name = pCreateInfo->ppEnabledExtensionNames[i];
-      int index = tu_get_instance_extension_index(ext_name);
-
-      if (index < 0 || !tu_instance_extensions_supported.extensions[index]) {
-         vk_object_base_finish(&instance->base);
-         vk_free2(&default_alloc, pAllocator, instance);
-         return vk_startup_errorf(instance, VK_ERROR_EXTENSION_NOT_PRESENT,
-                                  "Missing %s", ext_name);
-      }
-
-      instance->enabled_extensions.extensions[index] = true;
-   }
-
    result = vk_debug_report_instance_init(&instance->debug_report_callbacks);
    if (result != VK_SUCCESS) {
-      vk_object_base_finish(&instance->base);
-      vk_free2(&default_alloc, pAllocator, instance);
+      vk_instance_finish(&instance->vk);
+      vk_free(pAllocator, instance);
       return vk_startup_errorf(instance, result, "debug_report setup failure");
    }
 
@@ -302,8 +291,8 @@ tu_DestroyInstance(VkInstance _instance,
 
    vk_debug_report_instance_destroy(&instance->debug_report_callbacks);
 
-   vk_object_base_finish(&instance->base);
-   vk_free(&instance->alloc, instance);
+   vk_instance_finish(&instance->vk);
+   vk_free(&instance->vk.alloc, instance);
 }
 
 VkResult
@@ -827,7 +816,7 @@ tu_GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
          VkPhysicalDeviceSampleLocationsPropertiesEXT *properties =
             (VkPhysicalDeviceSampleLocationsPropertiesEXT *)ext;
          properties->sampleLocationSampleCounts = 0;
-         if (pdevice->supported_extensions.EXT_sample_locations) {
+         if (pdevice->vk.supported_extensions.EXT_sample_locations) {
             properties->sampleLocationSampleCounts =
                VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT;
          }
@@ -980,16 +969,6 @@ tu_queue_finish(struct tu_queue *queue)
    tu_drm_submitqueue_close(queue->device, queue->msm_queue_id);
 }
 
-static int
-tu_get_device_extension_index(const char *name)
-{
-   for (unsigned i = 0; i < TU_DEVICE_EXTENSION_COUNT; ++i) {
-      if (strcmp(name, tu_device_extensions[i].extensionName) == 0)
-         return i;
-   }
-   return -1;
-}
-
 VkResult
 tu_CreateDevice(VkPhysicalDevice physicalDevice,
                 const VkDeviceCreateInfo *pCreateInfo,
@@ -1036,13 +1015,19 @@ tu_CreateDevice(VkPhysicalDevice physicalDevice,
       }
    }
 
-   device = vk_zalloc2(&physical_device->instance->alloc, pAllocator,
+   device = vk_zalloc2(&physical_device->instance->vk.alloc, pAllocator,
                        sizeof(*device), 8, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
    if (!device)
       return vk_startup_errorf(physical_device->instance, VK_ERROR_OUT_OF_HOST_MEMORY, "OOM");
 
-   result = vk_device_init(&device->vk, NULL, NULL, pCreateInfo,
-         &physical_device->instance->alloc, pAllocator);
+   struct vk_device_dispatch_table dispatch_table;
+   vk_device_dispatch_table_from_entrypoints(
+      &dispatch_table, &tu_device_entrypoints, true);
+
+   result = vk_device_init(&device->vk, &physical_device->vk,
+                           &dispatch_table, pCreateInfo,
+                           &physical_device->instance->vk.alloc,
+                           pAllocator);
    if (result != VK_SUCCESS) {
       vk_free(&device->vk.alloc, device);
       return vk_startup_errorf(physical_device->instance, result,
@@ -1056,21 +1041,6 @@ tu_CreateDevice(VkPhysicalDevice physicalDevice,
 
    mtx_init(&device->bo_mutex, mtx_plain);
 
-   for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-      const char *ext_name = pCreateInfo->ppEnabledExtensionNames[i];
-      int index = tu_get_device_extension_index(ext_name);
-      if (index < 0 ||
-          !physical_device->supported_extensions.extensions[index]) {
-         vk_device_finish(&device->vk);
-         vk_free(&device->vk.alloc, device);
-         return vk_startup_errorf(physical_device->instance,
-                                  VK_ERROR_EXTENSION_NOT_PRESENT,
-                                  "Missing device extension '%s'", ext_name);
-      }
-
-      device->enabled_extensions.extensions[index] = true;
-   }
-
    for (unsigned i = 0; i < pCreateInfo->queueCreateInfoCount; i++) {
       const VkDeviceQueueCreateInfo *queue_create =
          &pCreateInfo->pQueueCreateInfos[i];
@@ -1347,15 +1317,6 @@ tu_EnumerateInstanceLayerProperties(uint32_t *pPropertyCount,
    return VK_SUCCESS;
 }
 
-VkResult
-tu_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
-                                  uint32_t *pPropertyCount,
-                                  VkLayerProperties *pProperties)
-{
-   *pPropertyCount = 0;
-   return VK_SUCCESS;
-}
-
 void
 tu_GetDeviceQueue2(VkDevice _device,
                    const VkDeviceQueueInfo2 *pQueueInfo,
@@ -1434,32 +1395,9 @@ tu_EnumerateInstanceExtensionProperties(const char *pLayerName,
    if (pLayerName)
       return vk_error(NULL, VK_ERROR_LAYER_NOT_PRESENT);
 
-   for (int i = 0; i < TU_INSTANCE_EXTENSION_COUNT; i++) {
+   for (int i = 0; i < VK_INSTANCE_EXTENSION_COUNT; i++) {
       if (tu_instance_extensions_supported.extensions[i]) {
-         vk_outarray_append(&out, prop) { *prop = tu_instance_extensions[i]; }
-      }
-   }
-
-   return vk_outarray_status(&out);
-}
-
-VkResult
-tu_EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
-                                      const char *pLayerName,
-                                      uint32_t *pPropertyCount,
-                                      VkExtensionProperties *pProperties)
-{
-   /* We spport no lyaers */
-   TU_FROM_HANDLE(tu_physical_device, device, physicalDevice);
-   VK_OUTARRAY_MAKE(out, pProperties, pPropertyCount);
-
-   /* We spport no lyaers */
-   if (pLayerName)
-      return vk_error(NULL, VK_ERROR_LAYER_NOT_PRESENT);
-
-   for (int i = 0; i < TU_DEVICE_EXTENSION_COUNT; i++) {
-      if (device->supported_extensions.extensions[i]) {
-         vk_outarray_append(&out, prop) { *prop = tu_device_extensions[i]; }
+         vk_outarray_append(&out, prop) { *prop = vk_instance_extensions[i]; }
       }
    }
 
@@ -1470,10 +1408,9 @@ PFN_vkVoidFunction
 tu_GetInstanceProcAddr(VkInstance _instance, const char *pName)
 {
    TU_FROM_HANDLE(tu_instance, instance, _instance);
-
-   return tu_lookup_entrypoint_checked(
-      pName, instance ? instance->api_version : 0,
-      instance ? &instance->enabled_extensions : NULL, NULL);
+   return vk_instance_get_proc_addr(&instance->vk,
+                                    &tu_instance_entrypoints,
+                                    pName);
 }
 
 /* The loader wants us to expose a second GetInstanceProcAddr function
@@ -1490,16 +1427,6 @@ vk_icdGetInstanceProcAddr(VkInstance instance, const char *pName)
    return tu_GetInstanceProcAddr(instance, pName);
 }
 
-PFN_vkVoidFunction
-tu_GetDeviceProcAddr(VkDevice _device, const char *pName)
-{
-   TU_FROM_HANDLE(tu_device, device, _device);
-
-   return tu_lookup_entrypoint_checked(pName, device->instance->api_version,
-                                       &device->instance->enabled_extensions,
-                                       &device->enabled_extensions);
-}
-
 VkResult
 tu_AllocateMemory(VkDevice _device,
                   const VkMemoryAllocateInfo *pAllocateInfo,
@@ -2154,7 +2081,7 @@ void tu_GetPhysicalDeviceMultisamplePropertiesEXT(
 {
    TU_FROM_HANDLE(tu_physical_device, pdevice, physicalDevice);
 
-   if (samples <= VK_SAMPLE_COUNT_4_BIT && pdevice->supported_extensions.EXT_sample_locations)
+   if (samples <= VK_SAMPLE_COUNT_4_BIT && pdevice->vk.supported_extensions.EXT_sample_locations)
       pMultisampleProperties->maxSampleLocationGridSize = (VkExtent2D){ 1, 1 };
    else
       pMultisampleProperties->maxSampleLocationGridSize = (VkExtent2D){ 0, 0 };
diff --git a/src/freedreno/vulkan/tu_drm.c b/src/freedreno/vulkan/tu_drm.c
index 256a80242b7..28f2c9531e8 100644
--- a/src/freedreno/vulkan/tu_drm.c
+++ b/src/freedreno/vulkan/tu_drm.c
@@ -356,10 +356,9 @@ tu_drm_device_init(struct tu_physical_device *device,
    if (instance->debug_flags & TU_DEBUG_STARTUP)
       mesa_logi("Found compatible device '%s'.", path);
 
-   vk_object_base_init(NULL, &device->base, VK_OBJECT_TYPE_PHYSICAL_DEVICE);
    device->instance = instance;
 
-   if (instance->enabled_extensions.KHR_display) {
+   if (instance->vk.enabled_extensions.KHR_display) {
       master_fd =
          open(drm_device->nodes[DRM_NODE_PRIMARY], O_RDWR | O_CLOEXEC);
       if (master_fd >= 0) {
diff --git a/src/freedreno/vulkan/tu_entrypoints_gen.py b/src/freedreno/vulkan/tu_entrypoints_gen.py
deleted file mode 100644
index 85e620b5729..00000000000
--- a/src/freedreno/vulkan/tu_entrypoints_gen.py
+++ /dev/null
@@ -1,510 +0,0 @@
-# coding=utf-8
-#
-# Copyright © 2015, 2017 Intel Corporation
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the "Software"),
-# to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense,
-# and/or sell copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice (including the next
-# paragraph) shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
-# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-
-import argparse
-import copy
-import functools
-import math
-import os
-import xml.etree.ElementTree as et
-
-from collections import OrderedDict, namedtuple
-from mako.template import Template
-
-from tu_extensions import VkVersion, MAX_API_VERSION, EXTENSIONS
-
-# We generate a static hash table for entry point lookup
-# (vkGetProcAddress). We use a linear congruential generator for our hash
-# function and a power-of-two size table. The prime numbers are determined
-# experimentally.
-
-# We currently don't use layers in tu, but keeping the ability for anv
-# anyways, so we can use it for device groups.
-LAYERS = [
-    'tu'
-]
-
-TEMPLATE_H = Template("""\
-/* This file generated from ${filename}, don't edit directly. */
-
-struct tu_dispatch_table {
-   union {
-      void *entrypoints[${len(entrypoints)}];
-      struct {
-      % for e in entrypoints:
-        % if e.guard is not None:
-#ifdef ${e.guard}
-          PFN_${e.name} ${e.name};
-#else
-          void *${e.name};
-# endif
-        % else:
-          PFN_${e.name} ${e.name};
-        % endif
-      % endfor
-      };
-   };
-};
-
-% for e in entrypoints:
-  % if e.alias:
-    <% continue %>
-  % endif
-  % if e.guard is not None:
-#ifdef ${e.guard}
-  % endif
-  % for layer in LAYERS:
-  VKAPI_ATTR ${e.return_type} ${e.prefixed_name(layer)}(${e.decl_params()});
-  % endfor
-  % if e.guard is not None:
-#endif // ${e.guard}
-  % endif
-% endfor
-""", output_encoding='utf-8')
-
-TEMPLATE_C = Template(u"""\
-/*
- * Copyright © 2015 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-/* This file generated from ${filename}, don't edit directly. */
-
-#include "tu_private.h"
-
-struct string_map_entry {
-   uint32_t name;
-   uint32_t hash;
-   uint32_t num;
-};
-
-/* We use a big string constant to avoid lots of relocations from the entry
- * point table to lots of little strings. The entries in the entry point table
- * store the index into this big string.
- */
-
-static const char strings[] =
-% for s in strmap.sorted_strings:
-    "${s.string}\\0"
-% endfor
-;
-
-static const struct string_map_entry string_map_entries[] = {
-% for s in strmap.sorted_strings:
-    { ${s.offset}, ${'{:0=#8x}'.format(s.hash)}, ${s.num} }, /* ${s.string} */
-% endfor
-};
-
-/* Hash table stats:
- * size ${len(strmap.sorted_strings)} entries
- * collisions entries:
-% for i in range(10):
- *     ${i}${'+' if i == 9 else ' '}     ${strmap.collisions[i]}
-% endfor
- */
-
-#define none 0xffff
-static const uint16_t string_map[${strmap.hash_size}] = {
-% for e in strmap.mapping:
-    ${ '{:0=#6x}'.format(e) if e >= 0 else 'none' },
-% endfor
-};
-
-/* Weak aliases for all potential implementations. These will resolve to
- * NULL if they're not defined, which lets the resolve_entrypoint() function
- * either pick the correct entry point.
- */
-
-% for layer in LAYERS:
-  % for e in entrypoints:
-    % if e.alias:
-      <% continue %>
-    % endif
-    % if e.guard is not None:
-#ifdef ${e.guard}
-    % endif
-    ${e.return_type} ${e.prefixed_name(layer)}(${e.decl_params()}) __attribute__ ((weak));
-    % if e.guard is not None:
-#endif // ${e.guard}
-    % endif
-  % endfor
-
-  const struct tu_dispatch_table ${layer}_layer = {
-  % for e in entrypoints:
-    % if e.guard is not None:
-#ifdef ${e.guard}
-    % endif
-    .${e.name} = ${e.prefixed_name(layer)},
-    % if e.guard is not None:
-#endif // ${e.guard}
-    % endif
-  % endfor
-  };
-% endfor
-
-static void * __attribute__ ((noinline))
-tu_resolve_entrypoint(uint32_t index)
-{
-   return tu_layer.entrypoints[index];
-}
-
-/** Return true if the core version or extension in which the given entrypoint
- * is defined is enabled.
- *
- * If instance is NULL, we only allow the 3 commands explicitly allowed by the vk
- * spec.
- *
- * If device is NULL, all device extensions are considered enabled.
- */
-static bool
-tu_entrypoint_is_enabled(int index, uint32_t core_version,
-                         const struct tu_instance_extension_table *instance,
-                         const struct tu_device_extension_table *device)
-{
-   switch (index) {
-% for e in entrypoints:
-   case ${e.num}:
-   % if not e.device_command:
-      if (device) return false;
-   % endif
-   % if e.name == 'vkGetInstanceProcAddr' or e.name == 'vkCreateInstance' or e.name == 'vkEnumerateInstanceExtensionProperties' or e.name == 'vkEnumerateInstanceLayerProperties' or e.name == 'vkEnumerateInstanceVersion':
-      return !device;
-   % elif e.core_version:
-      return instance && ${e.core_version.c_vk_version()} <= core_version;
-   % elif e.extensions:
-      % for ext in e.extensions:
-         % if ext.type == 'instance':
-      if (instance && instance->${ext.name[3:]}) return true;
-         % else:
-      if (instance && (!device || device->${ext.name[3:]})) return true;
-         % endif
-      %endfor
-      return false;
-   % else:
-      return instance;
-   % endif
-% endfor
-   default:
-      return false;
-   }
-}
-
-static int
-tu_lookup_entrypoint(const char *name)
-{
-   static const uint32_t prime_factor = ${strmap.prime_factor};
-   static const uint32_t prime_step = ${strmap.prime_step};
-   const struct string_map_entry *e;
-   uint32_t hash, h;
-   uint16_t i;
-   const char *p;
-
-   hash = 0;
-   for (p = name; *p; p++)
-       hash = hash * prime_factor + *p;
-
-   h = hash;
-   while (1) {
-       i = string_map[h & ${strmap.hash_mask}];
-       if (i == none)
-          return -1;
-       e = &string_map_entries[i];
-       if (e->hash == hash && strcmp(name, strings + e->name) == 0)
-           return e->num;
-       h += prime_step;
-   }
-
-   return -1;
-}
-
-void *
-tu_lookup_entrypoint_unchecked(const char *name)
-{
-   int index = tu_lookup_entrypoint(name);
-   if (index < 0)
-      return NULL;
-   return tu_resolve_entrypoint(index);
-}
-
-void *
-tu_lookup_entrypoint_checked(const char *name,
-                              uint32_t core_version,
-                              const struct tu_instance_extension_table *instance,
-                              const struct tu_device_extension_table *device)
-{
-   int index = tu_lookup_entrypoint(name);
-   if (index < 0 || !tu_entrypoint_is_enabled(index, core_version, instance, device))
-      return NULL;
-   return tu_resolve_entrypoint(index);
-}""", output_encoding='utf-8')
-
-U32_MASK = 2**32 - 1
-
-PRIME_FACTOR = 5024183
-PRIME_STEP = 19
-
-def round_to_pow2(x):
-    return 2**int(math.ceil(math.log(x, 2)))
-
-class StringIntMapEntry(object):
-    def __init__(self, string, num):
-        self.string = string
-        self.num = num
-
-        # Calculate the same hash value that we will calculate in C.
-        h = 0
-        for c in string:
-            h = ((h * PRIME_FACTOR) + ord(c)) & U32_MASK
-        self.hash = h
-
-        self.offset = None
-
-class StringIntMap(object):
-    def __init__(self):
-        self.baked = False
-        self.strings = dict()
-
-    def add_string(self, string, num):
-        assert not self.baked
-        assert string not in self.strings
-        assert num >= 0 and num < 2**31
-        self.strings[string] = StringIntMapEntry(string, num)
-
-    def bake(self):
-        self.sorted_strings = \
-            sorted(self.strings.values(), key=lambda x: x.string)
-        offset = 0
-        for entry in self.sorted_strings:
-            entry.offset = offset
-            offset += len(entry.string) + 1
-
-        # Save off some values that we'll need in C
-        self.hash_size = round_to_pow2(len(self.strings) * 1.25)
-        self.hash_mask = self.hash_size - 1
-        self.prime_factor = PRIME_FACTOR
-        self.prime_step = PRIME_STEP
-
-        self.mapping = [-1] * self.hash_size
-        self.collisions = [0] * 10
-        for idx, s in enumerate(self.sorted_strings):
-            level = 0
-            h = s.hash
-            while self.mapping[h & self.hash_mask] >= 0:
-                h = h + PRIME_STEP
-                level = level + 1
-            self.collisions[min(level, 9)] += 1
-            self.mapping[h & self.hash_mask] = idx
-
-EntrypointParam = namedtuple('EntrypointParam', 'type name decl')
-
-class EntrypointBase(object):
-    def __init__(self, name):
-        self.name = name
-        self.alias = None
-        self.guard = None
-        self.enabled = False
-        self.num = None
-        # Extensions which require this entrypoint
-        self.core_version = None
-        self.extensions = []
-
-class Entrypoint(EntrypointBase):
-    def __init__(self, name, return_type, params, guard = None):
-        super(Entrypoint, self).__init__(name)
-        self.return_type = return_type
-        self.params = params
-        self.guard = guard
-        self.device_command = len(params) > 0 and (params[0].type == 'VkDevice' or params[0].type == 'VkQueue' or params[0].type == 'VkCommandBuffer')
-
-    def prefixed_name(self, prefix):
-        assert self.name.startswith('vk')
-        return prefix + '_' + self.name[2:]
-
-    def decl_params(self):
-        return ', '.join(p.decl for p in self.params)
-
-    def call_params(self):
-        return ', '.join(p.name for p in self.params)
-
-class EntrypointAlias(EntrypointBase):
-    def __init__(self, name, entrypoint):
-        super(EntrypointAlias, self).__init__(name)
-        self.alias = entrypoint
-        self.device_command = entrypoint.device_command
-
-    def prefixed_name(self, prefix):
-        return self.alias.prefixed_name(prefix)
-
-def get_entrypoints(doc, entrypoints_to_defines, start_index):
-    """Extract the entry points from the registry."""
-    entrypoints = OrderedDict()
-
-    for command in doc.findall('./commands/command'):
-       if 'alias' in command.attrib:
-           alias = command.attrib['name']
-           target = command.attrib['alias']
-           entrypoints[alias] = EntrypointAlias(alias, entrypoints[target])
-       else:
-           name = command.find('./proto/name').text
-           ret_type = command.find('./proto/type').text
-           params = [EntrypointParam(
-               type = p.find('./type').text,
-               name = p.find('./name').text,
-               decl = ''.join(p.itertext())
-           ) for p in command.findall('./param')]
-           guard = entrypoints_to_defines.get(name)
-           # They really need to be unique
-           assert name not in entrypoints
-           entrypoints[name] = Entrypoint(name, ret_type, params, guard)
-
-    for feature in doc.findall('./feature'):
-        assert feature.attrib['api'] == 'vulkan'
-        version = VkVersion(feature.attrib['number'])
-        if version > MAX_API_VERSION:
-            continue
-
-        for command in feature.findall('./require/command'):
-            e = entrypoints[command.attrib['name']]
-            e.enabled = True
-            assert e.core_version is None
-            e.core_version = version
-
-    supported_exts = dict((ext.name, ext) for ext in EXTENSIONS)
-    for extension in doc.findall('.extensions/extension'):
-        ext_name = extension.attrib['name']
-        if ext_name not in supported_exts:
-            continue
-
-        ext = supported_exts[ext_name]
-        ext.type = extension.attrib['type']
-
-        for command in extension.findall('./require/command'):
-            e = entrypoints[command.attrib['name']]
-            e.enabled = True
-            assert e.core_version is None
-            e.extensions.append(ext)
-
-    # if the base command is not supported by the driver yet, don't alias aliases
-    for e in entrypoints.values():
-        if e.alias and not e.alias.enabled:
-            e_clone = copy.deepcopy(e.alias)
-            e_clone.enabled = True
-            e_clone.name = e.name
-            entrypoints[e.name] = e_clone
-
-    return [e for e in entrypoints.values() if e.enabled]
-
-
-def get_entrypoints_defines(doc):
-    """Maps entry points to extension defines."""
-    entrypoints_to_defines = {}
-
-    for extension in doc.findall('./extensions/extension[@protect]'):
-        define = extension.attrib['protect']
-
-        for entrypoint in extension.findall('./require/command'):
-            fullname = entrypoint.attrib['name']
-            entrypoints_to_defines[fullname] = define
-
-    platform_define = {}
-    for platform in doc.findall('./platforms/platform'):
-        name = platform.attrib['name']
-        define = platform.attrib['protect']
-        platform_define[name] = define
-
-    for extension in doc.findall('./extensions/extension[@platform]'):
-        platform = extension.attrib['platform']
-        define = platform_define[platform]
-
-        for entrypoint in extension.findall('./require/command'):
-            fullname = entrypoint.attrib['name']
-            entrypoints_to_defines[fullname] = define
-
-    return entrypoints_to_defines
-
-
-def gen_code(entrypoints):
-    """Generate the C code."""
-    strmap = StringIntMap()
-    for e in entrypoints:
-        strmap.add_string(e.name, e.num)
-    strmap.bake()
-
-    return TEMPLATE_C.render(entrypoints=entrypoints,
-                             LAYERS=LAYERS,
-                             strmap=strmap,
-                             filename=os.path.basename(__file__))
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--outdir', help='Where to write the files.',
-                        required=True)
-    parser.add_argument('--xml',
-                        help='Vulkan API XML file.',
-                        required=True,
-                        action='append',
-                        dest='xml_files')
-    args = parser.parse_args()
-
-    entrypoints = []
-
-    for filename in args.xml_files:
-        doc = et.parse(filename)
-        entrypoints += get_entrypoints(doc, get_entrypoints_defines(doc),
-                                       start_index=len(entrypoints))
-
-    for num, e in enumerate(entrypoints):
-        e.num = num
-
-    # For outputting entrypoints.h we generate a tu_EntryPoint() prototype
-    # per entry point.
-    with open(os.path.join(args.outdir, 'tu_entrypoints.h'), 'wb') as f:
-        f.write(TEMPLATE_H.render(entrypoints=entrypoints,
-                                  LAYERS=LAYERS,
-                                  filename=os.path.basename(__file__)))
-    with open(os.path.join(args.outdir, 'tu_entrypoints.c'), 'wb') as f:
-        f.write(gen_code(entrypoints))
-
-
-if __name__ == '__main__':
-    main()
diff --git a/src/freedreno/vulkan/tu_extensions.py b/src/freedreno/vulkan/tu_extensions.py
index ed53f94b991..655c2105bff 100644
--- a/src/freedreno/vulkan/tu_extensions.py
+++ b/src/freedreno/vulkan/tu_extensions.py
@@ -118,4 +118,5 @@ if __name__ == '__main__':
                         dest='xml_files')
     args = parser.parse_args()
 
-    gen_extensions('tu', args.xml_files, API_VERSIONS, MAX_API_VERSION, EXTENSIONS, args.out_c, args.out_h)
+    gen_extensions('tu', args.xml_files, API_VERSIONS, MAX_API_VERSION,
+                   EXTENSIONS, args.out_c, args.out_h, type_prefix='vk')
diff --git a/src/freedreno/vulkan/tu_formats.c b/src/freedreno/vulkan/tu_formats.c
index 7f6e5e6b0e8..6a5b9ababe7 100644
--- a/src/freedreno/vulkan/tu_formats.c
+++ b/src/freedreno/vulkan/tu_formats.c
@@ -401,7 +401,7 @@ tu_physical_device_get_format_properties(
       if (desc->layout != UTIL_FORMAT_LAYOUT_SUBSAMPLED)
          optimal |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT;
 
-      if (physical_device->supported_extensions.EXT_filter_cubic)
+      if (physical_device->vk.supported_extensions.EXT_filter_cubic)
          optimal |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT;
    }
 
diff --git a/src/freedreno/vulkan/tu_private.h b/src/freedreno/vulkan/tu_private.h
index 347505fd3a6..92f54a9b41b 100644
--- a/src/freedreno/vulkan/tu_private.h
+++ b/src/freedreno/vulkan/tu_private.h
@@ -54,6 +54,10 @@
 #include "vk_alloc.h"
 #include "vk_debug_report.h"
 #include "vk_device.h"
+#include "vk_dispatch_table.h"
+#include "vk_extensions.h"
+#include "vk_instance.h"
+#include "vk_physical_device.h"
 #include "wsi_common.h"
 
 #include "ir3/ir3_compiler.h"
@@ -170,18 +174,9 @@ __tu_finishme(const char *file, int line, const char *format, ...)
       tu_finishme("stub %s", __func__);                                      \
    } while (0)
 
-void *
-tu_lookup_entrypoint_unchecked(const char *name);
-void *
-tu_lookup_entrypoint_checked(
-   const char *name,
-   uint32_t core_version,
-   const struct tu_instance_extension_table *instance,
-   const struct tu_device_extension_table *device);
-
 struct tu_physical_device
 {
-   struct vk_object_base base;
+   struct vk_physical_device vk;
 
    struct tu_instance *instance;
 
@@ -208,8 +203,6 @@ struct tu_physical_device
     * the pipeline cache defined by apps.
     */
    struct disk_cache *disk_cache;
-
-   struct tu_device_extension_table supported_extensions;
 };
 
 enum tu_debug_flags
@@ -228,9 +221,7 @@ enum tu_debug_flags
 
 struct tu_instance
 {
-   struct vk_object_base base;
-
-   VkAllocationCallbacks alloc;
+   struct vk_instance vk;
 
    uint32_t api_version;
    int physical_device_count;
@@ -239,8 +230,6 @@ struct tu_instance
    enum tu_debug_flags debug_flags;
 
    struct vk_debug_report_instance debug_report_callbacks;
-
-   struct tu_instance_extension_table enabled_extensions;
 };
 
 VkResult
@@ -382,8 +371,6 @@ struct tu_device
 
    struct tu_bo global_bo;
 
-   struct tu_device_extension_table enabled_extensions;
-
    uint32_t vsc_draw_strm_pitch;
    uint32_t vsc_prim_strm_pitch;
    BITSET_DECLARE(custom_border_color, TU_BORDER_COLOR_COUNT);
diff --git a/src/freedreno/vulkan/tu_wsi.c b/src/freedreno/vulkan/tu_wsi.c
index 7a1f7dd5d37..c1191d716f3 100644
--- a/src/freedreno/vulkan/tu_wsi.c
+++ b/src/freedreno/vulkan/tu_wsi.c
@@ -32,7 +32,8 @@
 static VKAPI_PTR PFN_vkVoidFunction
 tu_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char *pName)
 {
-   return tu_lookup_entrypoint_unchecked(pName);
+   TU_FROM_HANDLE(tu_physical_device, pdevice, physicalDevice);
+   return vk_instance_get_proc_addr_unchecked(&pdevice->instance->vk, pName);
 }
 
 VkResult
@@ -43,7 +44,7 @@ tu_wsi_init(struct tu_physical_device *physical_device)
    result = wsi_device_init(&physical_device->wsi_device,
                             tu_physical_device_to_handle(physical_device),
                             tu_wsi_proc_addr,
-                            &physical_device->instance->alloc,
+                            &physical_device->instance->vk.alloc,
                             physical_device->master_fd, NULL,
                             false);
    if (result != VK_SUCCESS)
@@ -58,7 +59,7 @@ void
 tu_wsi_finish(struct tu_physical_device *physical_device)
 {
    wsi_device_finish(&physical_device->wsi_device,
-                     &physical_device->instance->alloc);
+                     &physical_device->instance->vk.alloc);
 }
 
 void
@@ -69,7 +70,7 @@ tu_DestroySurfaceKHR(VkInstance _instance,
    TU_FROM_HANDLE(tu_instance, instance, _instance);
    ICD_FROM_HANDLE(VkIcdSurfaceBase, surface, _surface);
 
-   vk_free2(&instance->alloc, pAllocator, surface);
+   vk_free2(&instance->vk.alloc, pAllocator, surface);
 }
 
 VkResult
diff --git a/src/freedreno/vulkan/tu_wsi_display.c b/src/freedreno/vulkan/tu_wsi_display.c
index 9227ca63db1..76fbb4b8702 100644
--- a/src/freedreno/vulkan/tu_wsi_display.c
+++ b/src/freedreno/vulkan/tu_wsi_display.c
@@ -197,7 +197,7 @@ tu_CreateDisplayPlaneSurfaceKHR(
    if (allocator)
       alloc = allocator;
    else
-      alloc = &instance->alloc;
+      alloc = &instance->vk.alloc;
 
    return wsi_create_display_surface(_instance, alloc,
                                      create_info, surface);
diff --git a/src/freedreno/vulkan/tu_wsi_wayland.c b/src/freedreno/vulkan/tu_wsi_wayland.c
index b9148a1e28f..cfaea0622ae 100644
--- a/src/freedreno/vulkan/tu_wsi_wayland.c
+++ b/src/freedreno/vulkan/tu_wsi_wayland.c
@@ -53,7 +53,7 @@ tu_CreateWaylandSurfaceKHR(VkInstance _instance,
    if (pAllocator)
       alloc = pAllocator;
    else
-      alloc = &instance->alloc;
+      alloc = &instance->vk.alloc;
 
    return wsi_create_wl_surface(alloc, pCreateInfo, pSurface);
 }
diff --git a/src/freedreno/vulkan/tu_wsi_x11.c b/src/freedreno/vulkan/tu_wsi_x11.c
index 180e504a043..e6ce75e7f85 100644
--- a/src/freedreno/vulkan/tu_wsi_x11.c
+++ b/src/freedreno/vulkan/tu_wsi_x11.c
@@ -75,7 +75,7 @@ VkResult tu_CreateXcbSurfaceKHR(
    if (pAllocator)
       alloc = pAllocator;
    else
-      alloc = &instance->alloc;
+      alloc = &instance->vk.alloc;
 
    return wsi_create_xcb_surface(alloc, pCreateInfo, pSurface);
 }
@@ -94,7 +94,7 @@ VkResult tu_CreateXlibSurfaceKHR(
    if (pAllocator)
       alloc = pAllocator;
    else
-      alloc = &instance->alloc;
+      alloc = &instance->vk.alloc;
 
    return wsi_create_xlib_surface(alloc, pCreateInfo, pSurface);
 }