diff --git a/vulkan/README.md b/vulkan/README.md
index 44747fd..9fba728 100644
--- a/vulkan/README.md
+++ b/vulkan/README.md
@@ -22,7 +22,7 @@
 - You should now have `$GOPATH/bin/apic`. You might want to add `$GOPATH/bin` to your `$PATH`.
 
 ### Generating code
-To generate `libvulkan/dispatch_gen.*`,
+To generate `libvulkan/*_gen.*`,
 - `$ cd libvulkan`
-- `$ apic template ../api/vulkan.api dispatch.tmpl`
-Similar for `nulldrv/null_driver_gen.*`.
\ No newline at end of file
+- `$ apic template ../api/vulkan.api code-generator.tmpl`
+Similar for `nulldrv/null_driver_gen.*`.
diff --git a/vulkan/libvulkan/Android.mk b/vulkan/libvulkan/Android.mk
index 85b8ab2..e60d74c 100644
--- a/vulkan/libvulkan/Android.mk
+++ b/vulkan/libvulkan/Android.mk
@@ -19,6 +19,7 @@
 LOCAL_SANITIZE := integer
 
 LOCAL_CFLAGS := -DLOG_TAG=\"vulkan\" \
+	-DVK_USE_PLATFORM_ANDROID_KHR \
 	-std=c99 -fvisibility=hidden -fstrict-aliasing \
 	-Weverything -Werror \
 	-Wno-padded \
@@ -38,6 +39,8 @@
 	system/core/libsync/include
 
 LOCAL_SRC_FILES := \
+	api.cpp \
+	api_gen.cpp \
 	debug_report.cpp \
 	dispatch_gen.cpp \
 	layers_extensions.cpp \
diff --git a/vulkan/libvulkan/api.cpp b/vulkan/libvulkan/api.cpp
new file mode 100644
index 0000000..9c5aa3b
--- /dev/null
+++ b/vulkan/libvulkan/api.cpp
@@ -0,0 +1,1024 @@
+/*
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// The API layer of the loader defines Vulkan API and manages layers.  The
+// entrypoints are generated and defined in api_dispatch.cpp.  Most of them
+// simply find the dispatch table and jump.
+//
+// There are a few of them requiring manual code for things such as layer
+// discovery or chaining.  They call into functions defined in this file.
+
+#include <stdlib.h>
+#include <string.h>
+#include <algorithm>
+#include <mutex>
+#include <new>
+#include <utility>
+#include <cutils/properties.h>
+#include <log/log.h>
+
+#include <vulkan/vk_layer_interface.h>
+#include "api.h"
+#include "driver.h"
+#include "loader.h"
+
+namespace vulkan {
+namespace api {
+
+namespace {
+
+// Provide overridden layer names when there are implicit layers.  No effect
+// otherwise.
+class OverrideLayerNames {
+   public:
+    OverrideLayerNames(bool is_instance, const VkAllocationCallbacks& allocator)
+        : is_instance_(is_instance),
+          allocator_(allocator),
+          scope_(VK_SYSTEM_ALLOCATION_SCOPE_COMMAND),
+          names_(nullptr),
+          name_count_(0),
+          implicit_layers_() {
+        implicit_layers_.result = VK_SUCCESS;
+    }
+
+    ~OverrideLayerNames() {
+        allocator_.pfnFree(allocator_.pUserData, names_);
+        allocator_.pfnFree(allocator_.pUserData, implicit_layers_.elements);
+        allocator_.pfnFree(allocator_.pUserData, implicit_layers_.name_pool);
+    }
+
+    VkResult parse(const char* const* names, uint32_t count) {
+        add_implicit_layers();
+
+        const auto& arr = implicit_layers_;
+        if (arr.result != VK_SUCCESS)
+            return arr.result;
+
+        // no need to override when there is no implicit layer
+        if (!arr.count)
+            return VK_SUCCESS;
+
+        names_ = allocate_name_array(arr.count + count);
+        if (!names_)
+            return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+        // add implicit layer names
+        for (uint32_t i = 0; i < arr.count; i++)
+            names_[i] = get_implicit_layer_name(i);
+
+        name_count_ = arr.count;
+
+        // add explicit layer names
+        for (uint32_t i = 0; i < count; i++) {
+            // ignore explicit layers that are also implicit
+            if (is_implicit_layer(names[i]))
+                continue;
+
+            names_[name_count_++] = names[i];
+        }
+
+        return VK_SUCCESS;
+    }
+
+    const char* const* names() const { return names_; }
+
+    uint32_t count() const { return name_count_; }
+
+   private:
+    struct ImplicitLayer {
+        int priority;
+        size_t name_offset;
+    };
+
+    struct ImplicitLayerArray {
+        ImplicitLayer* elements;
+        uint32_t max_count;
+        uint32_t count;
+
+        char* name_pool;
+        size_t max_pool_size;
+        size_t pool_size;
+
+        VkResult result;
+    };
+
+    void add_implicit_layers() {
+        if (!driver::Debuggable())
+            return;
+
+        parse_debug_vulkan_layers();
+        property_list(parse_debug_vulkan_layer, this);
+
+        // sort by priorities
+        auto& arr = implicit_layers_;
+        std::sort(arr.elements, arr.elements + arr.count,
+                  [](const ImplicitLayer& a, const ImplicitLayer& b) {
+                      return (a.priority < b.priority);
+                  });
+    }
+
+    void parse_debug_vulkan_layers() {
+        // debug.vulkan.layers specifies colon-separated layer names
+        char prop[PROPERTY_VALUE_MAX];
+        if (!property_get("debug.vulkan.layers", prop, ""))
+            return;
+
+        // assign negative/high priorities to them
+        int prio = -PROPERTY_VALUE_MAX;
+
+        const char* p = prop;
+        const char* delim;
+        while ((delim = strchr(p, ':'))) {
+            if (delim > p)
+                add_implicit_layer(prio, p, static_cast<size_t>(delim - p));
+
+            prio++;
+            p = delim + 1;
+        }
+
+        if (p[0] != '\0')
+            add_implicit_layer(prio, p, strlen(p));
+    }
+
+    static void parse_debug_vulkan_layer(const char* key,
+                                         const char* val,
+                                         void* user_data) {
+        static const char prefix[] = "debug.vulkan.layer.";
+        const size_t prefix_len = sizeof(prefix) - 1;
+
+        if (strncmp(key, prefix, prefix_len) || val[0] == '\0')
+            return;
+        key += prefix_len;
+
+        // debug.vulkan.layer.<priority>
+        int priority = -1;
+        if (key[0] >= '0' && key[0] <= '9')
+            priority = atoi(key);
+
+        if (priority < 0) {
+            ALOGW("Ignored implicit layer %s with invalid priority %s", val,
+                  key);
+            return;
+        }
+
+        OverrideLayerNames& override_layers =
+            *reinterpret_cast<OverrideLayerNames*>(user_data);
+        override_layers.add_implicit_layer(priority, val, strlen(val));
+    }
+
+    void add_implicit_layer(int priority, const char* name, size_t len) {
+        if (!grow_implicit_layer_array(1, 0))
+            return;
+
+        auto& arr = implicit_layers_;
+        auto& layer = arr.elements[arr.count++];
+
+        layer.priority = priority;
+        layer.name_offset = add_implicit_layer_name(name, len);
+
+        ALOGV("Added implicit layer %s",
+              get_implicit_layer_name(arr.count - 1));
+    }
+
+    size_t add_implicit_layer_name(const char* name, size_t len) {
+        if (!grow_implicit_layer_array(0, len + 1))
+            return 0;
+
+        // add the name to the pool
+        auto& arr = implicit_layers_;
+        size_t offset = arr.pool_size;
+        char* dst = arr.name_pool + offset;
+
+        std::copy(name, name + len, dst);
+        dst[len] = '\0';
+
+        arr.pool_size += len + 1;
+
+        return offset;
+    }
+
+    bool grow_implicit_layer_array(uint32_t layer_count, size_t name_size) {
+        const uint32_t initial_max_count = 16;
+        const size_t initial_max_pool_size = 512;
+
+        auto& arr = implicit_layers_;
+
+        // grow the element array if needed
+        while (arr.count + layer_count > arr.max_count) {
+            uint32_t new_max_count =
+                (arr.max_count) ? (arr.max_count << 1) : initial_max_count;
+            void* new_mem = nullptr;
+
+            if (new_max_count > arr.max_count) {
+                new_mem = allocator_.pfnReallocation(
+                    allocator_.pUserData, arr.elements,
+                    sizeof(ImplicitLayer) * new_max_count,
+                    alignof(ImplicitLayer), scope_);
+            }
+
+            if (!new_mem) {
+                arr.result = VK_ERROR_OUT_OF_HOST_MEMORY;
+                arr.count = 0;
+                return false;
+            }
+
+            arr.elements = reinterpret_cast<ImplicitLayer*>(new_mem);
+            arr.max_count = new_max_count;
+        }
+
+        // grow the name pool if needed
+        while (arr.pool_size + name_size > arr.max_pool_size) {
+            size_t new_max_pool_size = (arr.max_pool_size)
+                                           ? (arr.max_pool_size << 1)
+                                           : initial_max_pool_size;
+            void* new_mem = nullptr;
+
+            if (new_max_pool_size > arr.max_pool_size) {
+                new_mem = allocator_.pfnReallocation(
+                    allocator_.pUserData, arr.name_pool, new_max_pool_size,
+                    alignof(char), scope_);
+            }
+
+            if (!new_mem) {
+                arr.result = VK_ERROR_OUT_OF_HOST_MEMORY;
+                arr.pool_size = 0;
+                return false;
+            }
+
+            arr.name_pool = reinterpret_cast<char*>(new_mem);
+            arr.max_pool_size = new_max_pool_size;
+        }
+
+        return true;
+    }
+
+    const char* get_implicit_layer_name(uint32_t index) const {
+        const auto& arr = implicit_layers_;
+
+        // this may return nullptr when arr.result is not VK_SUCCESS
+        return implicit_layers_.name_pool + arr.elements[index].name_offset;
+    }
+
+    bool is_implicit_layer(const char* name) const {
+        const auto& arr = implicit_layers_;
+
+        for (uint32_t i = 0; i < arr.count; i++) {
+            if (strcmp(name, get_implicit_layer_name(i)) == 0)
+                return true;
+        }
+
+        return false;
+    }
+
+    const char** allocate_name_array(uint32_t count) const {
+        return reinterpret_cast<const char**>(allocator_.pfnAllocation(
+            allocator_.pUserData, sizeof(const char*) * count,
+            alignof(const char*), scope_));
+    }
+
+    const bool is_instance_;
+    const VkAllocationCallbacks& allocator_;
+    const VkSystemAllocationScope scope_;
+
+    const char** names_;
+    uint32_t name_count_;
+
+    ImplicitLayerArray implicit_layers_;
+};
+
+// Provide overridden extension names when there are implicit extensions.
+// No effect otherwise.
+//
+// This is used only to enable VK_EXT_debug_report.
+class OverrideExtensionNames {
+   public:
+    OverrideExtensionNames(bool is_instance,
+                           const VkAllocationCallbacks& allocator)
+        : is_instance_(is_instance),
+          allocator_(allocator),
+          scope_(VK_SYSTEM_ALLOCATION_SCOPE_COMMAND),
+          names_(nullptr),
+          name_count_(0),
+          install_debug_callback_(false) {}
+
+    ~OverrideExtensionNames() {
+        allocator_.pfnFree(allocator_.pUserData, names_);
+    }
+
+    VkResult parse(const char* const* names, uint32_t count) {
+        // this is only for debug.vulkan.enable_callback
+        if (!enable_debug_callback())
+            return VK_SUCCESS;
+
+        names_ = allocate_name_array(count + 1);
+        if (!names_)
+            return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+        std::copy(names, names + count, names_);
+
+        name_count_ = count;
+        names_[name_count_++] = "VK_EXT_debug_report";
+
+        install_debug_callback_ = true;
+
+        return VK_SUCCESS;
+    }
+
+    const char* const* names() const { return names_; }
+
+    uint32_t count() const { return name_count_; }
+
+    bool install_debug_callback() const { return install_debug_callback_; }
+
+   private:
+    bool enable_debug_callback() const {
+        return (is_instance_ && driver::Debuggable() &&
+                property_get_bool("debug.vulkan.enable_callback", false));
+    }
+
+    const char** allocate_name_array(uint32_t count) const {
+        return reinterpret_cast<const char**>(allocator_.pfnAllocation(
+            allocator_.pUserData, sizeof(const char*) * count,
+            alignof(const char*), scope_));
+    }
+
+    const bool is_instance_;
+    const VkAllocationCallbacks& allocator_;
+    const VkSystemAllocationScope scope_;
+
+    const char** names_;
+    uint32_t name_count_;
+    bool install_debug_callback_;
+};
+
+// vkCreateInstance and vkCreateDevice helpers with support for layer
+// chaining.
+class LayerChain {
+   public:
+    static VkResult create_instance(const VkInstanceCreateInfo* create_info,
+                                    const VkAllocationCallbacks* allocator,
+                                    VkInstance* instance_out);
+
+    static VkResult create_device(VkPhysicalDevice physical_dev,
+                                  const VkDeviceCreateInfo* create_info,
+                                  const VkAllocationCallbacks* allocator,
+                                  VkDevice* dev_out);
+
+    static void destroy_instance(VkInstance instance,
+                                 const VkAllocationCallbacks* allocator);
+
+    static void destroy_device(VkDevice dev,
+                               const VkAllocationCallbacks* allocator);
+
+   private:
+    struct ActiveLayer {
+        LayerRef ref;
+        union {
+            VkLayerInstanceLink instance_link;
+            VkLayerDeviceLink device_link;
+        };
+    };
+
+    LayerChain(bool is_instance, const VkAllocationCallbacks& allocator);
+    ~LayerChain();
+
+    VkResult activate_layers(const char* const* layer_names,
+                             uint32_t layer_count,
+                             const char* const* extension_names,
+                             uint32_t extension_count);
+    ActiveLayer* allocate_layer_array(uint32_t count) const;
+    VkResult load_layer(ActiveLayer& layer, const char* name);
+    void setup_layer_links();
+
+    bool empty() const;
+    void modify_create_info(VkInstanceCreateInfo& info);
+    void modify_create_info(VkDeviceCreateInfo& info);
+
+    VkResult create(const VkInstanceCreateInfo* create_info,
+                    const VkAllocationCallbacks* allocator,
+                    VkInstance* instance_out);
+
+    VkResult create(VkPhysicalDevice physical_dev,
+                    const VkDeviceCreateInfo* create_info,
+                    const VkAllocationCallbacks* allocator,
+                    VkDevice* dev_out);
+
+    template <typename DataType>
+    void steal_layers(DataType& data);
+
+    static void destroy_layers(ActiveLayer* layers,
+                               uint32_t count,
+                               const VkAllocationCallbacks& allocator);
+
+    static VKAPI_ATTR VkBool32
+    debug_report_callback(VkDebugReportFlagsEXT flags,
+                          VkDebugReportObjectTypeEXT obj_type,
+                          uint64_t obj,
+                          size_t location,
+                          int32_t msg_code,
+                          const char* layer_prefix,
+                          const char* msg,
+                          void* user_data);
+
+    const bool is_instance_;
+    const VkAllocationCallbacks& allocator_;
+
+    OverrideLayerNames override_layers_;
+    OverrideExtensionNames override_extensions_;
+
+    ActiveLayer* layers_;
+    uint32_t layer_count_;
+
+    PFN_vkGetInstanceProcAddr get_instance_proc_addr_;
+    PFN_vkGetDeviceProcAddr get_device_proc_addr_;
+
+    union {
+        VkLayerInstanceCreateInfo instance_chain_info_;
+        VkLayerDeviceCreateInfo device_chain_info_;
+    };
+};
+
+LayerChain::LayerChain(bool is_instance, const VkAllocationCallbacks& allocator)
+    : is_instance_(is_instance),
+      allocator_(allocator),
+      override_layers_(is_instance, allocator),
+      override_extensions_(is_instance, allocator),
+      layers_(nullptr),
+      layer_count_(0),
+      get_instance_proc_addr_(nullptr),
+      get_device_proc_addr_(nullptr) {}
+
+LayerChain::~LayerChain() {
+    destroy_layers(layers_, layer_count_, allocator_);
+}
+
+VkResult LayerChain::activate_layers(const char* const* layer_names,
+                                     uint32_t layer_count,
+                                     const char* const* extension_names,
+                                     uint32_t extension_count) {
+    VkResult result = override_layers_.parse(layer_names, layer_count);
+    if (result != VK_SUCCESS)
+        return result;
+
+    result = override_extensions_.parse(extension_names, extension_count);
+    if (result != VK_SUCCESS)
+        return result;
+
+    if (override_layers_.count()) {
+        layer_names = override_layers_.names();
+        layer_count = override_layers_.count();
+    }
+
+    if (!layer_count) {
+        // point head of chain to the driver
+        get_instance_proc_addr_ = driver::GetInstanceProcAddr;
+        if (!is_instance_)
+            get_device_proc_addr_ = driver::GetDeviceProcAddr;
+
+        return VK_SUCCESS;
+    }
+
+    layers_ = allocate_layer_array(layer_count);
+    if (!layers_)
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+    // load layers
+    for (uint32_t i = 0; i < layer_count; i++) {
+        result = load_layer(layers_[i], layer_names[i]);
+        if (result != VK_SUCCESS)
+            return result;
+
+        // count loaded layers for proper destructions on errors
+        layer_count_++;
+    }
+
+    setup_layer_links();
+
+    return VK_SUCCESS;
+}
+
+LayerChain::ActiveLayer* LayerChain::allocate_layer_array(
+    uint32_t count) const {
+    VkSystemAllocationScope scope = (is_instance_)
+                                        ? VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
+                                        : VK_SYSTEM_ALLOCATION_SCOPE_DEVICE;
+
+    return reinterpret_cast<ActiveLayer*>(allocator_.pfnAllocation(
+        allocator_.pUserData, sizeof(ActiveLayer) * count, alignof(ActiveLayer),
+        scope));
+}
+
+VkResult LayerChain::load_layer(ActiveLayer& layer, const char* name) {
+    if (is_instance_)
+        new (&layer) ActiveLayer{GetInstanceLayerRef(name), {}};
+    else
+        new (&layer) ActiveLayer{GetDeviceLayerRef(name), {}};
+
+    if (!layer.ref) {
+        ALOGE("Failed to load layer %s", name);
+        layer.ref.~LayerRef();
+        return VK_ERROR_LAYER_NOT_PRESENT;
+    }
+
+    ALOGI("Loaded %s layer %s", (is_instance_) ? "instance" : "device", name);
+
+    return VK_SUCCESS;
+}
+
+void LayerChain::setup_layer_links() {
+    if (is_instance_) {
+        for (uint32_t i = 0; i < layer_count_; i++) {
+            ActiveLayer& layer = layers_[i];
+
+            // point head of chain to the first layer
+            if (i == 0)
+                get_instance_proc_addr_ = layer.ref.GetGetInstanceProcAddr();
+
+            // point tail of chain to the driver
+            if (i == layer_count_ - 1) {
+                layer.instance_link.pNext = nullptr;
+                layer.instance_link.pfnNextGetInstanceProcAddr =
+                    driver::GetInstanceProcAddr;
+                break;
+            }
+
+            const ActiveLayer& next = layers_[i + 1];
+
+            // const_cast as some naughty layers want to modify our links!
+            layer.instance_link.pNext =
+                const_cast<VkLayerInstanceLink*>(&next.instance_link);
+            layer.instance_link.pfnNextGetInstanceProcAddr =
+                next.ref.GetGetInstanceProcAddr();
+        }
+    } else {
+        for (uint32_t i = 0; i < layer_count_; i++) {
+            ActiveLayer& layer = layers_[i];
+
+            // point head of chain to the first layer
+            if (i == 0) {
+                get_instance_proc_addr_ = layer.ref.GetGetInstanceProcAddr();
+                get_device_proc_addr_ = layer.ref.GetGetDeviceProcAddr();
+            }
+
+            // point tail of chain to the driver
+            if (i == layer_count_ - 1) {
+                layer.device_link.pNext = nullptr;
+                layer.device_link.pfnNextGetInstanceProcAddr =
+                    driver::GetInstanceProcAddr;
+                layer.device_link.pfnNextGetDeviceProcAddr =
+                    driver::GetDeviceProcAddr;
+                break;
+            }
+
+            const ActiveLayer& next = layers_[i + 1];
+
+            // const_cast as some naughty layers want to modify our links!
+            layer.device_link.pNext =
+                const_cast<VkLayerDeviceLink*>(&next.device_link);
+            layer.device_link.pfnNextGetInstanceProcAddr =
+                next.ref.GetGetInstanceProcAddr();
+            layer.device_link.pfnNextGetDeviceProcAddr =
+                next.ref.GetGetDeviceProcAddr();
+        }
+    }
+}
+
+bool LayerChain::empty() const {
+    return (!layer_count_ && !override_layers_.count() &&
+            !override_extensions_.count());
+}
+
+void LayerChain::modify_create_info(VkInstanceCreateInfo& info) {
+    if (layer_count_) {
+        const ActiveLayer& layer = layers_[0];
+
+        instance_chain_info_.sType =
+            VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
+        instance_chain_info_.function = VK_LAYER_FUNCTION_LINK;
+        // TODO fix vk_layer_interface.h and get rid of const_cast?
+        instance_chain_info_.u.pLayerInfo =
+            const_cast<VkLayerInstanceLink*>(&layer.instance_link);
+
+        // insert layer info
+        instance_chain_info_.pNext = info.pNext;
+        info.pNext = &instance_chain_info_;
+    }
+
+    if (override_layers_.count()) {
+        info.enabledLayerCount = override_layers_.count();
+        info.ppEnabledLayerNames = override_layers_.names();
+    }
+
+    if (override_extensions_.count()) {
+        info.enabledExtensionCount = override_extensions_.count();
+        info.ppEnabledExtensionNames = override_extensions_.names();
+    }
+}
+
+void LayerChain::modify_create_info(VkDeviceCreateInfo& info) {
+    if (layer_count_) {
+        const ActiveLayer& layer = layers_[0];
+
+        device_chain_info_.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
+        device_chain_info_.function = VK_LAYER_FUNCTION_LINK;
+        // TODO fix vk_layer_interface.h and get rid of const_cast?
+        device_chain_info_.u.pLayerInfo =
+            const_cast<VkLayerDeviceLink*>(&layer.device_link);
+
+        // insert layer info
+        device_chain_info_.pNext = info.pNext;
+        info.pNext = &device_chain_info_;
+    }
+
+    if (override_layers_.count()) {
+        info.enabledLayerCount = override_layers_.count();
+        info.ppEnabledLayerNames = override_layers_.names();
+    }
+
+    if (override_extensions_.count()) {
+        info.enabledExtensionCount = override_extensions_.count();
+        info.ppEnabledExtensionNames = override_extensions_.names();
+    }
+}
+
+VkResult LayerChain::create(const VkInstanceCreateInfo* create_info,
+                            const VkAllocationCallbacks* allocator,
+                            VkInstance* instance_out) {
+    // call down the chain
+    PFN_vkCreateInstance create_instance =
+        reinterpret_cast<PFN_vkCreateInstance>(
+            get_instance_proc_addr_(VK_NULL_HANDLE, "vkCreateInstance"));
+    VkInstance instance;
+    VkResult result = create_instance(create_info, allocator, &instance);
+    if (result != VK_SUCCESS)
+        return result;
+
+    // initialize InstanceData
+    InstanceData& data = GetData(instance);
+    memset(&data, 0, sizeof(data));
+
+    data.instance = instance;
+
+    if (!InitDispatchTable(instance, get_instance_proc_addr_)) {
+        if (data.dispatch.DestroyInstance)
+            data.dispatch.DestroyInstance(instance, allocator);
+
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    // install debug report callback
+    if (override_extensions_.install_debug_callback()) {
+        PFN_vkCreateDebugReportCallbackEXT create_debug_report_callback =
+            reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(
+                get_instance_proc_addr_(instance,
+                                        "vkCreateDebugReportCallbackEXT"));
+        data.destroy_debug_callback =
+            reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(
+                get_instance_proc_addr_(instance,
+                                        "vkDestroyDebugReportCallbackEXT"));
+        if (!create_debug_report_callback || !data.destroy_debug_callback) {
+            ALOGE("Broken VK_EXT_debug_report support");
+            data.dispatch.DestroyInstance(instance, allocator);
+            return VK_ERROR_INITIALIZATION_FAILED;
+        }
+
+        VkDebugReportCallbackCreateInfoEXT debug_callback_info = {};
+        debug_callback_info.sType =
+            VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
+        debug_callback_info.flags =
+            VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
+        debug_callback_info.pfnCallback = debug_report_callback;
+
+        VkDebugReportCallbackEXT debug_callback;
+        result = create_debug_report_callback(instance, &debug_callback_info,
+                                              nullptr, &debug_callback);
+        if (result != VK_SUCCESS) {
+            ALOGE("Failed to install debug report callback");
+            data.dispatch.DestroyInstance(instance, allocator);
+            return VK_ERROR_INITIALIZATION_FAILED;
+        }
+
+        data.debug_callback = debug_callback;
+
+        ALOGI("Installed debug report callback");
+    }
+
+    steal_layers(data);
+
+    *instance_out = instance;
+
+    return VK_SUCCESS;
+}
+
+VkResult LayerChain::create(VkPhysicalDevice physical_dev,
+                            const VkDeviceCreateInfo* create_info,
+                            const VkAllocationCallbacks* allocator,
+                            VkDevice* dev_out) {
+    // call down the chain
+    //
+    // TODO Instance call chain available at
+    // GetData(physical_dev).dispatch.CreateDevice is ignored.  Is that
+    // right?
+    VkInstance instance = GetData(physical_dev).instance;
+    PFN_vkCreateDevice create_device = reinterpret_cast<PFN_vkCreateDevice>(
+        get_instance_proc_addr_(instance, "vkCreateDevice"));
+    VkDevice dev;
+    VkResult result = create_device(physical_dev, create_info, allocator, &dev);
+    if (result != VK_SUCCESS)
+        return result;
+
+    // initialize DeviceData
+    DeviceData& data = GetData(dev);
+    memset(&data, 0, sizeof(data));
+
+    if (!InitDispatchTable(dev, get_device_proc_addr_)) {
+        if (data.dispatch.DestroyDevice)
+            data.dispatch.DestroyDevice(dev, allocator);
+
+        return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    steal_layers(data);
+
+    *dev_out = dev;
+
+    return VK_SUCCESS;
+}
+
+template <typename DataType>
+void LayerChain::steal_layers(DataType& data) {
+    data.layers = layers_;
+    data.layer_count = layer_count_;
+
+    layers_ = nullptr;
+    layer_count_ = 0;
+}
+
+void LayerChain::destroy_layers(ActiveLayer* layers,
+                                uint32_t count,
+                                const VkAllocationCallbacks& allocator) {
+    for (uint32_t i = 0; i < count; i++)
+        layers[i].ref.~LayerRef();
+
+    allocator.pfnFree(allocator.pUserData, layers);
+}
+
+VkBool32 LayerChain::debug_report_callback(VkDebugReportFlagsEXT flags,
+                                           VkDebugReportObjectTypeEXT obj_type,
+                                           uint64_t obj,
+                                           size_t location,
+                                           int32_t msg_code,
+                                           const char* layer_prefix,
+                                           const char* msg,
+                                           void* user_data) {
+    int prio;
+
+    if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT)
+        prio = ANDROID_LOG_ERROR;
+    else if (flags & (VK_DEBUG_REPORT_WARNING_BIT_EXT |
+                      VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT))
+        prio = ANDROID_LOG_WARN;
+    else if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)
+        prio = ANDROID_LOG_INFO;
+    else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT)
+        prio = ANDROID_LOG_DEBUG;
+    else
+        prio = ANDROID_LOG_UNKNOWN;
+
+    LOG_PRI(prio, LOG_TAG, "[%s] Code %d : %s", layer_prefix, msg_code, msg);
+
+    (void)obj_type;
+    (void)obj;
+    (void)location;
+    (void)user_data;
+
+    return false;
+}
+
+VkResult LayerChain::create_instance(const VkInstanceCreateInfo* create_info,
+                                     const VkAllocationCallbacks* allocator,
+                                     VkInstance* instance_out) {
+    LayerChain chain(true,
+                     (allocator) ? *allocator : driver::GetDefaultAllocator());
+
+    VkResult result = chain.activate_layers(
+        create_info->ppEnabledLayerNames, create_info->enabledLayerCount,
+        create_info->ppEnabledExtensionNames,
+        create_info->enabledExtensionCount);
+    if (result != VK_SUCCESS)
+        return result;
+
+    // use a local create info when the chain is not empty
+    VkInstanceCreateInfo local_create_info;
+    if (!chain.empty()) {
+        local_create_info = *create_info;
+        chain.modify_create_info(local_create_info);
+        create_info = &local_create_info;
+    }
+
+    return chain.create(create_info, allocator, instance_out);
+}
+
+VkResult LayerChain::create_device(VkPhysicalDevice physical_dev,
+                                   const VkDeviceCreateInfo* create_info,
+                                   const VkAllocationCallbacks* allocator,
+                                   VkDevice* dev_out) {
+    LayerChain chain(false, (allocator)
+                                ? *allocator
+                                : driver::GetData(physical_dev).allocator);
+
+    VkResult result = chain.activate_layers(
+        create_info->ppEnabledLayerNames, create_info->enabledLayerCount,
+        create_info->ppEnabledExtensionNames,
+        create_info->enabledExtensionCount);
+    if (result != VK_SUCCESS)
+        return result;
+
+    // use a local create info when the chain is not empty
+    VkDeviceCreateInfo local_create_info;
+    if (!chain.empty()) {
+        local_create_info = *create_info;
+        chain.modify_create_info(local_create_info);
+        create_info = &local_create_info;
+    }
+
+    return chain.create(physical_dev, create_info, allocator, dev_out);
+}
+
+void LayerChain::destroy_instance(VkInstance instance,
+                                  const VkAllocationCallbacks* allocator) {
+    InstanceData& data = GetData(instance);
+
+    if (data.debug_callback != VK_NULL_HANDLE)
+        data.destroy_debug_callback(instance, data.debug_callback, allocator);
+
+    ActiveLayer* layers = reinterpret_cast<ActiveLayer*>(data.layers);
+    uint32_t layer_count = data.layer_count;
+
+    VkAllocationCallbacks local_allocator;
+    if (!allocator)
+        local_allocator = driver::GetData(instance).allocator;
+
+    // this also destroys InstanceData
+    data.dispatch.DestroyInstance(instance, allocator);
+
+    destroy_layers(layers, layer_count,
+                   (allocator) ? *allocator : local_allocator);
+}
+
+void LayerChain::destroy_device(VkDevice device,
+                                const VkAllocationCallbacks* allocator) {
+    DeviceData& data = GetData(device);
+
+    ActiveLayer* layers = reinterpret_cast<ActiveLayer*>(data.layers);
+    uint32_t layer_count = data.layer_count;
+
+    VkAllocationCallbacks local_allocator;
+    if (!allocator)
+        local_allocator = driver::GetData(device).allocator;
+
+    // this also destroys DeviceData
+    data.dispatch.DestroyDevice(device, allocator);
+
+    destroy_layers(layers, layer_count,
+                   (allocator) ? *allocator : local_allocator);
+}
+
+// ----------------------------------------------------------------------------
+
+bool EnsureInitialized() {
+    static std::once_flag once_flag;
+    static bool initialized;
+
+    std::call_once(once_flag, []() {
+        if (driver::OpenHAL()) {
+            DiscoverLayers();
+            initialized = true;
+        }
+    });
+
+    return initialized;
+}
+
+}  // anonymous namespace
+
+VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
+                        const VkAllocationCallbacks* pAllocator,
+                        VkInstance* pInstance) {
+    if (!EnsureInitialized())
+        return VK_ERROR_INITIALIZATION_FAILED;
+
+    return LayerChain::create_instance(pCreateInfo, pAllocator, pInstance);
+}
+
+void DestroyInstance(VkInstance instance,
+                     const VkAllocationCallbacks* pAllocator) {
+    if (instance != VK_NULL_HANDLE)
+        LayerChain::destroy_instance(instance, pAllocator);
+}
+
+VkResult CreateDevice(VkPhysicalDevice physicalDevice,
+                      const VkDeviceCreateInfo* pCreateInfo,
+                      const VkAllocationCallbacks* pAllocator,
+                      VkDevice* pDevice) {
+    return LayerChain::create_device(physicalDevice, pCreateInfo, pAllocator,
+                                     pDevice);
+}
+
+void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
+    if (device != VK_NULL_HANDLE)
+        LayerChain::destroy_device(device, pAllocator);
+}
+
+VkResult EnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
+                                          VkLayerProperties* pProperties) {
+    if (!EnsureInitialized())
+        return VK_ERROR_INITIALIZATION_FAILED;
+
+    uint32_t count =
+        EnumerateInstanceLayers(pProperties ? *pPropertyCount : 0, pProperties);
+
+    if (!pProperties || *pPropertyCount > count)
+        *pPropertyCount = count;
+
+    return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
+}
+
+VkResult EnumerateInstanceExtensionProperties(
+    const char* pLayerName,
+    uint32_t* pPropertyCount,
+    VkExtensionProperties* pProperties) {
+    if (!EnsureInitialized())
+        return VK_ERROR_INITIALIZATION_FAILED;
+
+    if (pLayerName) {
+        const VkExtensionProperties* props;
+        uint32_t count;
+        GetInstanceLayerExtensions(pLayerName, &props, &count);
+
+        if (!pProperties || *pPropertyCount > count)
+            *pPropertyCount = count;
+        if (pProperties)
+            std::copy(props, props + *pPropertyCount, pProperties);
+
+        return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
+    }
+
+    // TODO how about extensions from implicitly enabled layers?
+    return vulkan::driver::EnumerateInstanceExtensionProperties(
+        nullptr, pPropertyCount, pProperties);
+}
+
+VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
+                                        uint32_t* pPropertyCount,
+                                        VkLayerProperties* pProperties) {
+    (void)physicalDevice;
+
+    uint32_t count =
+        EnumerateDeviceLayers(pProperties ? *pPropertyCount : 0, pProperties);
+
+    if (!pProperties || *pPropertyCount > count)
+        *pPropertyCount = count;
+
+    return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
+}
+
+VkResult EnumerateDeviceExtensionProperties(
+    VkPhysicalDevice physicalDevice,
+    const char* pLayerName,
+    uint32_t* pPropertyCount,
+    VkExtensionProperties* pProperties) {
+    if (pLayerName) {
+        const VkExtensionProperties* props;
+        uint32_t count;
+        GetDeviceLayerExtensions(pLayerName, &props, &count);
+
+        if (!pProperties || *pPropertyCount > count)
+            *pPropertyCount = count;
+        if (pProperties)
+            std::copy(props, props + *pPropertyCount, pProperties);
+
+        return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
+    }
+
+    // TODO how about extensions from implicitly enabled layers?
+    const InstanceData& data = GetData(physicalDevice);
+    return data.dispatch.EnumerateDeviceExtensionProperties(
+        physicalDevice, nullptr, pPropertyCount, pProperties);
+}
+
+}  // namespace api
+}  // namespace vulkan
diff --git a/vulkan/libvulkan/api.h b/vulkan/libvulkan/api.h
new file mode 100644
index 0000000..ded7d17
--- /dev/null
+++ b/vulkan/libvulkan/api.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LIBVULKAN_API_H
+#define LIBVULKAN_API_H 1
+
+#include <vulkan/vulkan.h>
+#include "api_gen.h"
+#include "driver.h"
+
+namespace vulkan {
+namespace api {
+
+// clang-format off
+VKAPI_ATTR VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
+VKAPI_ATTR void DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
+VKAPI_ATTR void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult EnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+VKAPI_ATTR VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+VKAPI_ATTR VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+// clang-format on
+
+inline InstanceData& GetData(VkInstance instance) {
+    return driver::GetData(instance).opaque_api_data;
+}
+
+inline InstanceData& GetData(VkPhysicalDevice physical_dev) {
+    return driver::GetData(physical_dev).opaque_api_data;
+}
+
+inline DeviceData& GetData(VkDevice dev) {
+    return driver::GetData(dev).opaque_api_data;
+}
+
+inline DeviceData& GetData(VkQueue queue) {
+    return driver::GetData(queue).opaque_api_data;
+}
+
+inline DeviceData& GetData(VkCommandBuffer cmd) {
+    return driver::GetData(cmd).opaque_api_data;
+}
+
+}  // namespace api
+}  // namespace vulkan
+
+#endif  // LIBVULKAN_API_H
diff --git a/vulkan/libvulkan/api_gen.cpp b/vulkan/libvulkan/api_gen.cpp
new file mode 100644
index 0000000..0c4cd9a
--- /dev/null
+++ b/vulkan/libvulkan/api_gen.cpp
@@ -0,0 +1,1170 @@
+/*
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// WARNING: This file is generated. See ../README.md for instructions.
+
+#include <string.h>
+#include <algorithm>
+#include <log/log.h>
+
+#include "api.h"
+
+namespace vulkan {
+namespace api {
+
+#define UNLIKELY(expr) __builtin_expect((expr), 0)
+
+#define INIT_PROC(obj, proc)                                           \
+    do {                                                               \
+        data.dispatch.proc =                                           \
+            reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \
+        if (UNLIKELY(!data.dispatch.proc)) {                           \
+            ALOGE("missing " #obj " proc: vk" #proc);                  \
+            success = false;                                           \
+        }                                                              \
+    } while (0)
+
+// TODO do we want to point to a stub or nullptr when ext is not enabled?
+#define INIT_PROC_EXT(ext, obj, proc) \
+    do {                              \
+        INIT_PROC(obj, proc);         \
+    } while (0)
+
+bool InitDispatchTable(VkInstance instance,
+                       PFN_vkGetInstanceProcAddr get_proc) {
+    auto& data = GetData(instance);
+    bool success = true;
+
+    // clang-format off
+    INIT_PROC(instance, DestroyInstance);
+    INIT_PROC(instance, EnumeratePhysicalDevices);
+    INIT_PROC(instance, GetInstanceProcAddr);
+    INIT_PROC(instance, GetPhysicalDeviceProperties);
+    INIT_PROC(instance, GetPhysicalDeviceQueueFamilyProperties);
+    INIT_PROC(instance, GetPhysicalDeviceMemoryProperties);
+    INIT_PROC(instance, GetPhysicalDeviceFeatures);
+    INIT_PROC(instance, GetPhysicalDeviceFormatProperties);
+    INIT_PROC(instance, GetPhysicalDeviceImageFormatProperties);
+    INIT_PROC(instance, CreateDevice);
+    INIT_PROC(instance, EnumerateDeviceLayerProperties);
+    INIT_PROC(instance, EnumerateDeviceExtensionProperties);
+    INIT_PROC(instance, GetPhysicalDeviceSparseImageFormatProperties);
+    INIT_PROC_EXT(KHR_surface, instance, DestroySurfaceKHR);
+    INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfaceSupportKHR);
+    INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfaceCapabilitiesKHR);
+    INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfaceFormatsKHR);
+    INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfacePresentModesKHR);
+    INIT_PROC_EXT(KHR_android_surface, instance, CreateAndroidSurfaceKHR);
+    // clang-format on
+
+    return success;
+}
+
+bool InitDispatchTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc) {
+    auto& data = GetData(dev);
+    bool success = true;
+
+    // clang-format off
+    INIT_PROC(dev, GetDeviceProcAddr);
+    INIT_PROC(dev, DestroyDevice);
+    INIT_PROC(dev, GetDeviceQueue);
+    INIT_PROC(dev, QueueSubmit);
+    INIT_PROC(dev, QueueWaitIdle);
+    INIT_PROC(dev, DeviceWaitIdle);
+    INIT_PROC(dev, AllocateMemory);
+    INIT_PROC(dev, FreeMemory);
+    INIT_PROC(dev, MapMemory);
+    INIT_PROC(dev, UnmapMemory);
+    INIT_PROC(dev, FlushMappedMemoryRanges);
+    INIT_PROC(dev, InvalidateMappedMemoryRanges);
+    INIT_PROC(dev, GetDeviceMemoryCommitment);
+    INIT_PROC(dev, GetBufferMemoryRequirements);
+    INIT_PROC(dev, BindBufferMemory);
+    INIT_PROC(dev, GetImageMemoryRequirements);
+    INIT_PROC(dev, BindImageMemory);
+    INIT_PROC(dev, GetImageSparseMemoryRequirements);
+    INIT_PROC(dev, QueueBindSparse);
+    INIT_PROC(dev, CreateFence);
+    INIT_PROC(dev, DestroyFence);
+    INIT_PROC(dev, ResetFences);
+    INIT_PROC(dev, GetFenceStatus);
+    INIT_PROC(dev, WaitForFences);
+    INIT_PROC(dev, CreateSemaphore);
+    INIT_PROC(dev, DestroySemaphore);
+    INIT_PROC(dev, CreateEvent);
+    INIT_PROC(dev, DestroyEvent);
+    INIT_PROC(dev, GetEventStatus);
+    INIT_PROC(dev, SetEvent);
+    INIT_PROC(dev, ResetEvent);
+    INIT_PROC(dev, CreateQueryPool);
+    INIT_PROC(dev, DestroyQueryPool);
+    INIT_PROC(dev, GetQueryPoolResults);
+    INIT_PROC(dev, CreateBuffer);
+    INIT_PROC(dev, DestroyBuffer);
+    INIT_PROC(dev, CreateBufferView);
+    INIT_PROC(dev, DestroyBufferView);
+    INIT_PROC(dev, CreateImage);
+    INIT_PROC(dev, DestroyImage);
+    INIT_PROC(dev, GetImageSubresourceLayout);
+    INIT_PROC(dev, CreateImageView);
+    INIT_PROC(dev, DestroyImageView);
+    INIT_PROC(dev, CreateShaderModule);
+    INIT_PROC(dev, DestroyShaderModule);
+    INIT_PROC(dev, CreatePipelineCache);
+    INIT_PROC(dev, DestroyPipelineCache);
+    INIT_PROC(dev, GetPipelineCacheData);
+    INIT_PROC(dev, MergePipelineCaches);
+    INIT_PROC(dev, CreateGraphicsPipelines);
+    INIT_PROC(dev, CreateComputePipelines);
+    INIT_PROC(dev, DestroyPipeline);
+    INIT_PROC(dev, CreatePipelineLayout);
+    INIT_PROC(dev, DestroyPipelineLayout);
+    INIT_PROC(dev, CreateSampler);
+    INIT_PROC(dev, DestroySampler);
+    INIT_PROC(dev, CreateDescriptorSetLayout);
+    INIT_PROC(dev, DestroyDescriptorSetLayout);
+    INIT_PROC(dev, CreateDescriptorPool);
+    INIT_PROC(dev, DestroyDescriptorPool);
+    INIT_PROC(dev, ResetDescriptorPool);
+    INIT_PROC(dev, AllocateDescriptorSets);
+    INIT_PROC(dev, FreeDescriptorSets);
+    INIT_PROC(dev, UpdateDescriptorSets);
+    INIT_PROC(dev, CreateFramebuffer);
+    INIT_PROC(dev, DestroyFramebuffer);
+    INIT_PROC(dev, CreateRenderPass);
+    INIT_PROC(dev, DestroyRenderPass);
+    INIT_PROC(dev, GetRenderAreaGranularity);
+    INIT_PROC(dev, CreateCommandPool);
+    INIT_PROC(dev, DestroyCommandPool);
+    INIT_PROC(dev, ResetCommandPool);
+    INIT_PROC(dev, AllocateCommandBuffers);
+    INIT_PROC(dev, FreeCommandBuffers);
+    INIT_PROC(dev, BeginCommandBuffer);
+    INIT_PROC(dev, EndCommandBuffer);
+    INIT_PROC(dev, ResetCommandBuffer);
+    INIT_PROC(dev, CmdBindPipeline);
+    INIT_PROC(dev, CmdSetViewport);
+    INIT_PROC(dev, CmdSetScissor);
+    INIT_PROC(dev, CmdSetLineWidth);
+    INIT_PROC(dev, CmdSetDepthBias);
+    INIT_PROC(dev, CmdSetBlendConstants);
+    INIT_PROC(dev, CmdSetDepthBounds);
+    INIT_PROC(dev, CmdSetStencilCompareMask);
+    INIT_PROC(dev, CmdSetStencilWriteMask);
+    INIT_PROC(dev, CmdSetStencilReference);
+    INIT_PROC(dev, CmdBindDescriptorSets);
+    INIT_PROC(dev, CmdBindIndexBuffer);
+    INIT_PROC(dev, CmdBindVertexBuffers);
+    INIT_PROC(dev, CmdDraw);
+    INIT_PROC(dev, CmdDrawIndexed);
+    INIT_PROC(dev, CmdDrawIndirect);
+    INIT_PROC(dev, CmdDrawIndexedIndirect);
+    INIT_PROC(dev, CmdDispatch);
+    INIT_PROC(dev, CmdDispatchIndirect);
+    INIT_PROC(dev, CmdCopyBuffer);
+    INIT_PROC(dev, CmdCopyImage);
+    INIT_PROC(dev, CmdBlitImage);
+    INIT_PROC(dev, CmdCopyBufferToImage);
+    INIT_PROC(dev, CmdCopyImageToBuffer);
+    INIT_PROC(dev, CmdUpdateBuffer);
+    INIT_PROC(dev, CmdFillBuffer);
+    INIT_PROC(dev, CmdClearColorImage);
+    INIT_PROC(dev, CmdClearDepthStencilImage);
+    INIT_PROC(dev, CmdClearAttachments);
+    INIT_PROC(dev, CmdResolveImage);
+    INIT_PROC(dev, CmdSetEvent);
+    INIT_PROC(dev, CmdResetEvent);
+    INIT_PROC(dev, CmdWaitEvents);
+    INIT_PROC(dev, CmdPipelineBarrier);
+    INIT_PROC(dev, CmdBeginQuery);
+    INIT_PROC(dev, CmdEndQuery);
+    INIT_PROC(dev, CmdResetQueryPool);
+    INIT_PROC(dev, CmdWriteTimestamp);
+    INIT_PROC(dev, CmdCopyQueryPoolResults);
+    INIT_PROC(dev, CmdPushConstants);
+    INIT_PROC(dev, CmdBeginRenderPass);
+    INIT_PROC(dev, CmdNextSubpass);
+    INIT_PROC(dev, CmdEndRenderPass);
+    INIT_PROC(dev, CmdExecuteCommands);
+    INIT_PROC_EXT(KHR_swapchain, dev, CreateSwapchainKHR);
+    INIT_PROC_EXT(KHR_swapchain, dev, DestroySwapchainKHR);
+    INIT_PROC_EXT(KHR_swapchain, dev, GetSwapchainImagesKHR);
+    INIT_PROC_EXT(KHR_swapchain, dev, AcquireNextImageKHR);
+    INIT_PROC_EXT(KHR_swapchain, dev, QueuePresentKHR);
+    // clang-format on
+
+    return success;
+}
+
+}  // namespace api
+}  // namespace vulkan
+
+// clang-format off
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
+    // call into api.cpp
+    return vulkan::api::CreateInstance(pCreateInfo, pAllocator, pInstance);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
+    // call into api.cpp
+    vulkan::api::DestroyInstance(instance, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {
+    return vulkan::api::GetData(instance).dispatch.EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) {
+    if (device == VK_NULL_HANDLE) {
+        ALOGE("vkGetDeviceProcAddr called with invalid device");
+        return nullptr;
+    }
+
+    static const char* const known_non_device_names[] = {
+        "vkCreateAndroidSurfaceKHR",
+        "vkCreateDebugReportCallbackEXT",
+        "vkCreateDevice",
+        "vkCreateInstance",
+        "vkDebugReportMessageEXT",
+        "vkDestroyDebugReportCallbackEXT",
+        "vkDestroyInstance",
+        "vkDestroySurfaceKHR",
+        "vkEnumerateDeviceExtensionProperties",
+        "vkEnumerateDeviceLayerProperties",
+        "vkEnumerateInstanceExtensionProperties",
+        "vkEnumerateInstanceLayerProperties",
+        "vkEnumeratePhysicalDevices",
+        "vkGetInstanceProcAddr",
+        "vkGetPhysicalDeviceFeatures",
+        "vkGetPhysicalDeviceFormatProperties",
+        "vkGetPhysicalDeviceImageFormatProperties",
+        "vkGetPhysicalDeviceMemoryProperties",
+        "vkGetPhysicalDeviceProperties",
+        "vkGetPhysicalDeviceQueueFamilyProperties",
+        "vkGetPhysicalDeviceSparseImageFormatProperties",
+        "vkGetPhysicalDeviceSurfaceCapabilitiesKHR",
+        "vkGetPhysicalDeviceSurfaceFormatsKHR",
+        "vkGetPhysicalDeviceSurfacePresentModesKHR",
+        "vkGetPhysicalDeviceSurfaceSupportKHR",
+    };
+    // 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); })) {
+        ALOGE("vkGetDeviceProcAddr called with %s", pName);
+        return nullptr;
+    }
+    // clang-format off
+
+    return vulkan::api::GetData(device).dispatch.GetDeviceProcAddr(device, pName);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
+    // global functions
+    if (!instance) {
+        if (strcmp(pName, "vkCreateInstance") == 0) return reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::CreateInstance);
+        if (strcmp(pName, "vkEnumerateInstanceLayerProperties") == 0) return reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::EnumerateInstanceLayerProperties);
+        if (strcmp(pName, "vkEnumerateInstanceExtensionProperties") == 0) return reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::EnumerateInstanceExtensionProperties);
+
+        ALOGE("vkGetInstanceProcAddr called with %s without instance",  pName);
+        return nullptr;
+    }
+
+    static const struct Hook {
+        const char* name;
+        PFN_vkVoidFunction proc;
+    } hooks[] = {
+        { "vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR) },
+        { "vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateCommandBuffers) },
+        { "vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateDescriptorSets) },
+        { "vkAllocateMemory", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateMemory) },
+        { "vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkBeginCommandBuffer) },
+        { "vkBindBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory) },
+        { "vkBindImageMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory) },
+        { "vkCmdBeginQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginQuery) },
+        { "vkCmdBeginRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass) },
+        { "vkCmdBindDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets) },
+        { "vkCmdBindIndexBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer) },
+        { "vkCmdBindPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindPipeline) },
+        { "vkCmdBindVertexBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers) },
+        { "vkCmdBlitImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage) },
+        { "vkCmdClearAttachments", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearAttachments) },
+        { "vkCmdClearColorImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearColorImage) },
+        { "vkCmdClearDepthStencilImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearDepthStencilImage) },
+        { "vkCmdCopyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer) },
+        { "vkCmdCopyBufferToImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage) },
+        { "vkCmdCopyImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage) },
+        { "vkCmdCopyImageToBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer) },
+        { "vkCmdCopyQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyQueryPoolResults) },
+        { "vkCmdDispatch", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatch) },
+        { "vkCmdDispatchIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchIndirect) },
+        { "vkCmdDraw", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDraw) },
+        { "vkCmdDrawIndexed", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexed) },
+        { "vkCmdDrawIndexedIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirect) },
+        { "vkCmdDrawIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirect) },
+        { "vkCmdEndQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndQuery) },
+        { "vkCmdEndRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass) },
+        { "vkCmdExecuteCommands", reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteCommands) },
+        { "vkCmdFillBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdFillBuffer) },
+        { "vkCmdNextSubpass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass) },
+        { "vkCmdPipelineBarrier", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier) },
+        { "vkCmdPushConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants) },
+        { "vkCmdResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent) },
+        { "vkCmdResetQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetQueryPool) },
+        { "vkCmdResolveImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage) },
+        { "vkCmdSetBlendConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetBlendConstants) },
+        { "vkCmdSetDepthBias", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBias) },
+        { "vkCmdSetDepthBounds", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBounds) },
+        { "vkCmdSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent) },
+        { "vkCmdSetLineWidth", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineWidth) },
+        { "vkCmdSetScissor", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissor) },
+        { "vkCmdSetStencilCompareMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilCompareMask) },
+        { "vkCmdSetStencilReference", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilReference) },
+        { "vkCmdSetStencilWriteMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilWriteMask) },
+        { "vkCmdSetViewport", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewport) },
+        { "vkCmdUpdateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdUpdateBuffer) },
+        { "vkCmdWaitEvents", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents) },
+        { "vkCmdWriteTimestamp", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp) },
+        { "vkCreateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBuffer) },
+        { "vkCreateBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBufferView) },
+        { "vkCreateCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateCommandPool) },
+        { "vkCreateComputePipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateComputePipelines) },
+        { "vkCreateDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorPool) },
+        { "vkCreateDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorSetLayout) },
+        { "vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::CreateDevice) },
+        { "vkCreateEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCreateEvent) },
+        { "vkCreateFence", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFence) },
+        { "vkCreateFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFramebuffer) },
+        { "vkCreateGraphicsPipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateGraphicsPipelines) },
+        { "vkCreateImage", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImage) },
+        { "vkCreateImageView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImageView) },
+        { "vkCreateInstance", nullptr },
+        { "vkCreatePipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineCache) },
+        { "vkCreatePipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineLayout) },
+        { "vkCreateQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateQueryPool) },
+        { "vkCreateRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass) },
+        { "vkCreateSampler", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSampler) },
+        { "vkCreateSemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSemaphore) },
+        { "vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkCreateShaderModule) },
+        { "vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR) },
+        { "vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBuffer) },
+        { "vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferView) },
+        { "vkDestroyCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCommandPool) },
+        { "vkDestroyDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorPool) },
+        { "vkDestroyDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorSetLayout) },
+        { "vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::DestroyDevice) },
+        { "vkDestroyEvent", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyEvent) },
+        { "vkDestroyFence", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFence) },
+        { "vkDestroyFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFramebuffer) },
+        { "vkDestroyImage", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImage) },
+        { "vkDestroyImageView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImageView) },
+        { "vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::DestroyInstance) },
+        { "vkDestroyPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipeline) },
+        { "vkDestroyPipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineCache) },
+        { "vkDestroyPipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineLayout) },
+        { "vkDestroyQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyQueryPool) },
+        { "vkDestroyRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyRenderPass) },
+        { "vkDestroySampler", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySampler) },
+        { "vkDestroySemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySemaphore) },
+        { "vkDestroyShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderModule) },
+        { "vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR) },
+        { "vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkDeviceWaitIdle) },
+        { "vkEndCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkEndCommandBuffer) },
+        { "vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::EnumerateDeviceExtensionProperties) },
+        { "vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::EnumerateDeviceLayerProperties) },
+        { "vkEnumerateInstanceExtensionProperties", nullptr },
+        { "vkEnumerateInstanceLayerProperties", nullptr },
+        { "vkFlushMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkFlushMappedMemoryRanges) },
+        { "vkFreeCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkFreeCommandBuffers) },
+        { "vkFreeDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkFreeDescriptorSets) },
+        { "vkFreeMemory", reinterpret_cast<PFN_vkVoidFunction>(vkFreeMemory) },
+        { "vkGetBufferMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferMemoryRequirements) },
+        { "vkGetDeviceMemoryCommitment", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryCommitment) },
+        { "vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceProcAddr) },
+        { "vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceQueue) },
+        { "vkGetEventStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetEventStatus) },
+        { "vkGetFenceStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceStatus) },
+        { "vkGetImageMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements) },
+        { "vkGetImageSparseMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements) },
+        { "vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout) },
+        { "vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetInstanceProcAddr) },
+        { "vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData) },
+        { "vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults) },
+        { "vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity) },
+        { "vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR) },
+        { "vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges) },
+        { "vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory) },
+        { "vkMergePipelineCaches", reinterpret_cast<PFN_vkVoidFunction>(vkMergePipelineCaches) },
+        { "vkQueueBindSparse", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparse) },
+        { "vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR) },
+        { "vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit) },
+        { "vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitIdle) },
+        { "vkResetCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandBuffer) },
+        { "vkResetCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandPool) },
+        { "vkResetDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetDescriptorPool) },
+        { "vkResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkResetEvent) },
+        { "vkResetFences", reinterpret_cast<PFN_vkVoidFunction>(vkResetFences) },
+        { "vkSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkSetEvent) },
+        { "vkUnmapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory) },
+        { "vkUpdateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSets) },
+        { "vkWaitForFences", reinterpret_cast<PFN_vkVoidFunction>(vkWaitForFences) },
+    };
+    // 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)
+            ALOGE("vkGetInstanceProcAddr called with %s with instance", pName);
+        return hook->proc;
+    }
+    // clang-format off
+
+    return vulkan::api::GetData(instance).dispatch.GetInstanceProcAddr(instance, pName);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
+    vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceProperties(physicalDevice, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
+    vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
+    vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
+    vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
+    vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+    return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
+    // call into api.cpp
+    return vulkan::api::CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
+    // call into api.cpp
+    vulkan::api::DestroyDevice(device, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+    // call into api.cpp
+    return vulkan::api::EnumerateInstanceLayerProperties(pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+    // call into api.cpp
+    return vulkan::api::EnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+    // call into api.cpp
+    return vulkan::api::EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+    // call into api.cpp
+    return vulkan::api::EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
+    vulkan::api::GetData(device).dispatch.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
+    return vulkan::api::GetData(queue).dispatch.QueueSubmit(queue, submitCount, pSubmits, fence);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkQueueWaitIdle(VkQueue queue) {
+    return vulkan::api::GetData(queue).dispatch.QueueWaitIdle(queue);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkDeviceWaitIdle(VkDevice device) {
+    return vulkan::api::GetData(device).dispatch.DeviceWaitIdle(device);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
+    return vulkan::api::GetData(device).dispatch.AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.FreeMemory(device, memory, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
+    return vulkan::api::GetData(device).dispatch.MapMemory(device, memory, offset, size, flags, ppData);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
+    vulkan::api::GetData(device).dispatch.UnmapMemory(device, memory);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
+    return vulkan::api::GetData(device).dispatch.FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
+    return vulkan::api::GetData(device).dispatch.InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
+    vulkan::api::GetData(device).dispatch.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
+    vulkan::api::GetData(device).dispatch.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+    return vulkan::api::GetData(device).dispatch.BindBufferMemory(device, buffer, memory, memoryOffset);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
+    vulkan::api::GetData(device).dispatch.GetImageMemoryRequirements(device, image, pMemoryRequirements);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+    return vulkan::api::GetData(device).dispatch.BindImageMemory(device, image, memory, memoryOffset);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+    vulkan::api::GetData(device).dispatch.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
+    vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
+    return vulkan::api::GetData(queue).dispatch.QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+    return vulkan::api::GetData(device).dispatch.CreateFence(device, pCreateInfo, pAllocator, pFence);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyFence(device, fence, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
+    return vulkan::api::GetData(device).dispatch.ResetFences(device, fenceCount, pFences);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetFenceStatus(VkDevice device, VkFence fence) {
+    return vulkan::api::GetData(device).dispatch.GetFenceStatus(device, fence);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
+    return vulkan::api::GetData(device).dispatch.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
+    return vulkan::api::GetData(device).dispatch.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroySemaphore(device, semaphore, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
+    return vulkan::api::GetData(device).dispatch.CreateEvent(device, pCreateInfo, pAllocator, pEvent);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyEvent(device, event, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetEventStatus(VkDevice device, VkEvent event) {
+    return vulkan::api::GetData(device).dispatch.GetEventStatus(device, event);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkSetEvent(VkDevice device, VkEvent event) {
+    return vulkan::api::GetData(device).dispatch.SetEvent(device, event);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetEvent(VkDevice device, VkEvent event) {
+    return vulkan::api::GetData(device).dispatch.ResetEvent(device, event);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
+    return vulkan::api::GetData(device).dispatch.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyQueryPool(device, queryPool, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
+    return vulkan::api::GetData(device).dispatch.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
+    return vulkan::api::GetData(device).dispatch.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyBuffer(device, buffer, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
+    return vulkan::api::GetData(device).dispatch.CreateBufferView(device, pCreateInfo, pAllocator, pView);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyBufferView(device, bufferView, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
+    return vulkan::api::GetData(device).dispatch.CreateImage(device, pCreateInfo, pAllocator, pImage);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyImage(device, image, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+    vulkan::api::GetData(device).dispatch.GetImageSubresourceLayout(device, image, pSubresource, pLayout);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
+    return vulkan::api::GetData(device).dispatch.CreateImageView(device, pCreateInfo, pAllocator, pView);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyImageView(device, imageView, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
+    return vulkan::api::GetData(device).dispatch.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyShaderModule(device, shaderModule, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
+    return vulkan::api::GetData(device).dispatch.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyPipelineCache(device, pipelineCache, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
+    return vulkan::api::GetData(device).dispatch.GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
+    return vulkan::api::GetData(device).dispatch.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    return vulkan::api::GetData(device).dispatch.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    return vulkan::api::GetData(device).dispatch.CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyPipeline(device, pipeline, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
+    return vulkan::api::GetData(device).dispatch.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyPipelineLayout(device, pipelineLayout, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
+    return vulkan::api::GetData(device).dispatch.CreateSampler(device, pCreateInfo, pAllocator, pSampler);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroySampler(device, sampler, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
+    return vulkan::api::GetData(device).dispatch.CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
+    return vulkan::api::GetData(device).dispatch.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyDescriptorPool(device, descriptorPool, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
+    return vulkan::api::GetData(device).dispatch.ResetDescriptorPool(device, descriptorPool, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
+    return vulkan::api::GetData(device).dispatch.AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
+    return vulkan::api::GetData(device).dispatch.FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
+    vulkan::api::GetData(device).dispatch.UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
+    return vulkan::api::GetData(device).dispatch.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyFramebuffer(device, framebuffer, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+    return vulkan::api::GetData(device).dispatch.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyRenderPass(device, renderPass, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+    vulkan::api::GetData(device).dispatch.GetRenderAreaGranularity(device, renderPass, pGranularity);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
+    return vulkan::api::GetData(device).dispatch.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroyCommandPool(device, commandPool, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
+    return vulkan::api::GetData(device).dispatch.ResetCommandPool(device, commandPool, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
+    return vulkan::api::GetData(device).dispatch.AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
+    vulkan::api::GetData(device).dispatch.FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
+    return vulkan::api::GetData(commandBuffer).dispatch.BeginCommandBuffer(commandBuffer, pBeginInfo);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
+    return vulkan::api::GetData(commandBuffer).dispatch.EndCommandBuffer(commandBuffer);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
+    return vulkan::api::GetData(commandBuffer).dispatch.ResetCommandBuffer(commandBuffer, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdSetLineWidth(commandBuffer, lineWidth);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdSetBlendConstants(commandBuffer, blendConstants);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdSetStencilReference(commandBuffer, faceMask, reference);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdDispatch(commandBuffer, x, y, z);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdDispatchIndirect(commandBuffer, buffer, offset);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdSetEvent(commandBuffer, event, stageMask);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdResetEvent(commandBuffer, event, stageMask);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdBeginQuery(commandBuffer, queryPool, query, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdEndQuery(commandBuffer, queryPool, query);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdNextSubpass(commandBuffer, contents);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdEndRenderPass(commandBuffer);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
+    vulkan::api::GetData(commandBuffer).dispatch.CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(instance).dispatch.DestroySurfaceKHR(instance, surface, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
+    return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
+    return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
+    return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
+    return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
+    return vulkan::api::GetData(device).dispatch.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {
+    vulkan::api::GetData(device).dispatch.DestroySwapchainKHR(device, swapchain, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
+    return vulkan::api::GetData(device).dispatch.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
+    return vulkan::api::GetData(device).dispatch.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
+    return vulkan::api::GetData(queue).dispatch.QueuePresentKHR(queue, pPresentInfo);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    return vulkan::api::GetData(instance).dispatch.CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+}
+
+// clang-format on
diff --git a/vulkan/libvulkan/api_gen.h b/vulkan/libvulkan/api_gen.h
new file mode 100644
index 0000000..54be83b
--- /dev/null
+++ b/vulkan/libvulkan/api_gen.h
@@ -0,0 +1,188 @@
+/*
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// WARNING: This file is generated. See ../README.md for instructions.
+
+#ifndef LIBVULKAN_API_GEN_H
+#define LIBVULKAN_API_GEN_H
+
+#include <vulkan/vulkan.h>
+
+namespace vulkan {
+namespace api {
+
+struct InstanceDispatchTable {
+    // clang-format off
+    PFN_vkDestroyInstance DestroyInstance;
+    PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
+    PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
+    PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
+    PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
+    PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
+    PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
+    PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
+    PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
+    PFN_vkCreateDevice CreateDevice;
+    PFN_vkEnumerateDeviceLayerProperties EnumerateDeviceLayerProperties;
+    PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
+    PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
+    PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
+    PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
+    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
+    PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
+    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
+    PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
+    // clang-format on
+};
+
+struct DeviceDispatchTable {
+    // clang-format off
+    PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
+    PFN_vkDestroyDevice DestroyDevice;
+    PFN_vkGetDeviceQueue GetDeviceQueue;
+    PFN_vkQueueSubmit QueueSubmit;
+    PFN_vkQueueWaitIdle QueueWaitIdle;
+    PFN_vkDeviceWaitIdle DeviceWaitIdle;
+    PFN_vkAllocateMemory AllocateMemory;
+    PFN_vkFreeMemory FreeMemory;
+    PFN_vkMapMemory MapMemory;
+    PFN_vkUnmapMemory UnmapMemory;
+    PFN_vkFlushMappedMemoryRanges FlushMappedMemoryRanges;
+    PFN_vkInvalidateMappedMemoryRanges InvalidateMappedMemoryRanges;
+    PFN_vkGetDeviceMemoryCommitment GetDeviceMemoryCommitment;
+    PFN_vkGetBufferMemoryRequirements GetBufferMemoryRequirements;
+    PFN_vkBindBufferMemory BindBufferMemory;
+    PFN_vkGetImageMemoryRequirements GetImageMemoryRequirements;
+    PFN_vkBindImageMemory BindImageMemory;
+    PFN_vkGetImageSparseMemoryRequirements GetImageSparseMemoryRequirements;
+    PFN_vkQueueBindSparse QueueBindSparse;
+    PFN_vkCreateFence CreateFence;
+    PFN_vkDestroyFence DestroyFence;
+    PFN_vkResetFences ResetFences;
+    PFN_vkGetFenceStatus GetFenceStatus;
+    PFN_vkWaitForFences WaitForFences;
+    PFN_vkCreateSemaphore CreateSemaphore;
+    PFN_vkDestroySemaphore DestroySemaphore;
+    PFN_vkCreateEvent CreateEvent;
+    PFN_vkDestroyEvent DestroyEvent;
+    PFN_vkGetEventStatus GetEventStatus;
+    PFN_vkSetEvent SetEvent;
+    PFN_vkResetEvent ResetEvent;
+    PFN_vkCreateQueryPool CreateQueryPool;
+    PFN_vkDestroyQueryPool DestroyQueryPool;
+    PFN_vkGetQueryPoolResults GetQueryPoolResults;
+    PFN_vkCreateBuffer CreateBuffer;
+    PFN_vkDestroyBuffer DestroyBuffer;
+    PFN_vkCreateBufferView CreateBufferView;
+    PFN_vkDestroyBufferView DestroyBufferView;
+    PFN_vkCreateImage CreateImage;
+    PFN_vkDestroyImage DestroyImage;
+    PFN_vkGetImageSubresourceLayout GetImageSubresourceLayout;
+    PFN_vkCreateImageView CreateImageView;
+    PFN_vkDestroyImageView DestroyImageView;
+    PFN_vkCreateShaderModule CreateShaderModule;
+    PFN_vkDestroyShaderModule DestroyShaderModule;
+    PFN_vkCreatePipelineCache CreatePipelineCache;
+    PFN_vkDestroyPipelineCache DestroyPipelineCache;
+    PFN_vkGetPipelineCacheData GetPipelineCacheData;
+    PFN_vkMergePipelineCaches MergePipelineCaches;
+    PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines;
+    PFN_vkCreateComputePipelines CreateComputePipelines;
+    PFN_vkDestroyPipeline DestroyPipeline;
+    PFN_vkCreatePipelineLayout CreatePipelineLayout;
+    PFN_vkDestroyPipelineLayout DestroyPipelineLayout;
+    PFN_vkCreateSampler CreateSampler;
+    PFN_vkDestroySampler DestroySampler;
+    PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout;
+    PFN_vkDestroyDescriptorSetLayout DestroyDescriptorSetLayout;
+    PFN_vkCreateDescriptorPool CreateDescriptorPool;
+    PFN_vkDestroyDescriptorPool DestroyDescriptorPool;
+    PFN_vkResetDescriptorPool ResetDescriptorPool;
+    PFN_vkAllocateDescriptorSets AllocateDescriptorSets;
+    PFN_vkFreeDescriptorSets FreeDescriptorSets;
+    PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
+    PFN_vkCreateFramebuffer CreateFramebuffer;
+    PFN_vkDestroyFramebuffer DestroyFramebuffer;
+    PFN_vkCreateRenderPass CreateRenderPass;
+    PFN_vkDestroyRenderPass DestroyRenderPass;
+    PFN_vkGetRenderAreaGranularity GetRenderAreaGranularity;
+    PFN_vkCreateCommandPool CreateCommandPool;
+    PFN_vkDestroyCommandPool DestroyCommandPool;
+    PFN_vkResetCommandPool ResetCommandPool;
+    PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
+    PFN_vkFreeCommandBuffers FreeCommandBuffers;
+    PFN_vkBeginCommandBuffer BeginCommandBuffer;
+    PFN_vkEndCommandBuffer EndCommandBuffer;
+    PFN_vkResetCommandBuffer ResetCommandBuffer;
+    PFN_vkCmdBindPipeline CmdBindPipeline;
+    PFN_vkCmdSetViewport CmdSetViewport;
+    PFN_vkCmdSetScissor CmdSetScissor;
+    PFN_vkCmdSetLineWidth CmdSetLineWidth;
+    PFN_vkCmdSetDepthBias CmdSetDepthBias;
+    PFN_vkCmdSetBlendConstants CmdSetBlendConstants;
+    PFN_vkCmdSetDepthBounds CmdSetDepthBounds;
+    PFN_vkCmdSetStencilCompareMask CmdSetStencilCompareMask;
+    PFN_vkCmdSetStencilWriteMask CmdSetStencilWriteMask;
+    PFN_vkCmdSetStencilReference CmdSetStencilReference;
+    PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets;
+    PFN_vkCmdBindIndexBuffer CmdBindIndexBuffer;
+    PFN_vkCmdBindVertexBuffers CmdBindVertexBuffers;
+    PFN_vkCmdDraw CmdDraw;
+    PFN_vkCmdDrawIndexed CmdDrawIndexed;
+    PFN_vkCmdDrawIndirect CmdDrawIndirect;
+    PFN_vkCmdDrawIndexedIndirect CmdDrawIndexedIndirect;
+    PFN_vkCmdDispatch CmdDispatch;
+    PFN_vkCmdDispatchIndirect CmdDispatchIndirect;
+    PFN_vkCmdCopyBuffer CmdCopyBuffer;
+    PFN_vkCmdCopyImage CmdCopyImage;
+    PFN_vkCmdBlitImage CmdBlitImage;
+    PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage;
+    PFN_vkCmdCopyImageToBuffer CmdCopyImageToBuffer;
+    PFN_vkCmdUpdateBuffer CmdUpdateBuffer;
+    PFN_vkCmdFillBuffer CmdFillBuffer;
+    PFN_vkCmdClearColorImage CmdClearColorImage;
+    PFN_vkCmdClearDepthStencilImage CmdClearDepthStencilImage;
+    PFN_vkCmdClearAttachments CmdClearAttachments;
+    PFN_vkCmdResolveImage CmdResolveImage;
+    PFN_vkCmdSetEvent CmdSetEvent;
+    PFN_vkCmdResetEvent CmdResetEvent;
+    PFN_vkCmdWaitEvents CmdWaitEvents;
+    PFN_vkCmdPipelineBarrier CmdPipelineBarrier;
+    PFN_vkCmdBeginQuery CmdBeginQuery;
+    PFN_vkCmdEndQuery CmdEndQuery;
+    PFN_vkCmdResetQueryPool CmdResetQueryPool;
+    PFN_vkCmdWriteTimestamp CmdWriteTimestamp;
+    PFN_vkCmdCopyQueryPoolResults CmdCopyQueryPoolResults;
+    PFN_vkCmdPushConstants CmdPushConstants;
+    PFN_vkCmdBeginRenderPass CmdBeginRenderPass;
+    PFN_vkCmdNextSubpass CmdNextSubpass;
+    PFN_vkCmdEndRenderPass CmdEndRenderPass;
+    PFN_vkCmdExecuteCommands CmdExecuteCommands;
+    PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
+    PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
+    PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
+    PFN_vkAcquireNextImageKHR AcquireNextImageKHR;
+    PFN_vkQueuePresentKHR QueuePresentKHR;
+    // clang-format on
+};
+
+bool InitDispatchTable(VkInstance instance, PFN_vkGetInstanceProcAddr get_proc);
+bool InitDispatchTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc);
+
+}  // namespace api
+}  // namespace vulkan
+
+#endif  // LIBVULKAN_API_GEN_H
diff --git a/vulkan/libvulkan/code-generator.tmpl b/vulkan/libvulkan/code-generator.tmpl
new file mode 100644
index 0000000..7ebe983
--- /dev/null
+++ b/vulkan/libvulkan/code-generator.tmpl
@@ -0,0 +1,519 @@
+{{define "Copyright"}}
+/*
+•* Copyright 2016 The Android Open Source Project
+•*
+•* Licensed under the Apache License, Version 2.0 (the "License");
+•* you may not use this file except in compliance with the License.
+•* You may obtain a copy of the License at
+•*
+•*      http://www.apache.org/licenses/LICENSE-2.0
+•*
+•* Unless required by applicable law or agreed to in writing, software
+•* distributed under the License is distributed on an "AS IS" BASIS,
+•* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+•* See the License for the specific language governing permissions and
+•* limitations under the License.
+•*/
+¶{{end}}
+
+{{Include "../api/templates/vulkan_common.tmpl"}}
+{{Global "clang-format" (Strings "clang-format" "-style=file")}}
+{{Macro "DefineGlobals" $}}
+{{$ | Macro "api_gen.h"   | Format (Global "clang-format") | Write "api_gen.h"  }}
+{{$ | Macro "api_gen.cpp" | Format (Global "clang-format") | Write "api_gen.cpp"}}
+
+{{/*
+-------------------------------------------------------------------------------
+  api_gen.h
+-------------------------------------------------------------------------------
+*/}}
+{{define "api_gen.h"}}
+{{Macro "Copyright"}}
+¶
+// WARNING: This file is generated. See ../README.md for instructions.
+¶
+#ifndef LIBVULKAN_API_GEN_H
+#define LIBVULKAN_API_GEN_H
+¶
+#include <vulkan/vulkan.h>
+¶
+namespace vulkan {«
+namespace api {«
+¶
+struct InstanceDispatchTable {
+  // clang-format off
+  {{range $f := AllCommands $}}
+    {{if (Macro "api.IsInstanceDispatchTableEntry" $f)}}
+      {{Macro "C++.DeclareDispatchTableEntry" $f}};
+    {{end}}
+  {{end}}
+  // clang-format on
+};
+¶
+struct DeviceDispatchTable {
+  // clang-format off
+  {{range $f := AllCommands $}}
+    {{if (Macro "api.IsDeviceDispatchTableEntry" $f)}}
+      {{Macro "C++.DeclareDispatchTableEntry" $f}};
+    {{end}}
+  {{end}}
+  // clang-format on
+};
+¶
+bool InitDispatchTable(VkInstance instance, PFN_vkGetInstanceProcAddr get_proc);
+bool InitDispatchTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc);
+¶
+»} // namespace api
+»} // namespace vulkan
+¶
+#endif // LIBVULKAN_API_GEN_H
+¶{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  api_gen.cpp
+-------------------------------------------------------------------------------
+*/}}
+{{define "api_gen.cpp"}}
+{{Macro "Copyright"}}
+¶
+// WARNING: This file is generated. See ../README.md for instructions.
+¶
+#include <string.h>
+#include <algorithm>
+#include <log/log.h>
+¶
+#include "api.h"
+¶
+namespace vulkan {«
+namespace api {«
+¶
+{{Macro "C++.DefineInitProcMacros" "dispatch"}}
+¶
+bool InitDispatchTable(VkInstance instance, PFN_vkGetInstanceProcAddr get_proc) {
+    auto& data = GetData(instance);
+    bool success = true;
+    ¶
+    // clang-format off
+    {{range $f := AllCommands $}}
+      {{if (Macro "api.IsInstanceDispatchTableEntry" $f)}}
+        {{Macro "C++.InitProc" $f}}
+      {{end}}
+    {{end}}
+    // clang-format on
+    ¶
+    return success;
+}
+¶
+bool InitDispatchTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc) {
+    auto& data = GetData(dev);
+    bool success = true;
+    ¶
+    // clang-format off
+    {{range $f := AllCommands $}}
+      {{if (Macro "api.IsDeviceDispatchTableEntry" $f)}}
+        {{Macro "C++.InitProc" $f}}
+      {{end}}
+    {{end}}
+    // clang-format on
+    ¶
+    return success;
+}
+¶
+»} // namespace api
+»} // namespace vulkan
+¶
+// clang-format off
+¶
+{{range $f := AllCommands $}}
+  {{if (Macro "IsFunctionExported" $f)}}
+    __attribute__((visibility("default")))
+    VKAPI_ATTR {{Node "Type" $f.Return}} {{$f.Name}}({{Macro "Parameters" $f}}) {
+      {{     if eq $f.Name "vkGetInstanceProcAddr"}}
+        {{Macro "api.C++.InterceptInstanceProcAddr" $}}
+      {{else if eq $f.Name "vkGetDeviceProcAddr"}}
+        {{Macro "api.C++.InterceptDeviceProcAddr" $}}
+      {{end}}
+
+      {{Macro "api.C++.Dispatch" $f}}
+    }
+    ¶
+  {{end}}
+{{end}}
+¶
+// clang-format on
+¶{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emits a declaration of a dispatch table entry.
+------------------------------------------------------------------------------
+*/}}
+{{define "C++.DeclareDispatchTableEntry"}}
+  {{AssertType $ "Function"}}
+
+  {{Macro "FunctionPtrName" $}} {{Macro "BaseName" $}}
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  Emits macros to help initialize dispatch tables.
+-------------------------------------------------------------------------------
+*/}}
+{{define "C++.DefineInitProcMacros"}}
+  #define UNLIKELY(expr) __builtin_expect((expr), 0)
+  ¶
+  #define INIT_PROC(obj, proc) do {                             \
+      data.{{$}}.proc = reinterpret_cast<PFN_vk ## proc>(       \
+              get_proc(obj, "vk" # proc));                      \
+      if (UNLIKELY(!data.{{$}}.proc)) {                         \
+          ALOGE("missing " # obj " proc: vk" # proc);           \
+          success = false;                                      \
+      }                                                         \
+  } while(0)
+  ¶
+  // TODO do we want to point to a stub or nullptr when ext is not enabled?
+  #define INIT_PROC_EXT(ext, obj, proc) do {                    \
+      INIT_PROC(obj, proc);                                     \
+  } while(0)
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  Emits code to invoke INIT_PROC or INIT_PROC_EXT.
+-------------------------------------------------------------------------------
+*/}}
+{{define "C++.InitProc"}}
+  {{AssertType $ "Function"}}
+
+  {{$ext := GetAnnotation $ "extension"}}
+  {{if $ext}}
+    INIT_PROC_EXT({{Macro "BaseName" $ext}}, §
+  {{else}}
+    INIT_PROC(§
+  {{end}}
+
+  {{if (Macro "IsInstanceDispatched" $)}}
+    instance, §
+  {{else}}
+    dev, §
+  {{end}}
+
+  {{Macro "BaseName" $}});
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emits true if a function is exported and instance-dispatched.
+------------------------------------------------------------------------------
+*/}}
+{{define "api.IsInstanceDispatchTableEntry"}}
+  {{AssertType $ "Function"}}
+
+  {{if and (Macro "IsFunctionExported" $) (Macro "IsInstanceDispatched" $)}}
+    true
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emits true if a function is exported and device-dispatched.
+------------------------------------------------------------------------------
+*/}}
+{{define "api.IsDeviceDispatchTableEntry"}}
+  {{AssertType $ "Function"}}
+
+  {{if and (Macro "IsFunctionExported" $) (Macro "IsDeviceDispatched" $)}}
+    true
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emits true if a function is intercepted by vulkan::api.
+------------------------------------------------------------------------------
+*/}}
+{{define "api.IsIntercepted"}}
+  {{AssertType $ "Function"}}
+
+  {{if (Macro "IsFunctionSupported" $)}}
+    {{/* Global functions cannot be dispatched at all */}}
+    {{     if (Macro "IsGloballyDispatched" $)}}true
+
+    {{/* VkPhysicalDevice functions that manage device layers */}}
+    {{else if eq $.Name "vkCreateDevice"}}true
+    {{else if eq $.Name "vkEnumerateDeviceLayerProperties"}}true
+    {{else if eq $.Name "vkEnumerateDeviceExtensionProperties"}}true
+
+    {{/* Destroy functions of dispatchable objects */}}
+    {{else if eq $.Name "vkDestroyInstance"}}true
+    {{else if eq $.Name "vkDestroyDevice"}}true
+
+    {{end}}
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emits code for vkGetInstanceProcAddr for function interception.
+------------------------------------------------------------------------------
+*/}}
+{{define "api.C++.InterceptInstanceProcAddr"}}
+  {{AssertType $ "API"}}
+
+  // global functions
+  if (!instance) {
+    {{range $f := AllCommands $}}
+      {{if (Macro "IsGloballyDispatched" $f)}}
+        if (strcmp(pName, "{{$f.Name}}") == 0) return §
+          reinterpret_cast<PFN_vkVoidFunction>(§
+            vulkan::api::{{Macro "BaseName" $f}});
+      {{end}}
+    {{end}}
+    ¶
+    ALOGE("vkGetInstanceProcAddr called with %s without instance",  pName);
+    return nullptr;
+  }
+  ¶
+  static const struct Hook {
+    const char* name;
+    PFN_vkVoidFunction proc;
+  } hooks[] = {
+    {{range $f := SortBy (AllCommands $) "FunctionName"}}
+      {{if (Macro "IsFunctionExported" $f)}}
+        {{/* hide global functions */}}
+        {{if (Macro "IsGloballyDispatched" $f)}}
+          { "{{$f.Name}}", nullptr },
+
+        {{/* redirect intercepted functions */}}
+        {{else if (Macro "api.IsIntercepted" $f)}}
+          { "{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§
+            vulkan::api::{{Macro "BaseName" $f}}) },
+
+        {{/* redirect vkGetInstanceProcAddr to itself */}}
+        {{else if eq $f.Name "vkGetInstanceProcAddr"}}
+          { "{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>({{$f.Name}}) },
+
+        {{/* redirect device functions to themselves as a workaround for
+             layers that do not intercept in their vkGetInstanceProcAddr */}}
+        {{else if (Macro "IsDeviceDispatched" $f)}}
+          { "{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>({{$f.Name}}) },
+
+        {{end}}
+      {{end}}
+    {{end}}
+  };
+  // clang-format on
+  constexpr size_t count = sizeof(hooks) / sizeof(hooks[0]);
+  auto hook = std::lower_bound(
+    hooks, hooks + count, pName,
+    [](const Hook& h, const char* n) { return strcmp(h.name, n) < 0; });
+  if (hook <  hooks + count && strcmp(hook->name, pName) == 0) {
+    if (!hook->proc)
+      ALOGE("vkGetInstanceProcAddr called with %s with instance",  pName);
+    return hook->proc;
+  }
+  // clang-format off
+  ¶
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emits code for vkGetDeviceProcAddr for function interception.
+------------------------------------------------------------------------------
+*/}}
+{{define "api.C++.InterceptDeviceProcAddr"}}
+  {{AssertType $ "API"}}
+
+  if (device == VK_NULL_HANDLE) {
+    ALOGE("vkGetDeviceProcAddr called with invalid device");
+    return nullptr;
+  }
+  ¶
+  static const char* const known_non_device_names[] = {
+    {{range $f := SortBy (AllCommands $) "FunctionName"}}
+      {{if (Macro "IsFunctionSupported" $f)}}
+        {{if not (Macro "IsDeviceDispatched" $f)}}
+          "{{$f.Name}}",
+        {{end}}
+      {{end}}
+    {{end}}
+  };
+  // clang-format on
+  constexpr size_t count = sizeof(known_non_device_names) /
+    sizeof(known_non_device_names[0]);
+  if (!pName ||
+      std::binary_search(
+        known_non_device_names, known_non_device_names + count, pName,
+        [](const char* a, const char* b) { return (strcmp(a, b) < 0); })) {
+    ALOGE("vkGetDeviceProcAddr called with %s", pName);
+    return nullptr;
+  }
+  // clang-format off
+  ¶
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emits code to dispatch a function.
+------------------------------------------------------------------------------
+*/}}
+{{define "api.C++.Dispatch"}}
+  {{AssertType $ "Function"}}
+
+  {{if (Macro "api.IsIntercepted" $)}}// call into api.cpp{{end}}
+  {{if not (IsVoid $.Return.Type)}}return §{{end}}
+
+  {{if (Macro "api.IsIntercepted" $)}}
+    vulkan::api::§
+  {{else}}
+    {{$p0 := index $.CallParameters 0}}
+    vulkan::api::GetData({{$p0.Name}}).dispatch.§
+  {{end}}
+
+  {{Macro "BaseName" $}}({{Macro "Arguments" $}});
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  Emits a function/extension name without the "vk"/"VK_" prefix.
+-------------------------------------------------------------------------------
+*/}}
+{{define "BaseName"}}
+  {{     if IsFunction $}}{{TrimPrefix "vk" $.Name}}
+  {{else if eq $.Name "extension"}}{{TrimPrefix "VK_" (index $.Arguments 0)}}
+  {{else}}{{Error "invalid use of BaseName"}}
+  {{end}}
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+  Emits a comma-separated list of C parameter names for the given command.
+-------------------------------------------------------------------------------
+*/}}
+{{define "Arguments"}}
+  {{AssertType $ "Function"}}
+
+  {{ForEach $.CallParameters "ParameterName" | JoinWith ", "}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+------------------------------------------------------------------------------
+*/}}
+{{define "IsGloballyDispatched"}}
+  {{AssertType $ "Function"}}
+  {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Global")}}
+    true
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emit "true" for supported functions that undergo table dispatch. Only global
+  functions and functions handled in the loader top without calling into
+  lower layers are not dispatched.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsInstanceDispatched"}}
+  {{AssertType $ "Function"}}
+  {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Instance")}}
+    true
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emit "true" for supported functions that can have device-specific dispatch.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsDeviceDispatched"}}
+  {{AssertType $ "Function"}}
+  {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Device")}}
+    true
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emit "true" if a function is core or from a supportable extension.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsFunctionSupported"}}
+  {{AssertType $ "Function"}}
+  {{if not (GetAnnotation $ "pfn")}}
+    {{$ext := GetAnnotation $ "extension"}}
+    {{if not $ext}}true
+    {{else if not (Macro "IsExtensionBlacklisted" $ext)}}true
+    {{end}}
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Decides whether a function should be exported from the Android Vulkan
+  library. Functions in the core API and in loader extensions are exported.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsFunctionExported"}}
+  {{AssertType $ "Function"}}
+
+  {{if (Macro "IsFunctionSupported" $)}}
+    {{$ext := GetAnnotation $ "extension"}}
+    {{if $ext}}
+      {{Macro "IsExtensionExported" $ext}}
+    {{else}}
+      true
+    {{end}}
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Emit "true" if an extension is unsupportable on Android.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsExtensionBlacklisted"}}
+  {{$ext := index $.Arguments 0}}
+  {{     if eq $ext "VK_KHR_display"}}true
+  {{else if eq $ext "VK_KHR_display_swapchain"}}true
+  {{else if eq $ext "VK_KHR_xlib_surface"}}true
+  {{else if eq $ext "VK_KHR_xcb_surface"}}true
+  {{else if eq $ext "VK_KHR_wayland_surface"}}true
+  {{else if eq $ext "VK_KHR_mir_surface"}}true
+  {{else if eq $ext "VK_KHR_win32_surface"}}true
+  {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+  Reports whether an extension is implemented entirely by the loader,
+  so drivers should not enumerate it.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsExtensionExported"}}
+  {{$ext := index $.Arguments 0}}
+  {{     if eq $ext "VK_KHR_surface"}}true
+  {{else if eq $ext "VK_KHR_swapchain"}}true
+  {{else if eq $ext "VK_KHR_android_surface"}}true
+  {{end}}
+{{end}}
diff --git a/vulkan/libvulkan/dispatch.tmpl b/vulkan/libvulkan/dispatch.tmpl
index 0a0338e..67ead4a 100644
--- a/vulkan/libvulkan/dispatch.tmpl
+++ b/vulkan/libvulkan/dispatch.tmpl
@@ -44,32 +44,11 @@
 ¶
 // WARNING: This file is generated. See ../README.md for instructions.
 ¶
-#define VK_USE_PLATFORM_ANDROID_KHR
 #include <vulkan/vk_android_native_buffer.h>
 #include <vulkan/vulkan.h>
 ¶
 namespace vulkan {
 ¶
-struct InstanceDispatchTable {«
-  // clang-format off
-  {{range $f := AllCommands $}}
-    {{if (Macro "IsInstanceDispatched" $f)}}
-      {{Macro "FunctionPtrName" $f}} {{Macro "BaseName" $f}};
-    {{end}}
-  {{end}}
-  // clang-format on
-»};
-¶
-struct DeviceDispatchTable {«
-  // clang-format off
-  {{range $f := AllCommands $}}
-    {{if (Macro "IsDeviceDispatched" $f)}}
-      {{Macro "FunctionPtrName" $f}} {{Macro "BaseName" $f}};
-    {{end}}
-  {{end}}
-  // clang-format on
-»};
-¶
 struct DriverDispatchTable {«
   // clang-format off
   {{range $f := AllCommands $}}
@@ -82,6 +61,10 @@
 
     PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
 
+    PFN_vkDestroyDevice DestroyDevice;
+    PFN_vkGetDeviceQueue GetDeviceQueue;
+    PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
+
     {{/* TODO(jessehall): Needed by swapchain code. Figure out a better way of
          handling this that avoids the special case. Probably should rework
          things so the driver dispatch table has all driver functions. Probably
@@ -156,40 +139,6 @@
     return Lookup(name, procs, procs + N);
 }
 ¶
-const NameProc kLoaderExportProcs[] = {«
-    // clang-format off
-  {{range $f := SortBy (AllCommands $) "FunctionName"}}
-    {{if (Macro "IsExported" $f)}}
-      {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>({{$f.Name}})},
-    {{end}}
-  {{end}}
-    // clang-format on
-»};
-¶
-const NameProc kLoaderGlobalProcs[] = {«
-    // clang-format off
-  {{range $f := SortBy (AllCommands $) "FunctionName"}}
-    {{if and (Macro "HasLoaderTopImpl" $f) (eq (Macro "Vtbl" $f) "Global")}}
-      {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§
-        static_cast<{{Macro "FunctionPtrName" $f}}>(§
-          {{Macro "BaseName" $f}}_Top))},
-    {{end}}
-  {{end}}
-    // clang-format on
-»};
-¶
-const NameProc kLoaderTopProcs[] = {«
-    // clang-format off
-  {{range $f := SortBy (AllCommands $) "FunctionName"}}
-    {{if (Macro "HasLoaderTopImpl" $f)}}
-      {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§
-        static_cast<{{Macro "FunctionPtrName" $f}}>(§
-          {{Macro "BaseName" $f}}_Top))},
-    {{end}}
-  {{end}}
-    // clang-format on
-»};
-¶
 const NameProc kLoaderBottomProcs[] = {«
     // clang-format off
   {{range $f := SortBy (AllCommands $) "FunctionName"}}
@@ -202,125 +151,14 @@
     // clang-format on
 »};
 ¶
-struct NameOffset {
-    const char* name;
-    size_t offset;
-};
-¶
-ssize_t Lookup(const char* name,
-               const NameOffset* begin,
-               const NameOffset* end) {
-    const auto& entry = std::lower_bound(
-        begin, end, name, [](const NameOffset& e, const char* n) {
-            return strcmp(e.name, n) < 0;
-        });
-    if (entry == end || strcmp(entry->name, name) != 0)
-        return -1;
-    return static_cast<ssize_t>(entry->offset);
-}
-¶
-template <size_t N, class Table>
-PFN_vkVoidFunction Lookup(const char* name,
-                          const NameOffset (&offsets)[N],
-                          const Table& table) {
-    ssize_t offset = Lookup(name, offsets, offsets + N);
-    if (offset < 0)
-        return nullptr;
-    uintptr_t base = reinterpret_cast<uintptr_t>(&table);
-    return *reinterpret_cast<PFN_vkVoidFunction*>(base +
-                                                  static_cast<size_t>(offset));
-}
-¶
-const NameOffset kInstanceDispatchOffsets[] = {«
-  // clang-format off
-  {{range $f := SortBy (AllCommands $) "FunctionName"}}
-    {{if (Macro "IsInstanceDispatched" $f)}}
-      {"{{$f.Name}}", offsetof(InstanceDispatchTable, {{Macro "BaseName" $f}})},
-    {{end}}
-  {{end}}
-  // clang-format on
-»};
-¶
-const NameOffset kDeviceDispatchOffsets[] = {«
-  // clang-format off
-  {{range $f := SortBy (AllCommands $) "FunctionName"}}
-    {{if (Macro "IsDeviceDispatched" $f)}}
-      {"{{$f.Name}}", offsetof(DeviceDispatchTable, {{Macro "BaseName" $f}})},
-    {{end}}
-  {{end}}
-  // clang-format on
-»};
-¶
 } // anonymous namespace
 ¶
 namespace vulkan {
 ¶
-PFN_vkVoidFunction GetLoaderExportProcAddr(const char* name) {
-    return Lookup(name, kLoaderExportProcs);
-}
-¶
-PFN_vkVoidFunction GetLoaderGlobalProcAddr(const char* name) {
-    return Lookup(name, kLoaderGlobalProcs);
-}
-¶
-PFN_vkVoidFunction GetLoaderTopProcAddr(const char* name) {
-    return Lookup(name, kLoaderTopProcs);
-}
-¶
 PFN_vkVoidFunction GetLoaderBottomProcAddr(const char* name) {
     return Lookup(name, kLoaderBottomProcs);
 }
 ¶
-PFN_vkVoidFunction GetDispatchProcAddr(const InstanceDispatchTable& dispatch,
-                                       const char* name) {
-    return Lookup(name, kInstanceDispatchOffsets, dispatch);
-}
-¶
-PFN_vkVoidFunction GetDispatchProcAddr(const DeviceDispatchTable& dispatch,
-                                       const char* name) {
-    return Lookup(name, kDeviceDispatchOffsets, dispatch);
-}
-¶
-bool LoadInstanceDispatchTable(VkInstance instance,
-                               PFN_vkGetInstanceProcAddr get_proc_addr,
-                               InstanceDispatchTable& dispatch) {«
-    bool success = true;
-    // clang-format off
-  {{range $f := AllCommands $}}
-    {{if (Macro "IsInstanceDispatched" $f)}}
-    dispatch.{{Macro "BaseName" $f}} = §
-        reinterpret_cast<{{Macro "FunctionPtrName" $f}}>(§
-            get_proc_addr(instance, "{{$f.Name}}"));
-    if (UNLIKELY(!dispatch.{{Macro "BaseName" $f}})) {
-        ALOGE("missing instance proc: %s", "{{$f.Name}}");
-        success = false;
-    }
-    {{end}}
-  {{end}}
-    // clang-format on
-    return success;
-»}
-¶
-bool LoadDeviceDispatchTable(VkDevice device,
-                             PFN_vkGetDeviceProcAddr get_proc_addr,
-                             DeviceDispatchTable& dispatch) {«
-    bool success = true;
-    // clang-format off
-  {{range $f := AllCommands $}}
-    {{if (Macro "IsDeviceDispatched" $f)}}
-    dispatch.{{Macro "BaseName" $f}} = §
-        reinterpret_cast<{{Macro "FunctionPtrName" $f}}>(§
-            get_proc_addr(device, "{{$f.Name}}"));
-    if (UNLIKELY(!dispatch.{{Macro "BaseName" $f}})) {
-        ALOGE("missing device proc: %s", "{{$f.Name}}");
-        success = false;
-    }
-    {{end}}
-  {{end}}
-    // clang-format on
-    return success;
-»}
-¶
 bool LoadDriverDispatchTable(VkInstance instance,
                              PFN_vkGetInstanceProcAddr get_proc_addr,
                              const InstanceExtensionSet& extensions,
@@ -352,6 +190,21 @@
         ALOGE("missing driver proc: %s", "vkGetDeviceProcAddr");
         success = false;
     }
+    dispatch.DestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(get_proc_addr(instance, "vkDestroyDevice"));
+    if (UNLIKELY(!dispatch.DestroyDevice)) {
+        ALOGE("missing driver proc: %s", "vkDestroyDevice");
+        success = false;
+    }
+    dispatch.GetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(get_proc_addr(instance, "vkGetDeviceQueue"));
+    if (UNLIKELY(!dispatch.GetDeviceQueue)) {
+        ALOGE("missing driver proc: %s", "vkGetDeviceQueue");
+        success = false;
+    }
+    dispatch.AllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(get_proc_addr(instance, "vkAllocateCommandBuffers"));
+    if (UNLIKELY(!dispatch.AllocateCommandBuffers)) {
+        ALOGE("missing driver proc: %s", "vkAllocateCommandBuffers");
+        success = false;
+    }
     dispatch.CreateImage = reinterpret_cast<PFN_vkCreateImage>(get_proc_addr(instance, "vkCreateImage"));
     if (UNLIKELY(!dispatch.CreateImage)) {
         ALOGE("missing driver proc: %s", "vkCreateImage");
@@ -382,43 +235,11 @@
 »}
 ¶
 } // namespace vulkan
-¶
-// clang-format off
-¶
-{{range $f := AllCommands $}}
-  {{if and (not (GetAnnotation $f "pfn")) (Macro "IsExported" $f)}}
-    __attribute__((visibility("default")))
-    VKAPI_ATTR {{Node "Type" $f.Return}} {{$f.Name}}({{Macro "Parameters" $f}}) {
-      {{if not (IsVoid $f.Return.Type)}}return §{{end}}
-      {{Macro "Dispatch" $f}}({{Macro "Arguments" $f}});
-    }
-    ¶
-  {{end}}
-{{end}}
-¶
-// clang-format on
 ¶{{end}}
 
 
 {{/*
 -------------------------------------------------------------------------------
-  Emit the dispatch lookup for a function based on its first parameter.
--------------------------------------------------------------------------------
-*/}}
-{{define "Dispatch"}}
-  {{AssertType $ "Function"}}
-
-  {{if (Macro "HasLoaderTopImpl" $)}}
-    {{Macro "BaseName" $}}_Top§
-  {{else}}
-    {{$p0 := index $.CallParameters 0}}
-    GetDispatchTable({{$p0.Name}}).{{Macro "BaseName" $}}§
-  {{end}}
-{{end}}
-
-
-{{/*
--------------------------------------------------------------------------------
   Map an extension name to InstanceExtension or DeviceExtension enum value
 -------------------------------------------------------------------------------
 */}}
@@ -443,18 +264,6 @@
 
 
 {{/*
--------------------------------------------------------------------------------
-  Emits a comma-separated list of C parameter names for the given command.
--------------------------------------------------------------------------------
-*/}}
-{{define "Arguments"}}
-  {{AssertType $ "Function"}}
-
-  {{ForEach $.CallParameters "ParameterName" | JoinWith ", "}}
-{{end}}
-
-
-{{/*
 ------------------------------------------------------------------------------
   Emit "true" for supported functions that undergo table dispatch. Only global
   functions and functions handled in the loader top without calling into
@@ -471,23 +280,6 @@
 
 {{/*
 ------------------------------------------------------------------------------
-  Emit "true" for supported functions that can have device-specific dispatch.
-------------------------------------------------------------------------------
-*/}}
-{{define "IsDeviceDispatched"}}
-  {{AssertType $ "Function"}}
-  {{if (Macro "IsFunctionSupported" $)}}
-    {{if eq (Macro "Vtbl" $) "Device"}}
-      {{if ne $.Name "vkGetDeviceProcAddr"}}
-        true
-      {{end}}
-    {{end}}
-  {{end}}
-{{end}}
-
-
-{{/*
-------------------------------------------------------------------------------
   Emit "true" if a function is core or from a supportable extension.
 ------------------------------------------------------------------------------
 */}}
@@ -504,26 +296,6 @@
 
 {{/*
 ------------------------------------------------------------------------------
-  Decides whether a function should be exported from the Android Vulkan
-  library. Functions in the core API and in loader extensions are exported.
-------------------------------------------------------------------------------
-*/}}
-{{define "IsExported"}}
-  {{AssertType $ "Function"}}
-
-  {{if (Macro "IsFunctionSupported" $)}}
-    {{$ext := GetAnnotation $ "extension"}}
-    {{if $ext}}
-      {{Macro "IsLoaderExtension" $ext}}
-    {{else}}
-      true
-    {{end}}
-  {{end}}
-{{end}}
-
-
-{{/*
-------------------------------------------------------------------------------
   Reports whether an extension function is implemented entirely by the loader,
   and not implemented by drivers.
 ------------------------------------------------------------------------------
@@ -540,40 +312,6 @@
 
 {{/*
 -------------------------------------------------------------------------------
-  Emit "true" if the loader has a top-level implementation for the function
-  that should be called directly rather than dispatching to the first layer.
--------------------------------------------------------------------------------
-*/}}
-{{define "HasLoaderTopImpl"}}
-  {{AssertType $ "Function"}}
-
-  {{/* Global functions can't be dispatched */}}
-  {{     if and (not (GetAnnotation $ "pfn")) (eq (Macro "Vtbl" $) "Global")}}true
-
-  {{/* G*PA are implemented by reading the dispatch table, not by dispatching
-       through it. */}}
-  {{else if eq $.Name "vkGetInstanceProcAddr"}}true
-  {{else if eq $.Name "vkGetDeviceProcAddr"}}true
-
-  {{/* Loader top needs to initialize dispatch for device-level dispatchable
-       objects */}}
-  {{else if eq $.Name "vkGetDeviceQueue"}}true
-  {{else if eq $.Name "vkAllocateCommandBuffers"}}true
-  {{else if eq $.Name "vkCreateDevice"}}true
-  {{else if eq $.Name "vkEnumerateDeviceLayerProperties"}}true
-  {{else if eq $.Name "vkEnumerateDeviceExtensionProperties"}}true
-
-  {{/* vkDestroy for dispatchable objects needs to handle VK_NULL_HANDLE;
-       trying to dispatch through that would crash. */}}
-  {{else if eq $.Name "vkDestroyInstance"}}true
-  {{else if eq $.Name "vkDestroyDevice"}}true
-
-  {{end}}
-{{end}}
-
-
-{{/*
--------------------------------------------------------------------------------
   Emit "true" if the loader has a bottom-level implementation for the function
   which terminates the dispatch chain.
 -------------------------------------------------------------------------------
@@ -586,6 +324,9 @@
     {{else if (Macro "IsLoaderFunction" $)}}true
     {{else if (eq $.Name "vkCreateInstance")}}true
     {{else if (eq $.Name "vkGetDeviceProcAddr")}}true
+    {{else if (eq $.Name "vkDestroyDevice")}}true
+    {{else if (eq $.Name "vkGetDeviceQueue")}}true
+    {{else if (eq $.Name "vkAllocateCommandBuffers")}}true
     {{end}}
   {{end}}
 {{end}}
diff --git a/vulkan/libvulkan/dispatch_gen.cpp b/vulkan/libvulkan/dispatch_gen.cpp
index b41efb8..eacf1a1 100644
--- a/vulkan/libvulkan/dispatch_gen.cpp
+++ b/vulkan/libvulkan/dispatch_gen.cpp
@@ -47,187 +47,10 @@
     return Lookup(name, procs, procs + N);
 }
 
-const NameProc kLoaderExportProcs[] = {
-    // clang-format off
-    {"vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR)},
-    {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateCommandBuffers)},
-    {"vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateDescriptorSets)},
-    {"vkAllocateMemory", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateMemory)},
-    {"vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkBeginCommandBuffer)},
-    {"vkBindBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory)},
-    {"vkBindImageMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory)},
-    {"vkCmdBeginQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginQuery)},
-    {"vkCmdBeginRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass)},
-    {"vkCmdBindDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets)},
-    {"vkCmdBindIndexBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer)},
-    {"vkCmdBindPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindPipeline)},
-    {"vkCmdBindVertexBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers)},
-    {"vkCmdBlitImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage)},
-    {"vkCmdClearAttachments", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearAttachments)},
-    {"vkCmdClearColorImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearColorImage)},
-    {"vkCmdClearDepthStencilImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearDepthStencilImage)},
-    {"vkCmdCopyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer)},
-    {"vkCmdCopyBufferToImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage)},
-    {"vkCmdCopyImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage)},
-    {"vkCmdCopyImageToBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer)},
-    {"vkCmdCopyQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyQueryPoolResults)},
-    {"vkCmdDispatch", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatch)},
-    {"vkCmdDispatchIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchIndirect)},
-    {"vkCmdDraw", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDraw)},
-    {"vkCmdDrawIndexed", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexed)},
-    {"vkCmdDrawIndexedIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirect)},
-    {"vkCmdDrawIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirect)},
-    {"vkCmdEndQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndQuery)},
-    {"vkCmdEndRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass)},
-    {"vkCmdExecuteCommands", reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteCommands)},
-    {"vkCmdFillBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdFillBuffer)},
-    {"vkCmdNextSubpass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass)},
-    {"vkCmdPipelineBarrier", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier)},
-    {"vkCmdPushConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants)},
-    {"vkCmdResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent)},
-    {"vkCmdResetQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetQueryPool)},
-    {"vkCmdResolveImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage)},
-    {"vkCmdSetBlendConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetBlendConstants)},
-    {"vkCmdSetDepthBias", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBias)},
-    {"vkCmdSetDepthBounds", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBounds)},
-    {"vkCmdSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent)},
-    {"vkCmdSetLineWidth", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineWidth)},
-    {"vkCmdSetScissor", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissor)},
-    {"vkCmdSetStencilCompareMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilCompareMask)},
-    {"vkCmdSetStencilReference", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilReference)},
-    {"vkCmdSetStencilWriteMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilWriteMask)},
-    {"vkCmdSetViewport", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewport)},
-    {"vkCmdUpdateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdUpdateBuffer)},
-    {"vkCmdWaitEvents", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents)},
-    {"vkCmdWriteTimestamp", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp)},
-    {"vkCreateAndroidSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateAndroidSurfaceKHR)},
-    {"vkCreateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBuffer)},
-    {"vkCreateBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBufferView)},
-    {"vkCreateCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateCommandPool)},
-    {"vkCreateComputePipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateComputePipelines)},
-    {"vkCreateDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorPool)},
-    {"vkCreateDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorSetLayout)},
-    {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDevice)},
-    {"vkCreateEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCreateEvent)},
-    {"vkCreateFence", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFence)},
-    {"vkCreateFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFramebuffer)},
-    {"vkCreateGraphicsPipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateGraphicsPipelines)},
-    {"vkCreateImage", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImage)},
-    {"vkCreateImageView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImageView)},
-    {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(vkCreateInstance)},
-    {"vkCreatePipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineCache)},
-    {"vkCreatePipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineLayout)},
-    {"vkCreateQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateQueryPool)},
-    {"vkCreateRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass)},
-    {"vkCreateSampler", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSampler)},
-    {"vkCreateSemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSemaphore)},
-    {"vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkCreateShaderModule)},
-    {"vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR)},
-    {"vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBuffer)},
-    {"vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferView)},
-    {"vkDestroyCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCommandPool)},
-    {"vkDestroyDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorPool)},
-    {"vkDestroyDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorSetLayout)},
-    {"vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDevice)},
-    {"vkDestroyEvent", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyEvent)},
-    {"vkDestroyFence", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFence)},
-    {"vkDestroyFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFramebuffer)},
-    {"vkDestroyImage", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImage)},
-    {"vkDestroyImageView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImageView)},
-    {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyInstance)},
-    {"vkDestroyPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipeline)},
-    {"vkDestroyPipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineCache)},
-    {"vkDestroyPipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineLayout)},
-    {"vkDestroyQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyQueryPool)},
-    {"vkDestroyRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyRenderPass)},
-    {"vkDestroySampler", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySampler)},
-    {"vkDestroySemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySemaphore)},
-    {"vkDestroyShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderModule)},
-    {"vkDestroySurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySurfaceKHR)},
-    {"vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR)},
-    {"vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkDeviceWaitIdle)},
-    {"vkEndCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkEndCommandBuffer)},
-    {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateDeviceExtensionProperties)},
-    {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateDeviceLayerProperties)},
-    {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateInstanceExtensionProperties)},
-    {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateInstanceLayerProperties)},
-    {"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDevices)},
-    {"vkFlushMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkFlushMappedMemoryRanges)},
-    {"vkFreeCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkFreeCommandBuffers)},
-    {"vkFreeDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkFreeDescriptorSets)},
-    {"vkFreeMemory", reinterpret_cast<PFN_vkVoidFunction>(vkFreeMemory)},
-    {"vkGetBufferMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferMemoryRequirements)},
-    {"vkGetDeviceMemoryCommitment", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryCommitment)},
-    {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceProcAddr)},
-    {"vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceQueue)},
-    {"vkGetEventStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetEventStatus)},
-    {"vkGetFenceStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceStatus)},
-    {"vkGetImageMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements)},
-    {"vkGetImageSparseMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements)},
-    {"vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout)},
-    {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetInstanceProcAddr)},
-    {"vkGetPhysicalDeviceFeatures", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFeatures)},
-    {"vkGetPhysicalDeviceFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFormatProperties)},
-    {"vkGetPhysicalDeviceImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceImageFormatProperties)},
-    {"vkGetPhysicalDeviceMemoryProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMemoryProperties)},
-    {"vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties)},
-    {"vkGetPhysicalDeviceQueueFamilyProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyProperties)},
-    {"vkGetPhysicalDeviceSparseImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSparseImageFormatProperties)},
-    {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)},
-    {"vkGetPhysicalDeviceSurfaceFormatsKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceFormatsKHR)},
-    {"vkGetPhysicalDeviceSurfacePresentModesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfacePresentModesKHR)},
-    {"vkGetPhysicalDeviceSurfaceSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceSupportKHR)},
-    {"vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData)},
-    {"vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults)},
-    {"vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity)},
-    {"vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR)},
-    {"vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges)},
-    {"vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory)},
-    {"vkMergePipelineCaches", reinterpret_cast<PFN_vkVoidFunction>(vkMergePipelineCaches)},
-    {"vkQueueBindSparse", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparse)},
-    {"vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR)},
-    {"vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit)},
-    {"vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitIdle)},
-    {"vkResetCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandBuffer)},
-    {"vkResetCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandPool)},
-    {"vkResetDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetDescriptorPool)},
-    {"vkResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkResetEvent)},
-    {"vkResetFences", reinterpret_cast<PFN_vkVoidFunction>(vkResetFences)},
-    {"vkSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkSetEvent)},
-    {"vkUnmapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory)},
-    {"vkUpdateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSets)},
-    {"vkWaitForFences", reinterpret_cast<PFN_vkVoidFunction>(vkWaitForFences)},
-    // clang-format on
-};
-
-const NameProc kLoaderGlobalProcs[] = {
-    // clang-format off
-    {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateInstance>(CreateInstance_Top))},
-    {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceExtensionProperties>(EnumerateInstanceExtensionProperties_Top))},
-    {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceLayerProperties>(EnumerateInstanceLayerProperties_Top))},
-    // clang-format on
-};
-
-const NameProc kLoaderTopProcs[] = {
-    // clang-format off
-    {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateCommandBuffers>(AllocateCommandBuffers_Top))},
-    {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateDevice>(CreateDevice_Top))},
-    {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateInstance>(CreateInstance_Top))},
-    {"vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyDevice>(DestroyDevice_Top))},
-    {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyInstance>(DestroyInstance_Top))},
-    {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceExtensionProperties>(EnumerateDeviceExtensionProperties_Top))},
-    {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceLayerProperties>(EnumerateDeviceLayerProperties_Top))},
-    {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceExtensionProperties>(EnumerateInstanceExtensionProperties_Top))},
-    {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceLayerProperties>(EnumerateInstanceLayerProperties_Top))},
-    {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetDeviceProcAddr>(GetDeviceProcAddr_Top))},
-    {"vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetDeviceQueue>(GetDeviceQueue_Top))},
-    {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetInstanceProcAddr>(GetInstanceProcAddr_Top))},
-    // clang-format on
-};
-
 const NameProc kLoaderBottomProcs[] = {
     // clang-format off
     {"vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAcquireNextImageKHR>(AcquireNextImageKHR_Bottom))},
+    {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateCommandBuffers>(AllocateCommandBuffers_Bottom))},
     {"vkCreateAndroidSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateAndroidSurfaceKHR>(CreateAndroidSurfaceKHR_Bottom))},
     {"vkCreateDebugReportCallbackEXT", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateDebugReportCallbackEXT>(CreateDebugReportCallbackEXT_Bottom))},
     {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateDevice>(CreateDevice_Bottom))},
@@ -235,6 +58,7 @@
     {"vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateSwapchainKHR>(CreateSwapchainKHR_Bottom))},
     {"vkDebugReportMessageEXT", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDebugReportMessageEXT>(DebugReportMessageEXT_Bottom))},
     {"vkDestroyDebugReportCallbackEXT", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyDebugReportCallbackEXT>(DestroyDebugReportCallbackEXT_Bottom))},
+    {"vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyDevice>(DestroyDevice_Bottom))},
     {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyInstance>(DestroyInstance_Bottom))},
     {"vkDestroySurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroySurfaceKHR>(DestroySurfaceKHR_Bottom))},
     {"vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroySwapchainKHR>(DestroySwapchainKHR_Bottom))},
@@ -242,6 +66,7 @@
     {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceLayerProperties>(EnumerateDeviceLayerProperties_Bottom))},
     {"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumeratePhysicalDevices>(EnumeratePhysicalDevices_Bottom))},
     {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetDeviceProcAddr>(GetDeviceProcAddr_Bottom))},
+    {"vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetDeviceQueue>(GetDeviceQueue_Bottom))},
     {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetInstanceProcAddr>(GetInstanceProcAddr_Bottom))},
     {"vkGetPhysicalDeviceFeatures", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFeatures>(GetPhysicalDeviceFeatures_Bottom))},
     {"vkGetPhysicalDeviceFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFormatProperties>(GetPhysicalDeviceFormatProperties_Bottom))},
@@ -259,963 +84,14 @@
     // clang-format on
 };
 
-struct NameOffset {
-    const char* name;
-    size_t offset;
-};
-
-ssize_t Lookup(const char* name,
-               const NameOffset* begin,
-               const NameOffset* end) {
-    const auto& entry = std::lower_bound(
-        begin, end, name, [](const NameOffset& e, const char* n) {
-            return strcmp(e.name, n) < 0;
-        });
-    if (entry == end || strcmp(entry->name, name) != 0)
-        return -1;
-    return static_cast<ssize_t>(entry->offset);
-}
-
-template <size_t N, class Table>
-PFN_vkVoidFunction Lookup(const char* name,
-                          const NameOffset (&offsets)[N],
-                          const Table& table) {
-    ssize_t offset = Lookup(name, offsets, offsets + N);
-    if (offset < 0)
-        return nullptr;
-    uintptr_t base = reinterpret_cast<uintptr_t>(&table);
-    return *reinterpret_cast<PFN_vkVoidFunction*>(base +
-                                                  static_cast<size_t>(offset));
-}
-
-const NameOffset kInstanceDispatchOffsets[] = {
-    // clang-format off
-    {"vkCreateAndroidSurfaceKHR", offsetof(InstanceDispatchTable, CreateAndroidSurfaceKHR)},
-    {"vkCreateDebugReportCallbackEXT", offsetof(InstanceDispatchTable, CreateDebugReportCallbackEXT)},
-    {"vkCreateDevice", offsetof(InstanceDispatchTable, CreateDevice)},
-    {"vkDebugReportMessageEXT", offsetof(InstanceDispatchTable, DebugReportMessageEXT)},
-    {"vkDestroyDebugReportCallbackEXT", offsetof(InstanceDispatchTable, DestroyDebugReportCallbackEXT)},
-    {"vkDestroyInstance", offsetof(InstanceDispatchTable, DestroyInstance)},
-    {"vkDestroySurfaceKHR", offsetof(InstanceDispatchTable, DestroySurfaceKHR)},
-    {"vkEnumerateDeviceExtensionProperties", offsetof(InstanceDispatchTable, EnumerateDeviceExtensionProperties)},
-    {"vkEnumeratePhysicalDevices", offsetof(InstanceDispatchTable, EnumeratePhysicalDevices)},
-    {"vkGetPhysicalDeviceFeatures", offsetof(InstanceDispatchTable, GetPhysicalDeviceFeatures)},
-    {"vkGetPhysicalDeviceFormatProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceFormatProperties)},
-    {"vkGetPhysicalDeviceImageFormatProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceImageFormatProperties)},
-    {"vkGetPhysicalDeviceMemoryProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceMemoryProperties)},
-    {"vkGetPhysicalDeviceProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceProperties)},
-    {"vkGetPhysicalDeviceQueueFamilyProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceQueueFamilyProperties)},
-    {"vkGetPhysicalDeviceSparseImageFormatProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceSparseImageFormatProperties)},
-    {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", offsetof(InstanceDispatchTable, GetPhysicalDeviceSurfaceCapabilitiesKHR)},
-    {"vkGetPhysicalDeviceSurfaceFormatsKHR", offsetof(InstanceDispatchTable, GetPhysicalDeviceSurfaceFormatsKHR)},
-    {"vkGetPhysicalDeviceSurfacePresentModesKHR", offsetof(InstanceDispatchTable, GetPhysicalDeviceSurfacePresentModesKHR)},
-    {"vkGetPhysicalDeviceSurfaceSupportKHR", offsetof(InstanceDispatchTable, GetPhysicalDeviceSurfaceSupportKHR)},
-    // clang-format on
-};
-
-const NameOffset kDeviceDispatchOffsets[] = {
-    // clang-format off
-    {"vkAcquireNextImageKHR", offsetof(DeviceDispatchTable, AcquireNextImageKHR)},
-    {"vkAllocateCommandBuffers", offsetof(DeviceDispatchTable, AllocateCommandBuffers)},
-    {"vkAllocateDescriptorSets", offsetof(DeviceDispatchTable, AllocateDescriptorSets)},
-    {"vkAllocateMemory", offsetof(DeviceDispatchTable, AllocateMemory)},
-    {"vkBeginCommandBuffer", offsetof(DeviceDispatchTable, BeginCommandBuffer)},
-    {"vkBindBufferMemory", offsetof(DeviceDispatchTable, BindBufferMemory)},
-    {"vkBindImageMemory", offsetof(DeviceDispatchTable, BindImageMemory)},
-    {"vkCmdBeginQuery", offsetof(DeviceDispatchTable, CmdBeginQuery)},
-    {"vkCmdBeginRenderPass", offsetof(DeviceDispatchTable, CmdBeginRenderPass)},
-    {"vkCmdBindDescriptorSets", offsetof(DeviceDispatchTable, CmdBindDescriptorSets)},
-    {"vkCmdBindIndexBuffer", offsetof(DeviceDispatchTable, CmdBindIndexBuffer)},
-    {"vkCmdBindPipeline", offsetof(DeviceDispatchTable, CmdBindPipeline)},
-    {"vkCmdBindVertexBuffers", offsetof(DeviceDispatchTable, CmdBindVertexBuffers)},
-    {"vkCmdBlitImage", offsetof(DeviceDispatchTable, CmdBlitImage)},
-    {"vkCmdClearAttachments", offsetof(DeviceDispatchTable, CmdClearAttachments)},
-    {"vkCmdClearColorImage", offsetof(DeviceDispatchTable, CmdClearColorImage)},
-    {"vkCmdClearDepthStencilImage", offsetof(DeviceDispatchTable, CmdClearDepthStencilImage)},
-    {"vkCmdCopyBuffer", offsetof(DeviceDispatchTable, CmdCopyBuffer)},
-    {"vkCmdCopyBufferToImage", offsetof(DeviceDispatchTable, CmdCopyBufferToImage)},
-    {"vkCmdCopyImage", offsetof(DeviceDispatchTable, CmdCopyImage)},
-    {"vkCmdCopyImageToBuffer", offsetof(DeviceDispatchTable, CmdCopyImageToBuffer)},
-    {"vkCmdCopyQueryPoolResults", offsetof(DeviceDispatchTable, CmdCopyQueryPoolResults)},
-    {"vkCmdDispatch", offsetof(DeviceDispatchTable, CmdDispatch)},
-    {"vkCmdDispatchIndirect", offsetof(DeviceDispatchTable, CmdDispatchIndirect)},
-    {"vkCmdDraw", offsetof(DeviceDispatchTable, CmdDraw)},
-    {"vkCmdDrawIndexed", offsetof(DeviceDispatchTable, CmdDrawIndexed)},
-    {"vkCmdDrawIndexedIndirect", offsetof(DeviceDispatchTable, CmdDrawIndexedIndirect)},
-    {"vkCmdDrawIndirect", offsetof(DeviceDispatchTable, CmdDrawIndirect)},
-    {"vkCmdEndQuery", offsetof(DeviceDispatchTable, CmdEndQuery)},
-    {"vkCmdEndRenderPass", offsetof(DeviceDispatchTable, CmdEndRenderPass)},
-    {"vkCmdExecuteCommands", offsetof(DeviceDispatchTable, CmdExecuteCommands)},
-    {"vkCmdFillBuffer", offsetof(DeviceDispatchTable, CmdFillBuffer)},
-    {"vkCmdNextSubpass", offsetof(DeviceDispatchTable, CmdNextSubpass)},
-    {"vkCmdPipelineBarrier", offsetof(DeviceDispatchTable, CmdPipelineBarrier)},
-    {"vkCmdPushConstants", offsetof(DeviceDispatchTable, CmdPushConstants)},
-    {"vkCmdResetEvent", offsetof(DeviceDispatchTable, CmdResetEvent)},
-    {"vkCmdResetQueryPool", offsetof(DeviceDispatchTable, CmdResetQueryPool)},
-    {"vkCmdResolveImage", offsetof(DeviceDispatchTable, CmdResolveImage)},
-    {"vkCmdSetBlendConstants", offsetof(DeviceDispatchTable, CmdSetBlendConstants)},
-    {"vkCmdSetDepthBias", offsetof(DeviceDispatchTable, CmdSetDepthBias)},
-    {"vkCmdSetDepthBounds", offsetof(DeviceDispatchTable, CmdSetDepthBounds)},
-    {"vkCmdSetEvent", offsetof(DeviceDispatchTable, CmdSetEvent)},
-    {"vkCmdSetLineWidth", offsetof(DeviceDispatchTable, CmdSetLineWidth)},
-    {"vkCmdSetScissor", offsetof(DeviceDispatchTable, CmdSetScissor)},
-    {"vkCmdSetStencilCompareMask", offsetof(DeviceDispatchTable, CmdSetStencilCompareMask)},
-    {"vkCmdSetStencilReference", offsetof(DeviceDispatchTable, CmdSetStencilReference)},
-    {"vkCmdSetStencilWriteMask", offsetof(DeviceDispatchTable, CmdSetStencilWriteMask)},
-    {"vkCmdSetViewport", offsetof(DeviceDispatchTable, CmdSetViewport)},
-    {"vkCmdUpdateBuffer", offsetof(DeviceDispatchTable, CmdUpdateBuffer)},
-    {"vkCmdWaitEvents", offsetof(DeviceDispatchTable, CmdWaitEvents)},
-    {"vkCmdWriteTimestamp", offsetof(DeviceDispatchTable, CmdWriteTimestamp)},
-    {"vkCreateBuffer", offsetof(DeviceDispatchTable, CreateBuffer)},
-    {"vkCreateBufferView", offsetof(DeviceDispatchTable, CreateBufferView)},
-    {"vkCreateCommandPool", offsetof(DeviceDispatchTable, CreateCommandPool)},
-    {"vkCreateComputePipelines", offsetof(DeviceDispatchTable, CreateComputePipelines)},
-    {"vkCreateDescriptorPool", offsetof(DeviceDispatchTable, CreateDescriptorPool)},
-    {"vkCreateDescriptorSetLayout", offsetof(DeviceDispatchTable, CreateDescriptorSetLayout)},
-    {"vkCreateEvent", offsetof(DeviceDispatchTable, CreateEvent)},
-    {"vkCreateFence", offsetof(DeviceDispatchTable, CreateFence)},
-    {"vkCreateFramebuffer", offsetof(DeviceDispatchTable, CreateFramebuffer)},
-    {"vkCreateGraphicsPipelines", offsetof(DeviceDispatchTable, CreateGraphicsPipelines)},
-    {"vkCreateImage", offsetof(DeviceDispatchTable, CreateImage)},
-    {"vkCreateImageView", offsetof(DeviceDispatchTable, CreateImageView)},
-    {"vkCreatePipelineCache", offsetof(DeviceDispatchTable, CreatePipelineCache)},
-    {"vkCreatePipelineLayout", offsetof(DeviceDispatchTable, CreatePipelineLayout)},
-    {"vkCreateQueryPool", offsetof(DeviceDispatchTable, CreateQueryPool)},
-    {"vkCreateRenderPass", offsetof(DeviceDispatchTable, CreateRenderPass)},
-    {"vkCreateSampler", offsetof(DeviceDispatchTable, CreateSampler)},
-    {"vkCreateSemaphore", offsetof(DeviceDispatchTable, CreateSemaphore)},
-    {"vkCreateShaderModule", offsetof(DeviceDispatchTable, CreateShaderModule)},
-    {"vkCreateSwapchainKHR", offsetof(DeviceDispatchTable, CreateSwapchainKHR)},
-    {"vkDestroyBuffer", offsetof(DeviceDispatchTable, DestroyBuffer)},
-    {"vkDestroyBufferView", offsetof(DeviceDispatchTable, DestroyBufferView)},
-    {"vkDestroyCommandPool", offsetof(DeviceDispatchTable, DestroyCommandPool)},
-    {"vkDestroyDescriptorPool", offsetof(DeviceDispatchTable, DestroyDescriptorPool)},
-    {"vkDestroyDescriptorSetLayout", offsetof(DeviceDispatchTable, DestroyDescriptorSetLayout)},
-    {"vkDestroyDevice", offsetof(DeviceDispatchTable, DestroyDevice)},
-    {"vkDestroyEvent", offsetof(DeviceDispatchTable, DestroyEvent)},
-    {"vkDestroyFence", offsetof(DeviceDispatchTable, DestroyFence)},
-    {"vkDestroyFramebuffer", offsetof(DeviceDispatchTable, DestroyFramebuffer)},
-    {"vkDestroyImage", offsetof(DeviceDispatchTable, DestroyImage)},
-    {"vkDestroyImageView", offsetof(DeviceDispatchTable, DestroyImageView)},
-    {"vkDestroyPipeline", offsetof(DeviceDispatchTable, DestroyPipeline)},
-    {"vkDestroyPipelineCache", offsetof(DeviceDispatchTable, DestroyPipelineCache)},
-    {"vkDestroyPipelineLayout", offsetof(DeviceDispatchTable, DestroyPipelineLayout)},
-    {"vkDestroyQueryPool", offsetof(DeviceDispatchTable, DestroyQueryPool)},
-    {"vkDestroyRenderPass", offsetof(DeviceDispatchTable, DestroyRenderPass)},
-    {"vkDestroySampler", offsetof(DeviceDispatchTable, DestroySampler)},
-    {"vkDestroySemaphore", offsetof(DeviceDispatchTable, DestroySemaphore)},
-    {"vkDestroyShaderModule", offsetof(DeviceDispatchTable, DestroyShaderModule)},
-    {"vkDestroySwapchainKHR", offsetof(DeviceDispatchTable, DestroySwapchainKHR)},
-    {"vkDeviceWaitIdle", offsetof(DeviceDispatchTable, DeviceWaitIdle)},
-    {"vkEndCommandBuffer", offsetof(DeviceDispatchTable, EndCommandBuffer)},
-    {"vkFlushMappedMemoryRanges", offsetof(DeviceDispatchTable, FlushMappedMemoryRanges)},
-    {"vkFreeCommandBuffers", offsetof(DeviceDispatchTable, FreeCommandBuffers)},
-    {"vkFreeDescriptorSets", offsetof(DeviceDispatchTable, FreeDescriptorSets)},
-    {"vkFreeMemory", offsetof(DeviceDispatchTable, FreeMemory)},
-    {"vkGetBufferMemoryRequirements", offsetof(DeviceDispatchTable, GetBufferMemoryRequirements)},
-    {"vkGetDeviceMemoryCommitment", offsetof(DeviceDispatchTable, GetDeviceMemoryCommitment)},
-    {"vkGetDeviceQueue", offsetof(DeviceDispatchTable, GetDeviceQueue)},
-    {"vkGetEventStatus", offsetof(DeviceDispatchTable, GetEventStatus)},
-    {"vkGetFenceStatus", offsetof(DeviceDispatchTable, GetFenceStatus)},
-    {"vkGetImageMemoryRequirements", offsetof(DeviceDispatchTable, GetImageMemoryRequirements)},
-    {"vkGetImageSparseMemoryRequirements", offsetof(DeviceDispatchTable, GetImageSparseMemoryRequirements)},
-    {"vkGetImageSubresourceLayout", offsetof(DeviceDispatchTable, GetImageSubresourceLayout)},
-    {"vkGetPipelineCacheData", offsetof(DeviceDispatchTable, GetPipelineCacheData)},
-    {"vkGetQueryPoolResults", offsetof(DeviceDispatchTable, GetQueryPoolResults)},
-    {"vkGetRenderAreaGranularity", offsetof(DeviceDispatchTable, GetRenderAreaGranularity)},
-    {"vkGetSwapchainImagesKHR", offsetof(DeviceDispatchTable, GetSwapchainImagesKHR)},
-    {"vkInvalidateMappedMemoryRanges", offsetof(DeviceDispatchTable, InvalidateMappedMemoryRanges)},
-    {"vkMapMemory", offsetof(DeviceDispatchTable, MapMemory)},
-    {"vkMergePipelineCaches", offsetof(DeviceDispatchTable, MergePipelineCaches)},
-    {"vkQueueBindSparse", offsetof(DeviceDispatchTable, QueueBindSparse)},
-    {"vkQueuePresentKHR", offsetof(DeviceDispatchTable, QueuePresentKHR)},
-    {"vkQueueSubmit", offsetof(DeviceDispatchTable, QueueSubmit)},
-    {"vkQueueWaitIdle", offsetof(DeviceDispatchTable, QueueWaitIdle)},
-    {"vkResetCommandBuffer", offsetof(DeviceDispatchTable, ResetCommandBuffer)},
-    {"vkResetCommandPool", offsetof(DeviceDispatchTable, ResetCommandPool)},
-    {"vkResetDescriptorPool", offsetof(DeviceDispatchTable, ResetDescriptorPool)},
-    {"vkResetEvent", offsetof(DeviceDispatchTable, ResetEvent)},
-    {"vkResetFences", offsetof(DeviceDispatchTable, ResetFences)},
-    {"vkSetEvent", offsetof(DeviceDispatchTable, SetEvent)},
-    {"vkUnmapMemory", offsetof(DeviceDispatchTable, UnmapMemory)},
-    {"vkUpdateDescriptorSets", offsetof(DeviceDispatchTable, UpdateDescriptorSets)},
-    {"vkWaitForFences", offsetof(DeviceDispatchTable, WaitForFences)},
-    // clang-format on
-};
-
 }  // anonymous namespace
 
 namespace vulkan {
 
-PFN_vkVoidFunction GetLoaderExportProcAddr(const char* name) {
-    return Lookup(name, kLoaderExportProcs);
-}
-
-PFN_vkVoidFunction GetLoaderGlobalProcAddr(const char* name) {
-    return Lookup(name, kLoaderGlobalProcs);
-}
-
-PFN_vkVoidFunction GetLoaderTopProcAddr(const char* name) {
-    return Lookup(name, kLoaderTopProcs);
-}
-
 PFN_vkVoidFunction GetLoaderBottomProcAddr(const char* name) {
     return Lookup(name, kLoaderBottomProcs);
 }
 
-PFN_vkVoidFunction GetDispatchProcAddr(const InstanceDispatchTable& dispatch,
-                                       const char* name) {
-    return Lookup(name, kInstanceDispatchOffsets, dispatch);
-}
-
-PFN_vkVoidFunction GetDispatchProcAddr(const DeviceDispatchTable& dispatch,
-                                       const char* name) {
-    return Lookup(name, kDeviceDispatchOffsets, dispatch);
-}
-
-bool LoadInstanceDispatchTable(VkInstance instance,
-                               PFN_vkGetInstanceProcAddr get_proc_addr,
-                               InstanceDispatchTable& dispatch) {
-    bool success = true;
-    // clang-format off
-    dispatch.DestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(get_proc_addr(instance, "vkDestroyInstance"));
-    if (UNLIKELY(!dispatch.DestroyInstance)) {
-        ALOGE("missing instance proc: %s", "vkDestroyInstance");
-        success = false;
-    }
-    dispatch.EnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(get_proc_addr(instance, "vkEnumeratePhysicalDevices"));
-    if (UNLIKELY(!dispatch.EnumeratePhysicalDevices)) {
-        ALOGE("missing instance proc: %s", "vkEnumeratePhysicalDevices");
-        success = false;
-    }
-    dispatch.GetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceProperties"));
-    if (UNLIKELY(!dispatch.GetPhysicalDeviceProperties)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceProperties");
-        success = false;
-    }
-    dispatch.GetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceQueueFamilyProperties"));
-    if (UNLIKELY(!dispatch.GetPhysicalDeviceQueueFamilyProperties)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceQueueFamilyProperties");
-        success = false;
-    }
-    dispatch.GetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceMemoryProperties"));
-    if (UNLIKELY(!dispatch.GetPhysicalDeviceMemoryProperties)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceMemoryProperties");
-        success = false;
-    }
-    dispatch.GetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(get_proc_addr(instance, "vkGetPhysicalDeviceFeatures"));
-    if (UNLIKELY(!dispatch.GetPhysicalDeviceFeatures)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceFeatures");
-        success = false;
-    }
-    dispatch.GetPhysicalDeviceFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceFormatProperties"));
-    if (UNLIKELY(!dispatch.GetPhysicalDeviceFormatProperties)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceFormatProperties");
-        success = false;
-    }
-    dispatch.GetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceImageFormatProperties"));
-    if (UNLIKELY(!dispatch.GetPhysicalDeviceImageFormatProperties)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceImageFormatProperties");
-        success = false;
-    }
-    dispatch.CreateDevice = reinterpret_cast<PFN_vkCreateDevice>(get_proc_addr(instance, "vkCreateDevice"));
-    if (UNLIKELY(!dispatch.CreateDevice)) {
-        ALOGE("missing instance proc: %s", "vkCreateDevice");
-        success = false;
-    }
-    dispatch.EnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(get_proc_addr(instance, "vkEnumerateDeviceExtensionProperties"));
-    if (UNLIKELY(!dispatch.EnumerateDeviceExtensionProperties)) {
-        ALOGE("missing instance proc: %s", "vkEnumerateDeviceExtensionProperties");
-        success = false;
-    }
-    dispatch.GetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties"));
-    if (UNLIKELY(!dispatch.GetPhysicalDeviceSparseImageFormatProperties)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSparseImageFormatProperties");
-        success = false;
-    }
-    dispatch.DestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(get_proc_addr(instance, "vkDestroySurfaceKHR"));
-    if (UNLIKELY(!dispatch.DestroySurfaceKHR)) {
-        ALOGE("missing instance proc: %s", "vkDestroySurfaceKHR");
-        success = false;
-    }
-    dispatch.GetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR"));
-    if (UNLIKELY(!dispatch.GetPhysicalDeviceSurfaceSupportKHR)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSurfaceSupportKHR");
-        success = false;
-    }
-    dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
-    if (UNLIKELY(!dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
-        success = false;
-    }
-    dispatch.GetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
-    if (UNLIKELY(!dispatch.GetPhysicalDeviceSurfaceFormatsKHR)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSurfaceFormatsKHR");
-        success = false;
-    }
-    dispatch.GetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
-    if (UNLIKELY(!dispatch.GetPhysicalDeviceSurfacePresentModesKHR)) {
-        ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSurfacePresentModesKHR");
-        success = false;
-    }
-    dispatch.CreateAndroidSurfaceKHR = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(get_proc_addr(instance, "vkCreateAndroidSurfaceKHR"));
-    if (UNLIKELY(!dispatch.CreateAndroidSurfaceKHR)) {
-        ALOGE("missing instance proc: %s", "vkCreateAndroidSurfaceKHR");
-        success = false;
-    }
-    dispatch.CreateDebugReportCallbackEXT = reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(get_proc_addr(instance, "vkCreateDebugReportCallbackEXT"));
-    if (UNLIKELY(!dispatch.CreateDebugReportCallbackEXT)) {
-        ALOGE("missing instance proc: %s", "vkCreateDebugReportCallbackEXT");
-        success = false;
-    }
-    dispatch.DestroyDebugReportCallbackEXT = reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(get_proc_addr(instance, "vkDestroyDebugReportCallbackEXT"));
-    if (UNLIKELY(!dispatch.DestroyDebugReportCallbackEXT)) {
-        ALOGE("missing instance proc: %s", "vkDestroyDebugReportCallbackEXT");
-        success = false;
-    }
-    dispatch.DebugReportMessageEXT = reinterpret_cast<PFN_vkDebugReportMessageEXT>(get_proc_addr(instance, "vkDebugReportMessageEXT"));
-    if (UNLIKELY(!dispatch.DebugReportMessageEXT)) {
-        ALOGE("missing instance proc: %s", "vkDebugReportMessageEXT");
-        success = false;
-    }
-    // clang-format on
-    return success;
-}
-
-bool LoadDeviceDispatchTable(VkDevice device,
-                             PFN_vkGetDeviceProcAddr get_proc_addr,
-                             DeviceDispatchTable& dispatch) {
-    bool success = true;
-    // clang-format off
-    dispatch.DestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(get_proc_addr(device, "vkDestroyDevice"));
-    if (UNLIKELY(!dispatch.DestroyDevice)) {
-        ALOGE("missing device proc: %s", "vkDestroyDevice");
-        success = false;
-    }
-    dispatch.GetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(get_proc_addr(device, "vkGetDeviceQueue"));
-    if (UNLIKELY(!dispatch.GetDeviceQueue)) {
-        ALOGE("missing device proc: %s", "vkGetDeviceQueue");
-        success = false;
-    }
-    dispatch.QueueSubmit = reinterpret_cast<PFN_vkQueueSubmit>(get_proc_addr(device, "vkQueueSubmit"));
-    if (UNLIKELY(!dispatch.QueueSubmit)) {
-        ALOGE("missing device proc: %s", "vkQueueSubmit");
-        success = false;
-    }
-    dispatch.QueueWaitIdle = reinterpret_cast<PFN_vkQueueWaitIdle>(get_proc_addr(device, "vkQueueWaitIdle"));
-    if (UNLIKELY(!dispatch.QueueWaitIdle)) {
-        ALOGE("missing device proc: %s", "vkQueueWaitIdle");
-        success = false;
-    }
-    dispatch.DeviceWaitIdle = reinterpret_cast<PFN_vkDeviceWaitIdle>(get_proc_addr(device, "vkDeviceWaitIdle"));
-    if (UNLIKELY(!dispatch.DeviceWaitIdle)) {
-        ALOGE("missing device proc: %s", "vkDeviceWaitIdle");
-        success = false;
-    }
-    dispatch.AllocateMemory = reinterpret_cast<PFN_vkAllocateMemory>(get_proc_addr(device, "vkAllocateMemory"));
-    if (UNLIKELY(!dispatch.AllocateMemory)) {
-        ALOGE("missing device proc: %s", "vkAllocateMemory");
-        success = false;
-    }
-    dispatch.FreeMemory = reinterpret_cast<PFN_vkFreeMemory>(get_proc_addr(device, "vkFreeMemory"));
-    if (UNLIKELY(!dispatch.FreeMemory)) {
-        ALOGE("missing device proc: %s", "vkFreeMemory");
-        success = false;
-    }
-    dispatch.MapMemory = reinterpret_cast<PFN_vkMapMemory>(get_proc_addr(device, "vkMapMemory"));
-    if (UNLIKELY(!dispatch.MapMemory)) {
-        ALOGE("missing device proc: %s", "vkMapMemory");
-        success = false;
-    }
-    dispatch.UnmapMemory = reinterpret_cast<PFN_vkUnmapMemory>(get_proc_addr(device, "vkUnmapMemory"));
-    if (UNLIKELY(!dispatch.UnmapMemory)) {
-        ALOGE("missing device proc: %s", "vkUnmapMemory");
-        success = false;
-    }
-    dispatch.FlushMappedMemoryRanges = reinterpret_cast<PFN_vkFlushMappedMemoryRanges>(get_proc_addr(device, "vkFlushMappedMemoryRanges"));
-    if (UNLIKELY(!dispatch.FlushMappedMemoryRanges)) {
-        ALOGE("missing device proc: %s", "vkFlushMappedMemoryRanges");
-        success = false;
-    }
-    dispatch.InvalidateMappedMemoryRanges = reinterpret_cast<PFN_vkInvalidateMappedMemoryRanges>(get_proc_addr(device, "vkInvalidateMappedMemoryRanges"));
-    if (UNLIKELY(!dispatch.InvalidateMappedMemoryRanges)) {
-        ALOGE("missing device proc: %s", "vkInvalidateMappedMemoryRanges");
-        success = false;
-    }
-    dispatch.GetDeviceMemoryCommitment = reinterpret_cast<PFN_vkGetDeviceMemoryCommitment>(get_proc_addr(device, "vkGetDeviceMemoryCommitment"));
-    if (UNLIKELY(!dispatch.GetDeviceMemoryCommitment)) {
-        ALOGE("missing device proc: %s", "vkGetDeviceMemoryCommitment");
-        success = false;
-    }
-    dispatch.GetBufferMemoryRequirements = reinterpret_cast<PFN_vkGetBufferMemoryRequirements>(get_proc_addr(device, "vkGetBufferMemoryRequirements"));
-    if (UNLIKELY(!dispatch.GetBufferMemoryRequirements)) {
-        ALOGE("missing device proc: %s", "vkGetBufferMemoryRequirements");
-        success = false;
-    }
-    dispatch.BindBufferMemory = reinterpret_cast<PFN_vkBindBufferMemory>(get_proc_addr(device, "vkBindBufferMemory"));
-    if (UNLIKELY(!dispatch.BindBufferMemory)) {
-        ALOGE("missing device proc: %s", "vkBindBufferMemory");
-        success = false;
-    }
-    dispatch.GetImageMemoryRequirements = reinterpret_cast<PFN_vkGetImageMemoryRequirements>(get_proc_addr(device, "vkGetImageMemoryRequirements"));
-    if (UNLIKELY(!dispatch.GetImageMemoryRequirements)) {
-        ALOGE("missing device proc: %s", "vkGetImageMemoryRequirements");
-        success = false;
-    }
-    dispatch.BindImageMemory = reinterpret_cast<PFN_vkBindImageMemory>(get_proc_addr(device, "vkBindImageMemory"));
-    if (UNLIKELY(!dispatch.BindImageMemory)) {
-        ALOGE("missing device proc: %s", "vkBindImageMemory");
-        success = false;
-    }
-    dispatch.GetImageSparseMemoryRequirements = reinterpret_cast<PFN_vkGetImageSparseMemoryRequirements>(get_proc_addr(device, "vkGetImageSparseMemoryRequirements"));
-    if (UNLIKELY(!dispatch.GetImageSparseMemoryRequirements)) {
-        ALOGE("missing device proc: %s", "vkGetImageSparseMemoryRequirements");
-        success = false;
-    }
-    dispatch.QueueBindSparse = reinterpret_cast<PFN_vkQueueBindSparse>(get_proc_addr(device, "vkQueueBindSparse"));
-    if (UNLIKELY(!dispatch.QueueBindSparse)) {
-        ALOGE("missing device proc: %s", "vkQueueBindSparse");
-        success = false;
-    }
-    dispatch.CreateFence = reinterpret_cast<PFN_vkCreateFence>(get_proc_addr(device, "vkCreateFence"));
-    if (UNLIKELY(!dispatch.CreateFence)) {
-        ALOGE("missing device proc: %s", "vkCreateFence");
-        success = false;
-    }
-    dispatch.DestroyFence = reinterpret_cast<PFN_vkDestroyFence>(get_proc_addr(device, "vkDestroyFence"));
-    if (UNLIKELY(!dispatch.DestroyFence)) {
-        ALOGE("missing device proc: %s", "vkDestroyFence");
-        success = false;
-    }
-    dispatch.ResetFences = reinterpret_cast<PFN_vkResetFences>(get_proc_addr(device, "vkResetFences"));
-    if (UNLIKELY(!dispatch.ResetFences)) {
-        ALOGE("missing device proc: %s", "vkResetFences");
-        success = false;
-    }
-    dispatch.GetFenceStatus = reinterpret_cast<PFN_vkGetFenceStatus>(get_proc_addr(device, "vkGetFenceStatus"));
-    if (UNLIKELY(!dispatch.GetFenceStatus)) {
-        ALOGE("missing device proc: %s", "vkGetFenceStatus");
-        success = false;
-    }
-    dispatch.WaitForFences = reinterpret_cast<PFN_vkWaitForFences>(get_proc_addr(device, "vkWaitForFences"));
-    if (UNLIKELY(!dispatch.WaitForFences)) {
-        ALOGE("missing device proc: %s", "vkWaitForFences");
-        success = false;
-    }
-    dispatch.CreateSemaphore = reinterpret_cast<PFN_vkCreateSemaphore>(get_proc_addr(device, "vkCreateSemaphore"));
-    if (UNLIKELY(!dispatch.CreateSemaphore)) {
-        ALOGE("missing device proc: %s", "vkCreateSemaphore");
-        success = false;
-    }
-    dispatch.DestroySemaphore = reinterpret_cast<PFN_vkDestroySemaphore>(get_proc_addr(device, "vkDestroySemaphore"));
-    if (UNLIKELY(!dispatch.DestroySemaphore)) {
-        ALOGE("missing device proc: %s", "vkDestroySemaphore");
-        success = false;
-    }
-    dispatch.CreateEvent = reinterpret_cast<PFN_vkCreateEvent>(get_proc_addr(device, "vkCreateEvent"));
-    if (UNLIKELY(!dispatch.CreateEvent)) {
-        ALOGE("missing device proc: %s", "vkCreateEvent");
-        success = false;
-    }
-    dispatch.DestroyEvent = reinterpret_cast<PFN_vkDestroyEvent>(get_proc_addr(device, "vkDestroyEvent"));
-    if (UNLIKELY(!dispatch.DestroyEvent)) {
-        ALOGE("missing device proc: %s", "vkDestroyEvent");
-        success = false;
-    }
-    dispatch.GetEventStatus = reinterpret_cast<PFN_vkGetEventStatus>(get_proc_addr(device, "vkGetEventStatus"));
-    if (UNLIKELY(!dispatch.GetEventStatus)) {
-        ALOGE("missing device proc: %s", "vkGetEventStatus");
-        success = false;
-    }
-    dispatch.SetEvent = reinterpret_cast<PFN_vkSetEvent>(get_proc_addr(device, "vkSetEvent"));
-    if (UNLIKELY(!dispatch.SetEvent)) {
-        ALOGE("missing device proc: %s", "vkSetEvent");
-        success = false;
-    }
-    dispatch.ResetEvent = reinterpret_cast<PFN_vkResetEvent>(get_proc_addr(device, "vkResetEvent"));
-    if (UNLIKELY(!dispatch.ResetEvent)) {
-        ALOGE("missing device proc: %s", "vkResetEvent");
-        success = false;
-    }
-    dispatch.CreateQueryPool = reinterpret_cast<PFN_vkCreateQueryPool>(get_proc_addr(device, "vkCreateQueryPool"));
-    if (UNLIKELY(!dispatch.CreateQueryPool)) {
-        ALOGE("missing device proc: %s", "vkCreateQueryPool");
-        success = false;
-    }
-    dispatch.DestroyQueryPool = reinterpret_cast<PFN_vkDestroyQueryPool>(get_proc_addr(device, "vkDestroyQueryPool"));
-    if (UNLIKELY(!dispatch.DestroyQueryPool)) {
-        ALOGE("missing device proc: %s", "vkDestroyQueryPool");
-        success = false;
-    }
-    dispatch.GetQueryPoolResults = reinterpret_cast<PFN_vkGetQueryPoolResults>(get_proc_addr(device, "vkGetQueryPoolResults"));
-    if (UNLIKELY(!dispatch.GetQueryPoolResults)) {
-        ALOGE("missing device proc: %s", "vkGetQueryPoolResults");
-        success = false;
-    }
-    dispatch.CreateBuffer = reinterpret_cast<PFN_vkCreateBuffer>(get_proc_addr(device, "vkCreateBuffer"));
-    if (UNLIKELY(!dispatch.CreateBuffer)) {
-        ALOGE("missing device proc: %s", "vkCreateBuffer");
-        success = false;
-    }
-    dispatch.DestroyBuffer = reinterpret_cast<PFN_vkDestroyBuffer>(get_proc_addr(device, "vkDestroyBuffer"));
-    if (UNLIKELY(!dispatch.DestroyBuffer)) {
-        ALOGE("missing device proc: %s", "vkDestroyBuffer");
-        success = false;
-    }
-    dispatch.CreateBufferView = reinterpret_cast<PFN_vkCreateBufferView>(get_proc_addr(device, "vkCreateBufferView"));
-    if (UNLIKELY(!dispatch.CreateBufferView)) {
-        ALOGE("missing device proc: %s", "vkCreateBufferView");
-        success = false;
-    }
-    dispatch.DestroyBufferView = reinterpret_cast<PFN_vkDestroyBufferView>(get_proc_addr(device, "vkDestroyBufferView"));
-    if (UNLIKELY(!dispatch.DestroyBufferView)) {
-        ALOGE("missing device proc: %s", "vkDestroyBufferView");
-        success = false;
-    }
-    dispatch.CreateImage = reinterpret_cast<PFN_vkCreateImage>(get_proc_addr(device, "vkCreateImage"));
-    if (UNLIKELY(!dispatch.CreateImage)) {
-        ALOGE("missing device proc: %s", "vkCreateImage");
-        success = false;
-    }
-    dispatch.DestroyImage = reinterpret_cast<PFN_vkDestroyImage>(get_proc_addr(device, "vkDestroyImage"));
-    if (UNLIKELY(!dispatch.DestroyImage)) {
-        ALOGE("missing device proc: %s", "vkDestroyImage");
-        success = false;
-    }
-    dispatch.GetImageSubresourceLayout = reinterpret_cast<PFN_vkGetImageSubresourceLayout>(get_proc_addr(device, "vkGetImageSubresourceLayout"));
-    if (UNLIKELY(!dispatch.GetImageSubresourceLayout)) {
-        ALOGE("missing device proc: %s", "vkGetImageSubresourceLayout");
-        success = false;
-    }
-    dispatch.CreateImageView = reinterpret_cast<PFN_vkCreateImageView>(get_proc_addr(device, "vkCreateImageView"));
-    if (UNLIKELY(!dispatch.CreateImageView)) {
-        ALOGE("missing device proc: %s", "vkCreateImageView");
-        success = false;
-    }
-    dispatch.DestroyImageView = reinterpret_cast<PFN_vkDestroyImageView>(get_proc_addr(device, "vkDestroyImageView"));
-    if (UNLIKELY(!dispatch.DestroyImageView)) {
-        ALOGE("missing device proc: %s", "vkDestroyImageView");
-        success = false;
-    }
-    dispatch.CreateShaderModule = reinterpret_cast<PFN_vkCreateShaderModule>(get_proc_addr(device, "vkCreateShaderModule"));
-    if (UNLIKELY(!dispatch.CreateShaderModule)) {
-        ALOGE("missing device proc: %s", "vkCreateShaderModule");
-        success = false;
-    }
-    dispatch.DestroyShaderModule = reinterpret_cast<PFN_vkDestroyShaderModule>(get_proc_addr(device, "vkDestroyShaderModule"));
-    if (UNLIKELY(!dispatch.DestroyShaderModule)) {
-        ALOGE("missing device proc: %s", "vkDestroyShaderModule");
-        success = false;
-    }
-    dispatch.CreatePipelineCache = reinterpret_cast<PFN_vkCreatePipelineCache>(get_proc_addr(device, "vkCreatePipelineCache"));
-    if (UNLIKELY(!dispatch.CreatePipelineCache)) {
-        ALOGE("missing device proc: %s", "vkCreatePipelineCache");
-        success = false;
-    }
-    dispatch.DestroyPipelineCache = reinterpret_cast<PFN_vkDestroyPipelineCache>(get_proc_addr(device, "vkDestroyPipelineCache"));
-    if (UNLIKELY(!dispatch.DestroyPipelineCache)) {
-        ALOGE("missing device proc: %s", "vkDestroyPipelineCache");
-        success = false;
-    }
-    dispatch.GetPipelineCacheData = reinterpret_cast<PFN_vkGetPipelineCacheData>(get_proc_addr(device, "vkGetPipelineCacheData"));
-    if (UNLIKELY(!dispatch.GetPipelineCacheData)) {
-        ALOGE("missing device proc: %s", "vkGetPipelineCacheData");
-        success = false;
-    }
-    dispatch.MergePipelineCaches = reinterpret_cast<PFN_vkMergePipelineCaches>(get_proc_addr(device, "vkMergePipelineCaches"));
-    if (UNLIKELY(!dispatch.MergePipelineCaches)) {
-        ALOGE("missing device proc: %s", "vkMergePipelineCaches");
-        success = false;
-    }
-    dispatch.CreateGraphicsPipelines = reinterpret_cast<PFN_vkCreateGraphicsPipelines>(get_proc_addr(device, "vkCreateGraphicsPipelines"));
-    if (UNLIKELY(!dispatch.CreateGraphicsPipelines)) {
-        ALOGE("missing device proc: %s", "vkCreateGraphicsPipelines");
-        success = false;
-    }
-    dispatch.CreateComputePipelines = reinterpret_cast<PFN_vkCreateComputePipelines>(get_proc_addr(device, "vkCreateComputePipelines"));
-    if (UNLIKELY(!dispatch.CreateComputePipelines)) {
-        ALOGE("missing device proc: %s", "vkCreateComputePipelines");
-        success = false;
-    }
-    dispatch.DestroyPipeline = reinterpret_cast<PFN_vkDestroyPipeline>(get_proc_addr(device, "vkDestroyPipeline"));
-    if (UNLIKELY(!dispatch.DestroyPipeline)) {
-        ALOGE("missing device proc: %s", "vkDestroyPipeline");
-        success = false;
-    }
-    dispatch.CreatePipelineLayout = reinterpret_cast<PFN_vkCreatePipelineLayout>(get_proc_addr(device, "vkCreatePipelineLayout"));
-    if (UNLIKELY(!dispatch.CreatePipelineLayout)) {
-        ALOGE("missing device proc: %s", "vkCreatePipelineLayout");
-        success = false;
-    }
-    dispatch.DestroyPipelineLayout = reinterpret_cast<PFN_vkDestroyPipelineLayout>(get_proc_addr(device, "vkDestroyPipelineLayout"));
-    if (UNLIKELY(!dispatch.DestroyPipelineLayout)) {
-        ALOGE("missing device proc: %s", "vkDestroyPipelineLayout");
-        success = false;
-    }
-    dispatch.CreateSampler = reinterpret_cast<PFN_vkCreateSampler>(get_proc_addr(device, "vkCreateSampler"));
-    if (UNLIKELY(!dispatch.CreateSampler)) {
-        ALOGE("missing device proc: %s", "vkCreateSampler");
-        success = false;
-    }
-    dispatch.DestroySampler = reinterpret_cast<PFN_vkDestroySampler>(get_proc_addr(device, "vkDestroySampler"));
-    if (UNLIKELY(!dispatch.DestroySampler)) {
-        ALOGE("missing device proc: %s", "vkDestroySampler");
-        success = false;
-    }
-    dispatch.CreateDescriptorSetLayout = reinterpret_cast<PFN_vkCreateDescriptorSetLayout>(get_proc_addr(device, "vkCreateDescriptorSetLayout"));
-    if (UNLIKELY(!dispatch.CreateDescriptorSetLayout)) {
-        ALOGE("missing device proc: %s", "vkCreateDescriptorSetLayout");
-        success = false;
-    }
-    dispatch.DestroyDescriptorSetLayout = reinterpret_cast<PFN_vkDestroyDescriptorSetLayout>(get_proc_addr(device, "vkDestroyDescriptorSetLayout"));
-    if (UNLIKELY(!dispatch.DestroyDescriptorSetLayout)) {
-        ALOGE("missing device proc: %s", "vkDestroyDescriptorSetLayout");
-        success = false;
-    }
-    dispatch.CreateDescriptorPool = reinterpret_cast<PFN_vkCreateDescriptorPool>(get_proc_addr(device, "vkCreateDescriptorPool"));
-    if (UNLIKELY(!dispatch.CreateDescriptorPool)) {
-        ALOGE("missing device proc: %s", "vkCreateDescriptorPool");
-        success = false;
-    }
-    dispatch.DestroyDescriptorPool = reinterpret_cast<PFN_vkDestroyDescriptorPool>(get_proc_addr(device, "vkDestroyDescriptorPool"));
-    if (UNLIKELY(!dispatch.DestroyDescriptorPool)) {
-        ALOGE("missing device proc: %s", "vkDestroyDescriptorPool");
-        success = false;
-    }
-    dispatch.ResetDescriptorPool = reinterpret_cast<PFN_vkResetDescriptorPool>(get_proc_addr(device, "vkResetDescriptorPool"));
-    if (UNLIKELY(!dispatch.ResetDescriptorPool)) {
-        ALOGE("missing device proc: %s", "vkResetDescriptorPool");
-        success = false;
-    }
-    dispatch.AllocateDescriptorSets = reinterpret_cast<PFN_vkAllocateDescriptorSets>(get_proc_addr(device, "vkAllocateDescriptorSets"));
-    if (UNLIKELY(!dispatch.AllocateDescriptorSets)) {
-        ALOGE("missing device proc: %s", "vkAllocateDescriptorSets");
-        success = false;
-    }
-    dispatch.FreeDescriptorSets = reinterpret_cast<PFN_vkFreeDescriptorSets>(get_proc_addr(device, "vkFreeDescriptorSets"));
-    if (UNLIKELY(!dispatch.FreeDescriptorSets)) {
-        ALOGE("missing device proc: %s", "vkFreeDescriptorSets");
-        success = false;
-    }
-    dispatch.UpdateDescriptorSets = reinterpret_cast<PFN_vkUpdateDescriptorSets>(get_proc_addr(device, "vkUpdateDescriptorSets"));
-    if (UNLIKELY(!dispatch.UpdateDescriptorSets)) {
-        ALOGE("missing device proc: %s", "vkUpdateDescriptorSets");
-        success = false;
-    }
-    dispatch.CreateFramebuffer = reinterpret_cast<PFN_vkCreateFramebuffer>(get_proc_addr(device, "vkCreateFramebuffer"));
-    if (UNLIKELY(!dispatch.CreateFramebuffer)) {
-        ALOGE("missing device proc: %s", "vkCreateFramebuffer");
-        success = false;
-    }
-    dispatch.DestroyFramebuffer = reinterpret_cast<PFN_vkDestroyFramebuffer>(get_proc_addr(device, "vkDestroyFramebuffer"));
-    if (UNLIKELY(!dispatch.DestroyFramebuffer)) {
-        ALOGE("missing device proc: %s", "vkDestroyFramebuffer");
-        success = false;
-    }
-    dispatch.CreateRenderPass = reinterpret_cast<PFN_vkCreateRenderPass>(get_proc_addr(device, "vkCreateRenderPass"));
-    if (UNLIKELY(!dispatch.CreateRenderPass)) {
-        ALOGE("missing device proc: %s", "vkCreateRenderPass");
-        success = false;
-    }
-    dispatch.DestroyRenderPass = reinterpret_cast<PFN_vkDestroyRenderPass>(get_proc_addr(device, "vkDestroyRenderPass"));
-    if (UNLIKELY(!dispatch.DestroyRenderPass)) {
-        ALOGE("missing device proc: %s", "vkDestroyRenderPass");
-        success = false;
-    }
-    dispatch.GetRenderAreaGranularity = reinterpret_cast<PFN_vkGetRenderAreaGranularity>(get_proc_addr(device, "vkGetRenderAreaGranularity"));
-    if (UNLIKELY(!dispatch.GetRenderAreaGranularity)) {
-        ALOGE("missing device proc: %s", "vkGetRenderAreaGranularity");
-        success = false;
-    }
-    dispatch.CreateCommandPool = reinterpret_cast<PFN_vkCreateCommandPool>(get_proc_addr(device, "vkCreateCommandPool"));
-    if (UNLIKELY(!dispatch.CreateCommandPool)) {
-        ALOGE("missing device proc: %s", "vkCreateCommandPool");
-        success = false;
-    }
-    dispatch.DestroyCommandPool = reinterpret_cast<PFN_vkDestroyCommandPool>(get_proc_addr(device, "vkDestroyCommandPool"));
-    if (UNLIKELY(!dispatch.DestroyCommandPool)) {
-        ALOGE("missing device proc: %s", "vkDestroyCommandPool");
-        success = false;
-    }
-    dispatch.ResetCommandPool = reinterpret_cast<PFN_vkResetCommandPool>(get_proc_addr(device, "vkResetCommandPool"));
-    if (UNLIKELY(!dispatch.ResetCommandPool)) {
-        ALOGE("missing device proc: %s", "vkResetCommandPool");
-        success = false;
-    }
-    dispatch.AllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(get_proc_addr(device, "vkAllocateCommandBuffers"));
-    if (UNLIKELY(!dispatch.AllocateCommandBuffers)) {
-        ALOGE("missing device proc: %s", "vkAllocateCommandBuffers");
-        success = false;
-    }
-    dispatch.FreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(get_proc_addr(device, "vkFreeCommandBuffers"));
-    if (UNLIKELY(!dispatch.FreeCommandBuffers)) {
-        ALOGE("missing device proc: %s", "vkFreeCommandBuffers");
-        success = false;
-    }
-    dispatch.BeginCommandBuffer = reinterpret_cast<PFN_vkBeginCommandBuffer>(get_proc_addr(device, "vkBeginCommandBuffer"));
-    if (UNLIKELY(!dispatch.BeginCommandBuffer)) {
-        ALOGE("missing device proc: %s", "vkBeginCommandBuffer");
-        success = false;
-    }
-    dispatch.EndCommandBuffer = reinterpret_cast<PFN_vkEndCommandBuffer>(get_proc_addr(device, "vkEndCommandBuffer"));
-    if (UNLIKELY(!dispatch.EndCommandBuffer)) {
-        ALOGE("missing device proc: %s", "vkEndCommandBuffer");
-        success = false;
-    }
-    dispatch.ResetCommandBuffer = reinterpret_cast<PFN_vkResetCommandBuffer>(get_proc_addr(device, "vkResetCommandBuffer"));
-    if (UNLIKELY(!dispatch.ResetCommandBuffer)) {
-        ALOGE("missing device proc: %s", "vkResetCommandBuffer");
-        success = false;
-    }
-    dispatch.CmdBindPipeline = reinterpret_cast<PFN_vkCmdBindPipeline>(get_proc_addr(device, "vkCmdBindPipeline"));
-    if (UNLIKELY(!dispatch.CmdBindPipeline)) {
-        ALOGE("missing device proc: %s", "vkCmdBindPipeline");
-        success = false;
-    }
-    dispatch.CmdSetViewport = reinterpret_cast<PFN_vkCmdSetViewport>(get_proc_addr(device, "vkCmdSetViewport"));
-    if (UNLIKELY(!dispatch.CmdSetViewport)) {
-        ALOGE("missing device proc: %s", "vkCmdSetViewport");
-        success = false;
-    }
-    dispatch.CmdSetScissor = reinterpret_cast<PFN_vkCmdSetScissor>(get_proc_addr(device, "vkCmdSetScissor"));
-    if (UNLIKELY(!dispatch.CmdSetScissor)) {
-        ALOGE("missing device proc: %s", "vkCmdSetScissor");
-        success = false;
-    }
-    dispatch.CmdSetLineWidth = reinterpret_cast<PFN_vkCmdSetLineWidth>(get_proc_addr(device, "vkCmdSetLineWidth"));
-    if (UNLIKELY(!dispatch.CmdSetLineWidth)) {
-        ALOGE("missing device proc: %s", "vkCmdSetLineWidth");
-        success = false;
-    }
-    dispatch.CmdSetDepthBias = reinterpret_cast<PFN_vkCmdSetDepthBias>(get_proc_addr(device, "vkCmdSetDepthBias"));
-    if (UNLIKELY(!dispatch.CmdSetDepthBias)) {
-        ALOGE("missing device proc: %s", "vkCmdSetDepthBias");
-        success = false;
-    }
-    dispatch.CmdSetBlendConstants = reinterpret_cast<PFN_vkCmdSetBlendConstants>(get_proc_addr(device, "vkCmdSetBlendConstants"));
-    if (UNLIKELY(!dispatch.CmdSetBlendConstants)) {
-        ALOGE("missing device proc: %s", "vkCmdSetBlendConstants");
-        success = false;
-    }
-    dispatch.CmdSetDepthBounds = reinterpret_cast<PFN_vkCmdSetDepthBounds>(get_proc_addr(device, "vkCmdSetDepthBounds"));
-    if (UNLIKELY(!dispatch.CmdSetDepthBounds)) {
-        ALOGE("missing device proc: %s", "vkCmdSetDepthBounds");
-        success = false;
-    }
-    dispatch.CmdSetStencilCompareMask = reinterpret_cast<PFN_vkCmdSetStencilCompareMask>(get_proc_addr(device, "vkCmdSetStencilCompareMask"));
-    if (UNLIKELY(!dispatch.CmdSetStencilCompareMask)) {
-        ALOGE("missing device proc: %s", "vkCmdSetStencilCompareMask");
-        success = false;
-    }
-    dispatch.CmdSetStencilWriteMask = reinterpret_cast<PFN_vkCmdSetStencilWriteMask>(get_proc_addr(device, "vkCmdSetStencilWriteMask"));
-    if (UNLIKELY(!dispatch.CmdSetStencilWriteMask)) {
-        ALOGE("missing device proc: %s", "vkCmdSetStencilWriteMask");
-        success = false;
-    }
-    dispatch.CmdSetStencilReference = reinterpret_cast<PFN_vkCmdSetStencilReference>(get_proc_addr(device, "vkCmdSetStencilReference"));
-    if (UNLIKELY(!dispatch.CmdSetStencilReference)) {
-        ALOGE("missing device proc: %s", "vkCmdSetStencilReference");
-        success = false;
-    }
-    dispatch.CmdBindDescriptorSets = reinterpret_cast<PFN_vkCmdBindDescriptorSets>(get_proc_addr(device, "vkCmdBindDescriptorSets"));
-    if (UNLIKELY(!dispatch.CmdBindDescriptorSets)) {
-        ALOGE("missing device proc: %s", "vkCmdBindDescriptorSets");
-        success = false;
-    }
-    dispatch.CmdBindIndexBuffer = reinterpret_cast<PFN_vkCmdBindIndexBuffer>(get_proc_addr(device, "vkCmdBindIndexBuffer"));
-    if (UNLIKELY(!dispatch.CmdBindIndexBuffer)) {
-        ALOGE("missing device proc: %s", "vkCmdBindIndexBuffer");
-        success = false;
-    }
-    dispatch.CmdBindVertexBuffers = reinterpret_cast<PFN_vkCmdBindVertexBuffers>(get_proc_addr(device, "vkCmdBindVertexBuffers"));
-    if (UNLIKELY(!dispatch.CmdBindVertexBuffers)) {
-        ALOGE("missing device proc: %s", "vkCmdBindVertexBuffers");
-        success = false;
-    }
-    dispatch.CmdDraw = reinterpret_cast<PFN_vkCmdDraw>(get_proc_addr(device, "vkCmdDraw"));
-    if (UNLIKELY(!dispatch.CmdDraw)) {
-        ALOGE("missing device proc: %s", "vkCmdDraw");
-        success = false;
-    }
-    dispatch.CmdDrawIndexed = reinterpret_cast<PFN_vkCmdDrawIndexed>(get_proc_addr(device, "vkCmdDrawIndexed"));
-    if (UNLIKELY(!dispatch.CmdDrawIndexed)) {
-        ALOGE("missing device proc: %s", "vkCmdDrawIndexed");
-        success = false;
-    }
-    dispatch.CmdDrawIndirect = reinterpret_cast<PFN_vkCmdDrawIndirect>(get_proc_addr(device, "vkCmdDrawIndirect"));
-    if (UNLIKELY(!dispatch.CmdDrawIndirect)) {
-        ALOGE("missing device proc: %s", "vkCmdDrawIndirect");
-        success = false;
-    }
-    dispatch.CmdDrawIndexedIndirect = reinterpret_cast<PFN_vkCmdDrawIndexedIndirect>(get_proc_addr(device, "vkCmdDrawIndexedIndirect"));
-    if (UNLIKELY(!dispatch.CmdDrawIndexedIndirect)) {
-        ALOGE("missing device proc: %s", "vkCmdDrawIndexedIndirect");
-        success = false;
-    }
-    dispatch.CmdDispatch = reinterpret_cast<PFN_vkCmdDispatch>(get_proc_addr(device, "vkCmdDispatch"));
-    if (UNLIKELY(!dispatch.CmdDispatch)) {
-        ALOGE("missing device proc: %s", "vkCmdDispatch");
-        success = false;
-    }
-    dispatch.CmdDispatchIndirect = reinterpret_cast<PFN_vkCmdDispatchIndirect>(get_proc_addr(device, "vkCmdDispatchIndirect"));
-    if (UNLIKELY(!dispatch.CmdDispatchIndirect)) {
-        ALOGE("missing device proc: %s", "vkCmdDispatchIndirect");
-        success = false;
-    }
-    dispatch.CmdCopyBuffer = reinterpret_cast<PFN_vkCmdCopyBuffer>(get_proc_addr(device, "vkCmdCopyBuffer"));
-    if (UNLIKELY(!dispatch.CmdCopyBuffer)) {
-        ALOGE("missing device proc: %s", "vkCmdCopyBuffer");
-        success = false;
-    }
-    dispatch.CmdCopyImage = reinterpret_cast<PFN_vkCmdCopyImage>(get_proc_addr(device, "vkCmdCopyImage"));
-    if (UNLIKELY(!dispatch.CmdCopyImage)) {
-        ALOGE("missing device proc: %s", "vkCmdCopyImage");
-        success = false;
-    }
-    dispatch.CmdBlitImage = reinterpret_cast<PFN_vkCmdBlitImage>(get_proc_addr(device, "vkCmdBlitImage"));
-    if (UNLIKELY(!dispatch.CmdBlitImage)) {
-        ALOGE("missing device proc: %s", "vkCmdBlitImage");
-        success = false;
-    }
-    dispatch.CmdCopyBufferToImage = reinterpret_cast<PFN_vkCmdCopyBufferToImage>(get_proc_addr(device, "vkCmdCopyBufferToImage"));
-    if (UNLIKELY(!dispatch.CmdCopyBufferToImage)) {
-        ALOGE("missing device proc: %s", "vkCmdCopyBufferToImage");
-        success = false;
-    }
-    dispatch.CmdCopyImageToBuffer = reinterpret_cast<PFN_vkCmdCopyImageToBuffer>(get_proc_addr(device, "vkCmdCopyImageToBuffer"));
-    if (UNLIKELY(!dispatch.CmdCopyImageToBuffer)) {
-        ALOGE("missing device proc: %s", "vkCmdCopyImageToBuffer");
-        success = false;
-    }
-    dispatch.CmdUpdateBuffer = reinterpret_cast<PFN_vkCmdUpdateBuffer>(get_proc_addr(device, "vkCmdUpdateBuffer"));
-    if (UNLIKELY(!dispatch.CmdUpdateBuffer)) {
-        ALOGE("missing device proc: %s", "vkCmdUpdateBuffer");
-        success = false;
-    }
-    dispatch.CmdFillBuffer = reinterpret_cast<PFN_vkCmdFillBuffer>(get_proc_addr(device, "vkCmdFillBuffer"));
-    if (UNLIKELY(!dispatch.CmdFillBuffer)) {
-        ALOGE("missing device proc: %s", "vkCmdFillBuffer");
-        success = false;
-    }
-    dispatch.CmdClearColorImage = reinterpret_cast<PFN_vkCmdClearColorImage>(get_proc_addr(device, "vkCmdClearColorImage"));
-    if (UNLIKELY(!dispatch.CmdClearColorImage)) {
-        ALOGE("missing device proc: %s", "vkCmdClearColorImage");
-        success = false;
-    }
-    dispatch.CmdClearDepthStencilImage = reinterpret_cast<PFN_vkCmdClearDepthStencilImage>(get_proc_addr(device, "vkCmdClearDepthStencilImage"));
-    if (UNLIKELY(!dispatch.CmdClearDepthStencilImage)) {
-        ALOGE("missing device proc: %s", "vkCmdClearDepthStencilImage");
-        success = false;
-    }
-    dispatch.CmdClearAttachments = reinterpret_cast<PFN_vkCmdClearAttachments>(get_proc_addr(device, "vkCmdClearAttachments"));
-    if (UNLIKELY(!dispatch.CmdClearAttachments)) {
-        ALOGE("missing device proc: %s", "vkCmdClearAttachments");
-        success = false;
-    }
-    dispatch.CmdResolveImage = reinterpret_cast<PFN_vkCmdResolveImage>(get_proc_addr(device, "vkCmdResolveImage"));
-    if (UNLIKELY(!dispatch.CmdResolveImage)) {
-        ALOGE("missing device proc: %s", "vkCmdResolveImage");
-        success = false;
-    }
-    dispatch.CmdSetEvent = reinterpret_cast<PFN_vkCmdSetEvent>(get_proc_addr(device, "vkCmdSetEvent"));
-    if (UNLIKELY(!dispatch.CmdSetEvent)) {
-        ALOGE("missing device proc: %s", "vkCmdSetEvent");
-        success = false;
-    }
-    dispatch.CmdResetEvent = reinterpret_cast<PFN_vkCmdResetEvent>(get_proc_addr(device, "vkCmdResetEvent"));
-    if (UNLIKELY(!dispatch.CmdResetEvent)) {
-        ALOGE("missing device proc: %s", "vkCmdResetEvent");
-        success = false;
-    }
-    dispatch.CmdWaitEvents = reinterpret_cast<PFN_vkCmdWaitEvents>(get_proc_addr(device, "vkCmdWaitEvents"));
-    if (UNLIKELY(!dispatch.CmdWaitEvents)) {
-        ALOGE("missing device proc: %s", "vkCmdWaitEvents");
-        success = false;
-    }
-    dispatch.CmdPipelineBarrier = reinterpret_cast<PFN_vkCmdPipelineBarrier>(get_proc_addr(device, "vkCmdPipelineBarrier"));
-    if (UNLIKELY(!dispatch.CmdPipelineBarrier)) {
-        ALOGE("missing device proc: %s", "vkCmdPipelineBarrier");
-        success = false;
-    }
-    dispatch.CmdBeginQuery = reinterpret_cast<PFN_vkCmdBeginQuery>(get_proc_addr(device, "vkCmdBeginQuery"));
-    if (UNLIKELY(!dispatch.CmdBeginQuery)) {
-        ALOGE("missing device proc: %s", "vkCmdBeginQuery");
-        success = false;
-    }
-    dispatch.CmdEndQuery = reinterpret_cast<PFN_vkCmdEndQuery>(get_proc_addr(device, "vkCmdEndQuery"));
-    if (UNLIKELY(!dispatch.CmdEndQuery)) {
-        ALOGE("missing device proc: %s", "vkCmdEndQuery");
-        success = false;
-    }
-    dispatch.CmdResetQueryPool = reinterpret_cast<PFN_vkCmdResetQueryPool>(get_proc_addr(device, "vkCmdResetQueryPool"));
-    if (UNLIKELY(!dispatch.CmdResetQueryPool)) {
-        ALOGE("missing device proc: %s", "vkCmdResetQueryPool");
-        success = false;
-    }
-    dispatch.CmdWriteTimestamp = reinterpret_cast<PFN_vkCmdWriteTimestamp>(get_proc_addr(device, "vkCmdWriteTimestamp"));
-    if (UNLIKELY(!dispatch.CmdWriteTimestamp)) {
-        ALOGE("missing device proc: %s", "vkCmdWriteTimestamp");
-        success = false;
-    }
-    dispatch.CmdCopyQueryPoolResults = reinterpret_cast<PFN_vkCmdCopyQueryPoolResults>(get_proc_addr(device, "vkCmdCopyQueryPoolResults"));
-    if (UNLIKELY(!dispatch.CmdCopyQueryPoolResults)) {
-        ALOGE("missing device proc: %s", "vkCmdCopyQueryPoolResults");
-        success = false;
-    }
-    dispatch.CmdPushConstants = reinterpret_cast<PFN_vkCmdPushConstants>(get_proc_addr(device, "vkCmdPushConstants"));
-    if (UNLIKELY(!dispatch.CmdPushConstants)) {
-        ALOGE("missing device proc: %s", "vkCmdPushConstants");
-        success = false;
-    }
-    dispatch.CmdBeginRenderPass = reinterpret_cast<PFN_vkCmdBeginRenderPass>(get_proc_addr(device, "vkCmdBeginRenderPass"));
-    if (UNLIKELY(!dispatch.CmdBeginRenderPass)) {
-        ALOGE("missing device proc: %s", "vkCmdBeginRenderPass");
-        success = false;
-    }
-    dispatch.CmdNextSubpass = reinterpret_cast<PFN_vkCmdNextSubpass>(get_proc_addr(device, "vkCmdNextSubpass"));
-    if (UNLIKELY(!dispatch.CmdNextSubpass)) {
-        ALOGE("missing device proc: %s", "vkCmdNextSubpass");
-        success = false;
-    }
-    dispatch.CmdEndRenderPass = reinterpret_cast<PFN_vkCmdEndRenderPass>(get_proc_addr(device, "vkCmdEndRenderPass"));
-    if (UNLIKELY(!dispatch.CmdEndRenderPass)) {
-        ALOGE("missing device proc: %s", "vkCmdEndRenderPass");
-        success = false;
-    }
-    dispatch.CmdExecuteCommands = reinterpret_cast<PFN_vkCmdExecuteCommands>(get_proc_addr(device, "vkCmdExecuteCommands"));
-    if (UNLIKELY(!dispatch.CmdExecuteCommands)) {
-        ALOGE("missing device proc: %s", "vkCmdExecuteCommands");
-        success = false;
-    }
-    dispatch.CreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(get_proc_addr(device, "vkCreateSwapchainKHR"));
-    if (UNLIKELY(!dispatch.CreateSwapchainKHR)) {
-        ALOGE("missing device proc: %s", "vkCreateSwapchainKHR");
-        success = false;
-    }
-    dispatch.DestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(get_proc_addr(device, "vkDestroySwapchainKHR"));
-    if (UNLIKELY(!dispatch.DestroySwapchainKHR)) {
-        ALOGE("missing device proc: %s", "vkDestroySwapchainKHR");
-        success = false;
-    }
-    dispatch.GetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(get_proc_addr(device, "vkGetSwapchainImagesKHR"));
-    if (UNLIKELY(!dispatch.GetSwapchainImagesKHR)) {
-        ALOGE("missing device proc: %s", "vkGetSwapchainImagesKHR");
-        success = false;
-    }
-    dispatch.AcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(get_proc_addr(device, "vkAcquireNextImageKHR"));
-    if (UNLIKELY(!dispatch.AcquireNextImageKHR)) {
-        ALOGE("missing device proc: %s", "vkAcquireNextImageKHR");
-        success = false;
-    }
-    dispatch.QueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(get_proc_addr(device, "vkQueuePresentKHR"));
-    if (UNLIKELY(!dispatch.QueuePresentKHR)) {
-        ALOGE("missing device proc: %s", "vkQueuePresentKHR");
-        success = false;
-    }
-    // clang-format on
-    return success;
-}
-
 bool LoadDriverDispatchTable(VkInstance instance,
                              PFN_vkGetInstanceProcAddr get_proc_addr,
                              const InstanceExtensionSet& extensions,
@@ -1303,6 +179,21 @@
         ALOGE("missing driver proc: %s", "vkGetDeviceProcAddr");
         success = false;
     }
+    dispatch.DestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(get_proc_addr(instance, "vkDestroyDevice"));
+    if (UNLIKELY(!dispatch.DestroyDevice)) {
+        ALOGE("missing driver proc: %s", "vkDestroyDevice");
+        success = false;
+    }
+    dispatch.GetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(get_proc_addr(instance, "vkGetDeviceQueue"));
+    if (UNLIKELY(!dispatch.GetDeviceQueue)) {
+        ALOGE("missing driver proc: %s", "vkGetDeviceQueue");
+        success = false;
+    }
+    dispatch.AllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(get_proc_addr(instance, "vkAllocateCommandBuffers"));
+    if (UNLIKELY(!dispatch.AllocateCommandBuffers)) {
+        ALOGE("missing driver proc: %s", "vkAllocateCommandBuffers");
+        success = false;
+    }
     dispatch.CreateImage = reinterpret_cast<PFN_vkCreateImage>(get_proc_addr(instance, "vkCreateImage"));
     if (UNLIKELY(!dispatch.CreateImage)) {
         ALOGE("missing driver proc: %s", "vkCreateImage");
@@ -1333,747 +224,3 @@
 }
 
 }  // namespace vulkan
-
-// clang-format off
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
-    return CreateInstance_Top(pCreateInfo, pAllocator, pInstance);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
-    DestroyInstance_Top(instance, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {
-    return GetDispatchTable(instance).EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) {
-    return GetDeviceProcAddr_Top(device, pName);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
-    return GetInstanceProcAddr_Top(instance, pName);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
-    GetDispatchTable(physicalDevice).GetPhysicalDeviceProperties(physicalDevice, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
-    GetDispatchTable(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
-    GetDispatchTable(physicalDevice).GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
-    GetDispatchTable(physicalDevice).GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
-    GetDispatchTable(physicalDevice).GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
-    return GetDispatchTable(physicalDevice).GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
-    return CreateDevice_Top(physicalDevice, pCreateInfo, pAllocator, pDevice);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
-    DestroyDevice_Top(device, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
-    return EnumerateInstanceLayerProperties_Top(pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
-    return EnumerateInstanceExtensionProperties_Top(pLayerName, pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
-    return EnumerateDeviceLayerProperties_Top(physicalDevice, pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
-    return EnumerateDeviceExtensionProperties_Top(physicalDevice, pLayerName, pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
-    GetDeviceQueue_Top(device, queueFamilyIndex, queueIndex, pQueue);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
-    return GetDispatchTable(queue).QueueSubmit(queue, submitCount, pSubmits, fence);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkQueueWaitIdle(VkQueue queue) {
-    return GetDispatchTable(queue).QueueWaitIdle(queue);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkDeviceWaitIdle(VkDevice device) {
-    return GetDispatchTable(device).DeviceWaitIdle(device);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
-    return GetDispatchTable(device).AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).FreeMemory(device, memory, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
-    return GetDispatchTable(device).MapMemory(device, memory, offset, size, flags, ppData);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
-    GetDispatchTable(device).UnmapMemory(device, memory);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
-    return GetDispatchTable(device).FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
-    return GetDispatchTable(device).InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
-    GetDispatchTable(device).GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
-    GetDispatchTable(device).GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
-    return GetDispatchTable(device).BindBufferMemory(device, buffer, memory, memoryOffset);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
-    GetDispatchTable(device).GetImageMemoryRequirements(device, image, pMemoryRequirements);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
-    return GetDispatchTable(device).BindImageMemory(device, image, memory, memoryOffset);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
-    GetDispatchTable(device).GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
-    GetDispatchTable(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
-    return GetDispatchTable(queue).QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
-    return GetDispatchTable(device).CreateFence(device, pCreateInfo, pAllocator, pFence);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyFence(device, fence, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
-    return GetDispatchTable(device).ResetFences(device, fenceCount, pFences);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetFenceStatus(VkDevice device, VkFence fence) {
-    return GetDispatchTable(device).GetFenceStatus(device, fence);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
-    return GetDispatchTable(device).WaitForFences(device, fenceCount, pFences, waitAll, timeout);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
-    return GetDispatchTable(device).CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroySemaphore(device, semaphore, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
-    return GetDispatchTable(device).CreateEvent(device, pCreateInfo, pAllocator, pEvent);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyEvent(device, event, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetEventStatus(VkDevice device, VkEvent event) {
-    return GetDispatchTable(device).GetEventStatus(device, event);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkSetEvent(VkDevice device, VkEvent event) {
-    return GetDispatchTable(device).SetEvent(device, event);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetEvent(VkDevice device, VkEvent event) {
-    return GetDispatchTable(device).ResetEvent(device, event);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
-    return GetDispatchTable(device).CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyQueryPool(device, queryPool, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
-    return GetDispatchTable(device).GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
-    return GetDispatchTable(device).CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyBuffer(device, buffer, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
-    return GetDispatchTable(device).CreateBufferView(device, pCreateInfo, pAllocator, pView);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyBufferView(device, bufferView, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
-    return GetDispatchTable(device).CreateImage(device, pCreateInfo, pAllocator, pImage);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyImage(device, image, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
-    GetDispatchTable(device).GetImageSubresourceLayout(device, image, pSubresource, pLayout);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
-    return GetDispatchTable(device).CreateImageView(device, pCreateInfo, pAllocator, pView);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyImageView(device, imageView, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
-    return GetDispatchTable(device).CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyShaderModule(device, shaderModule, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
-    return GetDispatchTable(device).CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyPipelineCache(device, pipelineCache, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
-    return GetDispatchTable(device).GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
-    return GetDispatchTable(device).MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
-    return GetDispatchTable(device).CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
-    return GetDispatchTable(device).CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyPipeline(device, pipeline, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
-    return GetDispatchTable(device).CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyPipelineLayout(device, pipelineLayout, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
-    return GetDispatchTable(device).CreateSampler(device, pCreateInfo, pAllocator, pSampler);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroySampler(device, sampler, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
-    return GetDispatchTable(device).CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
-    return GetDispatchTable(device).CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyDescriptorPool(device, descriptorPool, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
-    return GetDispatchTable(device).ResetDescriptorPool(device, descriptorPool, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
-    return GetDispatchTable(device).AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
-    return GetDispatchTable(device).FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
-    GetDispatchTable(device).UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
-    return GetDispatchTable(device).CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyFramebuffer(device, framebuffer, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
-    return GetDispatchTable(device).CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyRenderPass(device, renderPass, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
-    GetDispatchTable(device).GetRenderAreaGranularity(device, renderPass, pGranularity);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
-    return GetDispatchTable(device).CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroyCommandPool(device, commandPool, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
-    return GetDispatchTable(device).ResetCommandPool(device, commandPool, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
-    return AllocateCommandBuffers_Top(device, pAllocateInfo, pCommandBuffers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
-    GetDispatchTable(device).FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
-    return GetDispatchTable(commandBuffer).BeginCommandBuffer(commandBuffer, pBeginInfo);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
-    return GetDispatchTable(commandBuffer).EndCommandBuffer(commandBuffer);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
-    return GetDispatchTable(commandBuffer).ResetCommandBuffer(commandBuffer, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
-    GetDispatchTable(commandBuffer).CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
-    GetDispatchTable(commandBuffer).CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
-    GetDispatchTable(commandBuffer).CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
-    GetDispatchTable(commandBuffer).CmdSetLineWidth(commandBuffer, lineWidth);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
-    GetDispatchTable(commandBuffer).CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
-    GetDispatchTable(commandBuffer).CmdSetBlendConstants(commandBuffer, blendConstants);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
-    GetDispatchTable(commandBuffer).CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
-    GetDispatchTable(commandBuffer).CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
-    GetDispatchTable(commandBuffer).CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
-    GetDispatchTable(commandBuffer).CmdSetStencilReference(commandBuffer, faceMask, reference);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
-    GetDispatchTable(commandBuffer).CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
-    GetDispatchTable(commandBuffer).CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
-    GetDispatchTable(commandBuffer).CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
-    GetDispatchTable(commandBuffer).CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
-    GetDispatchTable(commandBuffer).CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
-    GetDispatchTable(commandBuffer).CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
-    GetDispatchTable(commandBuffer).CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
-    GetDispatchTable(commandBuffer).CmdDispatch(commandBuffer, x, y, z);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
-    GetDispatchTable(commandBuffer).CmdDispatchIndirect(commandBuffer, buffer, offset);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
-    GetDispatchTable(commandBuffer).CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
-    GetDispatchTable(commandBuffer).CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
-    GetDispatchTable(commandBuffer).CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
-    GetDispatchTable(commandBuffer).CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
-    GetDispatchTable(commandBuffer).CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) {
-    GetDispatchTable(commandBuffer).CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
-    GetDispatchTable(commandBuffer).CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
-    GetDispatchTable(commandBuffer).CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
-    GetDispatchTable(commandBuffer).CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
-    GetDispatchTable(commandBuffer).CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
-    GetDispatchTable(commandBuffer).CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
-    GetDispatchTable(commandBuffer).CmdSetEvent(commandBuffer, event, stageMask);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
-    GetDispatchTable(commandBuffer).CmdResetEvent(commandBuffer, event, stageMask);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
-    GetDispatchTable(commandBuffer).CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
-    GetDispatchTable(commandBuffer).CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {
-    GetDispatchTable(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, query, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
-    GetDispatchTable(commandBuffer).CmdEndQuery(commandBuffer, queryPool, query);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
-    GetDispatchTable(commandBuffer).CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {
-    GetDispatchTable(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
-    GetDispatchTable(commandBuffer).CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {
-    GetDispatchTable(commandBuffer).CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
-    GetDispatchTable(commandBuffer).CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
-    GetDispatchTable(commandBuffer).CmdNextSubpass(commandBuffer, contents);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
-    GetDispatchTable(commandBuffer).CmdEndRenderPass(commandBuffer);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
-    GetDispatchTable(commandBuffer).CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(instance).DestroySurfaceKHR(instance, surface, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
-    return GetDispatchTable(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
-    return GetDispatchTable(physicalDevice).GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
-    return GetDispatchTable(physicalDevice).GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
-    return GetDispatchTable(physicalDevice).GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
-    return GetDispatchTable(device).CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {
-    GetDispatchTable(device).DestroySwapchainKHR(device, swapchain, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
-    return GetDispatchTable(device).GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
-    return GetDispatchTable(device).AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
-    return GetDispatchTable(queue).QueuePresentKHR(queue, pPresentInfo);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    return GetDispatchTable(instance).CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-}
-
-// clang-format on
diff --git a/vulkan/libvulkan/dispatch_gen.h b/vulkan/libvulkan/dispatch_gen.h
index cef4ccf..ca31caf 100644
--- a/vulkan/libvulkan/dispatch_gen.h
+++ b/vulkan/libvulkan/dispatch_gen.h
@@ -16,167 +16,11 @@
 
 // WARNING: This file is generated. See ../README.md for instructions.
 
-#define VK_USE_PLATFORM_ANDROID_KHR
 #include <vulkan/vk_android_native_buffer.h>
 #include <vulkan/vulkan.h>
 
 namespace vulkan {
 
-struct InstanceDispatchTable {
-    // clang-format off
-    PFN_vkDestroyInstance DestroyInstance;
-    PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
-    PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
-    PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
-    PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
-    PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
-    PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
-    PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
-    PFN_vkCreateDevice CreateDevice;
-    PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
-    PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
-    PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
-    PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
-    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
-    PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
-    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
-    PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
-    PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT;
-    PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT;
-    PFN_vkDebugReportMessageEXT DebugReportMessageEXT;
-    // clang-format on
-};
-
-struct DeviceDispatchTable {
-    // clang-format off
-    PFN_vkDestroyDevice DestroyDevice;
-    PFN_vkGetDeviceQueue GetDeviceQueue;
-    PFN_vkQueueSubmit QueueSubmit;
-    PFN_vkQueueWaitIdle QueueWaitIdle;
-    PFN_vkDeviceWaitIdle DeviceWaitIdle;
-    PFN_vkAllocateMemory AllocateMemory;
-    PFN_vkFreeMemory FreeMemory;
-    PFN_vkMapMemory MapMemory;
-    PFN_vkUnmapMemory UnmapMemory;
-    PFN_vkFlushMappedMemoryRanges FlushMappedMemoryRanges;
-    PFN_vkInvalidateMappedMemoryRanges InvalidateMappedMemoryRanges;
-    PFN_vkGetDeviceMemoryCommitment GetDeviceMemoryCommitment;
-    PFN_vkGetBufferMemoryRequirements GetBufferMemoryRequirements;
-    PFN_vkBindBufferMemory BindBufferMemory;
-    PFN_vkGetImageMemoryRequirements GetImageMemoryRequirements;
-    PFN_vkBindImageMemory BindImageMemory;
-    PFN_vkGetImageSparseMemoryRequirements GetImageSparseMemoryRequirements;
-    PFN_vkQueueBindSparse QueueBindSparse;
-    PFN_vkCreateFence CreateFence;
-    PFN_vkDestroyFence DestroyFence;
-    PFN_vkResetFences ResetFences;
-    PFN_vkGetFenceStatus GetFenceStatus;
-    PFN_vkWaitForFences WaitForFences;
-    PFN_vkCreateSemaphore CreateSemaphore;
-    PFN_vkDestroySemaphore DestroySemaphore;
-    PFN_vkCreateEvent CreateEvent;
-    PFN_vkDestroyEvent DestroyEvent;
-    PFN_vkGetEventStatus GetEventStatus;
-    PFN_vkSetEvent SetEvent;
-    PFN_vkResetEvent ResetEvent;
-    PFN_vkCreateQueryPool CreateQueryPool;
-    PFN_vkDestroyQueryPool DestroyQueryPool;
-    PFN_vkGetQueryPoolResults GetQueryPoolResults;
-    PFN_vkCreateBuffer CreateBuffer;
-    PFN_vkDestroyBuffer DestroyBuffer;
-    PFN_vkCreateBufferView CreateBufferView;
-    PFN_vkDestroyBufferView DestroyBufferView;
-    PFN_vkCreateImage CreateImage;
-    PFN_vkDestroyImage DestroyImage;
-    PFN_vkGetImageSubresourceLayout GetImageSubresourceLayout;
-    PFN_vkCreateImageView CreateImageView;
-    PFN_vkDestroyImageView DestroyImageView;
-    PFN_vkCreateShaderModule CreateShaderModule;
-    PFN_vkDestroyShaderModule DestroyShaderModule;
-    PFN_vkCreatePipelineCache CreatePipelineCache;
-    PFN_vkDestroyPipelineCache DestroyPipelineCache;
-    PFN_vkGetPipelineCacheData GetPipelineCacheData;
-    PFN_vkMergePipelineCaches MergePipelineCaches;
-    PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines;
-    PFN_vkCreateComputePipelines CreateComputePipelines;
-    PFN_vkDestroyPipeline DestroyPipeline;
-    PFN_vkCreatePipelineLayout CreatePipelineLayout;
-    PFN_vkDestroyPipelineLayout DestroyPipelineLayout;
-    PFN_vkCreateSampler CreateSampler;
-    PFN_vkDestroySampler DestroySampler;
-    PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout;
-    PFN_vkDestroyDescriptorSetLayout DestroyDescriptorSetLayout;
-    PFN_vkCreateDescriptorPool CreateDescriptorPool;
-    PFN_vkDestroyDescriptorPool DestroyDescriptorPool;
-    PFN_vkResetDescriptorPool ResetDescriptorPool;
-    PFN_vkAllocateDescriptorSets AllocateDescriptorSets;
-    PFN_vkFreeDescriptorSets FreeDescriptorSets;
-    PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
-    PFN_vkCreateFramebuffer CreateFramebuffer;
-    PFN_vkDestroyFramebuffer DestroyFramebuffer;
-    PFN_vkCreateRenderPass CreateRenderPass;
-    PFN_vkDestroyRenderPass DestroyRenderPass;
-    PFN_vkGetRenderAreaGranularity GetRenderAreaGranularity;
-    PFN_vkCreateCommandPool CreateCommandPool;
-    PFN_vkDestroyCommandPool DestroyCommandPool;
-    PFN_vkResetCommandPool ResetCommandPool;
-    PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
-    PFN_vkFreeCommandBuffers FreeCommandBuffers;
-    PFN_vkBeginCommandBuffer BeginCommandBuffer;
-    PFN_vkEndCommandBuffer EndCommandBuffer;
-    PFN_vkResetCommandBuffer ResetCommandBuffer;
-    PFN_vkCmdBindPipeline CmdBindPipeline;
-    PFN_vkCmdSetViewport CmdSetViewport;
-    PFN_vkCmdSetScissor CmdSetScissor;
-    PFN_vkCmdSetLineWidth CmdSetLineWidth;
-    PFN_vkCmdSetDepthBias CmdSetDepthBias;
-    PFN_vkCmdSetBlendConstants CmdSetBlendConstants;
-    PFN_vkCmdSetDepthBounds CmdSetDepthBounds;
-    PFN_vkCmdSetStencilCompareMask CmdSetStencilCompareMask;
-    PFN_vkCmdSetStencilWriteMask CmdSetStencilWriteMask;
-    PFN_vkCmdSetStencilReference CmdSetStencilReference;
-    PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets;
-    PFN_vkCmdBindIndexBuffer CmdBindIndexBuffer;
-    PFN_vkCmdBindVertexBuffers CmdBindVertexBuffers;
-    PFN_vkCmdDraw CmdDraw;
-    PFN_vkCmdDrawIndexed CmdDrawIndexed;
-    PFN_vkCmdDrawIndirect CmdDrawIndirect;
-    PFN_vkCmdDrawIndexedIndirect CmdDrawIndexedIndirect;
-    PFN_vkCmdDispatch CmdDispatch;
-    PFN_vkCmdDispatchIndirect CmdDispatchIndirect;
-    PFN_vkCmdCopyBuffer CmdCopyBuffer;
-    PFN_vkCmdCopyImage CmdCopyImage;
-    PFN_vkCmdBlitImage CmdBlitImage;
-    PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage;
-    PFN_vkCmdCopyImageToBuffer CmdCopyImageToBuffer;
-    PFN_vkCmdUpdateBuffer CmdUpdateBuffer;
-    PFN_vkCmdFillBuffer CmdFillBuffer;
-    PFN_vkCmdClearColorImage CmdClearColorImage;
-    PFN_vkCmdClearDepthStencilImage CmdClearDepthStencilImage;
-    PFN_vkCmdClearAttachments CmdClearAttachments;
-    PFN_vkCmdResolveImage CmdResolveImage;
-    PFN_vkCmdSetEvent CmdSetEvent;
-    PFN_vkCmdResetEvent CmdResetEvent;
-    PFN_vkCmdWaitEvents CmdWaitEvents;
-    PFN_vkCmdPipelineBarrier CmdPipelineBarrier;
-    PFN_vkCmdBeginQuery CmdBeginQuery;
-    PFN_vkCmdEndQuery CmdEndQuery;
-    PFN_vkCmdResetQueryPool CmdResetQueryPool;
-    PFN_vkCmdWriteTimestamp CmdWriteTimestamp;
-    PFN_vkCmdCopyQueryPoolResults CmdCopyQueryPoolResults;
-    PFN_vkCmdPushConstants CmdPushConstants;
-    PFN_vkCmdBeginRenderPass CmdBeginRenderPass;
-    PFN_vkCmdNextSubpass CmdNextSubpass;
-    PFN_vkCmdEndRenderPass CmdEndRenderPass;
-    PFN_vkCmdExecuteCommands CmdExecuteCommands;
-    PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
-    PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
-    PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
-    PFN_vkAcquireNextImageKHR AcquireNextImageKHR;
-    PFN_vkQueuePresentKHR QueuePresentKHR;
-    // clang-format on
-};
-
 struct DriverDispatchTable {
     // clang-format off
     PFN_vkDestroyInstance DestroyInstance;
@@ -194,6 +38,9 @@
     PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT;
     PFN_vkDebugReportMessageEXT DebugReportMessageEXT;
     PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
+    PFN_vkDestroyDevice DestroyDevice;
+    PFN_vkGetDeviceQueue GetDeviceQueue;
+    PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
     PFN_vkCreateImage CreateImage;
     PFN_vkDestroyImage DestroyImage;
     PFN_vkGetSwapchainGrallocUsageANDROID GetSwapchainGrallocUsageANDROID;
diff --git a/vulkan/libvulkan/driver.h b/vulkan/libvulkan/driver.h
new file mode 100644
index 0000000..de9d1c6
--- /dev/null
+++ b/vulkan/libvulkan/driver.h
@@ -0,0 +1,165 @@
+/*
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LIBVULKAN_DRIVER_H
+#define LIBVULKAN_DRIVER_H 1
+
+#include <inttypes.h>
+#include <type_traits>
+#include <log/log.h>
+
+#include <vulkan/vulkan.h>
+#include <hardware/hwvulkan.h>
+
+#include "api_gen.h"
+
+namespace vulkan {
+
+// This is here so that we can embed api::{Instance,Device}Data in
+// driver::{Instance,Device}Data to avoid pointer chasing.  They are
+// considered opaque to the driver layer.
+namespace api {
+
+struct InstanceData {
+    InstanceDispatchTable dispatch;
+
+    // for VkPhysicalDevice->VkInstance mapping
+    VkInstance instance;
+
+    // LayerChain::ActiveLayer array
+    void* layers;
+    uint32_t layer_count;
+
+    // debug.vulkan.enable_callback
+    PFN_vkDestroyDebugReportCallbackEXT destroy_debug_callback;
+    VkDebugReportCallbackEXT debug_callback;
+};
+
+struct DeviceData {
+    DeviceDispatchTable dispatch;
+
+    // LayerChain::ActiveLayer array
+    void* layers;
+    uint32_t layer_count;
+};
+
+}  // namespace api
+
+namespace driver {
+
+struct InstanceData {
+    api::InstanceData opaque_api_data;
+
+    const VkAllocationCallbacks allocator;
+};
+
+struct DeviceData {
+    api::DeviceData opaque_api_data;
+
+    const VkAllocationCallbacks allocator;
+};
+
+bool Debuggable();
+bool OpenHAL();
+const VkAllocationCallbacks& GetDefaultAllocator();
+
+// clang-format off
+VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
+VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
+VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+// clang-format on
+
+template <typename DispatchableType>
+void StaticAssertDispatchable(DispatchableType) {
+    static_assert(std::is_same<DispatchableType, VkInstance>::value ||
+                      std::is_same<DispatchableType, VkPhysicalDevice>::value ||
+                      std::is_same<DispatchableType, VkDevice>::value ||
+                      std::is_same<DispatchableType, VkQueue>::value ||
+                      std::is_same<DispatchableType, VkCommandBuffer>::value,
+                  "unrecognized dispatchable type");
+}
+
+template <typename DispatchableType>
+bool SetDataInternal(DispatchableType dispatchable, const void* data) {
+    StaticAssertDispatchable(dispatchable);
+
+    hwvulkan_dispatch_t* dispatch =
+        reinterpret_cast<hwvulkan_dispatch_t*>(dispatchable);
+    // must be magic or already set
+    if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC && dispatch->vtbl != data) {
+        ALOGE("invalid dispatchable object magic 0x%" PRIxPTR, dispatch->magic);
+        return false;
+    }
+
+    dispatch->vtbl = data;
+
+    return true;
+}
+
+template <typename DispatchableType>
+void* GetDataInternal(DispatchableType dispatchable) {
+    StaticAssertDispatchable(dispatchable);
+
+    const hwvulkan_dispatch_t* dispatch =
+        reinterpret_cast<const hwvulkan_dispatch_t*>(dispatchable);
+
+    return const_cast<void*>(dispatch->vtbl);
+}
+
+inline bool SetData(VkInstance instance, const InstanceData& data) {
+    return SetDataInternal(instance, &data);
+}
+
+inline bool SetData(VkPhysicalDevice physical_dev, const InstanceData& data) {
+    return SetDataInternal(physical_dev, &data);
+}
+
+inline bool SetData(VkDevice dev, const DeviceData& data) {
+    return SetDataInternal(dev, &data);
+}
+
+inline bool SetData(VkQueue queue, const DeviceData& data) {
+    return SetDataInternal(queue, &data);
+}
+
+inline bool SetData(VkCommandBuffer cmd, const DeviceData& data) {
+    return SetDataInternal(cmd, &data);
+}
+
+inline InstanceData& GetData(VkInstance instance) {
+    return *reinterpret_cast<InstanceData*>(GetDataInternal(instance));
+}
+
+inline InstanceData& GetData(VkPhysicalDevice physical_dev) {
+    return *reinterpret_cast<InstanceData*>(GetDataInternal(physical_dev));
+}
+
+inline DeviceData& GetData(VkDevice dev) {
+    return *reinterpret_cast<DeviceData*>(GetDataInternal(dev));
+}
+
+inline DeviceData& GetData(VkQueue queue) {
+    return *reinterpret_cast<DeviceData*>(GetDataInternal(queue));
+}
+
+inline DeviceData& GetData(VkCommandBuffer cmd) {
+    return *reinterpret_cast<DeviceData*>(GetDataInternal(cmd));
+}
+
+}  // namespace driver
+}  // namespace vulkan
+
+#endif  // LIBVULKAN_DRIVER_H
diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
index 6531968..65b09db 100644
--- a/vulkan/libvulkan/loader.cpp
+++ b/vulkan/libvulkan/loader.cpp
@@ -16,6 +16,7 @@
 
 // module header
 #include "loader.h"
+#include "driver.h"
 // standard C headers
 #include <dirent.h>
 #include <dlfcn.h>
@@ -150,7 +151,7 @@
         return ptr;
 
     void* new_ptr = nullptr;
-    if (posix_memalign(&new_ptr, alignment, size) != 0)
+    if (posix_memalign(&new_ptr, std::max(alignment, sizeof(void*)), size) != 0)
         return nullptr;
     if (ptr) {
         memcpy(new_ptr, ptr, std::min(old_size, size));
@@ -231,38 +232,21 @@
     g_driver_instance_extensions.reset(kKHR_android_surface);
 }
 
-bool EnsureInitialized() {
-    static std::once_flag once_flag;
-    std::call_once(once_flag, []() {
-        LoadVulkanHAL();
-        DiscoverLayers();
-    });
-    return g_hwdevice != nullptr;
-}
-
 // -----------------------------------------------------------------------------
 
 struct Instance {
     Instance(const VkAllocationCallbacks* alloc_callbacks)
-        : dispatch_ptr(&dispatch),
-          handle(reinterpret_cast<VkInstance>(&dispatch_ptr)),
-          alloc(alloc_callbacks),
-          num_physical_devices(0),
-          active_layers(CallbackAllocator<LayerRef>(alloc)),
-          message(VK_NULL_HANDLE) {
-        memset(&dispatch, 0, sizeof(dispatch));
+        : base{{}, *alloc_callbacks},
+          alloc(&base.allocator),
+          num_physical_devices(0) {
         memset(physical_devices, 0, sizeof(physical_devices));
         enabled_extensions.reset();
-        drv.instance = VK_NULL_HANDLE;
         memset(&drv.dispatch, 0, sizeof(drv.dispatch));
-        drv.num_physical_devices = 0;
     }
 
     ~Instance() {}
 
-    const InstanceDispatchTable* dispatch_ptr;
-    const VkInstance handle;
-    InstanceDispatchTable dispatch;
+    driver::InstanceData base;
 
     const VkAllocationCallbacks* alloc;
     uint32_t num_physical_devices;
@@ -270,29 +254,24 @@
     VkPhysicalDevice physical_devices[kMaxPhysicalDevices];
     DeviceExtensionSet physical_device_driver_extensions[kMaxPhysicalDevices];
 
-    Vector<LayerRef> active_layers;
-    VkDebugReportCallbackEXT message;
     DebugReportCallbackList debug_report_callbacks;
     InstanceExtensionSet enabled_extensions;
 
     struct {
-        VkInstance instance;
         DriverDispatchTable dispatch;
-        uint32_t num_physical_devices;
     } drv;  // may eventually be an array
 };
 
 struct Device {
     Device(Instance* instance_)
-        : instance(instance_),
-          active_layers(CallbackAllocator<LayerRef>(instance->alloc)) {
-        memset(&dispatch, 0, sizeof(dispatch));
+        : base{{}, *instance_->alloc}, instance(instance_) {
         enabled_extensions.reset();
     }
-    DeviceDispatchTable dispatch;
+
+    driver::DeviceData base;
+
     Instance* instance;
     PFN_vkGetDeviceProcAddr get_device_proc_addr;
-    Vector<LayerRef> active_layers;
     DeviceExtensionSet enabled_extensions;
 };
 
@@ -329,230 +308,25 @@
     typedef typename HandleTraits<THandle>::LoaderObjectType ObjectType;
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Winvalid-offsetof"
-    const size_t kDispatchOffset = offsetof(ObjectType, dispatch);
+    const size_t kBaseOffset = offsetof(ObjectType, base);
 #pragma clang diagnostic pop
 
-    const auto& dispatch = GetDispatchTable(handle);
-    uintptr_t dispatch_addr = reinterpret_cast<uintptr_t>(&dispatch);
-    uintptr_t object_addr = dispatch_addr - kDispatchOffset;
+    const auto& base = driver::GetData(handle);
+    uintptr_t base_addr = reinterpret_cast<uintptr_t>(&base);
+    uintptr_t object_addr = base_addr - kBaseOffset;
     return *reinterpret_cast<ObjectType*>(object_addr);
 }
 
 // -----------------------------------------------------------------------------
 
-void DestroyDevice(Device* device) {
-    const VkAllocationCallbacks* alloc = device->instance->alloc;
+void DestroyDevice(Device* device, VkDevice vkdevice) {
+    const auto& instance = *device->instance;
+
+    if (vkdevice != VK_NULL_HANDLE)
+        instance.drv.dispatch.DestroyDevice(vkdevice, instance.alloc);
+
     device->~Device();
-    alloc->pfnFree(alloc->pUserData, device);
-}
-
-template <class TObject>
-LayerRef GetLayerRef(const char* name);
-template <>
-LayerRef GetLayerRef<Instance>(const char* name) {
-    return GetInstanceLayerRef(name);
-}
-template <>
-LayerRef GetLayerRef<Device>(const char* name) {
-    return GetDeviceLayerRef(name);
-}
-
-template <class TObject>
-bool ActivateLayer(TObject* object, const char* name) {
-    LayerRef layer(GetLayerRef<TObject>(name));
-    if (!layer)
-        return false;
-    if (std::find(object->active_layers.begin(), object->active_layers.end(),
-                  layer) == object->active_layers.end()) {
-        try {
-            object->active_layers.push_back(std::move(layer));
-        } catch (std::bad_alloc&) {
-            // TODO(jessehall): We should fail with VK_ERROR_OUT_OF_MEMORY
-            // if we can't enable a requested layer. Callers currently ignore
-            // ActivateLayer's return value.
-            ALOGW("failed to activate layer '%s': out of memory", name);
-            return false;
-        }
-    }
-    ALOGV("activated layer '%s'", name);
-    return true;
-}
-
-struct InstanceNamesPair {
-    Instance* instance;
-    Vector<String>* layer_names;
-};
-
-void SetLayerNamesFromProperty(const char* name,
-                               const char* value,
-                               void* data) {
-    try {
-        const char prefix[] = "debug.vulkan.layer.";
-        const size_t prefixlen = sizeof(prefix) - 1;
-        if (value[0] == '\0' || strncmp(name, prefix, prefixlen) != 0)
-            return;
-        const char* number_str = name + prefixlen;
-        long layer_number = strtol(number_str, nullptr, 10);
-        if (layer_number <= 0 || layer_number == LONG_MAX) {
-            ALOGW("Cannot use a layer at number %ld from string %s",
-                  layer_number, number_str);
-            return;
-        }
-        auto instance_names_pair = static_cast<InstanceNamesPair*>(data);
-        Vector<String>* layer_names = instance_names_pair->layer_names;
-        Instance* instance = instance_names_pair->instance;
-        size_t layer_size = static_cast<size_t>(layer_number);
-        if (layer_size > layer_names->size()) {
-            layer_names->resize(
-                layer_size, String(CallbackAllocator<char>(instance->alloc)));
-        }
-        (*layer_names)[layer_size - 1] = value;
-    } catch (std::bad_alloc&) {
-        ALOGW("failed to handle property '%s'='%s': out of memory", name,
-              value);
-        return;
-    }
-}
-
-template <class TInfo, class TObject>
-VkResult ActivateAllLayers(TInfo create_info,
-                           Instance* instance,
-                           TObject* object) {
-    ALOG_ASSERT(create_info->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO ||
-                    create_info->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
-                "Cannot activate layers for unknown object %p", object);
-    CallbackAllocator<char> string_allocator(instance->alloc);
-    // Load system layers
-    if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {
-        char layer_prop[PROPERTY_VALUE_MAX];
-        property_get("debug.vulkan.layers", layer_prop, "");
-        char* strtok_state;
-        char* layer_name = nullptr;
-        while ((layer_name = strtok_r(layer_name ? nullptr : layer_prop, ":",
-                                      &strtok_state))) {
-            ActivateLayer(object, layer_name);
-        }
-        Vector<String> layer_names(CallbackAllocator<String>(instance->alloc));
-        InstanceNamesPair instance_names_pair = {.instance = instance,
-                                                 .layer_names = &layer_names};
-        property_list(SetLayerNamesFromProperty,
-                      static_cast<void*>(&instance_names_pair));
-        for (auto layer_name_element : layer_names) {
-            ActivateLayer(object, layer_name_element.c_str());
-        }
-    }
-    // Load app layers
-    for (uint32_t i = 0; i < create_info->enabledLayerCount; ++i) {
-        if (!ActivateLayer(object, create_info->ppEnabledLayerNames[i])) {
-            ALOGE("requested %s layer '%s' not present",
-                  create_info->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
-                      ? "instance"
-                      : "device",
-                  create_info->ppEnabledLayerNames[i]);
-            return VK_ERROR_LAYER_NOT_PRESENT;
-        }
-    }
-    return VK_SUCCESS;
-}
-
-template <class TCreateInfo, class TObject>
-bool AddLayersToCreateInfo(TCreateInfo& local_create_info,
-                           const TObject& object,
-                           const VkAllocationCallbacks* alloc,
-                           bool& allocatedMemory) {
-    // This should never happen and means there is a likely a bug in layer
-    // tracking
-    if (object->active_layers.size() < local_create_info.enabledLayerCount) {
-        ALOGE("Total number of layers is less than those enabled by the app!");
-        return false;
-    }
-    // Check if the total number of layers enabled is greater than those
-    // enabled by the application. If it is then we have system enabled
-    // layers which need to be added to the list of layers passed in through
-    // create.
-    if (object->active_layers.size() > local_create_info.enabledLayerCount) {
-        void* mem = alloc->pfnAllocation(
-            alloc->pUserData, object->active_layers.size() * sizeof(char*),
-            alignof(char*), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
-        if (mem) {
-            local_create_info.enabledLayerCount = 0;
-            const char** names = static_cast<const char**>(mem);
-            for (const auto& layer : object->active_layers) {
-                const char* name = layer.GetName();
-                names[local_create_info.enabledLayerCount++] = name;
-            }
-            local_create_info.ppEnabledLayerNames = names;
-        } else {
-            ALOGE("System layers cannot be enabled: memory allocation failed");
-            return false;
-        }
-        allocatedMemory = true;
-    } else {
-        allocatedMemory = false;
-    }
-    return true;
-}
-
-template <class T>
-void FreeAllocatedLayerCreateInfo(T& local_create_info,
-                                  const VkAllocationCallbacks* alloc) {
-    alloc->pfnFree(alloc->pUserData,
-                   const_cast<char**>(local_create_info.ppEnabledLayerNames));
-}
-
-template <class TCreateInfo>
-bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,
-                              const char* extension_name,
-                              const VkAllocationCallbacks* alloc) {
-    uint32_t extension_count = local_create_info.enabledExtensionCount;
-    local_create_info.enabledExtensionCount++;
-    void* mem = alloc->pfnAllocation(
-        alloc->pUserData,
-        local_create_info.enabledExtensionCount * sizeof(char*), alignof(char*),
-        VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
-    if (mem) {
-        const char** enabled_extensions = static_cast<const char**>(mem);
-        for (uint32_t i = 0; i < extension_count; ++i) {
-            enabled_extensions[i] =
-                local_create_info.ppEnabledExtensionNames[i];
-        }
-        enabled_extensions[extension_count] = extension_name;
-        local_create_info.ppEnabledExtensionNames = enabled_extensions;
-    } else {
-        ALOGE("%s extension cannot be enabled: memory allocation failed",
-              extension_name);
-        return false;
-    }
-    return true;
-}
-
-template <class T>
-void FreeAllocatedExtensionCreateInfo(T& local_create_info,
-                                      const VkAllocationCallbacks* alloc) {
-    alloc->pfnFree(
-        alloc->pUserData,
-        const_cast<char**>(local_create_info.ppEnabledExtensionNames));
-}
-
-VKAPI_ATTR
-VkBool32 LogDebugMessageCallback(VkDebugReportFlagsEXT flags,
-                                 VkDebugReportObjectTypeEXT /*objectType*/,
-                                 uint64_t /*object*/,
-                                 size_t /*location*/,
-                                 int32_t message_code,
-                                 const char* layer_prefix,
-                                 const char* message,
-                                 void* /*user_data*/) {
-    if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
-        ALOGE("[%s] Code %d : %s", layer_prefix, message_code, message);
-    } else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
-        ALOGW("[%s] Code %d : %s", layer_prefix, message_code, message);
-    }
-    return false;
-}
-
-VkResult Noop() {
-    return VK_SUCCESS;
+    instance.alloc->pfnFree(instance.alloc->pUserData, device);
 }
 
 /*
@@ -583,16 +357,11 @@
 // function, iff the lower vkCreateInstance call has been made and returned
 // successfully.
 void DestroyInstance(Instance* instance,
-                     const VkAllocationCallbacks* allocator) {
-    if (instance->message) {
-        PFN_vkDestroyDebugReportCallbackEXT destroy_debug_report_callback;
-        destroy_debug_report_callback =
-            reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(
-                GetInstanceProcAddr_Top(instance->handle,
-                                        "vkDestroyDebugReportCallbackEXT"));
-        destroy_debug_report_callback(instance->handle, instance->message,
-                                      allocator);
-    }
+                     const VkAllocationCallbacks* allocator,
+                     VkInstance vkinstance) {
+    if (vkinstance != VK_NULL_HANDLE && instance->drv.dispatch.DestroyInstance)
+        instance->drv.dispatch.DestroyInstance(vkinstance, allocator);
+
     instance->~Instance();
     allocator->pfnFree(allocator->pUserData, instance);
 }
@@ -610,20 +379,15 @@
                                VkInstance* vkinstance) {
     VkResult result;
 
-    VkLayerInstanceCreateInfo* chain_info =
-        const_cast<VkLayerInstanceCreateInfo*>(
-            static_cast<const VkLayerInstanceCreateInfo*>(create_info->pNext));
-    while (
-        chain_info &&
-        !(chain_info->sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO &&
-          chain_info->function == VK_LAYER_FUNCTION_INSTANCE)) {
-        chain_info = const_cast<VkLayerInstanceCreateInfo*>(
-            static_cast<const VkLayerInstanceCreateInfo*>(chain_info->pNext));
-    }
-    ALOG_ASSERT(chain_info != nullptr, "Missing initialization chain info!");
+    if (!allocator)
+        allocator = &kDefaultAllocCallbacks;
 
-    Instance& instance = GetDispatchParent(
-        static_cast<VkInstance>(chain_info->u.instanceInfo.instance_info));
+    void* instance_mem = allocator->pfnAllocation(
+        allocator->pUserData, sizeof(Instance), alignof(Instance),
+        VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+    if (!instance_mem)
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    Instance& instance = *new (instance_mem) Instance(allocator);
 
     // Check that all enabled extensions are supported
     uint32_t num_driver_extensions = 0;
@@ -645,19 +409,6 @@
                 continue;
             }
         }
-        bool supported = false;
-        for (const auto& layer : instance.active_layers) {
-            if (layer.SupportsExtension(name))
-                supported = true;
-        }
-        if (!supported) {
-            ALOGE(
-                "requested instance extension '%s' not supported by "
-                "loader, driver, or any active layers",
-                name);
-            DestroyInstance_Bottom(instance.handle, allocator);
-            return VK_ERROR_EXTENSION_NOT_PRESENT;
-        }
     }
 
     VkInstanceCreateInfo driver_create_info = *create_info;
@@ -686,60 +437,48 @@
             "different answers!");
     }
 
+    VkInstance drv_instance;
     result = g_hwdevice->CreateInstance(&driver_create_info, instance.alloc,
-                                        &instance.drv.instance);
+                                        &drv_instance);
     if (result != VK_SUCCESS) {
-        DestroyInstance_Bottom(instance.handle, allocator);
+        DestroyInstance(&instance, allocator, VK_NULL_HANDLE);
         return result;
     }
 
-    hwvulkan_dispatch_t* drv_dispatch =
-        reinterpret_cast<hwvulkan_dispatch_t*>(instance.drv.instance);
-    if (drv_dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
-        ALOGE("invalid VkInstance dispatch magic: 0x%" PRIxPTR,
-              drv_dispatch->magic);
-        DestroyInstance_Bottom(instance.handle, allocator);
+    if (!driver::SetData(drv_instance, instance.base)) {
+        DestroyInstance(&instance, allocator, drv_instance);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
-    // Skip setting drv_dispatch->vtbl, since we never call through it;
-    // we go through instance.drv.dispatch instead.
 
-    if (!LoadDriverDispatchTable(
-            instance.drv.instance, g_hwdevice->GetInstanceProcAddr,
-            instance.enabled_extensions, instance.drv.dispatch)) {
-        DestroyInstance_Bottom(instance.handle, allocator);
+    if (!LoadDriverDispatchTable(drv_instance, g_hwdevice->GetInstanceProcAddr,
+                                 instance.enabled_extensions,
+                                 instance.drv.dispatch)) {
+        DestroyInstance(&instance, allocator, drv_instance);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
     uint32_t num_physical_devices = 0;
     result = instance.drv.dispatch.EnumeratePhysicalDevices(
-        instance.drv.instance, &num_physical_devices, nullptr);
+        drv_instance, &num_physical_devices, nullptr);
     if (result != VK_SUCCESS) {
-        DestroyInstance_Bottom(instance.handle, allocator);
+        DestroyInstance(&instance, allocator, drv_instance);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
     num_physical_devices = std::min(num_physical_devices, kMaxPhysicalDevices);
     result = instance.drv.dispatch.EnumeratePhysicalDevices(
-        instance.drv.instance, &num_physical_devices,
-        instance.physical_devices);
+        drv_instance, &num_physical_devices, instance.physical_devices);
     if (result != VK_SUCCESS) {
-        DestroyInstance_Bottom(instance.handle, allocator);
+        DestroyInstance(&instance, allocator, drv_instance);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
     Vector<VkExtensionProperties> extensions(
         Vector<VkExtensionProperties>::allocator_type(instance.alloc));
     for (uint32_t i = 0; i < num_physical_devices; i++) {
-        hwvulkan_dispatch_t* pdev_dispatch =
-            reinterpret_cast<hwvulkan_dispatch_t*>(
-                instance.physical_devices[i]);
-        if (pdev_dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
-            ALOGE("invalid VkPhysicalDevice dispatch magic: 0x%" PRIxPTR,
-                  pdev_dispatch->magic);
-            DestroyInstance_Bottom(instance.handle, allocator);
+        if (!driver::SetData(instance.physical_devices[i], instance.base)) {
+            DestroyInstance(&instance, allocator, drv_instance);
             return VK_ERROR_INITIALIZATION_FAILED;
         }
-        pdev_dispatch->vtbl = instance.dispatch_ptr;
 
         uint32_t count;
         if ((result = instance.drv.dispatch.EnumerateDeviceExtensionProperties(
@@ -753,7 +492,7 @@
             extensions.resize(count);
         } catch (std::bad_alloc&) {
             ALOGE("instance creation failed: out of memory");
-            DestroyInstance_Bottom(instance.handle, allocator);
+            DestroyInstance(&instance, allocator, drv_instance);
             return VK_ERROR_OUT_OF_HOST_MEMORY;
         }
         if ((result = instance.drv.dispatch.EnumerateDeviceExtensionProperties(
@@ -778,10 +517,9 @@
         // Ignore driver attempts to support loader extensions
         instance.physical_device_driver_extensions[i].reset(kKHR_swapchain);
     }
-    instance.drv.num_physical_devices = num_physical_devices;
-    instance.num_physical_devices = instance.drv.num_physical_devices;
+    instance.num_physical_devices = num_physical_devices;
 
-    *vkinstance = instance.handle;
+    *vkinstance = drv_instance;
 
     return VK_SUCCESS;
 }
@@ -888,7 +626,7 @@
     }
     if ((pfn = GetLoaderBottomProcAddr(name)))
         return pfn;
-    return nullptr;
+    return g_hwdevice->GetInstanceProcAddr(vkinstance, name);
 }
 
 VkResult EnumeratePhysicalDevices_Bottom(VkInstance vkinstance,
@@ -968,15 +706,38 @@
             properties);
 }
 
-// This is a no-op, the Top function returns the aggregate layer property
-// data. This is to keep the dispatch generator happy.
 VKAPI_ATTR
 VkResult EnumerateDeviceExtensionProperties_Bottom(
-    VkPhysicalDevice /*pdev*/,
-    const char* /*layer_name*/,
-    uint32_t* /*properties_count*/,
-    VkExtensionProperties* /*properties*/) {
-    return VK_SUCCESS;
+    VkPhysicalDevice pdev,
+    const char* layer_name,
+    uint32_t* properties_count,
+    VkExtensionProperties* properties) {
+    (void)layer_name;
+
+    Instance& instance = GetDispatchParent(pdev);
+
+    size_t gpu_idx = 0;
+    while (instance.physical_devices[gpu_idx] != pdev)
+        gpu_idx++;
+    const DeviceExtensionSet driver_extensions =
+        instance.physical_device_driver_extensions[gpu_idx];
+
+    // We only support VK_KHR_swapchain if the GPU supports
+    // VK_ANDROID_native_buffer
+    VkExtensionProperties* available = static_cast<VkExtensionProperties*>(
+        alloca(kDeviceExtensionCount * sizeof(VkExtensionProperties)));
+    uint32_t num_extensions = 0;
+    if (driver_extensions[kANDROID_native_buffer]) {
+        available[num_extensions++] = VkExtensionProperties{
+            VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_SWAPCHAIN_SPEC_VERSION};
+    }
+
+    if (!properties || *properties_count > num_extensions)
+        *properties_count = num_extensions;
+    if (properties)
+        std::copy(available, available + *properties_count, properties);
+
+    return *properties_count < num_extensions ? VK_INCOMPLETE : VK_SUCCESS;
 }
 
 // This is a no-op, the Top function returns the aggregate layer property
@@ -994,23 +755,24 @@
                              const VkDeviceCreateInfo* create_info,
                              const VkAllocationCallbacks* allocator,
                              VkDevice* device_out) {
-    VkLayerDeviceCreateInfo* chain_info = const_cast<VkLayerDeviceCreateInfo*>(
-        static_cast<const VkLayerDeviceCreateInfo*>(create_info->pNext));
-    while (chain_info &&
-           !(chain_info->sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO &&
-             chain_info->function == VK_LAYER_FUNCTION_DEVICE)) {
-        chain_info = const_cast<VkLayerDeviceCreateInfo*>(
-            static_cast<const VkLayerDeviceCreateInfo*>(chain_info->pNext));
-    }
-    ALOG_ASSERT(chain_info != nullptr, "Missing initialization chain info!");
-
     Instance& instance = GetDispatchParent(gpu);
+
+    // FIXME(jessehall): We don't have good conventions or infrastructure yet to
+    // do better than just using the instance allocator and scope for
+    // everything. See b/26732122.
+    if (true /*!allocator*/)
+        allocator = instance.alloc;
+
+    void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Device),
+                                         alignof(Device),
+                                         VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
+    if (!mem)
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    Device* device = new (mem) Device(&instance);
+
     size_t gpu_idx = 0;
     while (instance.physical_devices[gpu_idx] != gpu)
         gpu_idx++;
-    Device* device = static_cast<Device*>(chain_info->u.deviceInfo.device_info);
-    PFN_vkGetInstanceProcAddr get_instance_proc_addr =
-        chain_info->u.deviceInfo.pfnNextGetInstanceProcAddr;
 
     VkDeviceCreateInfo driver_create_info = *create_info;
     driver_create_info.pNext = StripCreateExtensions(create_info->pNext);
@@ -1040,18 +802,6 @@
                 continue;
             }
         }
-        bool supported = false;
-        for (const auto& layer : device->active_layers) {
-            if (layer.SupportsExtension(name))
-                supported = true;
-        }
-        if (!supported) {
-            ALOGE(
-                "requested device extension '%s' not supported by loader, "
-                "driver, or any active layers",
-                name);
-            return VK_ERROR_EXTENSION_NOT_PRESENT;
-        }
     }
 
     driver_create_info.enabledExtensionCount = num_driver_extensions;
@@ -1060,25 +810,15 @@
     VkResult result = instance.drv.dispatch.CreateDevice(
         gpu, &driver_create_info, allocator, &drv_device);
     if (result != VK_SUCCESS) {
+        DestroyDevice(device, VK_NULL_HANDLE);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
-    hwvulkan_dispatch_t* drv_dispatch =
-        reinterpret_cast<hwvulkan_dispatch_t*>(drv_device);
-    if (drv_dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
-        ALOGE("invalid VkDevice dispatch magic: 0x%" PRIxPTR,
-              drv_dispatch->magic);
-        PFN_vkDestroyDevice destroy_device =
-            reinterpret_cast<PFN_vkDestroyDevice>(
-                instance.drv.dispatch.GetDeviceProcAddr(drv_device,
-                                                        "vkDestroyDevice"));
-        destroy_device(drv_device, allocator);
+    if (!driver::SetData(drv_device, device->base)) {
+        DestroyDevice(device, drv_device);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
-    // Set dispatch table for newly created Device
-    // CreateDevice_Top will fill in the details
-    drv_dispatch->vtbl = &device->dispatch;
     device->get_device_proc_addr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(
         instance.drv.dispatch.GetDeviceProcAddr(drv_device,
                                                 "vkGetDeviceProcAddr"));
@@ -1090,14 +830,13 @@
                             const VkAllocationCallbacks* allocator) {
     Instance& instance = GetDispatchParent(vkinstance);
 
-    // These checks allow us to call DestroyInstance_Bottom from any error
-    // path in CreateInstance_Bottom, before the driver instance is fully
-    // initialized.
-    if (instance.drv.instance != VK_NULL_HANDLE &&
-        instance.drv.dispatch.DestroyInstance) {
-        instance.drv.dispatch.DestroyInstance(instance.drv.instance, allocator);
-        instance.drv.instance = VK_NULL_HANDLE;
+    VkAllocationCallbacks local_allocator;
+    if (!allocator) {
+        local_allocator = *instance.alloc;
+        allocator = &local_allocator;
     }
+
+    DestroyInstance(&instance, allocator, vkinstance);
 }
 
 VkResult CreateSwapchainKHR_Disabled(VkDevice,
@@ -1185,507 +924,36 @@
     return GetDispatchParent(vkdevice).get_device_proc_addr(vkdevice, name);
 }
 
-// -----------------------------------------------------------------------------
-// Loader top functions. These are called directly from the loader entry
-// points or from the application (via vkGetInstanceProcAddr) without going
-// through a dispatch table.
-
-VkResult EnumerateInstanceExtensionProperties_Top(
-    const char* layer_name,
-    uint32_t* properties_count,
-    VkExtensionProperties* properties) {
-    if (!EnsureInitialized())
-        return VK_ERROR_INITIALIZATION_FAILED;
-
-    const VkExtensionProperties* extensions = nullptr;
-    uint32_t num_extensions = 0;
-    if (layer_name) {
-        GetInstanceLayerExtensions(layer_name, &extensions, &num_extensions);
-    } else {
-        VkExtensionProperties* available = static_cast<VkExtensionProperties*>(
-            alloca(kInstanceExtensionCount * sizeof(VkExtensionProperties)));
-        available[num_extensions++] = VkExtensionProperties{
-            VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION};
-        available[num_extensions++] =
-            VkExtensionProperties{VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
-                                  VK_KHR_ANDROID_SURFACE_SPEC_VERSION};
-        if (g_driver_instance_extensions[kEXT_debug_report]) {
-            available[num_extensions++] =
-                VkExtensionProperties{VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
-                                      VK_EXT_DEBUG_REPORT_SPEC_VERSION};
-        }
-        // TODO(jessehall): We need to also enumerate extensions supported by
-        // implicitly-enabled layers. Currently we don't have that list of
-        // layers until instance creation.
-        extensions = available;
-    }
-
-    if (!properties || *properties_count > num_extensions)
-        *properties_count = num_extensions;
-    if (properties)
-        std::copy(extensions, extensions + *properties_count, properties);
-    return *properties_count < num_extensions ? VK_INCOMPLETE : VK_SUCCESS;
+void DestroyDevice_Bottom(VkDevice vkdevice, const VkAllocationCallbacks*) {
+    DestroyDevice(&GetDispatchParent(vkdevice), vkdevice);
 }
 
-VkResult EnumerateInstanceLayerProperties_Top(uint32_t* properties_count,
-                                              VkLayerProperties* properties) {
-    if (!EnsureInitialized())
-        return VK_ERROR_INITIALIZATION_FAILED;
+void GetDeviceQueue_Bottom(VkDevice vkdevice,
+                           uint32_t family,
+                           uint32_t index,
+                           VkQueue* queue_out) {
+    const auto& device = GetDispatchParent(vkdevice);
+    const auto& instance = *device.instance;
 
-    uint32_t layer_count =
-        EnumerateInstanceLayers(properties ? *properties_count : 0, properties);
-    if (!properties || *properties_count > layer_count)
-        *properties_count = layer_count;
-    return *properties_count < layer_count ? VK_INCOMPLETE : VK_SUCCESS;
+    instance.drv.dispatch.GetDeviceQueue(vkdevice, family, index, queue_out);
+    driver::SetData(*queue_out, device.base);
 }
 
-VKAPI_ATTR
-VkResult EnumerateDeviceExtensionProperties_Top(
-    VkPhysicalDevice gpu,
-    const char* layer_name,
-    uint32_t* properties_count,
-    VkExtensionProperties* properties) {
-    const VkExtensionProperties* extensions = nullptr;
-    uint32_t num_extensions = 0;
-
-    ALOGV("EnumerateDeviceExtensionProperties_Top:");
-    if (layer_name) {
-        ALOGV("  layer %s", layer_name);
-        GetDeviceLayerExtensions(layer_name, &extensions, &num_extensions);
-    } else {
-        ALOGV("  no layer");
-        Instance& instance = GetDispatchParent(gpu);
-        size_t gpu_idx = 0;
-        while (instance.physical_devices_top[gpu_idx] != gpu)
-            gpu_idx++;
-        const DeviceExtensionSet driver_extensions =
-            instance.physical_device_driver_extensions[gpu_idx];
-
-        // We only support VK_KHR_swapchain if the GPU supports
-        // VK_ANDROID_native_buffer
-        VkExtensionProperties* available = static_cast<VkExtensionProperties*>(
-            alloca(kDeviceExtensionCount * sizeof(VkExtensionProperties)));
-        if (driver_extensions[kANDROID_native_buffer]) {
-            available[num_extensions++] = VkExtensionProperties{
-                VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_SWAPCHAIN_SPEC_VERSION};
-        }
-
-        // TODO(jessehall): We need to also enumerate extensions supported by
-        // implicitly-enabled layers. Currently we don't have that list of
-        // layers until instance creation.
-        extensions = available;
-    }
-
-    ALOGV("  num: %d, extensions: %p", num_extensions, extensions);
-    if (!properties || *properties_count > num_extensions)
-        *properties_count = num_extensions;
-    if (properties)
-        std::copy(extensions, extensions + *properties_count, properties);
-    return *properties_count < num_extensions ? VK_INCOMPLETE : VK_SUCCESS;
-}
-
-VkResult CreateInstance_Top(const VkInstanceCreateInfo* create_info,
-                            const VkAllocationCallbacks* allocator,
-                            VkInstance* instance_out) {
-    VkResult result;
-
-    if (!EnsureInitialized())
-        return VK_ERROR_INITIALIZATION_FAILED;
-
-    if (!allocator)
-        allocator = &kDefaultAllocCallbacks;
-
-    VkInstanceCreateInfo local_create_info = *create_info;
-    create_info = &local_create_info;
-
-    void* instance_mem = allocator->pfnAllocation(
-        allocator->pUserData, sizeof(Instance), alignof(Instance),
-        VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (!instance_mem)
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    Instance* instance = new (instance_mem) Instance(allocator);
-
-    result = ActivateAllLayers(create_info, instance, instance);
-    if (result != VK_SUCCESS) {
-        DestroyInstance(instance, allocator);
-        return result;
-    }
-
-    uint32_t activated_layers = 0;
-    VkLayerInstanceCreateInfo chain_info;
-    VkLayerInstanceLink* layer_instance_link_info = nullptr;
-    PFN_vkGetInstanceProcAddr next_gipa = GetInstanceProcAddr_Bottom;
-    VkInstance local_instance = nullptr;
-
-    if (instance->active_layers.size() > 0) {
-        chain_info.u.pLayerInfo = nullptr;
-        chain_info.pNext = create_info->pNext;
-        chain_info.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
-        chain_info.function = VK_LAYER_FUNCTION_LINK;
-        local_create_info.pNext = &chain_info;
-
-        layer_instance_link_info = static_cast<VkLayerInstanceLink*>(alloca(
-            sizeof(VkLayerInstanceLink) * instance->active_layers.size()));
-        if (!layer_instance_link_info) {
-            ALOGE("Failed to alloc Instance objects for layers");
-            DestroyInstance(instance, allocator);
-            return VK_ERROR_OUT_OF_HOST_MEMORY;
-        }
-
-        /* Create instance chain of enabled layers */
-        for (auto rit = instance->active_layers.rbegin();
-             rit != instance->active_layers.rend(); ++rit) {
-            LayerRef& layer = *rit;
-            layer_instance_link_info[activated_layers].pNext =
-                chain_info.u.pLayerInfo;
-            layer_instance_link_info[activated_layers]
-                .pfnNextGetInstanceProcAddr = next_gipa;
-            chain_info.u.pLayerInfo =
-                &layer_instance_link_info[activated_layers];
-            next_gipa = layer.GetGetInstanceProcAddr();
-
-            ALOGV("Insert instance layer %s (v%u)", layer.GetName(),
-                  layer.GetSpecVersion());
-
-            activated_layers++;
-        }
-    }
-
-    PFN_vkCreateInstance create_instance =
-        reinterpret_cast<PFN_vkCreateInstance>(
-            next_gipa(VK_NULL_HANDLE, "vkCreateInstance"));
-    if (!create_instance) {
-        DestroyInstance(instance, allocator);
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-    VkLayerInstanceCreateInfo instance_create_info;
-
-    instance_create_info.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
-    instance_create_info.function = VK_LAYER_FUNCTION_INSTANCE;
-
-    instance_create_info.u.instanceInfo.instance_info = instance;
-    instance_create_info.u.instanceInfo.pfnNextGetInstanceProcAddr = next_gipa;
-
-    instance_create_info.pNext = local_create_info.pNext;
-    local_create_info.pNext = &instance_create_info;
-
-    // Force enable callback extension if required
-    bool enable_callback = false;
-    if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {
-        enable_callback =
-            property_get_bool("debug.vulkan.enable_callback", false);
-        if (enable_callback) {
-            if (!AddExtensionToCreateInfo(local_create_info,
-                                          "VK_EXT_debug_report", allocator)) {
-                DestroyInstance(instance, allocator);
-                return VK_ERROR_INITIALIZATION_FAILED;
-            }
-        }
-    }
-    bool allocatedLayerMem;
-    if (!AddLayersToCreateInfo(local_create_info, instance, allocator,
-                               allocatedLayerMem)) {
-        if (enable_callback) {
-            FreeAllocatedExtensionCreateInfo(local_create_info, allocator);
-        }
-        DestroyInstance(instance, allocator);
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-
-    result = create_instance(&local_create_info, allocator, &local_instance);
-
-    if (allocatedLayerMem) {
-        FreeAllocatedLayerCreateInfo(local_create_info, allocator);
-    }
-    if (enable_callback) {
-        FreeAllocatedExtensionCreateInfo(local_create_info, allocator);
-    }
-
-    if (result != VK_SUCCESS) {
-        DestroyInstance(instance, allocator);
-        return result;
-    }
-
-    const InstanceDispatchTable& instance_dispatch =
-        GetDispatchTable(local_instance);
-    if (!LoadInstanceDispatchTable(
-            local_instance, next_gipa,
-            const_cast<InstanceDispatchTable&>(instance_dispatch))) {
-        ALOGV("Failed to initialize instance dispatch table");
-        PFN_vkDestroyInstance destroy_instance =
-            reinterpret_cast<PFN_vkDestroyInstance>(
-                next_gipa(local_instance, "vkDestroyInstance"));
-        if (!destroy_instance) {
-            ALOGD("Loader unable to find DestroyInstance");
-            return VK_ERROR_INITIALIZATION_FAILED;
-        }
-        destroy_instance(local_instance, allocator);
-        DestroyInstance(instance, allocator);
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-
-    // Capture the physical devices from the top of the
-    // chain in case it has been wrapped by a layer.
-    uint32_t num_physical_devices = 0;
-    result = instance_dispatch.EnumeratePhysicalDevices(
-        local_instance, &num_physical_devices, nullptr);
-    if (result != VK_SUCCESS) {
-        DestroyInstance(instance, allocator);
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-    num_physical_devices = std::min(num_physical_devices, kMaxPhysicalDevices);
-    result = instance_dispatch.EnumeratePhysicalDevices(
-        local_instance, &num_physical_devices,
-        instance->physical_devices_top);
-    if (result != VK_SUCCESS) {
-        DestroyInstance(instance, allocator);
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-    *instance_out = local_instance;
-
-    if (enable_callback) {
-        const VkDebugReportCallbackCreateInfoEXT callback_create_info = {
-            .sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT,
-            .flags =
-                VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT,
-            .pfnCallback = LogDebugMessageCallback,
-        };
-        PFN_vkCreateDebugReportCallbackEXT create_debug_report_callback =
-            reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(
-                GetInstanceProcAddr_Top(instance->handle,
-                                        "vkCreateDebugReportCallbackEXT"));
-        create_debug_report_callback(instance->handle, &callback_create_info,
-                                     allocator, &instance->message);
-    }
-
-    return result;
-}
-
-PFN_vkVoidFunction GetInstanceProcAddr_Top(VkInstance vkinstance,
-                                           const char* name) {
-    // vkGetInstanceProcAddr(NULL_HANDLE, ..) only works for global commands
-    if (!vkinstance)
-        return GetLoaderGlobalProcAddr(name);
-
-    const InstanceDispatchTable& dispatch = GetDispatchTable(vkinstance);
-    PFN_vkVoidFunction pfn;
-    // Always go through the loader-top function if there is one.
-    if ((pfn = GetLoaderTopProcAddr(name)))
-        return pfn;
-    // Otherwise, look up the handler in the instance dispatch table
-    if ((pfn = GetDispatchProcAddr(dispatch, name)))
-        return pfn;
-    // Anything not handled already must be a device-dispatched function
-    // without a loader-top. We must return a function that will dispatch based
-    // on the dispatchable object parameter -- which is exactly what the
-    // exported functions do. So just return them here.
-    return GetLoaderExportProcAddr(name);
-}
-
-void DestroyInstance_Top(VkInstance vkinstance,
-                         const VkAllocationCallbacks* allocator) {
-    if (!vkinstance)
-        return;
-    if (!allocator)
-        allocator = &kDefaultAllocCallbacks;
-    GetDispatchTable(vkinstance).DestroyInstance(vkinstance, allocator);
-    DestroyInstance(&(GetDispatchParent(vkinstance)), allocator);
-}
-
-VKAPI_ATTR
-VkResult EnumerateDeviceLayerProperties_Top(VkPhysicalDevice /*pdev*/,
-                                               uint32_t* properties_count,
-                                               VkLayerProperties* properties) {
-    uint32_t layer_count =
-        EnumerateDeviceLayers(properties ? *properties_count : 0, properties);
-    if (!properties || *properties_count > layer_count)
-        *properties_count = layer_count;
-    return *properties_count < layer_count ? VK_INCOMPLETE : VK_SUCCESS;
-}
-
-VKAPI_ATTR
-VkResult CreateDevice_Top(VkPhysicalDevice gpu,
-                          const VkDeviceCreateInfo* create_info,
-                          const VkAllocationCallbacks* allocator,
-                          VkDevice* device_out) {
-    Instance& instance = GetDispatchParent(gpu);
-    VkResult result;
-
-    // FIXME(jessehall): We don't have good conventions or infrastructure yet to
-    // do better than just using the instance allocator and scope for
-    // everything. See b/26732122.
-    if (true /*!allocator*/)
-        allocator = instance.alloc;
-
-    void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Device),
-                                         alignof(Device),
-                                         VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
-    if (!mem)
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    Device* device = new (mem) Device(&instance);
-
-    result = ActivateAllLayers(create_info, &instance, device);
-    if (result != VK_SUCCESS) {
-        DestroyDevice(device);
-        return result;
-    }
-
-    uint32_t activated_layers = 0;
-    VkLayerDeviceCreateInfo chain_info;
-    VkLayerDeviceLink* layer_device_link_info = nullptr;
-    PFN_vkGetInstanceProcAddr next_gipa = GetInstanceProcAddr_Bottom;
-    PFN_vkGetDeviceProcAddr next_gdpa = GetDeviceProcAddr_Bottom;
-    VkDeviceCreateInfo local_create_info = *create_info;
-    VkDevice local_device = nullptr;
-
-    if (device->active_layers.size() > 0) {
-        chain_info.u.pLayerInfo = nullptr;
-        chain_info.pNext = local_create_info.pNext;
-        chain_info.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
-        chain_info.function = VK_LAYER_FUNCTION_LINK;
-        local_create_info.pNext = &chain_info;
-
-        layer_device_link_info = static_cast<VkLayerDeviceLink*>(
-            alloca(sizeof(VkLayerDeviceLink) * device->active_layers.size()));
-        if (!layer_device_link_info) {
-            ALOGE("Failed to alloc Device objects for layers");
-            DestroyDevice(device);
-            return VK_ERROR_OUT_OF_HOST_MEMORY;
-        }
-
-        /* Create device chain of enabled layers */
-        for (auto rit = device->active_layers.rbegin();
-             rit != device->active_layers.rend(); ++rit) {
-            LayerRef& layer = *rit;
-            layer_device_link_info[activated_layers].pNext =
-                chain_info.u.pLayerInfo;
-            layer_device_link_info[activated_layers].pfnNextGetDeviceProcAddr =
-                next_gdpa;
-            layer_device_link_info[activated_layers]
-                .pfnNextGetInstanceProcAddr = next_gipa;
-            chain_info.u.pLayerInfo = &layer_device_link_info[activated_layers];
-
-            next_gipa = layer.GetGetInstanceProcAddr();
-            next_gdpa = layer.GetGetDeviceProcAddr();
-
-            ALOGV("Insert device layer %s (v%u)", layer.GetName(),
-                  layer.GetSpecVersion());
-
-            activated_layers++;
-        }
-    }
-
-    PFN_vkCreateDevice create_device = reinterpret_cast<PFN_vkCreateDevice>(
-        next_gipa(instance.handle, "vkCreateDevice"));
-    if (!create_device) {
-        ALOGE("Unable to find vkCreateDevice for driver");
-        DestroyDevice(device);
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-
-    VkLayerDeviceCreateInfo device_create_info;
-
-    device_create_info.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
-    device_create_info.function = VK_LAYER_FUNCTION_DEVICE;
-
-    device_create_info.u.deviceInfo.device_info = device;
-    device_create_info.u.deviceInfo.pfnNextGetInstanceProcAddr = next_gipa;
-
-    device_create_info.pNext = local_create_info.pNext;
-    local_create_info.pNext = &device_create_info;
-
-    bool allocatedLayerMem;
-    if (!AddLayersToCreateInfo(local_create_info, device, allocator,
-                               allocatedLayerMem)) {
-        DestroyDevice(device);
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-
-    result = create_device(gpu, &local_create_info, allocator, &local_device);
-
-    if (allocatedLayerMem) {
-        FreeAllocatedLayerCreateInfo(local_create_info, allocator);
-    }
-
-    if (result != VK_SUCCESS) {
-        DestroyDevice(device);
-        return result;
-    }
-
-    // Set dispatch table for newly created Device
-    hwvulkan_dispatch_t* vulkan_dispatch =
-        reinterpret_cast<hwvulkan_dispatch_t*>(local_device);
-    vulkan_dispatch->vtbl = &device->dispatch;
-
-    const DeviceDispatchTable& device_dispatch = GetDispatchTable(local_device);
-    if (!LoadDeviceDispatchTable(
-            local_device, next_gdpa,
-            const_cast<DeviceDispatchTable&>(device_dispatch))) {
-        ALOGV("Failed to initialize device dispatch table");
-        PFN_vkDestroyDevice destroy_device =
-            reinterpret_cast<PFN_vkDestroyDevice>(
-                next_gipa(instance.handle, "vkDestroyDevice"));
-        ALOG_ASSERT(destroy_device != nullptr,
-                    "Loader unable to find DestroyDevice");
-        destroy_device(local_device, allocator);
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-    *device_out = local_device;
-
-    return VK_SUCCESS;
-}
-
-PFN_vkVoidFunction GetDeviceProcAddr_Top(VkDevice device, const char* name) {
-    PFN_vkVoidFunction pfn;
-    if (!device)
-        return nullptr;
-    if ((pfn = GetLoaderTopProcAddr(name)))
-        return pfn;
-    return GetDispatchProcAddr(GetDispatchTable(device), name);
-}
-
-void GetDeviceQueue_Top(VkDevice vkdevice,
-                        uint32_t family,
-                        uint32_t index,
-                        VkQueue* queue_out) {
-    const auto& table = GetDispatchTable(vkdevice);
-    table.GetDeviceQueue(vkdevice, family, index, queue_out);
-    hwvulkan_dispatch_t* queue_dispatch =
-        reinterpret_cast<hwvulkan_dispatch_t*>(*queue_out);
-    if (queue_dispatch->magic != HWVULKAN_DISPATCH_MAGIC &&
-        queue_dispatch->vtbl != &table)
-        ALOGE("invalid VkQueue dispatch magic: 0x%" PRIxPTR,
-              queue_dispatch->magic);
-    queue_dispatch->vtbl = &table;
-}
-
-VkResult AllocateCommandBuffers_Top(
+VkResult AllocateCommandBuffers_Bottom(
     VkDevice vkdevice,
     const VkCommandBufferAllocateInfo* alloc_info,
     VkCommandBuffer* cmdbufs) {
-    const auto& table = GetDispatchTable(vkdevice);
-    VkResult result =
-        table.AllocateCommandBuffers(vkdevice, alloc_info, cmdbufs);
-    if (result != VK_SUCCESS)
-        return result;
-    for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
-        hwvulkan_dispatch_t* cmdbuf_dispatch =
-            reinterpret_cast<hwvulkan_dispatch_t*>(cmdbufs[i]);
-        ALOGE_IF(cmdbuf_dispatch->magic != HWVULKAN_DISPATCH_MAGIC,
-                 "invalid VkCommandBuffer dispatch magic: 0x%" PRIxPTR,
-                 cmdbuf_dispatch->magic);
-        cmdbuf_dispatch->vtbl = &table;
-    }
-    return VK_SUCCESS;
-}
+    const auto& device = GetDispatchParent(vkdevice);
+    const auto& instance = *device.instance;
 
-void DestroyDevice_Top(VkDevice vkdevice,
-                       const VkAllocationCallbacks* /*allocator*/) {
-    if (!vkdevice)
-        return;
-    Device& device = GetDispatchParent(vkdevice);
-    device.dispatch.DestroyDevice(vkdevice, device.instance->alloc);
-    DestroyDevice(&device);
+    VkResult result = instance.drv.dispatch.AllocateCommandBuffers(
+        vkdevice, alloc_info, cmdbufs);
+    if (result == VK_SUCCESS) {
+        for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++)
+            driver::SetData(cmdbufs[i], device.base);
+    }
+
+    return result;
 }
 
 // -----------------------------------------------------------------------------
@@ -1699,7 +967,7 @@
 }
 
 VkInstance GetDriverInstance(VkInstance instance) {
-    return GetDispatchParent(instance).drv.instance;
+    return instance;
 }
 
 const DriverDispatchTable& GetDriverDispatch(VkInstance instance) {
@@ -1718,4 +986,60 @@
     return GetDispatchParent(instance).debug_report_callbacks;
 }
 
+namespace driver {
+
+bool Debuggable() {
+    return (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0) >= 0);
+}
+
+bool OpenHAL() {
+    if (!g_hwdevice)
+        LoadVulkanHAL();
+
+    return (g_hwdevice != nullptr);
+}
+
+const VkAllocationCallbacks& GetDefaultAllocator() {
+    return kDefaultAllocCallbacks;
+}
+
+PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName) {
+    return GetInstanceProcAddr_Bottom(instance, pName);
+}
+
+PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName) {
+    return GetDeviceProcAddr_Bottom(device, pName);
+}
+
+VkResult EnumerateInstanceExtensionProperties(
+    const char* pLayerName,
+    uint32_t* pPropertyCount,
+    VkExtensionProperties* pProperties) {
+    (void)pLayerName;
+
+    VkExtensionProperties* available = static_cast<VkExtensionProperties*>(
+        alloca(kInstanceExtensionCount * sizeof(VkExtensionProperties)));
+    uint32_t num_extensions = 0;
+
+    available[num_extensions++] = VkExtensionProperties{
+        VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION};
+    available[num_extensions++] =
+        VkExtensionProperties{VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
+                              VK_KHR_ANDROID_SURFACE_SPEC_VERSION};
+    if (g_driver_instance_extensions[kEXT_debug_report]) {
+        available[num_extensions++] =
+            VkExtensionProperties{VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
+                                  VK_EXT_DEBUG_REPORT_SPEC_VERSION};
+    }
+
+    if (!pProperties || *pPropertyCount > num_extensions)
+        *pPropertyCount = num_extensions;
+    if (pProperties)
+        std::copy(available, available + *pPropertyCount, pProperties);
+
+    return *pPropertyCount < num_extensions ? VK_INCOMPLETE : VK_SUCCESS;
+}
+
+}  // namespace driver
+
 }  // namespace vulkan
diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
index ada66f1..0ec08b2 100644
--- a/vulkan/libvulkan/loader.h
+++ b/vulkan/libvulkan/loader.h
@@ -38,45 +38,10 @@
 };
 typedef std::bitset<kDeviceExtensionCount> DeviceExtensionSet;
 
-inline const InstanceDispatchTable& GetDispatchTable(VkInstance instance) {
-    return **reinterpret_cast<InstanceDispatchTable**>(instance);
-}
-
-inline const InstanceDispatchTable& GetDispatchTable(
-    VkPhysicalDevice physical_device) {
-    return **reinterpret_cast<InstanceDispatchTable**>(physical_device);
-}
-
-inline const DeviceDispatchTable& GetDispatchTable(VkDevice device) {
-    return **reinterpret_cast<DeviceDispatchTable**>(device);
-}
-
-inline const DeviceDispatchTable& GetDispatchTable(VkQueue queue) {
-    return **reinterpret_cast<DeviceDispatchTable**>(queue);
-}
-
-inline const DeviceDispatchTable& GetDispatchTable(
-    VkCommandBuffer command_buffer) {
-    return **reinterpret_cast<DeviceDispatchTable**>(command_buffer);
-}
-
 // -----------------------------------------------------------------------------
 // dispatch_gen.cpp
 
-PFN_vkVoidFunction GetLoaderExportProcAddr(const char* name);
-PFN_vkVoidFunction GetLoaderGlobalProcAddr(const char* name);
-PFN_vkVoidFunction GetLoaderTopProcAddr(const char* name);
 PFN_vkVoidFunction GetLoaderBottomProcAddr(const char* name);
-PFN_vkVoidFunction GetDispatchProcAddr(const InstanceDispatchTable& dispatch,
-                                       const char* name);
-PFN_vkVoidFunction GetDispatchProcAddr(const DeviceDispatchTable& dispatch,
-                                       const char* name);
-bool LoadInstanceDispatchTable(VkInstance instance,
-                               PFN_vkGetInstanceProcAddr get_proc_addr,
-                               InstanceDispatchTable& dispatch);
-bool LoadDeviceDispatchTable(VkDevice device,
-                             PFN_vkGetDeviceProcAddr get_proc_addr,
-                             DeviceDispatchTable& dispatch);
 bool LoadDriverDispatchTable(VkInstance instance,
                              PFN_vkGetInstanceProcAddr get_proc_addr,
                              const InstanceExtensionSet& extensions,
@@ -86,19 +51,6 @@
 // loader.cpp
 
 // clang-format off
-VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties_Top(const char* layer_name, uint32_t* count, VkExtensionProperties* properties);
-VKAPI_ATTR VkResult EnumerateInstanceLayerProperties_Top(uint32_t* count, VkLayerProperties* properties);
-VKAPI_ATTR VkResult CreateInstance_Top(const VkInstanceCreateInfo* create_info, const VkAllocationCallbacks* allocator, VkInstance* instance_out);
-VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr_Top(VkInstance instance, const char* name);
-VKAPI_ATTR void DestroyInstance_Top(VkInstance instance, const VkAllocationCallbacks* allocator);
-VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr_Top(VkDevice drv_device, const char* name);
-VKAPI_ATTR void GetDeviceQueue_Top(VkDevice drv_device, uint32_t family, uint32_t index, VkQueue* out_queue);
-VKAPI_ATTR VkResult AllocateCommandBuffers_Top(VkDevice device, const VkCommandBufferAllocateInfo* alloc_info, VkCommandBuffer* cmdbufs);
-VKAPI_ATTR VkResult EnumerateDeviceLayerProperties_Top(VkPhysicalDevice pdev, uint32_t* properties_count, VkLayerProperties* properties);
-VKAPI_ATTR VkResult EnumerateDeviceExtensionProperties_Top(VkPhysicalDevice pdev, const char * layer_name, uint32_t* properties_count, VkExtensionProperties* properties);
-VKAPI_ATTR VkResult CreateDevice_Top(VkPhysicalDevice pdev, const VkDeviceCreateInfo* create_info, const VkAllocationCallbacks* allocator, VkDevice* device_out);
-VKAPI_ATTR void DestroyDevice_Top(VkDevice drv_device, const VkAllocationCallbacks* allocator);
-
 VKAPI_ATTR VkResult CreateInstance_Bottom(const VkInstanceCreateInfo* create_info, const VkAllocationCallbacks* allocator, VkInstance* vkinstance);
 VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr_Bottom(VkInstance, const char* name);
 VKAPI_ATTR VkResult EnumeratePhysicalDevices_Bottom(VkInstance vkinstance, uint32_t* pdev_count, VkPhysicalDevice* pdevs);
@@ -114,6 +66,9 @@
 VKAPI_ATTR VkResult CreateDevice_Bottom(VkPhysicalDevice pdev, const VkDeviceCreateInfo* create_info, const VkAllocationCallbacks* allocator, VkDevice* device_out);
 VKAPI_ATTR void DestroyInstance_Bottom(VkInstance vkinstance, const VkAllocationCallbacks* allocator);
 VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr_Bottom(VkDevice vkdevice, const char* name);
+VKAPI_ATTR void DestroyDevice_Bottom(VkDevice device, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR void GetDeviceQueue_Bottom(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+VKAPI_ATTR VkResult AllocateCommandBuffers_Bottom(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
 // clang-format on
 
 const VkAllocationCallbacks* GetAllocator(VkInstance instance);