diff --git a/src/vulkan/util/vk_dispatch_table_gen.py b/src/vulkan/util/vk_dispatch_table_gen.py
index 334896029ab..f1561bc2610 100644
--- a/src/vulkan/util/vk_dispatch_table_gen.py
+++ b/src/vulkan/util/vk_dispatch_table_gen.py
@@ -50,6 +50,8 @@ TEMPLATE_H = Template(COPYRIGHT + """\
 #include "vulkan/vulkan_intel.h"
 #include "vulkan/vk_android_native_buffer.h"
 
+#include "vk_extensions.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -108,6 +110,40 @@ vk_device_dispatch_table_load(struct vk_device_dispatch_table *table,
                               PFN_vkGetDeviceProcAddr gpa,
                               VkDevice device);
 
+PFN_vkVoidFunction
+vk_instance_dispatch_table_get(const struct vk_instance_dispatch_table *table,
+                               const char *name);
+
+PFN_vkVoidFunction
+vk_physical_device_dispatch_table_get(const struct vk_physical_device_dispatch_table *table,
+                                      const char *name);
+
+PFN_vkVoidFunction
+vk_device_dispatch_table_get(const struct vk_device_dispatch_table *table,
+                             const char *name);
+
+PFN_vkVoidFunction
+vk_instance_dispatch_table_get_if_supported(
+    const struct vk_instance_dispatch_table *table,
+    const char *name,
+    uint32_t core_version,
+    const struct vk_instance_extension_table *instance_exts);
+
+PFN_vkVoidFunction
+vk_physical_device_dispatch_table_get_if_supported(
+    const struct vk_physical_device_dispatch_table *table,
+    const char *name,
+    uint32_t core_version,
+    const struct vk_instance_extension_table *instance_exts);
+
+PFN_vkVoidFunction
+vk_device_dispatch_table_get_if_supported(
+    const struct vk_device_dispatch_table *table,
+    const char *name,
+    uint32_t core_version,
+    const struct vk_instance_extension_table *instance_exts,
+    const struct vk_device_extension_table *device_exts);
+
 #ifdef __cplusplus
 }
 #endif
@@ -120,6 +156,9 @@ TEMPLATE_C = Template(COPYRIGHT + """\
 
 #include "vk_dispatch_table.h"
 
+#include "util/macros.h"
+#include "string.h"
+
 <%def name="load_dispatch_table(type, VkType, ProcAddr, entrypoints)">
 void
 vk_${type}_dispatch_table_load(struct vk_${type}_dispatch_table *table,
@@ -158,8 +197,336 @@ ${load_dispatch_table('physical_device', 'VkInstance', 'GetInstanceProcAddr',
 ${load_dispatch_table('device', 'VkDevice', 'GetDeviceProcAddr',
                       device_entrypoints)}
 
+
+struct string_map_entry {
+   uint32_t name;
+   uint32_t hash;
+   uint32_t num;
+};
+
+/* We use a big string constant to avoid lots of reloctions from the entry
+ * point table to lots of little strings. The entries in the entry point table
+ * store the index into this big string.
+ */
+
+<%def name="strmap(strmap, prefix)">
+static const char ${prefix}_strings[] =
+% for s in strmap.sorted_strings:
+    "${s.string}\\0"
+% endfor
+;
+
+static const struct string_map_entry ${prefix}_string_map_entries[] = {
+% for s in strmap.sorted_strings:
+    { ${s.offset}, ${'{:0=#8x}'.format(s.hash)}, ${s.num} }, /* ${s.string} */
+% endfor
+};
+
+/* Hash table stats:
+ * size ${len(strmap.sorted_strings)} entries
+ * collisions entries:
+% for i in range(10):
+ *     ${i}${'+' if i == 9 else ' '}     ${strmap.collisions[i]}
+% endfor
+ */
+
+#define none 0xffff
+static const uint16_t ${prefix}_string_map[${strmap.hash_size}] = {
+% for e in strmap.mapping:
+    ${ '{:0=#6x}'.format(e) if e >= 0 else 'none' },
+% endfor
+};
+
+static int
+${prefix}_string_map_lookup(const char *str)
+{
+    static const uint32_t prime_factor = ${strmap.prime_factor};
+    static const uint32_t prime_step = ${strmap.prime_step};
+    const struct string_map_entry *e;
+    uint32_t hash, h;
+    uint16_t i;
+    const char *p;
+
+    hash = 0;
+    for (p = str; *p; p++)
+        hash = hash * prime_factor + *p;
+
+    h = hash;
+    while (1) {
+        i = ${prefix}_string_map[h & ${strmap.hash_mask}];
+        if (i == none)
+           return -1;
+        e = &${prefix}_string_map_entries[i];
+        if (e->hash == hash && strcmp(str, ${prefix}_strings + e->name) == 0)
+            return e->num;
+        h += prime_step;
+    }
+
+    return -1;
+}
+</%def>
+
+${strmap(instance_strmap, 'instance')}
+${strmap(physical_device_strmap, 'physical_device')}
+${strmap(device_strmap, 'device')}
+
+<% assert len(instance_entrypoints) < 2**8 %>
+static const uint8_t instance_compaction_table[] = {
+% for e in instance_entrypoints:
+    ${e.disp_table_index},
+% endfor
+};
+
+<% assert len(physical_device_entrypoints) < 2**8 %>
+static const uint8_t physical_device_compaction_table[] = {
+% for e in physical_device_entrypoints:
+    ${e.disp_table_index},
+% endfor
+};
+
+<% assert len(device_entrypoints) < 2**16 %>
+static const uint16_t device_compaction_table[] = {
+% for e in device_entrypoints:
+    ${e.disp_table_index},
+% endfor
+};
+
+static bool
+vk_instance_entrypoint_is_enabled(int index, uint32_t core_version,
+                                  const struct vk_instance_extension_table *instance)
+{
+   switch (index) {
+% for e in instance_entrypoints:
+   case ${e.entry_table_index}:
+      /* ${e.name} */
+   % if e.core_version:
+      return ${e.core_version.c_vk_version()} <= core_version;
+   % elif e.extensions:
+     % for ext in e.extensions:
+        % if ext.type == 'instance':
+      if (instance->${ext.name[3:]}) return true;
+        % else:
+      /* All device extensions are considered enabled at the instance level */
+      return true;
+        % endif
+     % endfor
+      return false;
+   % else:
+      return true;
+   % endif
+% endfor
+   default:
+      return false;
+   }
+}
+
+/** Return true if the core version or extension in which the given entrypoint
+ * is defined is enabled.
+ *
+ * If device is NULL, all device extensions are considered enabled.
+ */
+static bool
+vk_physical_device_entrypoint_is_enabled(int index, uint32_t core_version,
+                                         const struct vk_instance_extension_table *instance)
+{
+   switch (index) {
+% for e in physical_device_entrypoints:
+   case ${e.entry_table_index}:
+      /* ${e.name} */
+   % if e.core_version:
+      return ${e.core_version.c_vk_version()} <= core_version;
+   % elif e.extensions:
+     % for ext in e.extensions:
+        % if ext.type == 'instance':
+      if (instance->${ext.name[3:]}) return true;
+        % else:
+      /* All device extensions are considered enabled at the instance level */
+      return true;
+        % endif
+     % endfor
+      return false;
+   % else:
+      return true;
+   % endif
+% endfor
+   default:
+      return false;
+   }
+}
+
+/** Return true if the core version or extension in which the given entrypoint
+ * is defined is enabled.
+ *
+ * If device is NULL, all device extensions are considered enabled.
+ */
+static bool
+vk_device_entrypoint_is_enabled(int index, uint32_t core_version,
+                                const struct vk_instance_extension_table *instance,
+                                const struct vk_device_extension_table *device)
+{
+   switch (index) {
+% for e in device_entrypoints:
+   case ${e.entry_table_index}:
+      /* ${e.name} */
+   % if e.core_version:
+      return ${e.core_version.c_vk_version()} <= core_version;
+   % elif e.extensions:
+     % for ext in e.extensions:
+        % if ext.type == 'instance':
+      if (instance->${ext.name[3:]}) return true;
+        % else:
+      if (!device || device->${ext.name[3:]}) return true;
+        % endif
+     % endfor
+      return false;
+   % else:
+      return true;
+   % endif
+% endfor
+   default:
+      return false;
+   }
+}
+
+<%def name="lookup_funcs(type)">
+static PFN_vkVoidFunction
+vk_${type}_dispatch_table_get_for_entry_index(
+    const struct vk_${type}_dispatch_table *table, int entry_index)
+{
+    assert(entry_index < ARRAY_SIZE(${type}_compaction_table));
+    int disp_index = ${type}_compaction_table[entry_index];
+    return ((PFN_vkVoidFunction *)table)[disp_index];
+}
+
+PFN_vkVoidFunction
+vk_${type}_dispatch_table_get(
+    const struct vk_${type}_dispatch_table *table, const char *name)
+{
+    int entry_index = ${type}_string_map_lookup(name);
+    if (entry_index < 0)
+        return NULL;
+
+    return vk_${type}_dispatch_table_get_for_entry_index(table, entry_index);
+}
+</%def>
+
+${lookup_funcs('instance')}
+${lookup_funcs('physical_device')}
+${lookup_funcs('device')}
+
+PFN_vkVoidFunction
+vk_instance_dispatch_table_get_if_supported(
+    const struct vk_instance_dispatch_table *table,
+    const char *name,
+    uint32_t core_version,
+    const struct vk_instance_extension_table *instance_exts)
+{
+    int entry_index = instance_string_map_lookup(name);
+    if (entry_index < 0)
+        return NULL;
+
+    if (!vk_instance_entrypoint_is_enabled(entry_index, core_version,
+                                           instance_exts))
+        return NULL;
+
+    return vk_instance_dispatch_table_get_for_entry_index(table, entry_index);
+}
+
+PFN_vkVoidFunction
+vk_physical_device_dispatch_table_get_if_supported(
+    const struct vk_physical_device_dispatch_table *table,
+    const char *name,
+    uint32_t core_version,
+    const struct vk_instance_extension_table *instance_exts)
+{
+    int entry_index = physical_device_string_map_lookup(name);
+    if (entry_index < 0)
+        return NULL;
+
+    if (!vk_physical_device_entrypoint_is_enabled(entry_index, core_version,
+                                                  instance_exts))
+        return NULL;
+
+    return vk_physical_device_dispatch_table_get_for_entry_index(table, entry_index);
+}
+
+PFN_vkVoidFunction
+vk_device_dispatch_table_get_if_supported(
+    const struct vk_device_dispatch_table *table,
+    const char *name,
+    uint32_t core_version,
+    const struct vk_instance_extension_table *instance_exts,
+    const struct vk_device_extension_table *device_exts)
+{
+    int entry_index = device_string_map_lookup(name);
+    if (entry_index < 0)
+        return NULL;
+
+    if (!vk_device_entrypoint_is_enabled(entry_index, core_version,
+                                         instance_exts, device_exts))
+        return NULL;
+
+    return vk_device_dispatch_table_get_for_entry_index(table, entry_index);
+}
 """, output_encoding='utf-8')
 
+U32_MASK = 2**32 - 1
+
+PRIME_FACTOR = 5024183
+PRIME_STEP = 19
+
+class StringIntMapEntry(object):
+    def __init__(self, string, num):
+        self.string = string
+        self.num = num
+
+        # Calculate the same hash value that we will calculate in C.
+        h = 0
+        for c in string:
+            h = ((h * PRIME_FACTOR) + ord(c)) & U32_MASK
+        self.hash = h
+
+        self.offset = None
+
+def round_to_pow2(x):
+    return 2**int(math.ceil(math.log(x, 2)))
+
+class StringIntMap(object):
+    def __init__(self):
+        self.baked = False
+        self.strings = dict()
+
+    def add_string(self, string, num):
+        assert not self.baked
+        assert string not in self.strings
+        assert 0 <= num < 2**31
+        self.strings[string] = StringIntMapEntry(string, num)
+
+    def bake(self):
+        self.sorted_strings = \
+            sorted(self.strings.values(), key=lambda x: x.string)
+        offset = 0
+        for entry in self.sorted_strings:
+            entry.offset = offset
+            offset += len(entry.string) + 1
+
+        # Save off some values that we'll need in C
+        self.hash_size = round_to_pow2(len(self.strings) * 1.25)
+        self.hash_mask = self.hash_size - 1
+        self.prime_factor = PRIME_FACTOR
+        self.prime_step = PRIME_STEP
+
+        self.mapping = [-1] * self.hash_size
+        self.collisions = [0] * 10
+        for idx, s in enumerate(self.sorted_strings):
+            level = 0
+            h = s.hash
+            while self.mapping[h & self.hash_mask] >= 0:
+                h = h + PRIME_STEP
+                level = level + 1
+            self.collisions[min(level, 9)] += 1
+            self.mapping[h & self.hash_mask] = idx
+
 EntrypointParam = namedtuple('EntrypointParam', 'type name decl')
 
 class EntrypointBase(object):
@@ -168,7 +535,7 @@ class EntrypointBase(object):
         self.name = name[2:]
         self.alias = None
         self.guard = None
-        self.num = None
+        self.entry_table_index = None
         # Extensions which require this entrypoint
         self.core_version = None
         self.extensions = []
@@ -183,6 +550,7 @@ class Entrypoint(EntrypointBase):
         self.params = params
         self.guard = guard
         self.aliases = []
+        self.disp_table_index = None
 
     def is_physical_device_entrypoint(self):
         return self.params[0].type in ('VkPhysicalDevice', )
@@ -219,6 +587,10 @@ class EntrypointAlias(EntrypointBase):
     def return_type(self):
         return self.alias.return_type
 
+    @property
+    def disp_table_index(self):
+        return self.alias.disp_table_index
+
     def decl_params(self):
         return self.alias.decl_params()
 
@@ -333,6 +705,33 @@ def main():
         else:
             instance_entrypoints.append(e)
 
+    for i, e in enumerate(e for e in device_entrypoints if not e.alias):
+        e.disp_table_index = i
+
+    device_strmap = StringIntMap()
+    for i, e in enumerate(device_entrypoints):
+        e.entry_table_index = i
+        device_strmap.add_string("vk" + e.name, e.entry_table_index)
+    device_strmap.bake()
+
+    for i, e in enumerate(e for e in physical_device_entrypoints if not e.alias):
+        e.disp_table_index = i
+
+    physical_device_strmap = StringIntMap()
+    for i, e in enumerate(physical_device_entrypoints):
+        e.entry_table_index = i
+        physical_device_strmap.add_string("vk" + e.name, e.entry_table_index)
+    physical_device_strmap.bake()
+
+    for i, e in enumerate(e for e in instance_entrypoints if not e.alias):
+        e.disp_table_index = i
+
+    instance_strmap = StringIntMap()
+    for i, e in enumerate(instance_entrypoints):
+        e.entry_table_index = i
+        instance_strmap.add_string("vk" + e.name, e.entry_table_index)
+    instance_strmap.bake()
+
     # For outputting entrypoints.h we generate a anv_EntryPoint() prototype
     # per entry point.
     try:
@@ -342,10 +741,14 @@ def main():
                                           physical_device_entrypoints=physical_device_entrypoints,
                                           device_entrypoints=device_entrypoints,
                                           filename=os.path.basename(__file__)))
+        if args.out_c:
             with open(args.out_c, 'wb') as f:
                 f.write(TEMPLATE_C.render(instance_entrypoints=instance_entrypoints,
                                           physical_device_entrypoints=physical_device_entrypoints,
                                           device_entrypoints=device_entrypoints,
+                                          instance_strmap=instance_strmap,
+                                          physical_device_strmap=physical_device_strmap,
+                                          device_strmap=device_strmap,
                                           filename=os.path.basename(__file__)))
     except Exception:
         # In the event there's an error, this imports some helpers from mako