#!/usr/bin/python3 -i # # Copyright (c) 2015-2016 Valve Corporation # Copyright (c) 2015-2016 LunarG, Inc. # Copyright (c) 2015-2016 Google Inc. # # 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. # # Author: Tobin Ehlis # Author: Mark Lobodzinski # # This script generates the dispatch portion of a factory layer which intercepts # all Vulkan functions. The resultant factory layer allows rapid development of # layers and interceptors. import os,re,sys from generator import * from common_codegen import * # LayerFactoryGeneratorOptions - subclass of GeneratorOptions. # # Adds options used by LayerFactoryOutputGenerator objects during factory # layer generation. # # Additional members # prefixText - list of strings to prefix generated header with # (usually a copyright statement + calling convention macros). # protectFile - True if multiple inclusion protection should be # generated (based on the filename) around the entire header. # protectFeature - True if #ifndef..#endif protection should be # generated around a feature interface in the header file. # genFuncPointers - True if function pointer typedefs should be # generated # protectProto - If conditional protection should be generated # around prototype declarations, set to either '#ifdef' # to require opt-in (#ifdef protectProtoStr) or '#ifndef' # to require opt-out (#ifndef protectProtoStr). Otherwise # set to None. # protectProtoStr - #ifdef/#ifndef symbol to use around prototype # declarations, if protectProto is set # apicall - string to use for the function declaration prefix, # such as APICALL on Windows. # apientry - string to use for the calling convention macro, # in typedefs, such as APIENTRY. # apientryp - string to use for the calling convention macro # in function pointer typedefs, such as APIENTRYP. # indentFuncProto - True if prototype declarations should put each # parameter on a separate line # indentFuncPointer - True if typedefed function pointers should put each # parameter on a separate line # alignFuncParam - if nonzero and parameters are being put on a # separate line, align parameter names at the specified column class LayerChassisGeneratorOptions(GeneratorOptions): def __init__(self, filename = None, directory = '.', apiname = None, profile = None, versions = '.*', emitversions = '.*', defaultExtensions = None, addExtensions = None, removeExtensions = None, emitExtensions = None, sortProcedure = regSortFeatures, prefixText = "", genFuncPointers = True, protectFile = True, protectFeature = True, apicall = '', apientry = '', apientryp = '', indentFuncProto = True, indentFuncPointer = False, alignFuncParam = 0, helper_file_type = '', expandEnumerants = True): GeneratorOptions.__init__(self, filename, directory, apiname, profile, versions, emitversions, defaultExtensions, addExtensions, removeExtensions, emitExtensions, sortProcedure) self.prefixText = prefixText self.genFuncPointers = genFuncPointers self.protectFile = protectFile self.protectFeature = protectFeature self.apicall = apicall self.apientry = apientry self.apientryp = apientryp self.indentFuncProto = indentFuncProto self.indentFuncPointer = indentFuncPointer self.alignFuncParam = alignFuncParam # LayerChassisOutputGenerator - subclass of OutputGenerator. # Generates a LayerFactory layer that intercepts all API entrypoints # This is intended to be used as a starting point for creating custom layers # # ---- methods ---- # LayerChassisOutputGenerator(errFile, warnFile, diagFile) - args as for # OutputGenerator. Defines additional internal state. # ---- methods overriding base class ---- # beginFile(genOpts) # endFile() # beginFeature(interface, emit) # endFeature() # genType(typeinfo,name) # genStruct(typeinfo,name) # genGroup(groupinfo,name) # genEnum(enuminfo, name) # genCmd(cmdinfo) class LayerChassisOutputGenerator(OutputGenerator): """Generate specified API interfaces in a specific style, such as a C header""" # This is an ordered list of sections in the header file. TYPE_SECTIONS = ['include', 'define', 'basetype', 'handle', 'enum', 'group', 'bitmask', 'funcpointer', 'struct'] ALL_SECTIONS = TYPE_SECTIONS + ['command'] manual_functions = [ # Include functions here to be interecpted w/ manually implemented function bodies 'vkGetDeviceProcAddr', 'vkGetInstanceProcAddr', 'vkGetPhysicalDeviceProcAddr', 'vkCreateDevice', 'vkDestroyDevice', 'vkCreateInstance', 'vkDestroyInstance', 'vkCreateDebugReportCallbackEXT', 'vkDestroyDebugReportCallbackEXT', 'vkEnumerateInstanceLayerProperties', 'vkEnumerateInstanceExtensionProperties', 'vkEnumerateDeviceLayerProperties', 'vkEnumerateDeviceExtensionProperties', ] alt_ret_codes = [ # Include functions here which must tolerate VK_INCOMPLETE as a return code 'vkEnumeratePhysicalDevices', 'vkEnumeratePhysicalDeviceGroupsKHR', 'vkGetValidationCacheDataEXT', 'vkGetPipelineCacheData', 'vkGetShaderInfoAMD', 'vkGetPhysicalDeviceDisplayPropertiesKHR', 'vkGetPhysicalDeviceDisplayProperties2KHR', 'vkGetPhysicalDeviceDisplayPlanePropertiesKHR', 'vkGetDisplayPlaneSupportedDisplaysKHR', 'vkGetDisplayModePropertiesKHR', 'vkGetDisplayModeProperties2KHR', 'vkGetPhysicalDeviceSurfaceFormatsKHR', 'vkGetPhysicalDeviceSurfacePresentModesKHR', 'vkGetPhysicalDevicePresentRectanglesKHR', 'vkGetPastPresentationTimingGOOGLE', 'vkGetSwapchainImagesKHR', 'vkEnumerateInstanceLayerProperties', 'vkEnumerateDeviceLayerProperties', 'vkEnumerateInstanceExtensionProperties', 'vkEnumerateDeviceExtensionProperties', 'vkGetPhysicalDeviceCalibrateableTimeDomainsEXT', ] pre_dispatch_debug_utils_functions = { 'vkSetDebugUtilsObjectNameEXT' : 'layer_data->report_data->debugUtilsObjectNameMap->insert(std::make_pair((uint64_t &&) pNameInfo->objectHandle, pNameInfo->pObjectName));', 'vkQueueBeginDebugUtilsLabelEXT' : 'BeginQueueDebugUtilsLabel(layer_data->report_data, queue, pLabelInfo);', 'vkQueueInsertDebugUtilsLabelEXT' : 'InsertQueueDebugUtilsLabel(layer_data->report_data, queue, pLabelInfo);', 'vkCmdBeginDebugUtilsLabelEXT' : 'BeginCmdDebugUtilsLabel(layer_data->report_data, commandBuffer, pLabelInfo);', 'vkCmdInsertDebugUtilsLabelEXT' : 'InsertCmdDebugUtilsLabel(layer_data->report_data, commandBuffer, pLabelInfo);' } post_dispatch_debug_utils_functions = { 'vkQueueEndDebugUtilsLabelEXT' : 'EndQueueDebugUtilsLabel(layer_data->report_data, queue);', 'vkCmdEndDebugUtilsLabelEXT' : 'EndCmdDebugUtilsLabel(layer_data->report_data, commandBuffer);', 'vkCmdInsertDebugUtilsLabelEXT' : 'InsertCmdDebugUtilsLabel(layer_data->report_data, commandBuffer, pLabelInfo);' } precallvalidate_loop = "for (auto intercept : layer_data->object_dispatch) {" precallrecord_loop = precallvalidate_loop postcallrecord_loop = "for (auto intercept : layer_data->object_dispatch) {" inline_custom_header_preamble = """ #define NOMINMAX #include #include #include #include #include #include #include #include #include #include "vk_loader_platform.h" #include "vulkan/vulkan.h" #include "vk_layer_config.h" #include "vk_layer_data.h" #include "vk_layer_logging.h" #include "vk_object_types.h" #include "vulkan/vk_layer.h" #include "vk_enum_string_helper.h" #include "vk_layer_extension_utils.h" #include "vk_layer_utils.h" #include "vulkan/vk_layer.h" #include "vk_dispatch_table_helper.h" #include "vk_validation_error_messages.h" #include "vk_extension_helper.h" #include "vk_safe_struct.h" extern uint64_t global_unique_id; extern std::unordered_map unique_id_mapping; """ inline_custom_header_class_definition = """ // Layer object type identifiers enum LayerObjectTypeId { LayerObjectTypeThreading, LayerObjectTypeParameterValidation, LayerObjectTypeObjectTracker, LayerObjectTypeCoreValidation, }; struct TEMPLATE_STATE { VkDescriptorUpdateTemplateKHR desc_update_template; safe_VkDescriptorUpdateTemplateCreateInfo create_info; TEMPLATE_STATE(VkDescriptorUpdateTemplateKHR update_template, safe_VkDescriptorUpdateTemplateCreateInfo *pCreateInfo) : desc_update_template(update_template), create_info(*pCreateInfo) {} }; class LAYER_PHYS_DEV_PROPERTIES { public: VkPhysicalDeviceProperties properties; std::vector queue_family_properties; }; // Layer chassis validation object base class definition class ValidationObject { public: uint32_t api_version; debug_report_data* report_data = nullptr; std::vector logging_callback; std::vector logging_messenger; VkLayerInstanceDispatchTable instance_dispatch_table; VkLayerDispatchTable device_dispatch_table; InstanceExtensions instance_extensions; DeviceExtensions device_extensions = {}; VkInstance instance = VK_NULL_HANDLE; VkPhysicalDevice physical_device = VK_NULL_HANDLE; VkDevice device = VK_NULL_HANDLE; LAYER_PHYS_DEV_PROPERTIES phys_dev_properties = {}; std::vector object_dispatch; LayerObjectTypeId container_type; // Constructor ValidationObject(){}; // Destructor virtual ~ValidationObject() {}; std::mutex validation_object_mutex; virtual void write_lock() { validation_object_mutex.lock(); } virtual void write_unlock() { validation_object_mutex.unlock(); } ValidationObject* GetValidationObject(std::vector& object_dispatch, LayerObjectTypeId object_type) { for (auto validation_object : object_dispatch) { if (validation_object->container_type == object_type) { return validation_object; } } return nullptr; }; std::string layer_name = "CHASSIS"; // Handle Wrapping Data // Reverse map display handles std::unordered_map display_id_reverse_mapping; std::unordered_map> desc_template_map; struct SubpassesUsageStates { std::unordered_set subpasses_using_color_attachment; std::unordered_set subpasses_using_depthstencil_attachment; }; // Uses unwrapped handles std::unordered_map renderpasses_states; // Map of wrapped swapchain handles to arrays of wrapped swapchain image IDs // Each swapchain has an immutable list of wrapped swapchain image IDs -- always return these IDs if they exist std::unordered_map> swapchain_wrapped_image_handle_map; // Map of wrapped descriptor pools to set of wrapped descriptor sets allocated from each pool std::unordered_map> pool_descriptor_sets_map; // Unwrap a handle. Must hold lock. template HandleType Unwrap(HandleType wrappedHandle) { // TODO: don't use operator[] here. return (HandleType)unique_id_mapping[reinterpret_cast(wrappedHandle)]; } // Wrap a newly created handle with a new unique ID, and return the new ID -- must hold lock. template HandleType WrapNew(HandleType newlyCreatedHandle) { auto unique_id = global_unique_id++; unique_id_mapping[unique_id] = reinterpret_cast(newlyCreatedHandle); return (HandleType)unique_id; } // Specialized handling for VkDisplayKHR. Adds an entry to enable reverse-lookup. Must hold lock. VkDisplayKHR WrapDisplay(VkDisplayKHR newlyCreatedHandle, ValidationObject *map_data) { auto unique_id = global_unique_id++; unique_id_mapping[unique_id] = reinterpret_cast(newlyCreatedHandle); map_data->display_id_reverse_mapping[newlyCreatedHandle] = unique_id; return (VkDisplayKHR)unique_id; } // VkDisplayKHR objects don't have a single point of creation, so we need to see if one already exists in the map before // creating another. Must hold lock. VkDisplayKHR MaybeWrapDisplay(VkDisplayKHR handle, ValidationObject *map_data) { // See if this display is already known auto it = map_data->display_id_reverse_mapping.find(handle); if (it != map_data->display_id_reverse_mapping.end()) return (VkDisplayKHR)it->second; // Unknown, so wrap return WrapDisplay(handle, map_data); } // Pre/post hook point declarations """ inline_copyright_message = """ // This file is ***GENERATED***. Do Not Edit. // See layer_chassis_generator.py for modifications. /* Copyright (c) 2015-2019 The Khronos Group Inc. * Copyright (c) 2015-2019 Valve Corporation * Copyright (c) 2015-2019 LunarG, Inc. * Copyright (c) 2015-2019 Google Inc. * * 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. * * Author: Mark Lobodzinski */""" inline_custom_source_preamble = """ #include #include #define VALIDATION_ERROR_MAP_IMPL #include "chassis.h" #include "layer_chassis_dispatch.h" std::unordered_map layer_data_map; // Global unique object identifier. All increments must be guarded by a lock. uint64_t global_unique_id = 1; // Map uniqueID to actual object handle std::unordered_map unique_id_mapping; // TODO: This variable controls handle wrapping -- in the future it should be hooked // up to the new VALIDATION_FEATURES extension. Temporarily, control with a compile-time flag. #if defined(LAYER_CHASSIS_CAN_WRAP_HANDLES) bool wrap_handles = true; #else const bool wrap_handles = false; #endif // Include child object (layer) definitions #if BUILD_OBJECT_TRACKER #include "object_lifetime_validation.h" #define OBJECT_LAYER_NAME "VK_LAYER_LUNARG_object_tracker" #elif BUILD_THREAD_SAFETY #include "thread_safety.h" #define OBJECT_LAYER_NAME "VK_LAYER_GOOGLE_threading" #elif BUILD_PARAMETER_VALIDATION #include "stateless_validation.h" #define OBJECT_LAYER_NAME "VK_LAYER_LUNARG_parameter_validation" #elif BUILD_CORE_VALIDATION #define OBJECT_LAYER_NAME "VK_LAYER_LUNARG_core_validation" #else #define OBJECT_LAYER_NAME "VK_LAYER_GOOGLE_unique_objects" #endif namespace vulkan_layer_chassis { using std::unordered_map; static const VkLayerProperties global_layer = { OBJECT_LAYER_NAME, VK_LAYER_API_VERSION, 1, "LunarG validation Layer", }; static const VkExtensionProperties instance_extensions[] = {{VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}}; extern const std::unordered_map name_to_funcptr_map; // Manually written functions // Check enabled instance extensions against supported instance extension whitelist static void InstanceExtensionWhitelist(ValidationObject *layer_data, const VkInstanceCreateInfo *pCreateInfo, VkInstance instance) { for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { // Check for recognized instance extensions if (!white_list(pCreateInfo->ppEnabledExtensionNames[i], kInstanceExtensionNames)) { log_msg(layer_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUIDUndefined, "Instance Extension %s is not supported by this layer. Using this extension may adversely affect validation " "results and/or produce undefined behavior.", pCreateInfo->ppEnabledExtensionNames[i]); } } } // Check enabled device extensions against supported device extension whitelist static void DeviceExtensionWhitelist(ValidationObject *layer_data, const VkDeviceCreateInfo *pCreateInfo, VkDevice device) { for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { // Check for recognized device extensions if (!white_list(pCreateInfo->ppEnabledExtensionNames[i], kDeviceExtensionNames)) { log_msg(layer_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUIDUndefined, "Device Extension %s is not supported by this layer. Using this extension may adversely affect validation " "results and/or produce undefined behavior.", pCreateInfo->ppEnabledExtensionNames[i]); } } } VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) { auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); if (!ApiParentExtensionEnabled(funcName, layer_data->device_extensions.device_extension_set)) { return nullptr; } const auto &item = name_to_funcptr_map.find(funcName); if (item != name_to_funcptr_map.end()) { return reinterpret_cast(item->second); } auto &table = layer_data->device_dispatch_table; if (!table.GetDeviceProcAddr) return nullptr; return table.GetDeviceProcAddr(device, funcName); } VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) { const auto &item = name_to_funcptr_map.find(funcName); if (item != name_to_funcptr_map.end()) { return reinterpret_cast(item->second); } auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); auto &table = layer_data->instance_dispatch_table; if (!table.GetInstanceProcAddr) return nullptr; return table.GetInstanceProcAddr(instance, funcName); } VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); auto &table = layer_data->instance_dispatch_table; if (!table.GetPhysicalDeviceProcAddr) return nullptr; return table.GetPhysicalDeviceProcAddr(instance, funcName); } VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) { return util_GetLayerProperties(1, &global_layer, pCount, pProperties); } VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) { return util_GetLayerProperties(1, &global_layer, pCount, pProperties); } VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) { if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties); return VK_ERROR_LAYER_NOT_PRESENT; } VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) { if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) return util_GetExtensionProperties(0, NULL, pCount, pProperties); assert(physicalDevice); auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map); return layer_data->instance_dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties); } VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) { VkLayerInstanceCreateInfo* chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); assert(chain_info->u.pLayerInfo); PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance"); if (fpCreateInstance == NULL) return VK_ERROR_INITIALIZATION_FAILED; chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; // Create temporary dispatch vector for pre-calls until instance is created std::vector local_object_dispatch; #if BUILD_OBJECT_TRACKER auto object_tracker = new ObjectLifetimes; local_object_dispatch.emplace_back(object_tracker); object_tracker->container_type = LayerObjectTypeObjectTracker; #elif BUILD_THREAD_SAFETY auto thread_checker = new ThreadSafety; local_object_dispatch.emplace_back(thread_checker); thread_checker->container_type = LayerObjectTypeThreading; #elif BUILD_PARAMETER_VALIDATION auto parameter_validation = new StatelessValidation; local_object_dispatch.emplace_back(parameter_validation); parameter_validation->container_type = LayerObjectTypeParameterValidation; #endif // Init dispatch array and call registration functions for (auto intercept : local_object_dispatch) { intercept->PreCallValidateCreateInstance(pCreateInfo, pAllocator, pInstance); } for (auto intercept : local_object_dispatch) { intercept->PreCallRecordCreateInstance(pCreateInfo, pAllocator, pInstance); } VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); if (result != VK_SUCCESS) return result; auto framework = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map); framework->object_dispatch = local_object_dispatch; framework->instance = *pInstance; layer_init_instance_dispatch_table(*pInstance, &framework->instance_dispatch_table, fpGetInstanceProcAddr); framework->report_data = debug_utils_create_instance(&framework->instance_dispatch_table, *pInstance, pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames); framework->api_version = framework->instance_extensions.InitFromInstanceCreateInfo( (pCreateInfo->pApplicationInfo ? pCreateInfo->pApplicationInfo->apiVersion : VK_API_VERSION_1_0), pCreateInfo); #if BUILD_OBJECT_TRACKER layer_debug_messenger_actions(framework->report_data, framework->logging_messenger, pAllocator, "lunarg_object_tracker"); object_tracker->report_data = framework->report_data; object_tracker->api_version = framework->api_version; #elif BUILD_THREAD_SAFETY layer_debug_messenger_actions(framework->report_data, framework->logging_messenger, pAllocator, "google_thread_checker"); thread_checker->report_data = framework->report_data; thread_checker->api_version = framework->api_version; #elif BUILD_PARAMETER_VALIDATION layer_debug_messenger_actions(framework->report_data, framework->logging_messenger, pAllocator, "lunarg_parameter_validation"); parameter_validation->report_data = framework->report_data; parameter_validation->api_version = framework->api_version; #else layer_debug_messenger_actions(framework->report_data, framework->logging_messenger, pAllocator, "lunarg_unique_objects"); #endif for (auto intercept : framework->object_dispatch) { intercept->PostCallRecordCreateInstance(pCreateInfo, pAllocator, pInstance); } InstanceExtensionWhitelist(framework, pCreateInfo, *pInstance); return result; } VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) { dispatch_key key = get_dispatch_key(instance); auto layer_data = GetLayerDataPtr(key, layer_data_map); """ + precallvalidate_loop + """ intercept->write_lock(); intercept->PreCallValidateDestroyInstance(instance, pAllocator); intercept->write_unlock(); } """ + precallrecord_loop + """ intercept->write_lock(); intercept->PreCallRecordDestroyInstance(instance, pAllocator); intercept->write_unlock(); } layer_data->instance_dispatch_table.DestroyInstance(instance, pAllocator); """ + postcallrecord_loop + """ intercept->write_lock(); intercept->PostCallRecordDestroyInstance(instance, pAllocator); intercept->write_unlock(); } // Clean up logging callback, if any while (layer_data->logging_messenger.size() > 0) { VkDebugUtilsMessengerEXT messenger = layer_data->logging_messenger.back(); layer_destroy_messenger_callback(layer_data->report_data, messenger, pAllocator); layer_data->logging_messenger.pop_back(); } while (layer_data->logging_callback.size() > 0) { VkDebugReportCallbackEXT callback = layer_data->logging_callback.back(); layer_destroy_report_callback(layer_data->report_data, callback, pAllocator); layer_data->logging_callback.pop_back(); } layer_debug_utils_destroy_instance(layer_data->report_data); for (auto item = layer_data->object_dispatch.begin(); item != layer_data->object_dispatch.end(); item++) { delete *item; } FreeLayerDataPtr(key, layer_data_map); } VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); auto instance_interceptor = GetLayerDataPtr(get_dispatch_key(gpu), layer_data_map); PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(instance_interceptor->instance, "vkCreateDevice"); if (fpCreateDevice == NULL) { return VK_ERROR_INITIALIZATION_FAILED; } chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; // Get physical device limits for device VkPhysicalDeviceProperties device_properties = {}; instance_interceptor->instance_dispatch_table.GetPhysicalDeviceProperties(gpu, &device_properties); // Setup the validation tables based on the application API version from the instance and the capabilities of the device driver uint32_t effective_api_version = std::min(device_properties.apiVersion, instance_interceptor->api_version); DeviceExtensions device_extensions = {}; device_extensions.InitFromDeviceCreateInfo(&instance_interceptor->instance_extensions, effective_api_version, pCreateInfo); for (auto item : instance_interceptor->object_dispatch) { item->device_extensions = device_extensions; } bool skip = false; for (auto intercept : instance_interceptor->object_dispatch) { intercept->write_lock(); skip |= intercept->PreCallValidateCreateDevice(gpu, pCreateInfo, pAllocator, pDevice); intercept->write_unlock(); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; } for (auto intercept : instance_interceptor->object_dispatch) { intercept->write_lock(); intercept->PreCallRecordCreateDevice(gpu, pCreateInfo, pAllocator, pDevice); intercept->write_unlock(); } VkResult result = fpCreateDevice(gpu, pCreateInfo, pAllocator, pDevice); if (result != VK_SUCCESS) { return result; } auto device_interceptor = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map); // Save local info in device object device_interceptor->phys_dev_properties.properties = device_properties; device_interceptor->api_version = device_interceptor->device_extensions.InitFromDeviceCreateInfo( &instance_interceptor->instance_extensions, effective_api_version, pCreateInfo); device_interceptor->device_extensions = device_extensions; layer_init_device_dispatch_table(*pDevice, &device_interceptor->device_dispatch_table, fpGetDeviceProcAddr); device_interceptor->device = *pDevice; device_interceptor->physical_device = gpu; device_interceptor->instance = instance_interceptor->instance; device_interceptor->report_data = layer_debug_utils_create_device(instance_interceptor->report_data, *pDevice); #if BUILD_OBJECT_TRACKER // Create child layer objects for this key and add to dispatch vector auto object_tracker = new ObjectLifetimes; // TODO: Initialize child objects with parent info thru constuctor taking a parent object object_tracker->container_type = LayerObjectTypeObjectTracker; object_tracker->physical_device = gpu; object_tracker->instance = instance_interceptor->instance; object_tracker->report_data = device_interceptor->report_data; object_tracker->device_dispatch_table = device_interceptor->device_dispatch_table; object_tracker->api_version = device_interceptor->api_version; device_interceptor->object_dispatch.emplace_back(object_tracker); #elif BUILD_THREAD_SAFETY auto thread_safety = new ThreadSafety; // TODO: Initialize child objects with parent info thru constuctor taking a parent object thread_safety->container_type = LayerObjectTypeThreading; thread_safety->physical_device = gpu; thread_safety->instance = instance_interceptor->instance; thread_safety->report_data = device_interceptor->report_data; thread_safety->device_dispatch_table = device_interceptor->device_dispatch_table; thread_safety->api_version = device_interceptor->api_version; device_interceptor->object_dispatch.emplace_back(thread_safety); #elif BUILD_PARAMETER_VALIDATION auto stateless_validation = new StatelessValidation; // TODO: Initialize child objects with parent info thru constuctor taking a parent object stateless_validation->container_type = LayerObjectTypeParameterValidation; stateless_validation->physical_device = gpu; stateless_validation->instance = instance_interceptor->instance; stateless_validation->report_data = device_interceptor->report_data; stateless_validation->device_dispatch_table = device_interceptor->device_dispatch_table; stateless_validation->api_version = device_interceptor->api_version; device_interceptor->object_dispatch.emplace_back(stateless_validation); #endif for (auto intercept : instance_interceptor->object_dispatch) { intercept->write_lock(); intercept->PostCallRecordCreateDevice(gpu, pCreateInfo, pAllocator, pDevice); intercept->write_unlock(); } DeviceExtensionWhitelist(device_interceptor, pCreateInfo, *pDevice); return result; } VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) { dispatch_key key = get_dispatch_key(device); auto layer_data = GetLayerDataPtr(key, layer_data_map); """ + precallvalidate_loop + """ intercept->write_lock(); intercept->PreCallValidateDestroyDevice(device, pAllocator); intercept->write_unlock(); } """ + precallrecord_loop + """ intercept->write_lock(); intercept->PreCallRecordDestroyDevice(device, pAllocator); intercept->write_unlock(); } layer_debug_utils_destroy_device(device); layer_data->device_dispatch_table.DestroyDevice(device, pAllocator); """ + postcallrecord_loop + """ intercept->write_lock(); intercept->PostCallRecordDestroyDevice(device, pAllocator); intercept->write_unlock(); } for (auto item = layer_data->object_dispatch.begin(); item != layer_data->object_dispatch.end(); item++) { delete *item; } FreeLayerDataPtr(key, layer_data_map); } VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); """ + precallvalidate_loop + """ intercept->write_lock(); intercept->PreCallValidateCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); intercept->write_unlock(); } """ + precallrecord_loop + """ intercept->write_lock(); intercept->PreCallRecordCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); intercept->write_unlock(); } VkResult result = DispatchCreateDebugReportCallbackEXT(layer_data, instance, pCreateInfo, pAllocator, pCallback); result = layer_create_report_callback(layer_data->report_data, false, pCreateInfo, pAllocator, pCallback); """ + postcallrecord_loop + """ intercept->write_lock(); intercept->PostCallRecordCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); intercept->write_unlock(); } return result; } VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator) { auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map); """ + precallvalidate_loop + """ intercept->write_lock(); intercept->PreCallValidateDestroyDebugReportCallbackEXT(instance, callback, pAllocator); intercept->write_unlock(); } """ + precallrecord_loop + """ intercept->write_lock(); intercept->PreCallRecordDestroyDebugReportCallbackEXT(instance, callback, pAllocator); intercept->write_unlock(); } DispatchDestroyDebugReportCallbackEXT(layer_data, instance, callback, pAllocator); layer_destroy_report_callback(layer_data->report_data, callback, pAllocator); """ + postcallrecord_loop + """ intercept->write_lock(); intercept->PostCallRecordDestroyDebugReportCallbackEXT(instance, callback, pAllocator); intercept->write_unlock(); } }""" inline_custom_source_postamble = """ // loader-layer interface v0, just wrappers since there is only a layer VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) { return vulkan_layer_chassis::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) { return vulkan_layer_chassis::EnumerateInstanceLayerProperties(pCount, pProperties); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) { // the layer command handles VK_NULL_HANDLE just fine internally assert(physicalDevice == VK_NULL_HANDLE); return vulkan_layer_chassis::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) { // the layer command handles VK_NULL_HANDLE just fine internally assert(physicalDevice == VK_NULL_HANDLE); return vulkan_layer_chassis::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties); } VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) { return vulkan_layer_chassis::GetDeviceProcAddr(dev, funcName); } VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { return vulkan_layer_chassis::GetInstanceProcAddr(instance, funcName); } VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_layerGetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { return vulkan_layer_chassis::GetPhysicalDeviceProcAddr(instance, funcName); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct) { assert(pVersionStruct != NULL); assert(pVersionStruct->sType == LAYER_NEGOTIATE_INTERFACE_STRUCT); // Fill in the function pointers if our version is at least capable of having the structure contain them. if (pVersionStruct->loaderLayerInterfaceVersion >= 2) { pVersionStruct->pfnGetInstanceProcAddr = vkGetInstanceProcAddr; pVersionStruct->pfnGetDeviceProcAddr = vkGetDeviceProcAddr; pVersionStruct->pfnGetPhysicalDeviceProcAddr = vk_layerGetPhysicalDeviceProcAddr; } return VK_SUCCESS; }""" def __init__(self, errFile = sys.stderr, warnFile = sys.stderr, diagFile = sys.stdout): OutputGenerator.__init__(self, errFile, warnFile, diagFile) # Internal state - accumulators for different inner block text self.sections = dict([(section, []) for section in self.ALL_SECTIONS]) self.intercepts = [] self.layer_factory = '' # String containing base layer factory class definition # Check if the parameter passed in is a pointer to an array def paramIsArray(self, param): return param.attrib.get('len') is not None # Check if the parameter passed in is a pointer def paramIsPointer(self, param): ispointer = False for elem in param: if ((elem.tag is not 'type') and (elem.tail is not None)) and '*' in elem.tail: ispointer = True return ispointer # Check if an object is a non-dispatchable handle def isHandleTypeNonDispatchable(self, handletype): handle = self.registry.tree.find("types/type/[name='" + handletype + "'][@category='handle']") if handle is not None and handle.find('type').text == 'VK_DEFINE_NON_DISPATCHABLE_HANDLE': return True else: return False # Check if an object is a dispatchable handle def isHandleTypeDispatchable(self, handletype): handle = self.registry.tree.find("types/type/[name='" + handletype + "'][@category='handle']") if handle is not None and handle.find('type').text == 'VK_DEFINE_HANDLE': return True else: return False # # def beginFile(self, genOpts): OutputGenerator.beginFile(self, genOpts) # Output Copyright write(self.inline_copyright_message, file=self.outFile) # Multiple inclusion protection self.header = False if (self.genOpts.filename and 'h' == self.genOpts.filename[-1]): self.header = True write('#pragma once', file=self.outFile) self.newline() if self.header: write(self.inline_custom_header_preamble, file=self.outFile) else: write(self.inline_custom_source_preamble, file=self.outFile) self.layer_factory += self.inline_custom_header_class_definition # # def endFile(self): # Finish C++ namespace and multiple inclusion protection self.newline() if not self.header: # Record intercepted procedures write('// Map of all APIs to be intercepted by this layer', file=self.outFile) write('const std::unordered_map name_to_funcptr_map = {', file=self.outFile) write('\n'.join(self.intercepts), file=self.outFile) write('};\n', file=self.outFile) self.newline() write('} // namespace vulkan_layer_chassis', file=self.outFile) if self.header: self.newline() # Output Layer Factory Class Definitions self.layer_factory += '};\n\n' self.layer_factory += 'extern std::unordered_map layer_data_map;' write(self.layer_factory, file=self.outFile) else: write(self.inline_custom_source_postamble, file=self.outFile) # Finish processing in superclass OutputGenerator.endFile(self) def beginFeature(self, interface, emit): # Start processing in superclass OutputGenerator.beginFeature(self, interface, emit) # Get feature extra protect self.featureExtraProtect = GetFeatureProtect(interface) # Accumulate includes, defines, types, enums, function pointer typedefs, end function prototypes separately for this # feature. They're only printed in endFeature(). self.sections = dict([(section, []) for section in self.ALL_SECTIONS]) def endFeature(self): # Actually write the interface to the output file. if (self.emit): self.newline() # If type declarations are needed by other features based on this one, it may be necessary to suppress the ExtraProtect, # or move it below the 'for section...' loop. if (self.featureExtraProtect != None): write('#ifdef', self.featureExtraProtect, file=self.outFile) for section in self.TYPE_SECTIONS: contents = self.sections[section] if contents: write('\n'.join(contents), file=self.outFile) self.newline() if (self.sections['command']): write('\n'.join(self.sections['command']), end=u'', file=self.outFile) self.newline() if (self.featureExtraProtect != None): write('#endif //', self.featureExtraProtect, file=self.outFile) # Finish processing in superclass OutputGenerator.endFeature(self) # # Append a definition to the specified section def appendSection(self, section, text): self.sections[section].append(text) # # Type generation def genType(self, typeinfo, name, alias): pass # # Struct (e.g. C "struct" type) generation. This is a special case of the tag where the contents are # interpreted as a set of tags instead of freeform C type declarations. The tags are just like # tags - they are a declaration of a struct or union member. Only simple member declarations are supported (no nested # structs etc.) def genStruct(self, typeinfo, typeName): OutputGenerator.genStruct(self, typeinfo, typeName) body = 'typedef ' + typeinfo.elem.get('category') + ' ' + typeName + ' {\n' # paramdecl = self.makeCParamDecl(typeinfo.elem, self.genOpts.alignFuncParam) for member in typeinfo.elem.findall('.//member'): body += self.makeCParamDecl(member, self.genOpts.alignFuncParam) body += ';\n' body += '} ' + typeName + ';\n' self.appendSection('struct', body) # # Group (e.g. C "enum" type) generation. These are concatenated together with other types. def genGroup(self, groupinfo, groupName, alias): pass # Enumerant generation # tags may specify their values in several ways, but are usually just integers. def genEnum(self, enuminfo, name, alias): pass # # Customize Cdecl for layer factory base class def BaseClassCdecl(self, elem, name): raw = self.makeCDecls(elem)[1] # Toss everything before the undecorated name prototype = raw.split("VKAPI_PTR *PFN_vk")[1] prototype = prototype.replace(")", "", 1) prototype = prototype.replace(";", " {};") # Build up pre/post call virtual function declarations pre_call_validate = 'virtual bool PreCallValidate' + prototype pre_call_validate = pre_call_validate.replace("{}", " { return false; }") pre_call_record = 'virtual void PreCallRecord' + prototype post_call_record = 'virtual void PostCallRecord' + prototype return ' %s\n %s\n %s\n' % (pre_call_validate, pre_call_record, post_call_record) # # Command generation def genCmd(self, cmdinfo, name, alias): ignore_functions = [ 'vkEnumerateInstanceVersion' ] if name in ignore_functions: return if self.header: # In the header declare all intercepts self.appendSection('command', '') self.appendSection('command', self.makeCDecls(cmdinfo.elem)[0]) if (self.featureExtraProtect != None): self.intercepts += [ '#ifdef %s' % self.featureExtraProtect ] self.layer_factory += '#ifdef %s\n' % self.featureExtraProtect # Update base class with virtual function declarations self.layer_factory += self.BaseClassCdecl(cmdinfo.elem, name) # Update function intercepts self.intercepts += [ ' {"%s", (void*)%s},' % (name,name[2:]) ] if (self.featureExtraProtect != None): self.intercepts += [ '#endif' ] self.layer_factory += '#endif\n' return if name in self.manual_functions: self.intercepts += [ ' {"%s", (void*)%s},' % (name,name[2:]) ] return # Record that the function will be intercepted if (self.featureExtraProtect != None): self.intercepts += [ '#ifdef %s' % self.featureExtraProtect ] self.intercepts += [ ' {"%s", (void*)%s},' % (name,name[2:]) ] if (self.featureExtraProtect != None): self.intercepts += [ '#endif' ] OutputGenerator.genCmd(self, cmdinfo, name, alias) # decls = self.makeCDecls(cmdinfo.elem) self.appendSection('command', '') self.appendSection('command', '%s {' % decls[0][:-1]) # Setup common to call wrappers. First parameter is always dispatchable dispatchable_type = cmdinfo.elem.find('param/type').text dispatchable_name = cmdinfo.elem.find('param/name').text # Default to device device_or_instance = 'device' dispatch_table_name = 'VkLayerDispatchTable' # Set to instance as necessary if dispatchable_type in ["VkPhysicalDevice", "VkInstance"] or name == 'vkCreateInstance': device_or_instance = 'instance' dispatch_table_name = 'VkLayerInstanceDispatchTable' self.appendSection('command', ' auto layer_data = GetLayerDataPtr(get_dispatch_key(%s), layer_data_map);' % (dispatchable_name)) api_function_name = cmdinfo.elem.attrib.get('name') params = cmdinfo.elem.findall('param/name') paramstext = ', '.join([str(param.text) for param in params]) API = api_function_name.replace('vk','Dispatch') + '(layer_data, ' # Declare result variable, if any. return_map = { 'PFN_vkVoidFunction': 'return nullptr;', 'VkBool32': 'return VK_FALSE;', 'VkDeviceAddress': 'return 0;', 'VkResult': 'return VK_ERROR_VALIDATION_FAILED_EXT;', 'void': 'return;', } resulttype = cmdinfo.elem.find('proto/type') assignresult = '' if (resulttype.text != 'void'): assignresult = resulttype.text + ' result = ' # Set up skip and locking self.appendSection('command', ' bool skip = false;') # Generate pre-call validation source code self.appendSection('command', ' %s' % self.precallvalidate_loop) self.appendSection('command', ' intercept->write_lock();') self.appendSection('command', ' skip |= intercept->PreCallValidate%s(%s);' % (api_function_name[2:], paramstext)) self.appendSection('command', ' intercept->write_unlock();') self.appendSection('command', ' if (skip) %s' % return_map[resulttype.text]) self.appendSection('command', ' }') # Generate pre-call state recording source code self.appendSection('command', ' %s' % self.precallrecord_loop) self.appendSection('command', ' intercept->write_lock();') self.appendSection('command', ' intercept->PreCallRecord%s(%s);' % (api_function_name[2:], paramstext)) self.appendSection('command', ' intercept->write_unlock();') self.appendSection('command', ' }') # Insert pre-dispatch debug utils function call if name in self.pre_dispatch_debug_utils_functions: self.appendSection('command', ' {') self.appendSection('command', ' std::lock_guard lock(layer_data->validation_object_mutex);') self.appendSection('command', ' %s' % self.pre_dispatch_debug_utils_functions[name]) self.appendSection('command', ' }') # Output dispatch (down-chain) function call self.appendSection('command', ' ' + assignresult + API + paramstext + ');') # Insert post-dispatch debug utils function call if name in self.post_dispatch_debug_utils_functions: self.appendSection('command', ' {') self.appendSection('command', ' std::lock_guard lock(layer_data->validation_object_mutex);') self.appendSection('command', ' %s' % self.post_dispatch_debug_utils_functions[name]) self.appendSection('command', ' }') # Generate post-call object processing source code return_type_indent = '' if (resulttype.text == 'VkResult'): return_type_indent = ' ' if name in self.alt_ret_codes: self.appendSection('command', ' if ((VK_SUCCESS == result) || (VK_INCOMPLETE == result)) {') else: self.appendSection('command', ' if (VK_SUCCESS == result) {') self.appendSection('command', '%s %s' % (return_type_indent, self.postcallrecord_loop)) self.appendSection('command', '%s intercept->write_lock();' % return_type_indent) self.appendSection('command', '%s intercept->PostCallRecord%s(%s);' % (return_type_indent,api_function_name[2:], paramstext)) self.appendSection('command', '%s intercept->write_unlock();' % return_type_indent) self.appendSection('command', '%s }' % return_type_indent) if (resulttype.text == 'VkResult'): self.appendSection('command', ' }') # Return result variable, if any. if (resulttype.text != 'void'): self.appendSection('command', ' return result;') self.appendSection('command', '}') # # Override makeProtoName to drop the "vk" prefix def makeProtoName(self, name, tail): return self.genOpts.apientry + name[2:] + tail