vk-layer-generate.py

   1 #!/usr/bin/env python3
   2 #
   3 # VK
   4 #
   5 # Copyright (c) 2015-2016 The Khronos Group Inc.
   6 # Copyright (c) 2015-2016 Valve Corporation
   7 # Copyright (c) 2015-2016 LunarG, Inc.
   8 # Copyright (c) 2015-2016 Google Inc.
   9 #
  10 # Licensed under the Apache License, Version 2.0 (the "License");
  11 # you may not use this file except in compliance with the License.
  12 # You may obtain a copy of the License at
  13 #
  14 #     http://www.apache.org/licenses/LICENSE-2.0
  15 #
  16 # Unless required by applicable law or agreed to in writing, software
  17 # distributed under the License is distributed on an "AS IS" BASIS,
  18 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19 # See the License for the specific language governing permissions and
  20 # limitations under the License.
  21 #
  22 # Author: Tobin Ehlis <tobine@google.com>
  23 # Author: Courtney Goeltzenleuchter <courtneygo@google.com>
  24 # Author: Jon Ashburn <jon@lunarg.com>
  25 # Author: Mark Lobodzinski <mark@lunarg.com>
  26 # Author: Mike Stroyan <stroyan@google.com>
  27 # Author: Tony Barbour <tony@LunarG.com>
  28 # Author: Chia-I Wu <olv@google.com>
  29 # Author: Gwan-gyeong Mun <kk.moon@samsung.com>
  30
  31 import sys
  32 import os
  33 import re
  34
  35 import vulkan
  36 import vk_helper
  37 from source_line_info import sourcelineinfo
  38 from collections import defaultdict
  39
  40 def proto_is_global(proto):
  41     global_function_names = [
  42         "CreateInstance",
  43         "EnumerateInstanceLayerProperties",
  44         "EnumerateInstanceExtensionProperties",
  45         "EnumerateDeviceLayerProperties",
  46         "EnumerateDeviceExtensionProperties",
  47         "CreateXcbSurfaceKHR",
  48         "GetPhysicalDeviceXcbPresentationSupportKHR",
  49         "CreateXlibSurfaceKHR",
  50         "GetPhysicalDeviceXlibPresentationSupportKHR",
  51         "CreateWaylandSurfaceKHR",
  52         "GetPhysicalDeviceWaylandPresentationSupportKHR",
  53         "CreateMirSurfaceKHR",
  54         "GetPhysicalDeviceMirPresentationSupportKHR",
  55         "CreateAndroidSurfaceKHR",
  56         "CreateWin32SurfaceKHR",
  57         "GetPhysicalDeviceWin32PresentationSupportKHR",
  58         "GetPhysicalDeviceDisplayPropertiesKHR",
  59         "GetPhysicalDeviceDisplayPlanePropertiesKHR",
  60         "GetDisplayPlaneSupportedDisplaysKHR",
  61         "GetDisplayModePropertiesKHR",
  62         "CreateDisplayModeKHR",
  63         "GetDisplayPlaneCapabilitiesKHR",
  64         "CreateDisplayPlaneSurfaceKHR"
  65     ]
  66     if proto.params[0].ty == "VkInstance" or proto.params[0].ty == "VkPhysicalDevice" or proto.name in global_function_names:
  67        return True
  68     else:
  69        return False
  70
  71 def wsi_name(ext_name):
  72     wsi_prefix = ""
  73     if 'Xcb' in ext_name:
  74         wsi_prefix = 'XCB'
  75     elif 'Xlib' in ext_name:
  76         wsi_prefix = 'XLIB'
  77     elif 'Win32' in ext_name:
  78         wsi_prefix = 'WIN32'
  79     elif 'Mir' in ext_name:
  80         wsi_prefix = 'MIR'
  81     elif 'Wayland' in ext_name:
  82         wsi_prefix = 'WAYLAND'
  83     elif 'Android' in ext_name:
  84         wsi_prefix = 'ANDROID'
  85     else:
  86         wsi_prefix = ''
  87     return wsi_prefix
  88
  89 def wsi_ifdef(ext_name):
  90     wsi_prefix = wsi_name(ext_name)
  91     if not wsi_prefix:
  92         return ''
  93     else:
  94         return "#ifdef VK_USE_PLATFORM_%s_KHR" % wsi_prefix
  95
  96 def wsi_endif(ext_name):
  97     wsi_prefix = wsi_name(ext_name)
  98     if not wsi_prefix:
  99         return ''
 100     else:
 101         return "#endif  // VK_USE_PLATFORM_%s_KHR" % wsi_prefix
 102
 103 def generate_get_proc_addr_check(name):
 104     return "    if (!%s || %s[0] != 'v' || %s[1] != 'k')\n" \
 105            "        return NULL;" % ((name,) * 3)
 106
 107 def ucc_to_U_C_C(CamelCase):
 108     temp = re.sub('(.)([A-Z][a-z]+)',  r'\1_\2', CamelCase)
 109     return re.sub('([a-z0-9])([A-Z])', r'\1_\2', temp).upper()
 110
 111 # Parse complete struct chain and add any new ndo_uses to the dict
 112 def gather_object_uses_in_struct(obj_list, struct_type):
 113     struct_uses = {}
 114     if vk_helper.typedef_rev_dict[struct_type] in vk_helper.struct_dict:
 115         struct_type = vk_helper.typedef_rev_dict[struct_type]
 116         # Parse elements of this struct param to identify objects and/or arrays of objects
 117         for m in sorted(vk_helper.struct_dict[struct_type]):
 118             array_len = "%s" % (str(vk_helper.struct_dict[struct_type][m]['array_size']))
 119             base_type = vk_helper.struct_dict[struct_type][m]['type']
 120             mem_name = vk_helper.struct_dict[struct_type][m]['name']
 121             if array_len != '0':
 122                 mem_name = "%s[%s]" % (mem_name, array_len)
 123             if base_type in obj_list:
 124                 #if array_len not in ndo_uses:
 125                 #    struct_uses[array_len] = []
 126                 #struct_uses[array_len].append("%s%s,%s" % (name_prefix, struct_name, base_type))
 127                 struct_uses[mem_name] = base_type
 128             elif vk_helper.is_type(base_type, 'struct'):
 129                 sub_uses = gather_object_uses_in_struct(obj_list, base_type)
 130                 if len(sub_uses) > 0:
 131                     struct_uses[mem_name] = sub_uses
 132     return struct_uses
 133
 134 # For the given list of object types, Parse the given list of params
 135 #  and return dict of params that use one of the obj_list types
 136 # Format of the dict is that terminal elements have <name>,<type>
 137 #  non-terminal elements will have <name>[<array_size>]
 138 # TODO : This analysis could be done up-front at vk_helper time
 139 def get_object_uses(obj_list, params):
 140     obj_uses = {}
 141     local_decls = {}
 142     param_count = 'NONE' # track params that give array sizes
 143     for p in params:
 144         base_type = p.ty.replace('const ', '').strip('*')
 145         array_len = ''
 146         is_ptr = False
 147         if 'count' in p.name.lower():
 148             param_count = p.name
 149         ptr_txt = ''
 150         if '*' in p.ty:
 151             is_ptr = True
 152             ptr_txt = '*'
 153         if base_type in obj_list:
 154             if is_ptr and 'const' in p.ty and param_count != 'NONE':
 155                 array_len = "[%s]" % param_count
 156                 # Non-arrays we can overwrite in place, but need local decl for arrays
 157                 local_decls[p.name] = '%s%s' % (base_type, ptr_txt)
 158             #if array_len not in obj_uses:
 159             #    obj_uses[array_len] = {}
 160             # obj_uses[array_len][p.name] = base_type
 161             obj_uses["%s%s" % (p.name, array_len)] = base_type
 162         elif vk_helper.is_type(base_type, 'struct'):
 163             struct_name = p.name
 164             if 'NONE' != param_count:
 165                 struct_name = "%s[%s]" % (struct_name, param_count)
 166             struct_uses = gather_object_uses_in_struct(obj_list, base_type)
 167             if len(struct_uses) > 0:
 168                 obj_uses[struct_name] = struct_uses
 169                 # This is a top-level struct w/ uses below it, so need local decl
 170                 local_decls['%s' % (p.name)] = '%s%s' % (base_type, ptr_txt)
 171     return (obj_uses, local_decls)
 172
 173 class Subcommand(object):
 174     def __init__(self, outfile):
 175         self.outfile = outfile
 176         self.headers = vulkan.headers
 177         self.protos = vulkan.protos
 178         self.no_addr = False
 179         self.layer_name = ""
 180         self.lineinfo = sourcelineinfo()
 181         self.wsi = sys.argv[1]
 182
 183     def run(self):
 184         if self.outfile:
 185             with open(self.outfile, "w") as outfile:
 186                 outfile.write(self.generate())
 187         else:
 188             print(self.generate())
 189
 190     def generate(self):
 191         copyright = self.generate_copyright()
 192         header = self.generate_header()
 193         body = self.generate_body()
 194         footer = self.generate_footer()
 195
 196         contents = []
 197         if copyright:
 198             contents.append(copyright)
 199         if header:
 200             contents.append(header)
 201         if body:
 202             contents.append(body)
 203         if footer:
 204             contents.append(footer)
 205
 206         return "\n\n".join(contents)
 207
 208     def generate_copyright(self):
 209         return """/* THIS FILE IS GENERATED.  DO NOT EDIT. */
 210
 211 /*
 212  * Copyright (c) 2015-2016 The Khronos Group Inc.
 213  * Copyright (c) 2015-2016 Valve Corporation
 214  * Copyright (c) 2015-2016 LunarG, Inc.
 215  * Copyright (c) 2015-2016 Google, Inc.
 216  *
 217  * Licensed under the Apache License, Version 2.0 (the "License");
 218  * you may not use this file except in compliance with the License.
 219  * You may obtain a copy of the License at
 220  *
 221  *     http://www.apache.org/licenses/LICENSE-2.0
 222  *
 223  * Unless required by applicable law or agreed to in writing, software
 224  * distributed under the License is distributed on an "AS IS" BASIS,
 225  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 226  * See the License for the specific language governing permissions and
 227  * limitations under the License.
 228  *
 229  * Author: Tobin Ehlis <tobine@google.com>
 230  * Author: Courtney Goeltzenleuchter <courtneygo@google.com>
 231  * Author: Jon Ashburn <jon@lunarg.com>
 232  * Author: Mark Lobodzinski <mark@lunarg.com>
 233  * Author: Mike Stroyan <stroyan@google.com>
 234  * Author: Tony Barbour <tony@LunarG.com>
 235  */"""
 236
 237     def generate_header(self):
 238         return "\n".join(["#include <" + h + ">" for h in self.headers])
 239
 240     def generate_body(self):
 241         pass
 242
 243     def generate_footer(self):
 244         pass
 245
 246     # Return set of printf '%' qualifier and input to that qualifier
 247     def _get_printf_params(self, vk_type, name, output_param, cpp=False):
 248         # TODO : Need ENUM and STRUCT checks here
 249         if vk_helper.is_type(vk_type, 'enum'):#"_TYPE" in vk_type: # TODO : This should be generic ENUM check
 250             return ("%s", "string_%s(%s)" % (vk_type.replace('const ', '').strip('*'), name))
 251         if "char*" == vk_type:
 252             return ("%s", name)
 253         if "uint64" in vk_type:
 254             if '*' in vk_type:
 255                 return ("%lu", "*%s" % name)
 256             return ("%lu", name)
 257         if vk_type.strip('*') in vulkan.object_non_dispatch_list:
 258             if '*' in vk_type:
 259                 return ("%lu", "%s" % name)
 260             return ("%lu", "%s" % name)
 261         if "size" in vk_type:
 262             if '*' in vk_type:
 263                 return ("%lu", "(unsigned long)*%s" % name)
 264             return ("%lu", "(unsigned long)%s" % name)
 265         if "float" in vk_type:
 266             if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
 267                 if cpp:
 268                     return ("[%i, %i, %i, %i]", '"[" << %s[0] << "," << %s[1] << "," << %s[2] << "," << %s[3] << "]"' % (name, name, name, name))
 269                 return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name))
 270             return ("%f", name)
 271         if "bool" in vk_type.lower() or 'xcb_randr_crtc_t' in vk_type:
 272             return ("%u", name)
 273         if True in [t in vk_type.lower() for t in ["int", "flags", "mask", "xcb_window_t"]]:
 274             if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
 275                 if cpp:
 276                     return ("[%i, %i, %i, %i]", "%s[0] << %s[1] << %s[2] << %s[3]" % (name, name, name, name))
 277                 return ("[%i, %i, %i, %i]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name))
 278             if '*' in vk_type:
 279                 if 'pUserData' == name:
 280                     return ("%i", "((pUserData == 0) ? 0 : *(pUserData))")
 281                 if 'const' in vk_type.lower():
 282                     return ("0x%p", "(void*)(%s)" % name)
 283                 return ("%i", "*(%s)" % name)
 284             return ("%i", name)
 285         # TODO : This is special-cased as there's only one "format" param currently and it's nice to expand it
 286         if "VkFormat" == vk_type:
 287             if cpp:
 288                 return ("0x%p", "&%s" % name)
 289             return ("{%s.channelFormat = %%s, %s.numericFormat = %%s}" % (name, name), "string_VK_COLOR_COMPONENT_FORMAT(%s.channelFormat), string_VK_FORMAT_RANGE_SIZE(%s.numericFormat)" % (name, name))
 290         if output_param:
 291             return ("0x%p", "(void*)*%s" % name)
 292         if vk_helper.is_type(vk_type, 'struct') and '*' not in vk_type:
 293             return ("0x%p", "(void*)(&%s)" % name)
 294         return ("0x%p", "(void*)(%s)" % name)
 295
 296     def _gen_create_msg_callback(self):
 297         r_body = []
 298         r_body.append('%s' % self.lineinfo.get())
 299         r_body.append('VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(')
 300         r_body.append('        VkInstance                                   instance,')
 301         r_body.append('        const VkDebugReportCallbackCreateInfoEXT*    pCreateInfo,')
 302         r_body.append('        const VkAllocationCallbacks*                 pAllocator,')
 303         r_body.append('        VkDebugReportCallbackEXT*                    pCallback)')
 304         r_body.append('{')
 305         # Switch to this code section for the new per-instance storage and debug callbacks
 306         if self.layer_name in ['unique_objects']:
 307             r_body.append('    VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(%s_instance_table_map, instance);' % self.layer_name )
 308             r_body.append('    VkResult result = pInstanceTable->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);')
 309             r_body.append('    if (VK_SUCCESS == result) {')
 310             r_body.append('        layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
 311             r_body.append('        result = layer_create_msg_callback(my_data->report_data,')
 312             r_body.append('                                           false,')
 313             r_body.append('                                           pCreateInfo,')
 314             r_body.append('                                           pAllocator,')
 315             r_body.append('                                           pCallback);')
 316             r_body.append('    }')
 317             r_body.append('    return result;')
 318         else:
 319             r_body.append('    VkResult result = instance_dispatch_table(instance)->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);')
 320             r_body.append('    if (VK_SUCCESS == result) {')
 321             r_body.append('        layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
 322             r_body.append('        result = layer_create_msg_callback(my_data->report_data, false, pCreateInfo, pAllocator, pCallback);')
 323             r_body.append('    }')
 324             r_body.append('    return result;')
 325         r_body.append('}')
 326         return "\n".join(r_body)
 327
 328     def _gen_destroy_msg_callback(self):
 329         r_body = []
 330         r_body.append('%s' % self.lineinfo.get())
 331         r_body.append('VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback, const VkAllocationCallbacks *pAllocator)')
 332         r_body.append('{')
 333         # Switch to this code section for the new per-instance storage and debug callbacks
 334         if self.layer_name in ['unique_objects']:
 335             r_body.append('    VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(%s_instance_table_map, instance);' % self.layer_name )
 336         else:
 337             r_body.append('    VkLayerInstanceDispatchTable *pInstanceTable = instance_dispatch_table(instance);')
 338         r_body.append('    pInstanceTable->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);')
 339         r_body.append('    layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
 340         r_body.append('    layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);')
 341         r_body.append('}')
 342         return "\n".join(r_body)
 343
 344     def _gen_debug_report_msg(self):
 345         r_body = []
 346         r_body.append('%s' % self.lineinfo.get())
 347         r_body.append('VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT    flags, VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg)')
 348         r_body.append('{')
 349         # Switch to this code section for the new per-instance storage and debug callbacks
 350         r_body.append('    VkLayerInstanceDispatchTable *pInstanceTable = instance_dispatch_table(instance);')
 351         r_body.append('    pInstanceTable->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);')
 352         r_body.append('}')
 353         return "\n".join(r_body)
 354
 355     def _gen_layer_logging_workaround(self):
 356         body = []
 357         body.append('%s' % self.lineinfo.get())
 358         body.append('// vk_layer_logging.h expects these to be defined')
 359         body.append('')
 360         body.append('VKAPI_ATTR VkResult VKAPI_CALL')
 361         body.append('vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,')
 362         body.append('                               const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) {')
 363         body.append('    return %s::CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);' % self.layer_name)
 364         body.append('}')
 365         body.append('')
 366         body.append('VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance,')
 367         body.append('                                                                           VkDebugReportCallbackEXT msgCallback,')
 368         body.append('                                                                           const VkAllocationCallbacks *pAllocator) {')
 369         body.append('    %s::DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);' % self.layer_name)
 370         body.append('}')
 371         body.append('')
 372         body.append('VKAPI_ATTR void VKAPI_CALL')
 373         body.append('vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object,')
 374         body.append('                        size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {')
 375         body.append('    %s::DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);' % self.layer_name)
 376         body.append('}')
 377
 378         return "\n".join(body)
 379
 380     def _gen_layer_interface_v0_functions(self):
 381         body = []
 382         body.append('%s' % self.lineinfo.get())
 383         body.append('// loader-layer interface v0, just wrappers since there is only a layer')
 384         body.append('')
 385
 386         body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,  VkExtensionProperties* pProperties)')
 387         body.append('{')
 388         body.append('    return %s::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);' % self.layer_name)
 389         body.append('}')
 390         body.append('')
 391         body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount,  VkLayerProperties* pProperties)')
 392         body.append('{')
 393         body.append('    return %s::EnumerateInstanceLayerProperties(pCount, pProperties);' % self.layer_name)
 394         body.append('}')
 395         body.append('')
 396         body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties* pProperties)')
 397         body.append('{')
 398         body.append('    // the layer command handles VK_NULL_HANDLE just fine internally')
 399         body.append('    assert(physicalDevice == VK_NULL_HANDLE);')
 400         body.append('    return %s::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties);' % self.layer_name)
 401         body.append('}')
 402         body.append('')
 403         body.append('VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName)')
 404         body.append('{')
 405         body.append('    return %s::GetDeviceProcAddr(dev, funcName);' % self.layer_name)
 406         body.append('}')
 407         body.append('')
 408         body.append('VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName)')
 409         body.append('{')
 410         body.append('    return %s::GetInstanceProcAddr(instance, funcName);' % self.layer_name)
 411         body.append('}')
 412         body.append('')
 413         body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,')
 414         body.append('                                                                                    const char *pLayerName, uint32_t *pCount,')
 415         body.append('                                                                                    VkExtensionProperties *pProperties)')
 416         body.append('{')
 417         body.append('    // the layer command handles VK_NULL_HANDLE just fine internally')
 418         body.append('    assert(physicalDevice == VK_NULL_HANDLE);')
 419         body.append('    return %s::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties);' % self.layer_name)
 420         body.append('}')
 421
 422         return "\n".join(body)
 423
 424     def _generate_dispatch_entrypoints(self, qual=""):
 425         if qual:
 426             qual += " "
 427
 428         funcs = []
 429         intercepted = []
 430         for proto in self.protos:
 431             if proto.name in ["EnumerateInstanceExtensionProperties",
 432                               "EnumerateInstanceLayerProperties",
 433                               "EnumerateDeviceLayerProperties",
 434                               "GetDeviceProcAddr",
 435                               "GetInstanceProcAddr"]:
 436                 funcs.append(proto.c_func(attr="VKAPI") + ';')
 437                 intercepted.append(proto)
 438             else:
 439                 intercept = self.generate_intercept(proto, qual)
 440                 if intercept is None:
 441                     # fill in default intercept for certain entrypoints
 442                     if 'CreateDebugReportCallbackEXT' == proto.name:
 443                         intercept = self._gen_layer_dbg_create_msg_callback()
 444                     elif 'DestroyDebugReportCallbackEXT' == proto.name:
 445                         intercept = self._gen_layer_dbg_destroy_msg_callback()
 446                     elif 'DebugReportMessageEXT' == proto.name:
 447                         intercept = self._gen_debug_report_msg()
 448                     elif 'CreateDevice' == proto.name:
 449                         funcs.append('/* CreateDevice HERE */')
 450
 451                 if intercept is not None:
 452                     funcs.append(intercept)
 453                     if not "KHR" in proto.name:
 454                         intercepted.append(proto)
 455
 456         instance_lookups = []
 457         device_lookups = []
 458         for proto in intercepted:
 459             if proto_is_global(proto):
 460                 instance_lookups.append("if (!strcmp(name, \"%s\"))" % proto.name)
 461                 instance_lookups.append("    return (PFN_vkVoidFunction) %s;" % (proto.name))
 462             else:
 463                 device_lookups.append("if (!strcmp(name, \"%s\"))" % proto.name)
 464                 device_lookups.append("    return (PFN_vkVoidFunction) %s;" % (proto.name))
 465
 466         # add customized intercept_core_device_command
 467         body = []
 468         body.append('%s' % self.lineinfo.get())
 469         body.append("static inline PFN_vkVoidFunction intercept_core_device_command(const char *name)")
 470         body.append("{")
 471         body.append(generate_get_proc_addr_check("name"))
 472         body.append("")
 473         body.append("    name += 2;")
 474         body.append("    %s" % "\n    ".join(device_lookups))
 475         body.append("")
 476         body.append("    return NULL;")
 477         body.append("}")
 478         # add intercept_core_instance_command
 479         body.append("static inline PFN_vkVoidFunction intercept_core_instance_command(const char *name)")
 480         body.append("{")
 481         body.append(generate_get_proc_addr_check("name"))
 482         body.append("")
 483         body.append("    name += 2;")
 484         body.append("    %s" % "\n    ".join(instance_lookups))
 485         body.append("")
 486         body.append("    return NULL;")
 487         body.append("}")
 488
 489         funcs.append("\n".join(body))
 490         return "\n\n".join(funcs)
 491
 492     def _generate_extensions(self):
 493         exts = []
 494         exts.append('%s' % self.lineinfo.get())
 495         exts.append(self._gen_create_msg_callback())
 496         exts.append(self._gen_destroy_msg_callback())
 497         exts.append(self._gen_debug_report_msg())
 498         return "\n".join(exts)
 499
 500     def _generate_layer_introspection_function(self):
 501         body = []
 502         body.append('%s' % self.lineinfo.get())
 503         body.append('static const VkLayerProperties globalLayerProps = {')
 504         body.append('    "VK_LAYER_GOOGLE_%s",' % self.layer_name)
 505         body.append('    VK_LAYER_API_VERSION, // specVersion')
 506         body.append('    1, // implementationVersion')
 507         body.append('    "Google Validation Layer"')
 508         body.append('};')
 509         body.append('')
 510
 511         body.append('VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount,  VkLayerProperties* pProperties)')
 512         body.append('{')
 513         body.append('    return util_GetLayerProperties(1, &globalLayerProps, pCount, pProperties);')
 514         body.append('}')
 515         body.append('')
 516         body.append('VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties* pProperties)')
 517         body.append('{')
 518         body.append('    return util_GetLayerProperties(1, &globalLayerProps, pCount, pProperties);')
 519         body.append('}')
 520         body.append('')
 521         body.append('VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,  VkExtensionProperties* pProperties)')
 522         body.append('{')
 523         body.append('    if (pLayerName && !strcmp(pLayerName, globalLayerProps.layerName))')
 524         body.append('        return util_GetExtensionProperties(0, NULL, pCount, pProperties);')
 525         body.append('')
 526         body.append('    return VK_ERROR_LAYER_NOT_PRESENT;')
 527         body.append('}')
 528         body.append('')
 529         body.append('VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,')
 530         body.append('                                                                  const char *pLayerName, uint32_t *pCount,')
 531         body.append('                                                                  VkExtensionProperties *pProperties)')
 532         body.append('{')
 533         body.append('    if (pLayerName && !strcmp(pLayerName, globalLayerProps.layerName))')
 534         body.append('        return util_GetExtensionProperties(0, nullptr, pCount, pProperties);')
 535         body.append('')
 536         body.append('    assert(physicalDevice);')
 537         body.append('    VkLayerInstanceDispatchTable* pTable = get_dispatch_table(%s_instance_table_map, physicalDevice);' % self.layer_name)
 538         body.append('    return pTable->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);')
 539         body.append('}')
 540
 541         return "\n".join(body)
 542
 543     def _generate_layer_gpa_function(self, extensions=[], instance_extensions=[]):
 544         func_body = []
 545 #
 546 # New style of GPA Functions for the new layer_data/layer_logging changes
 547 #
 548         if self.layer_name in ['unique_objects']:
 549             for ext_enable, ext_list in extensions:
 550                 func_body.append('%s' % self.lineinfo.get())
 551                 func_body.append('static inline PFN_vkVoidFunction intercept_%s_command(const char *name, VkDevice dev)' % ext_enable)
 552                 func_body.append('{')
 553                 func_body.append('    if (dev) {')
 554                 func_body.append('        layer_data *my_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map);')
 555                 func_body.append('        if (!my_data->%s)' % ext_enable)
 556                 func_body.append('            return nullptr;')
 557                 func_body.append('    }\n')
 558
 559                 for ext_name in ext_list:
 560                     func_body.append('    if (!strcmp("%s", name))\n'
 561                                      '        return reinterpret_cast<PFN_vkVoidFunction>(%s);' % (ext_name, ext_name[2:]))
 562                 func_body.append('\n    return nullptr;')
 563                 func_body.append('}\n')
 564
 565             func_body.append("VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* funcName)\n"
 566                              "{\n"
 567                              "    PFN_vkVoidFunction addr;\n"
 568                              "    addr = intercept_core_device_command(funcName);\n"
 569                              "    if (addr)\n"
 570                              "        return addr;\n"
 571                              "    assert(device);\n")
 572             for ext_enable, _ in extensions:
 573                 func_body.append('    addr = intercept_%s_command(funcName, device);' % ext_enable)
 574                 func_body.append('    if (addr)\n'
 575                                  '        return addr;')
 576             func_body.append("\n    if (get_dispatch_table(%s_device_table_map, device)->GetDeviceProcAddr == NULL)\n"
 577                              "        return NULL;\n"
 578                              "    return get_dispatch_table(%s_device_table_map, device)->GetDeviceProcAddr(device, funcName);\n"
 579                              "}\n" % (self.layer_name, self.layer_name))
 580
 581             # The WSI-related extensions have independent extension enables
 582             wsi_sub_enables = {'WIN32': 'win32_enabled',
 583                                'XLIB': 'xlib_enabled',
 584                                'XCB': 'xcb_enabled',
 585                                'MIR': 'mir_enabled',
 586                                'WAYLAND': 'wayland_enabled',
 587                                'ANDROID': 'android_enabled'}
 588
 589             for ext_enable, ext_list in instance_extensions:
 590                 func_body.append('%s' % self.lineinfo.get())
 591                 func_body.append('static inline PFN_vkVoidFunction intercept_%s_command(const char *name, VkInstance instance)' % ext_enable)
 592                 func_body.append('{')
 593                 if ext_enable == 'msg_callback_get_proc_addr':
 594                     func_body.append("    layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);\n"
 595                                      "    return debug_report_get_instance_proc_addr(my_data->report_data, name);")
 596                 else:
 597                     func_body.append("    VkLayerInstanceDispatchTable* pTable = get_dispatch_table(%s_instance_table_map, instance);" % self.layer_name)
 598                     func_body.append('    if (instanceExtMap.size() == 0 || !instanceExtMap[pTable].%s)' % ext_enable)
 599                     func_body.append('        return nullptr;\n')
 600
 601                     for ext_name in ext_list:
 602                         if wsi_name(ext_name):
 603                             func_body.append('%s' % wsi_ifdef(ext_name))
 604                             if wsi_sub_enables[wsi_name(ext_name)]:
 605                                 func_body.append('    if ((instanceExtMap[pTable].%s == true) && !strcmp("%s", name))\n'
 606                                                  '        return reinterpret_cast<PFN_vkVoidFunction>(%s);' % (wsi_sub_enables[wsi_name(ext_name)], ext_name, ext_name[2:]))
 607                         else:
 608                             func_body.append('    if (!strcmp("%s", name))\n'
 609                                              '        return reinterpret_cast<PFN_vkVoidFunction>(%s);' % (ext_name, ext_name[2:]))
 610                         if wsi_name(ext_name):
 611                             func_body.append('%s' % wsi_endif(ext_name))
 612
 613                     func_body.append('\n    return nullptr;')
 614                 func_body.append('}\n')
 615
 616             func_body.append("VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char* funcName)\n"
 617                              "{\n"
 618                              "    PFN_vkVoidFunction addr;\n"
 619                              "    addr = intercept_core_instance_command(funcName);\n"
 620                              "    if (!addr) {\n"
 621                              "        addr = intercept_core_device_command(funcName);\n"
 622                              "    }")
 623
 624             for ext_enable, _ in extensions:
 625                 func_body.append("    if (!addr) {\n"
 626                                  "        addr = intercept_%s_command(funcName, VkDevice(VK_NULL_HANDLE));\n"
 627                                  "    }" % ext_enable)
 628
 629             func_body.append("    if (addr) {\n"
 630                              "        return addr;\n"
 631                              "    }\n"
 632                              "    assert(instance);\n"
 633                              )
 634
 635             for ext_enable, _ in instance_extensions:
 636                 func_body.append('    addr = intercept_%s_command(funcName, instance);' % ext_enable)
 637                 func_body.append('    if (addr)\n'
 638                                  '        return addr;\n')
 639
 640             func_body.append("    if (get_dispatch_table(%s_instance_table_map, instance)->GetInstanceProcAddr == NULL) {\n"
 641                              "        return NULL;\n"
 642                              "    }\n"
 643                              "    return get_dispatch_table(%s_instance_table_map, instance)->GetInstanceProcAddr(instance, funcName);\n"
 644                              "}\n" % (self.layer_name, self.layer_name))
 645             return "\n".join(func_body)
 646         else:
 647             func_body.append('%s' % self.lineinfo.get())
 648             func_body.append("VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* funcName)\n"
 649                              "{\n"
 650                              "    PFN_vkVoidFunction addr;\n")
 651             func_body.append("\n"
 652                              "    loader_platform_thread_once(&initOnce, init%s);\n\n"
 653                              "    addr = intercept_core_device_command(funcName);\n"
 654                              "    if (addr)\n"
 655                              "        return addr;" % self.layer_name)
 656             func_body.append("    assert(device);\n")
 657             func_body.append('')
 658             func_body.append('    VkLayerDispatchTable *pDisp =  device_dispatch_table(device);')
 659             if 0 != len(extensions):
 660                 extra_space = ""
 661                 for (ext_enable, ext_list) in extensions:
 662                     if 0 != len(ext_enable):
 663                         func_body.append('    if (deviceExtMap.size() != 0 && deviceExtMap[pDisp].%s)' % ext_enable)
 664                         func_body.append('    {')
 665                         extra_space = "    "
 666                     for ext_name in ext_list:
 667                         func_body.append('    %sif (!strcmp("%s", funcName))\n'
 668                                          '            return reinterpret_cast<PFN_vkVoidFunction>(%s);' % (extra_space, ext_name, ext_name))
 669                     if 0 != len(ext_enable):
 670                         func_body.append('    }')
 671             func_body.append('%s' % self.lineinfo.get())
 672             func_body.append("    {\n"
 673                              "        if (pDisp->GetDeviceProcAddr == NULL)\n"
 674                              "            return NULL;\n"
 675                              "        return pDisp->GetDeviceProcAddr(device, funcName);\n"
 676                              "    }\n"
 677                              "}\n")
 678             func_body.append('%s' % self.lineinfo.get())
 679             func_body.append("VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char* funcName)\n"
 680                              "{\n"
 681                              "    PFN_vkVoidFunction addr;\n"
 682                              )
 683             func_body.append(
 684                              "    loader_platform_thread_once(&initOnce, init%s);\n\n"
 685                              "    addr = intercept_core_instance_command(funcName);\n"
 686                              "    if (addr)\n"
 687                              "        return addr;" % self.layer_name)
 688             func_body.append("    assert(instance);\n")
 689             func_body.append("")
 690             func_body.append("    VkLayerInstanceDispatchTable* pTable = instance_dispatch_table(instance);\n")
 691             if 0 != len(instance_extensions):
 692                 extra_space = ""
 693                 for (ext_enable, ext_list) in instance_extensions:
 694                     if 0 != len(ext_enable):
 695                         if ext_enable == 'msg_callback_get_proc_addr':
 696                             func_body.append("    layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);\n"
 697                                      "    addr = debug_report_get_instance_proc_addr(my_data->report_data, funcName);\n"
 698                                      "    if (addr) {\n"
 699                                      "        return addr;\n"
 700                                      "    }\n")
 701                         else:
 702                             func_body.append('    if (instanceExtMap.size() != 0 && instanceExtMap[pTable].%s)' % ext_enable)
 703                             func_body.append('    {')
 704                             extra_space = "    "
 705                             for ext_name in ext_list:
 706                                 if wsi_name(ext_name):
 707                                     func_body.append('%s' % wsi_ifdef(ext_name))
 708                                 func_body.append('    %sif (!strcmp("%s", funcName))\n'
 709                                          '            return reinterpret_cast<PFN_vkVoidFunction>(%s);' % (extra_space, ext_name, ext_name))
 710                                 if wsi_name(ext_name):
 711                                     func_body.append('%s' % wsi_endif(ext_name))
 712                             if 0 != len(ext_enable):
 713                                 func_body.append('    }\n')
 714
 715             func_body.append("    if (pTable->GetInstanceProcAddr == NULL)\n"
 716                              "        return NULL;\n"
 717                              "    return pTable->GetInstanceProcAddr(instance, funcName);\n"
 718                              "}\n")
 719             return "\n".join(func_body)
 720
 721
 722     def _generate_layer_initialization(self, init_opts=False, prefix='vk', lockname=None, condname=None):
 723         func_body = ["#include \"vk_dispatch_table_helper.h\""]
 724         func_body.append('%s' % self.lineinfo.get())
 725         func_body.append('static void init_%s(layer_data *my_data, const VkAllocationCallbacks *pAllocator)\n'
 726                          '{\n' % self.layer_name)
 727         if init_opts:
 728             func_body.append('%s' % self.lineinfo.get())
 729             func_body.append('')
 730             func_body.append('    layer_debug_actions(my_data->report_data, my_data->logging_callback, pAllocator, "lunarg_%s");' % self.layer_name)
 731             func_body.append('')
 732         if lockname is not None:
 733             func_body.append('%s' % self.lineinfo.get())
 734             func_body.append("    if (!%sLockInitialized)" % lockname)
 735             func_body.append("    {")
 736             func_body.append("        // TODO/TBD: Need to delete this mutex sometime.  How???")
 737             func_body.append("        loader_platform_thread_create_mutex(&%sLock);" % lockname)
 738             if condname is not None:
 739                 func_body.append("        loader_platform_thread_init_cond(&%sCond);" % condname)
 740             func_body.append("        %sLockInitialized = 1;" % lockname)
 741             func_body.append("    }")
 742         func_body.append("}\n")
 743         func_body.append('')
 744         return "\n".join(func_body)
 745
 746 class UniqueObjectsSubcommand(Subcommand):
 747     def generate_header(self):
 748         header_txt = []
 749         header_txt.append('%s' % self.lineinfo.get())
 750         header_txt.append('#include "unique_objects.h"')
 751         return "\n".join(header_txt)
 752
 753     # Generate UniqueObjects code for given struct_uses dict of objects that need to be unwrapped
 754     # vector_name_set is used to make sure we don't replicate vector names
 755     # first_level_param indicates if elements are passed directly into the function else they're below a ptr/struct
 756     # TODO : Comment this code
 757     def _gen_obj_code(self, struct_uses, param_type, indent, prefix, array_index, vector_name_set, first_level_param):
 758         decls = ''
 759         pre_code = ''
 760         post_code = ''
 761         for obj in sorted(struct_uses):
 762             name = obj
 763             array = ''
 764             if '[' in obj:
 765                 (name, array) = obj.split('[')
 766                 array = array.strip(']')
 767             ptr_type = False
 768             if 'p' == obj[0] and obj[1] != obj[1].lower(): # TODO : Not ideal way to determine ptr
 769                 ptr_type = True
 770             if isinstance(struct_uses[obj], dict):
 771                 local_prefix = ''
 772                 name = '%s%s' % (prefix, name)
 773                 if ptr_type:
 774                     if first_level_param and name in param_type:
 775                         pre_code += '%sif (%s) {\n' % (indent, name)
 776                     else: # shadow ptr will have been initialized at this point so check it vs. source ptr
 777                         pre_code += '%sif (local_%s) {\n' % (indent, name)
 778                     indent += '    '
 779                 if array != '':
 780                     if 'p' == array[0] and array[1] != array[1].lower(): # TODO : Not ideal way to determine ptr
 781                         count_prefix = '*'
 782                     else:
 783                         count_prefix = ''
 784                     idx = 'idx%s' % str(array_index)
 785                     array_index += 1
 786                     if first_level_param and name in param_type:
 787                         pre_code += '%slocal_%s = new safe_%s[%s%s];\n' % (indent, name, param_type[name].strip('*'), count_prefix, array)
 788                         post_code += '    if (local_%s)\n' % (name)
 789                         post_code += '        delete[] local_%s;\n' % (name)
 790                     pre_code += '%sfor (uint32_t %s=0; %s<%s%s%s; ++%s) {\n' % (indent, idx, idx, count_prefix, prefix, array, idx)
 791                     indent += '    '
 792                     if first_level_param:
 793                         pre_code += '%slocal_%s[%s].initialize(&%s[%s]);\n' % (indent, name, idx, name, idx)
 794                     local_prefix = '%s[%s].' % (name, idx)
 795                 elif ptr_type:
 796                     if first_level_param and name in param_type:
 797                         pre_code += '%slocal_%s = new safe_%s(%s);\n' % (indent, name, param_type[name].strip('*'), name)
 798                         post_code += '    if (local_%s)\n' % (name)
 799                         post_code += '        delete local_%s;\n' % (name)
 800                     local_prefix = '%s->' % (name)
 801                 else:
 802                     local_prefix = '%s.' % (name)
 803                 assert isinstance(decls, object)
 804                 (tmp_decl, tmp_pre, tmp_post) = self._gen_obj_code(struct_uses[obj], param_type, indent, local_prefix, array_index, vector_name_set, False)
 805                 decls += tmp_decl
 806                 pre_code += tmp_pre
 807                 post_code += tmp_post
 808                 if array != '':
 809                     indent = indent[4:]
 810                     pre_code += '%s}\n' % (indent)
 811                 if ptr_type:
 812                     indent = indent[4:]
 813                     pre_code += '%s}\n' % (indent)
 814             else:
 815                 if (array_index > 0) or array != '': # TODO : This is not ideal, really want to know if we're anywhere under an array
 816                     if first_level_param:
 817                         decls += '%s%s* local_%s = NULL;\n' % (indent, struct_uses[obj], name)
 818                     if array != '' and not first_level_param: # ptrs under structs will have been initialized so use local_*
 819                         pre_code += '%sif (local_%s%s) {\n' %(indent, prefix, name)
 820                     else:
 821                         pre_code += '%sif (%s%s) {\n' %(indent, prefix, name)
 822                     indent += '    '
 823                     if array != '':
 824                         idx = 'idx%s' % str(array_index)
 825                         array_index += 1
 826                         if first_level_param:
 827                             pre_code += '%slocal_%s = new %s[%s];\n' % (indent, name, struct_uses[obj], array)
 828                             post_code += '    if (local_%s)\n' % (name)
 829                             post_code += '        delete[] local_%s;\n' % (name)
 830                         pre_code += '%sfor (uint32_t %s=0; %s<%s%s; ++%s) {\n' % (indent, idx, idx, prefix, array, idx)
 831                         indent += '    '
 832                         name = '%s[%s]' % (name, idx)
 833                     if name not in vector_name_set:
 834                         vector_name_set.add(name)
 835                     pre_code += '%slocal_%s%s = (%s)my_map_data->unique_id_mapping[reinterpret_cast<const uint64_t &>(%s%s)];\n' % (indent, prefix, name, struct_uses[obj], prefix, name)
 836                     if array != '':
 837                         indent = indent[4:]
 838                         pre_code += '%s}\n' % (indent)
 839                     indent = indent[4:]
 840                     pre_code += '%s}\n' % (indent)
 841                 else:
 842                     pre_code += '%s\n' % (self.lineinfo.get())
 843                     if '->' in prefix: # need to update local struct
 844                         pre_code += '%slocal_%s%s = (%s)my_map_data->unique_id_mapping[reinterpret_cast<const uint64_t &>(%s%s)];\n' % (indent, prefix, name, struct_uses[obj], prefix, name)
 845                     else:
 846                         pre_code += '%s%s = (%s)my_map_data->unique_id_mapping[reinterpret_cast<uint64_t &>(%s)];\n' % (indent, name, struct_uses[obj], name)
 847         return decls, pre_code, post_code
 848
 849     def generate_intercept(self, proto, qual):
 850         create_func = False
 851         destroy_func = False
 852         last_param_index = None #typcially we look at all params for ndos
 853         pre_call_txt = '' # code prior to calling down chain such as unwrap uses of ndos
 854         post_call_txt = '' # code following call down chain such to wrap newly created ndos, or destroy local wrap struct
 855         funcs = []
 856         indent = '    ' # indent level for generated code
 857         decl = proto.c_func(attr="VKAPI")
 858         # A few API cases that are manual code
 859         # TODO : Special case Create*Pipelines funcs to handle creating multiple unique objects
 860         explicit_unique_objects_functions = ['GetSwapchainImagesKHR',
 861                                              'CreateSwapchainKHR',
 862                                              'CreateInstance',
 863                                              'DestroyInstance',
 864                                              'CreateDevice',
 865                                              'DestroyDevice',
 866                                              'AllocateMemory',
 867                                              'CreateComputePipelines',
 868                                              'CreateGraphicsPipelines',
 869                                              'GetPhysicalDeviceDisplayPropertiesKHR',
 870                                              'GetDisplayPlaneSupportedDisplaysKHR',
 871                                              'GetDisplayModePropertiesKHR'
 872                                              ]
 873         # TODO : This is hacky, need to make this a more general-purpose solution for all layers
 874         ifdef_dict = {'CreateXcbSurfaceKHR': 'VK_USE_PLATFORM_XCB_KHR',
 875                       'CreateAndroidSurfaceKHR': 'VK_USE_PLATFORM_ANDROID_KHR',
 876                       'CreateWin32SurfaceKHR': 'VK_USE_PLATFORM_WIN32_KHR',
 877                       'CreateXlibSurfaceKHR': 'VK_USE_PLATFORM_XLIB_KHR',
 878                       'CreateWaylandSurfaceKHR': 'VK_USE_PLATFORM_WAYLAND_KHR',
 879                       'CreateMirSurfaceKHR': 'VK_USE_PLATFORM_MIR_KHR'}
 880         # Give special treatment to create functions that return multiple new objects
 881         # This dict stores array name and size of array
 882         custom_create_dict = {'pDescriptorSets' : 'pAllocateInfo->descriptorSetCount'}
 883         pre_call_txt += '%s\n' % (self.lineinfo.get())
 884         if proto.name in explicit_unique_objects_functions:
 885             funcs.append('%s%s\n'
 886                      '{\n'
 887                      '    return explicit_%s;\n'
 888                      '}' % (qual, decl, proto.c_call()))
 889             return "".join(funcs)
 890         if True in [create_txt in proto.name for create_txt in ['Create', 'Allocate']]:
 891             create_func = True
 892             last_param_index = -1 # For create funcs don't care if last param is ndo
 893         if True in [destroy_txt in proto.name for destroy_txt in ['Destroy', 'Free']]:
 894             destroy_obj_type = proto.params[-2].ty
 895             if destroy_obj_type in vulkan.object_non_dispatch_list:
 896                 destroy_func = True
 897
 898         # First thing we need to do is gather uses of non-dispatchable-objects (ndos)
 899         (struct_uses, local_decls) = get_object_uses(vulkan.object_non_dispatch_list, proto.params[1:last_param_index])
 900
 901         dispatch_param = proto.params[0].name
 902         if 'CreateInstance' in proto.name:
 903            dispatch_param = '*' + proto.params[1].name
 904         pre_call_txt += '%slayer_data *my_map_data = get_my_data_ptr(get_dispatch_key(%s), layer_data_map);\n' % (indent, dispatch_param)
 905         if len(struct_uses) > 0:
 906             pre_call_txt += '// STRUCT USES:%s\n' % sorted(struct_uses)
 907             if len(local_decls) > 0:
 908                 pre_call_txt += '//LOCAL DECLS:%s\n' % sorted(local_decls)
 909             if destroy_func: # only one object
 910                 pre_call_txt += '%sstd::unique_lock<std::mutex> lock(global_lock);\n' % (indent)
 911                 for del_obj in sorted(struct_uses):
 912                     pre_call_txt += '%suint64_t local_%s = reinterpret_cast<uint64_t &>(%s);\n' % (indent, del_obj, del_obj)
 913                     pre_call_txt += '%s%s = (%s)my_map_data->unique_id_mapping[local_%s];\n' % (indent, del_obj, struct_uses[del_obj], del_obj)
 914                 pre_call_txt += '%smy_map_data->unique_id_mapping.erase(local_%s);\n' % (indent, proto.params[-2].name)
 915                 pre_call_txt += '%slock.unlock();\n' % (indent)
 916                 (pre_decl, pre_code, post_code) = ('', '', '')
 917             else:
 918                 (pre_decl, pre_code, post_code) = self._gen_obj_code(struct_uses, local_decls, '    ', '', 0, set(), True)
 919             # This is a bit hacky but works for now. Need to decl local versions of top-level structs
 920             for ld in sorted(local_decls):
 921                 init_null_txt = 'NULL';
 922                 if '*' not in local_decls[ld]:
 923                     init_null_txt = '{}';
 924                 if local_decls[ld].strip('*') not in vulkan.object_non_dispatch_list:
 925                     pre_decl += '    safe_%s local_%s = %s;\n' % (local_decls[ld], ld, init_null_txt)
 926             if pre_code != '': # lock around map uses
 927                 pre_code = '%s{\n%sstd::lock_guard<std::mutex> lock(global_lock);\n%s%s}\n' % (indent, indent, pre_code, indent)
 928             pre_call_txt += '%s%s' % (pre_decl, pre_code)
 929             post_call_txt += '%s' % (post_code)
 930         elif create_func:
 931             base_type = proto.params[-1].ty.replace('const ', '').strip('*')
 932             if base_type not in vulkan.object_non_dispatch_list:
 933                 return None
 934         else:
 935             return None
 936
 937         ret_val = ''
 938         ret_stmt = ''
 939         if proto.ret != "void":
 940             ret_val = "%s result = " % proto.ret
 941             ret_stmt = "    return result;\n"
 942         if create_func:
 943             obj_type = proto.params[-1].ty.strip('*')
 944             obj_name = proto.params[-1].name
 945             if obj_type in vulkan.object_non_dispatch_list:
 946                 local_name = "unique%s" % obj_type[2:]
 947                 post_call_txt += '%sif (VK_SUCCESS == result) {\n' % (indent)
 948                 indent += '    '
 949                 post_call_txt += '%sstd::lock_guard<std::mutex> lock(global_lock);\n' % (indent)
 950                 if obj_name in custom_create_dict:
 951                     post_call_txt += '%s\n' % (self.lineinfo.get())
 952                     local_name = '%ss' % (local_name) # add 's' to end for vector of many
 953                     post_call_txt += '%sfor (uint32_t i=0; i<%s; ++i) {\n' % (indent, custom_create_dict[obj_name])
 954                     indent += '    '
 955                     post_call_txt += '%suint64_t unique_id = global_unique_id++;\n' % (indent)
 956                     post_call_txt += '%smy_map_data->unique_id_mapping[unique_id] = reinterpret_cast<uint64_t &>(%s[i]);\n' % (indent, obj_name)
 957                     post_call_txt += '%s%s[i] = reinterpret_cast<%s&>(unique_id);\n' % (indent, obj_name, obj_type)
 958                     indent = indent[4:]
 959                     post_call_txt += '%s}\n' % (indent)
 960                 else:
 961                     post_call_txt += '%s\n' % (self.lineinfo.get())
 962                     post_call_txt += '%suint64_t unique_id = global_unique_id++;\n' % (indent)
 963                     post_call_txt += '%smy_map_data->unique_id_mapping[unique_id] = reinterpret_cast<uint64_t &>(*%s);\n' % (indent, obj_name)
 964                     post_call_txt += '%s*%s = reinterpret_cast<%s&>(unique_id);\n' % (indent, obj_name, obj_type)
 965                 indent = indent[4:]
 966                 post_call_txt += '%s}\n' % (indent)
 967
 968         call_sig = proto.c_call()
 969         # Replace default params with any custom local params
 970         for ld in local_decls:
 971             const_qualifier = ''
 972             for p in proto.params:
 973                 if ld == p.name and 'const' in p.ty:
 974                     const_qualifier = 'const'
 975             call_sig = call_sig.replace(ld, '(%s %s)local_%s' % (const_qualifier, local_decls[ld], ld))
 976         if proto_is_global(proto):
 977             table_type = "instance"
 978         else:
 979             table_type = "device"
 980         pre_call_txt += '%s\n' % (self.lineinfo.get())
 981         open_ifdef = ''
 982         close_ifdef = ''
 983         if proto.name in ifdef_dict:
 984             open_ifdef = '#ifdef %s\n' % (ifdef_dict[proto.name])
 985             close_ifdef = '#endif\n'
 986         funcs.append('%s'
 987                      '%s%s\n'
 988                      '{\n'
 989                      '%s'
 990                      '    %sget_dispatch_table(unique_objects_%s_table_map, %s)->%s;\n'
 991                      '%s'
 992                      '%s'
 993                      '}\n'
 994                      '%s' % (open_ifdef, qual, decl, pre_call_txt, ret_val, table_type, dispatch_param, call_sig, post_call_txt, ret_stmt, close_ifdef))
 995         return "\n\n".join(funcs)
 996
 997     def generate_body(self):
 998         self.layer_name = "unique_objects"
 999         extensions=[('wsi_enabled',
1000                      ['vkCreateSwapchainKHR',
1001                       'vkDestroySwapchainKHR', 'vkGetSwapchainImagesKHR',
1002                       'vkAcquireNextImageKHR', 'vkQueuePresentKHR'])]
1003         surface_wsi_instance_exts = [
1004                       'vkDestroySurfaceKHR',
1005                       'vkGetPhysicalDeviceSurfaceSupportKHR',
1006                       'vkGetPhysicalDeviceSurfaceCapabilitiesKHR',
1007                       'vkGetPhysicalDeviceSurfaceFormatsKHR',
1008                       'vkGetPhysicalDeviceSurfacePresentModesKHR']
1009         display_wsi_instance_exts = [
1010                       'vkGetPhysicalDeviceDisplayPropertiesKHR',
1011                       'vkGetPhysicalDeviceDisplayPlanePropertiesKHR',
1012                       'vkGetDisplayPlaneSupportedDisplaysKHR',
1013                       'vkGetDisplayModePropertiesKHR',
1014                       'vkCreateDisplayModeKHR',
1015                       'vkGetDisplayPlaneCapabilitiesKHR',
1016                       'vkCreateDisplayPlaneSurfaceKHR']
1017         if self.wsi == 'Win32':
1018             instance_extensions=[('wsi_enabled', surface_wsi_instance_exts),
1019                                  ('display_enabled', display_wsi_instance_exts),
1020                                  ('win32_enabled', ['vkCreateWin32SurfaceKHR'])]
1021         elif self.wsi == 'Android':
1022             instance_extensions=[('wsi_enabled', surface_wsi_instance_exts),
1023                                  ('android_enabled', ['vkCreateAndroidSurfaceKHR'])]
1024         elif self.wsi == 'Xcb' or self.wsi == 'Xlib' or self.wsi == 'Wayland' or self.wsi == 'Mir':
1025             instance_extensions=[('wsi_enabled', surface_wsi_instance_exts),
1026                                  ('display_enabled', display_wsi_instance_exts),
1027                                  ('xcb_enabled', ['vkCreateXcbSurfaceKHR']),
1028                                  ('xlib_enabled', ['vkCreateXlibSurfaceKHR']),
1029                                  ('wayland_enabled',  ['vkCreateWaylandSurfaceKHR']),
1030                                  ('mir_enabled', ['vkCreateMirSurfaceKHR'])]
1031         elif self.wsi == 'Display':
1032             instance_extensions=[('wsi_enabled', surface_wsi_instance_exts),
1033                                  ('display_enabled', display_wsi_instance_exts)]
1034         else:
1035             print('Error: Undefined DisplayServer')
1036             instance_extensions=[]
1037
1038         body = ["namespace %s {" % self.layer_name,
1039                 self._generate_dispatch_entrypoints(),
1040                 self._generate_layer_introspection_function(),
1041                 self._generate_layer_gpa_function(extensions,
1042                                                   instance_extensions),
1043                 "} // namespace %s" % self.layer_name,
1044                 self._gen_layer_interface_v0_functions()]
1045         return "\n\n".join(body)
1046
1047 def main():
1048     wsi = {
1049             "Win32",
1050             "Android",
1051             "Xcb",
1052             "Xlib",
1053             "Wayland",
1054             "Mir",
1055             "Display",
1056     }
1057
1058     subcommands = {
1059             "unique_objects" : UniqueObjectsSubcommand,
1060     }
1061
1062     if len(sys.argv) < 4 or sys.argv[1] not in wsi or sys.argv[2] not in subcommands or not os.path.exists(sys.argv[3]):
1063         print("Usage: %s <wsi> <subcommand> <input_header> [outdir]" % sys.argv[0])
1064         print
1065         print("Available subcommands are: %s" % " ".join(subcommands))
1066         exit(1)
1067
1068     hfp = vk_helper.HeaderFileParser(sys.argv[3])
1069     hfp.parse()
1070     vk_helper.enum_val_dict = hfp.get_enum_val_dict()
1071     vk_helper.enum_type_dict = hfp.get_enum_type_dict()
1072     vk_helper.struct_dict = hfp.get_struct_dict()
1073     vk_helper.typedef_fwd_dict = hfp.get_typedef_fwd_dict()
1074     vk_helper.typedef_rev_dict = hfp.get_typedef_rev_dict()
1075     vk_helper.types_dict = hfp.get_types_dict()
1076
1077     outfile = None
1078     if len(sys.argv) >= 5:
1079         outfile = sys.argv[4]
1080
1081     subcmd = subcommands[sys.argv[2]](outfile)
1082     subcmd.run()
1083
1084 if __name__ == "__main__":
1085     main()