const VkAllocationCallbacks *pAllocator,
VkDebugReportCallbackEXT *pCallback) {
VkDebugReportCallbackEXT *icd_info = NULL;
- const struct loader_icd *icd;
+ const struct loader_icd_term *icd_term;
struct loader_instance *inst = (struct loader_instance *)instance;
VkResult res = VK_SUCCESS;
uint32_t storage_idx;
}
storage_idx = 0;
- for (icd = inst->icds; icd; icd = icd->next) {
- if (!icd->CreateDebugReportCallbackEXT) {
+ for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) {
+ if (!icd_term->CreateDebugReportCallbackEXT) {
continue;
}
- res = icd->CreateDebugReportCallbackEXT(
- icd->instance, pCreateInfo, pAllocator, &icd_info[storage_idx]);
+ res = icd_term->CreateDebugReportCallbackEXT(icd_term->instance,
+ pCreateInfo, pAllocator,
+ &icd_info[storage_idx]);
if (res != VK_SUCCESS) {
goto out;
// Roll back on errors
if (VK_SUCCESS != res) {
storage_idx = 0;
- for (icd = inst->icds; icd; icd = icd->next) {
- if (NULL == icd->DestroyDebugReportCallbackEXT) {
+ for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) {
+ if (NULL == icd_term->DestroyDebugReportCallbackEXT) {
continue;
}
if (icd_info[storage_idx]) {
- icd->DestroyDebugReportCallbackEXT(
- icd->instance, icd_info[storage_idx], pAllocator);
+ icd_term->DestroyDebugReportCallbackEXT(
+ icd_term->instance, icd_info[storage_idx], pAllocator);
}
storage_idx++;
}
const VkAllocationCallbacks *pAllocator) {
uint32_t storage_idx;
VkDebugReportCallbackEXT *icd_info;
- const struct loader_icd *icd;
+ const struct loader_icd_term *icd_term;
struct loader_instance *inst = (struct loader_instance *)instance;
icd_info = *(VkDebugReportCallbackEXT **)&callback;
storage_idx = 0;
- for (icd = inst->icds; icd; icd = icd->next) {
- if (NULL == icd->DestroyDebugReportCallbackEXT) {
+ for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) {
+ if (NULL == icd_term->DestroyDebugReportCallbackEXT) {
continue;
}
if (icd_info[storage_idx]) {
- icd->DestroyDebugReportCallbackEXT(
- icd->instance, icd_info[storage_idx], pAllocator);
+ icd_term->DestroyDebugReportCallbackEXT(
+ icd_term->instance, icd_info[storage_idx], pAllocator);
}
storage_idx++;
}
VkInstance instance, VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
- const struct loader_icd *icd;
+ const struct loader_icd_term *icd_term;
struct loader_instance *inst = (struct loader_instance *)instance;
loader_platform_thread_lock_mutex(&loader_lock);
- for (icd = inst->icds; icd; icd = icd->next) {
- if (icd->DebugReportMessageEXT != NULL) {
- icd->DebugReportMessageEXT(icd->instance, flags, objType, object,
- location, msgCode, pLayerPrefix, pMsg);
+ for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) {
+ if (icd_term->DebugReportMessageEXT != NULL) {
+ icd_term->DebugReportMessageEXT(icd_term->instance, flags, objType,
+ object, location, msgCode,
+ pLayerPrefix, pMsg);
}
}
VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
VkExternalMemoryHandleTypeFlagsNV externalHandleType,
VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) {
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
- struct loader_icd *icd = phys_dev->this_icd;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
- if (!icd->GetPhysicalDeviceExternalImageFormatPropertiesNV) {
+ if (!icd_term->GetPhysicalDeviceExternalImageFormatPropertiesNV) {
if (externalHandleType) {
return VK_ERROR_FORMAT_NOT_SUPPORTED;
}
- if (!icd->GetPhysicalDeviceImageFormatProperties) {
+ if (!icd_term->GetPhysicalDeviceImageFormatProperties) {
return VK_ERROR_INITIALIZATION_FAILED;
}
pExternalImageFormatProperties->exportFromImportedHandleTypes = 0;
pExternalImageFormatProperties->compatibleHandleTypes = 0;
- return icd->GetPhysicalDeviceImageFormatProperties(
- phys_dev->phys_dev, format, type, tiling, usage, flags,
+ return icd_term->GetPhysicalDeviceImageFormatProperties(
+ phys_dev_term->phys_dev, format, type, tiling, usage, flags,
&pExternalImageFormatProperties->imageFormatProperties);
}
- return icd->GetPhysicalDeviceExternalImageFormatPropertiesNV(
- phys_dev->phys_dev, format, type, tiling, usage, flags,
+ return icd_term->GetPhysicalDeviceExternalImageFormatPropertiesNV(
+ phys_dev_term->phys_dev, format, type, tiling, usage, flags,
externalHandleType, pExternalImageFormatProperties);
}
struct loader_phys_dev_per_icd {
uint32_t count;
VkPhysicalDevice *phys_devs;
- struct loader_icd *this_icd;
+ struct loader_icd_term *this_icd_term;
};
enum loader_debug {
#else
static inline char *loader_getenv(const char *name,
- const struct loader_instance *inst) {
+ const struct loader_instance *inst) {
// stub func
(void)inst;
(void)name;
return NULL;
}
static inline void loader_free_getenv(const char *val,
- const struct loader_instance *inst) {
+ const struct loader_instance *inst) {
// stub func
(void)val;
(void)inst;
fputc('\n', stderr);
}
-VKAPI_ATTR VkResult VKAPI_CALL
-vkSetInstanceDispatch(VkInstance instance, void *object) {
+VKAPI_ATTR VkResult VKAPI_CALL vkSetInstanceDispatch(VkInstance instance,
+ void *object) {
struct loader_instance *inst = loader_get_instance(instance);
if (!inst) {
return VK_SUCCESS;
}
-VKAPI_ATTR VkResult VKAPI_CALL
-vkSetDeviceDispatch(VkDevice device, void *object) {
+VKAPI_ATTR VkResult VKAPI_CALL vkSetDeviceDispatch(VkDevice device,
+ void *object) {
struct loader_device *dev;
- struct loader_icd *icd = loader_get_icd_and_device(device, &dev, NULL);
+ struct loader_icd_term *icd_term =
+ loader_get_icd_and_device(device, &dev, NULL);
- if (!icd) {
+ if (NULL == icd_term) {
return VK_ERROR_INITIALIZATION_FAILED;
}
loader_set_dispatch(object, &dev->loader_dispatch);
inst, total_size, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (NULL == out) {
loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
- "Out of memory can't alloc space for registry data");
+ "Out of memory can't alloc space for "
+ "registry data");
return NULL;
}
out[0] = '\0';
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (NULL == out) {
loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
- "Out of memory can't realloc space for registry data");
+ "Out of memory can't realloc space for "
+ "registry data");
return NULL;
}
total_size *= 2;
loader_get_next_layer_property(const struct loader_instance *inst,
struct loader_layer_list *layer_list) {
if (layer_list->capacity == 0) {
- layer_list->list =
- loader_instance_heap_alloc(
- inst, sizeof(struct loader_layer_properties) * 64,
- VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ layer_list->list = loader_instance_heap_alloc(
+ inst, sizeof(struct loader_layer_properties) * 64,
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (layer_list->list == NULL) {
loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"Out of memory can't add any layer properties to list");
inst, (struct loader_generic_list *)&layer_list->list[i]
.instance_extension_list);
dev_ext_list = &layer_list->list[i].device_extension_list;
- if (dev_ext_list->capacity > 0 &&
- NULL != dev_ext_list->list &&
+ if (dev_ext_list->capacity > 0 && NULL != dev_ext_list->list &&
dev_ext_list->list->entrypoint_count > 0) {
for (j = 0; j < dev_ext_list->list->entrypoint_count; j++) {
- loader_instance_heap_free(inst, dev_ext_list->list->entrypoints[j]);
+ loader_instance_heap_free(inst,
+ dev_ext_list->list->entrypoints[j]);
}
loader_instance_heap_free(inst, dev_ext_list->list->entrypoints);
}
*/
static VkResult
loader_init_device_extensions(const struct loader_instance *inst,
- struct loader_physical_device *phys_dev,
+ struct loader_physical_device_term *phys_dev_term,
uint32_t count, VkExtensionProperties *ext_props,
struct loader_extension_list *ext_list) {
VkResult res;
VK_MAJOR(ext_props[i].specVersion),
VK_MINOR(ext_props[i].specVersion),
VK_PATCH(ext_props[i].specVersion));
- loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
- "Device Extension: %s (%s) version %s",
- ext_props[i].extensionName,
- phys_dev->this_icd->this_icd_lib->lib_name, spec_version);
+ loader_log(
+ inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
+ "Device Extension: %s (%s) version %s", ext_props[i].extensionName,
+ phys_dev_term->this_icd_term->scanned_icd->lib_name, spec_version);
res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
if (res != VK_SUCCESS)
return res;
}
VkResult loader_init_generic_list(const struct loader_instance *inst,
- struct loader_generic_list *list_info,
- size_t element_size) {
+ struct loader_generic_list *list_info,
+ size_t element_size) {
size_t capacity = 32 * element_size;
list_info->count = 0;
list_info->capacity = 0;
const VkExtensionProperties *cur_ext;
if (ext_list->list == NULL || ext_list->capacity == 0) {
- VkResult res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list,
- sizeof(VkExtensionProperties));
+ VkResult res = loader_init_generic_list(
+ inst, (struct loader_generic_list *)ext_list,
+ sizeof(VkExtensionProperties));
if (VK_SUCCESS != res) {
return res;
}
if (0 == strcmp(layer_prop->info.layerName, name) &&
(layer_prop->type & type)) {
/* Found a layer with the same name, add to found_list */
- if (VK_SUCCESS == loader_add_to_layer_list(inst, found_list, 1, layer_prop)) {
+ if (VK_SUCCESS ==
+ loader_add_to_layer_list(inst, found_list, 1, layer_prop)) {
found = true;
}
}
*/
VkResult loader_get_icd_loader_instance_extensions(
- const struct loader_instance *inst, struct loader_icd_libs *icd_libs,
+ const struct loader_instance *inst,
+ struct loader_icd_tramp_list *icd_tramp_list,
struct loader_extension_list *inst_exts) {
struct loader_extension_list icd_exts;
VkResult res = VK_SUCCESS;
"Build ICD instance extension list");
// traverse scanned icd list adding non-duplicate extensions to the list
- for (uint32_t i = 0; i < icd_libs->count; i++) {
+ for (uint32_t i = 0; i < icd_tramp_list->count; i++) {
res = loader_init_generic_list(inst,
(struct loader_generic_list *)&icd_exts,
sizeof(VkExtensionProperties));
goto out;
}
res = loader_add_instance_extensions(
- inst, icd_libs->list[i].EnumerateInstanceExtensionProperties,
- icd_libs->list[i].lib_name, &icd_exts);
+ inst, icd_tramp_list->scanned_list[i]
+ .EnumerateInstanceExtensionProperties,
+ icd_tramp_list->scanned_list[i].lib_name, &icd_exts);
if (VK_SUCCESS == res) {
res = loader_add_to_ext_list(inst, inst_exts, icd_exts.count,
icd_exts.list);
return res;
}
-struct loader_icd *loader_get_icd_and_device(const VkDevice device,
- struct loader_device **found_dev,
- uint32_t *icd_index) {
+struct loader_icd_term *
+loader_get_icd_and_device(const VkDevice device,
+ struct loader_device **found_dev,
+ uint32_t *icd_index) {
*found_dev = NULL;
uint32_t index = 0;
for (struct loader_instance *inst = loader.instances; inst;
inst = inst->next) {
- for (struct loader_icd *icd = inst->icds; icd; icd = icd->next) {
- for (struct loader_device *dev = icd->logical_device_list; dev;
+ for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term;
+ icd_term = icd_term->next) {
+ for (struct loader_device *dev = icd_term->logical_device_list; dev;
dev = dev->next)
/* Value comparison of device prevents object wrapping by layers
*/
if (NULL != icd_index) {
*icd_index = index;
}
- return icd;
+ return icd_term;
}
index++;
}
}
void loader_add_logical_device(const struct loader_instance *inst,
- struct loader_icd *icd,
+ struct loader_icd_term *icd_term,
struct loader_device *dev) {
- dev->next = icd->logical_device_list;
- icd->logical_device_list = dev;
+ dev->next = icd_term->logical_device_list;
+ icd_term->logical_device_list = dev;
}
void loader_remove_logical_device(const struct loader_instance *inst,
- struct loader_icd *icd,
+ struct loader_icd_term *icd_term,
struct loader_device *found_dev,
const VkAllocationCallbacks *pAllocator) {
struct loader_device *dev, *prev_dev;
- if (!icd || !found_dev)
+ if (!icd_term || !found_dev)
return;
prev_dev = NULL;
- dev = icd->logical_device_list;
+ dev = icd_term->logical_device_list;
while (dev && dev != found_dev) {
prev_dev = dev;
dev = dev->next;
if (prev_dev)
prev_dev->next = found_dev->next;
else
- icd->logical_device_list = found_dev->next;
+ icd_term->logical_device_list = found_dev->next;
loader_destroy_logical_device(inst, found_dev, pAllocator);
}
static void loader_icd_destroy(struct loader_instance *ptr_inst,
- struct loader_icd *icd,
+ struct loader_icd_term *icd_term,
const VkAllocationCallbacks *pAllocator) {
ptr_inst->total_icd_count--;
- for (struct loader_device *dev = icd->logical_device_list; dev;) {
+ for (struct loader_device *dev = icd_term->logical_device_list; dev;) {
struct loader_device *next_dev = dev->next;
loader_destroy_logical_device(ptr_inst, dev, pAllocator);
dev = next_dev;
}
- loader_instance_heap_free(ptr_inst, icd);
+ loader_instance_heap_free(ptr_inst, icd_term);
}
-static struct loader_icd *
+static struct loader_icd_term *
loader_icd_create(const struct loader_instance *inst) {
- struct loader_icd *icd;
+ struct loader_icd_term *icd_term;
- icd = loader_instance_heap_alloc(inst, sizeof(struct loader_icd),
- VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
- if (!icd) {
+ icd_term = loader_instance_heap_alloc(inst, sizeof(struct loader_icd_term),
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ if (!icd_term) {
return NULL;
}
- memset(icd, 0, sizeof(struct loader_icd));
+ memset(icd_term, 0, sizeof(struct loader_icd_term));
- return icd;
+ return icd_term;
}
-static struct loader_icd *
+static struct loader_icd_term *
loader_icd_add(struct loader_instance *ptr_inst,
- const struct loader_scanned_icds *icd_lib) {
- struct loader_icd *icd;
+ const struct loader_scanned_icd *scanned_icd) {
+ struct loader_icd_term *icd_term;
- icd = loader_icd_create(ptr_inst);
- if (!icd) {
+ icd_term = loader_icd_create(ptr_inst);
+ if (!icd_term) {
return NULL;
}
- icd->this_icd_lib = icd_lib;
- icd->this_instance = ptr_inst;
+ icd_term->scanned_icd = scanned_icd;
+ icd_term->this_instance = ptr_inst;
/* prepend to the list */
- icd->next = ptr_inst->icds;
- ptr_inst->icds = icd;
+ icd_term->next = ptr_inst->icd_terms;
+ ptr_inst->icd_terms = icd_term;
ptr_inst->total_icd_count++;
- return icd;
+ return icd_term;
}
+
/**
* Determine the ICD interface version to use.
* @param icd
* version 2 supports vk_icdNegotiateLoaderICDInterfaceVersion
*/
bool loader_get_icd_interface_version(
- PFN_vkNegotiateLoaderICDInterfaceVersion fp_negotiate_icd_version,
- uint32_t *pVersion) {
+ PFN_vkNegotiateLoaderICDInterfaceVersion fp_negotiate_icd_version,
+ uint32_t *pVersion) {
if (fp_negotiate_icd_version == NULL) {
// ICD does not support the negotiation API, it supports version 0 or 1
}
void loader_scanned_icd_clear(const struct loader_instance *inst,
- struct loader_icd_libs *icd_libs) {
- if (icd_libs->capacity == 0)
+ struct loader_icd_tramp_list *icd_tramp_list) {
+ if (icd_tramp_list->capacity == 0)
return;
- for (uint32_t i = 0; i < icd_libs->count; i++) {
- loader_platform_close_library(icd_libs->list[i].handle);
- loader_instance_heap_free(inst, icd_libs->list[i].lib_name);
- }
- loader_instance_heap_free(inst, icd_libs->list);
- icd_libs->capacity = 0;
- icd_libs->count = 0;
- icd_libs->list = NULL;
+ for (uint32_t i = 0; i < icd_tramp_list->count; i++) {
+ loader_platform_close_library(icd_tramp_list->scanned_list[i].handle);
+ loader_instance_heap_free(inst,
+ icd_tramp_list->scanned_list[i].lib_name);
+ }
+ loader_instance_heap_free(inst, icd_tramp_list->scanned_list);
+ icd_tramp_list->capacity = 0;
+ icd_tramp_list->count = 0;
+ icd_tramp_list->scanned_list = NULL;
}
-static VkResult loader_scanned_icd_init(const struct loader_instance *inst,
- struct loader_icd_libs *icd_libs) {
+static VkResult
+loader_scanned_icd_init(const struct loader_instance *inst,
+ struct loader_icd_tramp_list *icd_tramp_list) {
VkResult err = VK_SUCCESS;
- loader_scanned_icd_clear(inst, icd_libs);
- icd_libs->capacity = 8 * sizeof(struct loader_scanned_icds);
- icd_libs->list = loader_instance_heap_alloc(
- inst, icd_libs->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
- if (NULL == icd_libs->list) {
- loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+ loader_scanned_icd_clear(inst, icd_tramp_list);
+ icd_tramp_list->capacity = 8 * sizeof(struct loader_scanned_icd);
+ icd_tramp_list->scanned_list = loader_instance_heap_alloc(
+ inst, icd_tramp_list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ if (NULL == icd_tramp_list->scanned_list) {
+ loader_log(
+ inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"realloc failed for layer list when attempting to add new layer");
err = VK_ERROR_OUT_OF_HOST_MEMORY;
}
return err;
}
-static VkResult loader_scanned_icd_add(const struct loader_instance *inst,
- struct loader_icd_libs *icd_libs,
- const char *filename,
- uint32_t api_version) {
+static VkResult
+loader_scanned_icd_add(const struct loader_instance *inst,
+ struct loader_icd_tramp_list *icd_tramp_list,
+ const char *filename, uint32_t api_version) {
loader_platform_dl_handle handle;
PFN_vkCreateInstance fp_create_inst;
PFN_vkEnumerateInstanceExtensionProperties fp_get_inst_ext_props;
PFN_vkGetInstanceProcAddr fp_get_proc_addr;
PFN_vkNegotiateLoaderICDInterfaceVersion fp_negotiate_icd_version;
- struct loader_scanned_icds *new_node;
+ struct loader_scanned_icd *new_scanned_icd;
uint32_t interface_vers;
VkResult res = VK_SUCCESS;
}
// check for enough capacity
- if ((icd_libs->count * sizeof(struct loader_scanned_icds)) >=
- icd_libs->capacity) {
+ if ((icd_tramp_list->count * sizeof(struct loader_scanned_icd)) >=
+ icd_tramp_list->capacity) {
- icd_libs->list = loader_instance_heap_realloc(
- inst, icd_libs->list, icd_libs->capacity, icd_libs->capacity * 2,
- VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
- if (NULL == icd_libs->list) {
+ icd_tramp_list->scanned_list = loader_instance_heap_realloc(
+ inst, icd_tramp_list->scanned_list, icd_tramp_list->capacity,
+ icd_tramp_list->capacity * 2, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ if (NULL == icd_tramp_list->scanned_list) {
res = VK_ERROR_OUT_OF_HOST_MEMORY;
loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"realloc failed on icd library list");
goto out;
}
// double capacity
- icd_libs->capacity *= 2;
+ icd_tramp_list->capacity *= 2;
}
- new_node = &(icd_libs->list[icd_libs->count]);
+ new_scanned_icd = &(icd_tramp_list->scanned_list[icd_tramp_list->count]);
- new_node->handle = handle;
- new_node->api_version = api_version;
- new_node->GetInstanceProcAddr = fp_get_proc_addr;
- new_node->EnumerateInstanceExtensionProperties = fp_get_inst_ext_props;
- new_node->CreateInstance = fp_create_inst;
- new_node->interface_version = interface_vers;
+ new_scanned_icd->handle = handle;
+ new_scanned_icd->api_version = api_version;
+ new_scanned_icd->GetInstanceProcAddr = fp_get_proc_addr;
+ new_scanned_icd->EnumerateInstanceExtensionProperties =
+ fp_get_inst_ext_props;
+ new_scanned_icd->CreateInstance = fp_create_inst;
+ new_scanned_icd->interface_version = interface_vers;
- new_node->lib_name = (char *)loader_instance_heap_alloc(
+ new_scanned_icd->lib_name = (char *)loader_instance_heap_alloc(
inst, strlen(filename) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
- if (NULL == new_node->lib_name) {
+ if (NULL == new_scanned_icd->lib_name) {
res = VK_ERROR_OUT_OF_HOST_MEMORY;
loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
"Out of memory can't add icd");
goto out;
}
- strcpy(new_node->lib_name, filename);
- icd_libs->count++;
+ strcpy(new_scanned_icd->lib_name, filename);
+ icd_tramp_list->count++;
out:
return res;
}
-static bool loader_icd_init_entrys(struct loader_icd *icd, VkInstance inst,
+static bool loader_icd_init_entrys(struct loader_icd_term *icd_term,
+ VkInstance inst,
const PFN_vkGetInstanceProcAddr fp_gipa) {
/* initialize entrypoint function pointers */
#define LOOKUP_GIPA(func, required) \
do { \
- icd->func = (PFN_vk##func)fp_gipa(inst, "vk" #func); \
- if (!icd->func && required) { \
+ icd_term->func = (PFN_vk##func)fp_gipa(inst, "vk" #func); \
+ if (!icd_term->func && required) { \
loader_log((struct loader_instance *)inst, \
VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, \
loader_platform_get_proc_address_error("vk" #func)); \
"alloc failed for device extension list");
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
- memset(dst->device_extension_list.list, 0, sizeof(struct loader_dev_ext_props) *
- src->device_extension_list.count);
+ memset(dst->device_extension_list.list, 0,
+ sizeof(struct loader_dev_ext_props) *
+ src->device_extension_list.count);
dst->device_extension_list.capacity =
sizeof(struct loader_dev_ext_props) * src->device_extension_list.count;
"alloc failed for device extension list entrypoint array");
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
- memset(dst->device_extension_list.list->entrypoints, 0, sizeof(char *) * cnt);
+ memset(dst->device_extension_list.list->entrypoints, 0,
+ sizeof(char *) * cnt);
for (i = 0; i < cnt; i++) {
dst->device_extension_list.list->entrypoints[i] =
memset(props, 0, sizeof(struct loader_layer_properties));
props->type = VK_LAYER_TYPE_META_EXPLICT;
strncpy(props->info.description, "LunarG Standard Validation Layer",
- sizeof (props->info.description));
+ sizeof(props->info.description));
props->info.implementationVersion = 1;
strncpy(props->info.layerName, std_validation_str,
- sizeof (props->info.layerName));
+ sizeof(props->info.layerName));
// TODO what about specVersion? for now insert loader's built version
props->info.specVersion = VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION);
}
if (layer_instance_list && (layer_count > layer_instance_list->count))
return;
-
layer_list = layer_instance_list;
found = true;
return;
}
loader_init_std_validation_props(props);
-
}
-
}
static void loader_read_json_layer(
strlen(home_location));
if (home_loc == NULL) {
loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
- "Out of memory can't get manifest files");
+ "Out of memory can't get manifest files");
res = VK_ERROR_OUT_OF_HOST_MEMORY;
goto out;
}
* (on result == VK_SUCCESS) a list of icds that were discovered
*/
VkResult loader_icd_scan(const struct loader_instance *inst,
- struct loader_icd_libs *icds) {
+ struct loader_icd_tramp_list *icd_tramp_list) {
char *file_str;
uint16_t file_major_vers = 0;
uint16_t file_minor_vers = 0;
memset(&manifest_files, 0, sizeof(struct loader_manifest_files));
- res = loader_scanned_icd_init(inst, icds);
+ res = loader_scanned_icd_init(inst, icd_tramp_list);
if (VK_SUCCESS != res) {
goto out;
}
vers = loader_make_version(temp);
cJSON_Free(temp);
}
- res = loader_scanned_icd_add(inst, icds, fullpath, vers);
+ res = loader_scanned_icd_add(inst, icd_tramp_list, fullpath,
+ vers);
if (VK_SUCCESS != res) {
goto out;
}
void loader_override_terminating_device_proc(
VkDevice device, struct loader_dev_dispatch_table *disp_table) {
struct loader_device *dev;
- struct loader_icd *icd = loader_get_icd_and_device(device, &dev, NULL);
+ struct loader_icd_term *icd_term =
+ loader_get_icd_and_device(device, &dev, NULL);
// Certain device entry-points still need to go through a terminator before
// hitting the ICD. This could be for several reasons, but the main one
// is currently unwrapping an object before passing the appropriate info
// along to the ICD.
if ((PFN_vkVoidFunction)disp_table->core_dispatch.CreateSwapchainKHR ==
- (PFN_vkVoidFunction)icd->GetDeviceProcAddr(device,
- "vkCreateSwapchainKHR")) {
+ (PFN_vkVoidFunction)icd_term->GetDeviceProcAddr(
+ device, "vkCreateSwapchainKHR")) {
disp_table->core_dispatch.CreateSwapchainKHR =
terminator_vkCreateSwapchainKHR;
}
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
loader_gpa_device_internal(VkDevice device, const char *pName) {
struct loader_device *dev;
- struct loader_icd *icd = loader_get_icd_and_device(device, &dev, NULL);
+ struct loader_icd_term *icd_term =
+ loader_get_icd_and_device(device, &dev, NULL);
// Certain device entry-points still need to go through a terminator before
// hitting the ICD. This could be for several reasons, but the main one
return (PFN_vkVoidFunction)terminator_vkCreateSwapchainKHR;
}
- return icd->GetDeviceProcAddr(device, pName);
+ return icd_term->GetDeviceProcAddr(device, pName);
}
/**
dev->loader_dispatch.ext_dispatch.dev_ext[idx] =
(PFN_vkDevExt)gdpa_value;
} else {
- for (struct loader_icd *icd = inst->icds; icd != NULL;
- icd = icd->next) {
- struct loader_device *ldev = icd->logical_device_list;
+ for (struct loader_icd_term *icd_term = inst->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next) {
+ struct loader_device *ldev = icd_term->logical_device_list;
while (ldev) {
gdpa_value =
ldev->loader_dispatch.core_dispatch.GetDeviceProcAddr(
static bool loader_check_icds_for_address(struct loader_instance *inst,
const char *funcName) {
- struct loader_icd *icd;
- icd = inst->icds;
- while (icd) {
- if (icd->this_icd_lib->GetInstanceProcAddr(icd->instance, funcName))
+ struct loader_icd_term *icd_term;
+ icd_term = inst->icd_terms;
+ while (NULL != icd_term) {
+ if (icd_term->scanned_icd->GetInstanceProcAddr(icd_term->instance,
+ funcName))
// this icd supports funcName
return true;
- icd = icd->next;
+ icd_term = icd_term->next;
}
return false;
// check for enough capacity
if (list->capacity == 0) {
- list->index = loader_instance_heap_alloc(inst, 8 * sizeof(*(list->index)),
- VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ list->index =
+ loader_instance_heap_alloc(inst, 8 * sizeof(*(list->index)),
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (list->index == NULL) {
loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"loader_add_dev_ext_table() can't allocate list memory");
}
list->capacity = 8 * sizeof(*(list->index));
} else if (list->capacity < (list->count + 1) * sizeof(*(list->index))) {
- list->index = loader_instance_heap_realloc(inst, list->index, list->capacity,
- list->capacity * 2,
- VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ list->index = loader_instance_heap_realloc(
+ inst, list->index, list->capacity, list->capacity * 2,
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (list->index == NULL) {
loader_log(
inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
do {
if (!inst->disp_hash[i].func_name) {
assert(inst->disp_hash[i].list.capacity == 0);
- inst->disp_hash[i].func_name =
- (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1,
- VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ inst->disp_hash[i].func_name = (char *)loader_instance_heap_alloc(
+ inst, strlen(funcName) + 1,
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (inst->disp_hash[i].func_name == NULL) {
loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"loader_add_dev_ext_table() can't rallocate "
// Check if funcName is supported in either ICDs or a layer library
if (!loader_check_icds_for_address(inst, funcName) &&
- !loader_check_layer_list_for_address(&inst->instance_layer_list, funcName)) {
+ !loader_check_layer_list_for_address(&inst->instance_layer_list,
+ funcName)) {
// if support found in layers continue on
return NULL;
}
}
static loader_platform_dl_handle
-loader_open_layer_lib(const struct loader_instance *inst, const char *chain_type,
- struct loader_layer_properties *prop) {
+loader_open_layer_lib(const struct loader_instance *inst,
+ const char *chain_type,
+ struct loader_layer_properties *prop) {
if ((prop->lib_handle = loader_platform_open_library(prop->lib_name)) ==
NULL) {
return prop->lib_handle;
}
-static void
-loader_close_layer_lib(const struct loader_instance *inst,
- struct loader_layer_properties *prop) {
+static void loader_close_layer_lib(const struct loader_instance *inst,
+ struct loader_layer_properties *prop) {
if (prop->lib_handle) {
loader_platform_close_library(prop->lib_handle);
VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateInstance(
const VkInstanceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
- struct loader_icd *icd;
+ struct loader_icd_term *icd_term;
VkExtensionProperties *prop;
char **filtered_extension_names = NULL;
VkInstanceCreateInfo icd_create_info;
icd_create_info.ppEnabledExtensionNames =
(const char *const *)filtered_extension_names;
- for (uint32_t i = 0; i < ptr_instance->icd_libs.count; i++) {
- icd = loader_icd_add(ptr_instance, &ptr_instance->icd_libs.list[i]);
- if (NULL == icd) {
+ for (uint32_t i = 0; i < ptr_instance->icd_tramp_list.count; i++) {
+ icd_term = loader_icd_add(
+ ptr_instance, &ptr_instance->icd_tramp_list.scanned_list[i]);
+ if (NULL == icd_term) {
res = VK_ERROR_OUT_OF_HOST_MEMORY;
goto out;
}
// traverse scanned icd list adding non-duplicate extensions to the
// list
res = loader_init_generic_list(ptr_instance,
- (struct loader_generic_list *)&icd_exts,
- sizeof(VkExtensionProperties));
+ (struct loader_generic_list *)&icd_exts,
+ sizeof(VkExtensionProperties));
if (VK_ERROR_OUT_OF_HOST_MEMORY == res) {
// If out of memory, bail immediately.
goto out;
} else if (VK_SUCCESS != res) {
// Something bad happened with this ICD, so free it and try the
// next.
- ptr_instance->icds = icd->next;
- icd->next = NULL;
- loader_icd_destroy(ptr_instance, icd, pAllocator);
+ ptr_instance->icd_terms = icd_term->next;
+ icd_term->next = NULL;
+ loader_icd_destroy(ptr_instance, icd_term, pAllocator);
continue;
}
res = loader_add_instance_extensions(
ptr_instance,
- icd->this_icd_lib->EnumerateInstanceExtensionProperties,
- icd->this_icd_lib->lib_name, &icd_exts);
+ icd_term->scanned_icd->EnumerateInstanceExtensionProperties,
+ icd_term->scanned_icd->lib_name, &icd_exts);
if (VK_SUCCESS != res) {
- loader_destroy_generic_list(ptr_instance,
- (struct loader_generic_list *)&icd_exts);
+ loader_destroy_generic_list(
+ ptr_instance, (struct loader_generic_list *)&icd_exts);
if (VK_ERROR_OUT_OF_HOST_MEMORY == res) {
// If out of memory, bail immediately.
goto out;
} else {
// Something bad happened with this ICD, so free it and try
// the next.
- ptr_instance->icds = icd->next;
- icd->next = NULL;
- loader_icd_destroy(ptr_instance, icd, pAllocator);
+ ptr_instance->icd_terms = icd_term->next;
+ icd_term->next = NULL;
+ loader_icd_destroy(ptr_instance, icd_term, pAllocator);
continue;
}
}
loader_destroy_generic_list(ptr_instance,
(struct loader_generic_list *)&icd_exts);
- res = ptr_instance->icd_libs.list[i].CreateInstance(
- &icd_create_info, pAllocator, &(icd->instance));
+ res = ptr_instance->icd_tramp_list.scanned_list[i].CreateInstance(
+ &icd_create_info, pAllocator, &(icd_term->instance));
if (VK_ERROR_OUT_OF_HOST_MEMORY == res) {
// If out of memory, bail immediately.
goto out;
} else if (VK_SUCCESS != res) {
loader_log(ptr_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
"ICD ignored: failed to CreateInstance in ICD %d", i);
- ptr_instance->icds = icd->next;
- icd->next = NULL;
- loader_icd_destroy(ptr_instance, icd, pAllocator);
+ ptr_instance->icd_terms = icd_term->next;
+ icd_term->next = NULL;
+ loader_icd_destroy(ptr_instance, icd_term, pAllocator);
continue;
}
- if (!loader_icd_init_entrys(
- icd, icd->instance,
- ptr_instance->icd_libs.list[i].GetInstanceProcAddr)) {
+ if (!loader_icd_init_entrys(icd_term, icd_term->instance,
+ ptr_instance->icd_tramp_list.scanned_list[i]
+ .GetInstanceProcAddr)) {
loader_log(ptr_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
"ICD ignored: failed to CreateInstance and find "
"entrypoints with ICD");
* from it's initial value, the loader was unable to find
* a suitable ICD.
*/
- if (VK_SUCCESS == res && ptr_instance->icds == NULL) {
+ if (VK_SUCCESS == res && ptr_instance->icd_terms == NULL) {
res = VK_ERROR_INCOMPATIBLE_DRIVER;
}
out:
if (VK_SUCCESS != res) {
- while (NULL != ptr_instance->icds) {
- icd = ptr_instance->icds;
- ptr_instance->icds = icd->next;
- if (NULL != icd->instance) {
- icd->DestroyInstance(icd->instance, pAllocator);
+ while (NULL != ptr_instance->icd_terms) {
+ icd_term = ptr_instance->icd_terms;
+ ptr_instance->icd_terms = icd_term->next;
+ if (NULL != icd_term->instance) {
+ icd_term->DestroyInstance(icd_term->instance, pAllocator);
}
- loader_icd_destroy(ptr_instance, icd, pAllocator);
+ loader_icd_destroy(ptr_instance, icd_term, pAllocator);
}
}
VKAPI_ATTR void VKAPI_CALL terminator_DestroyInstance(
VkInstance instance, const VkAllocationCallbacks *pAllocator) {
struct loader_instance *ptr_instance = loader_instance(instance);
- struct loader_icd *icds = ptr_instance->icds;
- struct loader_icd *next_icd;
+ struct loader_icd_term *icd_terms = ptr_instance->icd_terms;
+ struct loader_icd_term *next_icd_term;
// Remove this instance from the list of instances:
struct loader_instance *prev = NULL;
next = next->next;
}
- while (icds) {
- if (icds->instance) {
- icds->DestroyInstance(icds->instance, pAllocator);
+ while (NULL != icd_terms) {
+ if (icd_terms->instance) {
+ icd_terms->DestroyInstance(icd_terms->instance, pAllocator);
}
- next_icd = icds->next;
- icds->instance = VK_NULL_HANDLE;
- loader_icd_destroy(ptr_instance, icds, pAllocator);
+ next_icd_term = icd_terms->next;
+ icd_terms->instance = VK_NULL_HANDLE;
+ loader_icd_destroy(ptr_instance, icd_terms, pAllocator);
- icds = next_icd;
+ icd_terms = next_icd_term;
}
loader_delete_layer_properties(ptr_instance,
&ptr_instance->instance_layer_list);
- loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
+ loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_tramp_list);
loader_destroy_generic_list(
ptr_instance, (struct loader_generic_list *)&ptr_instance->ext_list);
if (ptr_instance->phys_devs_term)
VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
VkResult res = VK_SUCCESS;
- struct loader_physical_device *phys_dev;
- phys_dev = (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term;
+ phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_device *dev = (struct loader_device *)*pDevice;
- PFN_vkCreateDevice fpCreateDevice = phys_dev->this_icd->CreateDevice;
+ PFN_vkCreateDevice fpCreateDevice = icd_term->CreateDevice;
struct loader_extension_list icd_exts;
icd_exts.list = NULL;
if (fpCreateDevice == NULL) {
- loader_log(phys_dev->this_icd->this_instance,
- VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+ loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"No vkCreateDevice command exposed by ICD %s",
- phys_dev->this_icd->this_icd_lib->lib_name);
+ icd_term->scanned_icd->lib_name);
res = VK_ERROR_INITIALIZATION_FAILED;
goto out;
}
(const char *const *)filtered_extension_names;
/* Get the physical device (ICD) extensions */
- res = loader_init_generic_list(phys_dev->this_icd->this_instance,
- (struct loader_generic_list *)&icd_exts,
- sizeof(VkExtensionProperties));
+ res = loader_init_generic_list(icd_term->this_instance,
+ (struct loader_generic_list *)&icd_exts,
+ sizeof(VkExtensionProperties));
if (VK_SUCCESS != res) {
goto out;
}
res = loader_add_device_extensions(
- phys_dev->this_icd->this_instance,
- phys_dev->this_icd->EnumerateDeviceExtensionProperties,
- phys_dev->phys_dev, phys_dev->this_icd->this_icd_lib->lib_name,
- &icd_exts);
+ icd_term->this_instance, icd_term->EnumerateDeviceExtensionProperties,
+ phys_dev_term->phys_dev, icd_term->scanned_icd->lib_name, &icd_exts);
if (res != VK_SUCCESS) {
goto out;
}
(char *)extension_name;
localCreateInfo.enabledExtensionCount++;
} else {
- loader_log(phys_dev->this_icd->this_instance,
- VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
- "vkCreateDevice extension %s not available for "
- "devices associated with ICD %s",
- extension_name,
- phys_dev->this_icd->this_icd_lib->lib_name);
+ loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT,
+ 0, "vkCreateDevice extension %s not available for "
+ "devices associated with ICD %s",
+ extension_name, icd_term->scanned_icd->lib_name);
}
}
- res = fpCreateDevice(phys_dev->phys_dev, &localCreateInfo, pAllocator,
+ res = fpCreateDevice(phys_dev_term->phys_dev, &localCreateInfo, pAllocator,
&dev->device);
if (res != VK_SUCCESS) {
- loader_log(phys_dev->this_icd->this_instance,
- VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+ loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"vkCreateDevice call failed in ICD %s",
- phys_dev->this_icd->this_icd_lib->lib_name);
+ icd_term->scanned_icd->lib_name);
goto out;
}
*pDevice = dev->device;
- loader_add_logical_device(phys_dev->this_icd->this_instance,
- phys_dev->this_icd, dev);
+ loader_add_logical_device(icd_term->this_instance, icd_term, dev);
/* Init dispatch pointer in new device object */
loader_init_dispatch(*pDevice, &dev->loader_dispatch);
out:
if (NULL != icd_exts.list) {
- loader_destroy_generic_list(phys_dev->this_icd->this_instance,
+ loader_destroy_generic_list(icd_term->this_instance,
(struct loader_generic_list *)&icd_exts);
}
return res;
}
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_EnumeratePhysicalDevices(VkInstance instance,
- uint32_t *pPhysicalDeviceCount,
- VkPhysicalDevice *pPhysicalDevices) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumeratePhysicalDevices(
+ VkInstance instance, uint32_t *pPhysicalDeviceCount,
+ VkPhysicalDevice *pPhysicalDevices) {
uint32_t i;
struct loader_instance *inst = (struct loader_instance *)instance;
VkResult res = VK_SUCCESS;
- struct loader_icd *icd;
+ struct loader_icd_term *icd_term;
struct loader_phys_dev_per_icd *phys_devs;
inst->total_gpu_count = 0;
if (!phys_devs)
return VK_ERROR_OUT_OF_HOST_MEMORY;
- icd = inst->icds;
+ icd_term = inst->icd_terms;
for (i = 0; i < inst->total_icd_count; i++) {
- assert(icd);
- res = icd->EnumeratePhysicalDevices(icd->instance, &phys_devs[i].count,
- NULL);
+ assert(icd_term);
+ res = icd_term->EnumeratePhysicalDevices(icd_term->instance,
+ &phys_devs[i].count, NULL);
if (res != VK_SUCCESS)
return res;
- icd = icd->next;
+ icd_term = icd_term->next;
}
- icd = inst->icds;
+ icd_term = inst->icd_terms;
for (i = 0; i < inst->total_icd_count; i++) {
- assert(icd);
+ assert(icd_term);
phys_devs[i].phys_devs = (VkPhysicalDevice *)loader_stack_alloc(
phys_devs[i].count * sizeof(VkPhysicalDevice));
if (!phys_devs[i].phys_devs) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
- res = icd->EnumeratePhysicalDevices(
- icd->instance, &(phys_devs[i].count), phys_devs[i].phys_devs);
+ res = icd_term->EnumeratePhysicalDevices(
+ icd_term->instance, &(phys_devs[i].count), phys_devs[i].phys_devs);
if ((res == VK_SUCCESS)) {
inst->total_gpu_count += phys_devs[i].count;
} else {
return res;
}
- phys_devs[i].this_icd = icd;
- icd = icd->next;
+ phys_devs[i].this_icd_term = icd_term;
+ icd_term = icd_term->next;
}
if (inst->total_gpu_count == 0) {
return VK_ERROR_INITIALIZATION_FAILED;
if (NULL == inst->phys_devs_term) {
inst->phys_devs_term = loader_instance_heap_alloc(
- inst, sizeof(struct loader_physical_device) * inst->total_gpu_count,
+ inst, sizeof(struct loader_physical_device_term) *
+ inst->total_gpu_count,
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (NULL == inst->phys_devs_term) {
return VK_ERROR_OUT_OF_HOST_MEMORY;
j++) {
loader_set_dispatch((void *)&inst->phys_devs_term[idx],
inst->disp);
- inst->phys_devs_term[idx].this_icd = phys_devs[i].this_icd;
+ inst->phys_devs_term[idx].this_icd_term =
+ phys_devs[i].this_icd_term;
inst->phys_devs_term[idx].icd_index = (uint8_t)(i);
inst->phys_devs_term[idx].phys_dev = phys_devs[i].phys_devs[j];
if (idx < copy_count) {
VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) {
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
- struct loader_icd *icd = phys_dev->this_icd;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
- if (icd->GetPhysicalDeviceProperties)
- icd->GetPhysicalDeviceProperties(phys_dev->phys_dev, pProperties);
+ if (icd_term->GetPhysicalDeviceProperties)
+ icd_term->GetPhysicalDeviceProperties(phys_dev_term->phys_dev,
+ pProperties);
}
VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties *pProperties) {
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
- struct loader_icd *icd = phys_dev->this_icd;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
- if (icd->GetPhysicalDeviceQueueFamilyProperties)
- icd->GetPhysicalDeviceQueueFamilyProperties(
- phys_dev->phys_dev, pQueueFamilyPropertyCount, pProperties);
+ if (icd_term->GetPhysicalDeviceQueueFamilyProperties)
+ icd_term->GetPhysicalDeviceQueueFamilyProperties(
+ phys_dev_term->phys_dev, pQueueFamilyPropertyCount, pProperties);
}
VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties *pProperties) {
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
- struct loader_icd *icd = phys_dev->this_icd;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
- if (icd->GetPhysicalDeviceMemoryProperties)
- icd->GetPhysicalDeviceMemoryProperties(phys_dev->phys_dev, pProperties);
+ if (icd_term->GetPhysicalDeviceMemoryProperties)
+ icd_term->GetPhysicalDeviceMemoryProperties(phys_dev_term->phys_dev,
+ pProperties);
}
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures *pFeatures) {
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
- struct loader_icd *icd = phys_dev->this_icd;
-
- if (icd->GetPhysicalDeviceFeatures)
- icd->GetPhysicalDeviceFeatures(phys_dev->phys_dev, pFeatures);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures(
+ VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) {
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
+
+ if (icd_term->GetPhysicalDeviceFeatures)
+ icd_term->GetPhysicalDeviceFeatures(phys_dev_term->phys_dev, pFeatures);
}
-VKAPI_ATTR void VKAPI_CALL
-terminator_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties *pFormatInfo) {
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
- struct loader_icd *icd = phys_dev->this_icd;
-
- if (icd->GetPhysicalDeviceFormatProperties)
- icd->GetPhysicalDeviceFormatProperties(phys_dev->phys_dev, format,
- pFormatInfo);
+VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties(
+ VkPhysicalDevice physicalDevice, VkFormat format,
+ VkFormatProperties *pFormatInfo) {
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
+
+ if (icd_term->GetPhysicalDeviceFormatProperties)
+ icd_term->GetPhysicalDeviceFormatProperties(phys_dev_term->phys_dev,
+ format, pFormatInfo);
}
VKAPI_ATTR VkResult VKAPI_CALL
VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
VkImageFormatProperties *pImageFormatProperties) {
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
- struct loader_icd *icd = phys_dev->this_icd;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
- if (!icd->GetPhysicalDeviceImageFormatProperties)
+ if (!icd_term->GetPhysicalDeviceImageFormatProperties)
return VK_ERROR_INITIALIZATION_FAILED;
- return icd->GetPhysicalDeviceImageFormatProperties(
- phys_dev->phys_dev, format, type, tiling, usage, flags,
+ return icd_term->GetPhysicalDeviceImageFormatProperties(
+ phys_dev_term->phys_dev, format, type, tiling, usage, flags,
pImageFormatProperties);
}
VkSampleCountFlagBits samples, VkImageUsageFlags usage,
VkImageTiling tiling, uint32_t *pNumProperties,
VkSparseImageFormatProperties *pProperties) {
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
- struct loader_icd *icd = phys_dev->this_icd;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
- if (icd->GetPhysicalDeviceSparseImageFormatProperties)
- icd->GetPhysicalDeviceSparseImageFormatProperties(
- phys_dev->phys_dev, format, type, samples, usage, tiling,
+ if (icd_term->GetPhysicalDeviceSparseImageFormatProperties)
+ icd_term->GetPhysicalDeviceSparseImageFormatProperties(
+ phys_dev_term->phys_dev, format, type, samples, usage, tiling,
pNumProperties, pProperties);
}
VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceExtensionProperties(
VkPhysicalDevice physicalDevice, const char *pLayerName,
uint32_t *pPropertyCount, VkExtensionProperties *pProperties) {
- struct loader_physical_device *phys_dev;
+ struct loader_physical_device_term *phys_dev_term;
struct loader_layer_list implicit_layer_list = {0};
struct loader_extension_list all_exts = {0};
/* Any layer or trampoline wrapping should be removed at this point in time
* can just cast to the expected type for VkPhysicalDevice. */
- phys_dev = (struct loader_physical_device *)physicalDevice;
+ phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
/* this case is during the call down the instance chain with pLayerName
* == NULL*/
- struct loader_icd *icd = phys_dev->this_icd;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
uint32_t icd_ext_count = *pPropertyCount;
VkResult res;
/* get device extensions */
- res = icd->EnumerateDeviceExtensionProperties(phys_dev->phys_dev, NULL,
- &icd_ext_count, pProperties);
+ res = icd_term->EnumerateDeviceExtensionProperties(
+ phys_dev_term->phys_dev, NULL, &icd_ext_count, pProperties);
if (res != VK_SUCCESS) {
goto out;
}
- if (!loader_init_layer_list(icd->this_instance, &implicit_layer_list)) {
+ if (!loader_init_layer_list(icd_term->this_instance,
+ &implicit_layer_list)) {
res = VK_ERROR_OUT_OF_HOST_MEMORY;
goto out;
}
loader_add_layer_implicit(
- icd->this_instance, VK_LAYER_TYPE_INSTANCE_IMPLICIT,
- &implicit_layer_list, &icd->this_instance->instance_layer_list);
+ icd_term->this_instance, VK_LAYER_TYPE_INSTANCE_IMPLICIT,
+ &implicit_layer_list, &icd_term->this_instance->instance_layer_list);
/* we need to determine which implicit layers are active,
* and then add their extensions. This can't be cached as
* it depends on results of environment variables (which can change).
*/
if (pProperties != NULL) {
/* initialize dev_extension list within the physicalDevice object */
- res = loader_init_device_extensions(icd->this_instance, phys_dev,
- icd_ext_count, pProperties,
- &icd_exts);
+ res = loader_init_device_extensions(icd_term->this_instance,
+ phys_dev_term, icd_ext_count,
+ pProperties, &icd_exts);
if (res != VK_SUCCESS) {
goto out;
}
* it depends on results of environment variables (which can
* change).
*/
- res = loader_add_to_ext_list(icd->this_instance, &all_exts,
+ res = loader_add_to_ext_list(icd_term->this_instance, &all_exts,
icd_exts.count, icd_exts.list);
if (res != VK_SUCCESS) {
goto out;
}
loader_add_layer_implicit(
- icd->this_instance, VK_LAYER_TYPE_INSTANCE_IMPLICIT,
- &implicit_layer_list, &icd->this_instance->instance_layer_list);
+ icd_term->this_instance, VK_LAYER_TYPE_INSTANCE_IMPLICIT,
+ &implicit_layer_list,
+ &icd_term->this_instance->instance_layer_list);
for (uint32_t i = 0; i < implicit_layer_list.count; i++) {
for (uint32_t j = 0;
j < implicit_layer_list.list[i].device_extension_list.count;
j++) {
- res = loader_add_to_ext_list(icd->this_instance, &all_exts, 1,
+ res = loader_add_to_ext_list(icd_term->this_instance, &all_exts,
+ 1,
&implicit_layer_list.list[i]
.device_extension_list.list[j]
.props);
if (NULL != implicit_layer_list.list) {
loader_destroy_generic_list(
- icd->this_instance,
+ icd_term->this_instance,
(struct loader_generic_list *)&implicit_layer_list);
}
if (NULL != all_exts.list) {
- loader_destroy_generic_list(icd->this_instance,
+ loader_destroy_generic_list(icd_term->this_instance,
(struct loader_generic_list *)&all_exts);
}
if (NULL != icd_exts.list) {
- loader_destroy_generic_list(icd->this_instance,
+ loader_destroy_generic_list(icd_term->this_instance,
(struct loader_generic_list *)&icd_exts);
}
return res;
}
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
- uint32_t *pPropertyCount,
- VkLayerProperties *pProperties) {
+VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceLayerProperties(
+ VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
+ VkLayerProperties *pProperties) {
// should never get here this call isn't dispatched down the chain
return VK_ERROR_INITIALIZATION_FAILED;
};
/* per ICD structure */
-struct loader_icd {
+struct loader_icd_term {
// pointers to find other structs
- const struct loader_scanned_icds *this_icd_lib;
+ const struct loader_scanned_icd *scanned_icd;
const struct loader_instance *this_instance;
struct loader_device *logical_device_list;
VkInstance instance; // instance object from the icd
PFN_vkCreateDisplayPlaneSurfaceKHR CreateDisplayPlaneSurfaceKHR;
PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
- struct loader_icd *next;
+ struct loader_icd_term *next;
};
// per ICD library structure
-struct loader_icd_libs {
+struct loader_icd_tramp_list {
size_t capacity;
uint32_t count;
- struct loader_scanned_icds *list;
+ struct loader_scanned_icd *scanned_list;
};
union loader_instance_extension_enables {
struct {
- uint8_t ext_debug_report : 1;
+ uint8_t ext_debug_report : 1;
uint8_t nv_external_memory_capabilities : 1;
};
uint64_t padding[4];
struct loader_instance {
VkLayerInstanceDispatchTable *disp; // must be first entry in structure
- uint32_t total_gpu_count; // count of the next two arrays
- struct loader_physical_device *phys_devs_term;
- struct loader_physical_device_tramp *
- phys_devs; // tramp wrapped physDev obj list
- uint32_t total_icd_count;
- struct loader_icd *icds;
+ uint32_t total_gpu_count;
+ struct loader_physical_device_term *phys_devs_term;
+ struct loader_physical_device_tramp *phys_devs_tramp;
+
struct loader_instance *next;
- struct loader_extension_list ext_list; // icds and loaders extensions
- union loader_instance_extension_enables enabled_known_extensions;
- struct loader_icd_libs icd_libs;
- struct loader_layer_list instance_layer_list;
+
+ uint32_t total_icd_count;
+ struct loader_icd_term *icd_terms;
+ struct loader_icd_tramp_list icd_tramp_list;
+
struct loader_dispatch_hash_entry disp_hash[MAX_NUM_DEV_EXTS];
struct loader_msg_callback_map_entry *icd_msg_callback_map;
+ struct loader_layer_list instance_layer_list;
struct loader_layer_list activated_layer_list;
bool activated_layers_are_std_val;
VkInstance instance; // layers/ICD instance returned to trampoline
+ struct loader_extension_list ext_list; // icds and loaders extensions
+ union loader_instance_extension_enables enabled_known_extensions;
+
VkLayerDbgFunctionNode *DbgFunctionHead;
uint32_t num_tmp_callbacks;
VkDebugReportCallbackCreateInfoEXT *tmp_dbg_create_infos;
};
/* VkPhysicalDevice requires special treatment by loader. Firstly, terminator
- * code must be able to get the struct loader_icd to call into the proper
+ * code must be able to get the struct loader_icd_term to call into the proper
* driver (multiple ICD/gpu case). This can be accomplished by wrapping the
* created VkPhysicalDevice in loader terminate_EnumeratePhysicalDevices().
* Secondly, the loader must be able to handle wrapped by layer VkPhysicalDevice
};
/* per enumerated PhysicalDevice structure, used to wrap in terminator code */
-struct loader_physical_device {
+struct loader_physical_device_term {
VkLayerInstanceDispatchTable *disp; // must be first entry in structure
- struct loader_icd *this_icd;
+ struct loader_icd_term *this_icd_term;
uint8_t icd_index;
VkPhysicalDevice phys_dev; // object from ICD
};
struct loader_instance *instances;
};
-struct loader_scanned_icds {
+struct loader_scanned_icd {
char *lib_name;
loader_platform_dl_handle handle;
uint32_t api_version;
};
/* helper function definitions */
-void *loader_instance_heap_alloc(const struct loader_instance *instance, size_t size, VkSystemAllocationScope allocationScope);
-void loader_instance_heap_free(const struct loader_instance *instance, void *pMemory);
-void *loader_instance_heap_realloc(const struct loader_instance *instance, void *pMemory, size_t orig_size, size_t size, VkSystemAllocationScope alloc_scope);
+void *loader_instance_heap_alloc(const struct loader_instance *instance,
+ size_t size,
+ VkSystemAllocationScope allocationScope);
+void loader_instance_heap_free(const struct loader_instance *instance,
+ void *pMemory);
+void *loader_instance_heap_realloc(const struct loader_instance *instance,
+ void *pMemory, size_t orig_size, size_t size,
+ VkSystemAllocationScope alloc_scope);
void *loader_instance_tls_heap_alloc(size_t size);
void loader_instance_tls_heap_free(void *pMemory);
-void *loader_device_heap_alloc(const struct loader_device *device, size_t size, VkSystemAllocationScope allocationScope);
+void *loader_device_heap_alloc(const struct loader_device *device, size_t size,
+ VkSystemAllocationScope allocationScope);
void loader_device_heap_free(const struct loader_device *device, void *pMemory);
-void *loader_device_heap_realloc(const struct loader_device *device, void *pMemory, size_t orig_size, size_t size, VkSystemAllocationScope alloc_scope);
+void *loader_device_heap_realloc(const struct loader_device *device,
+ void *pMemory, size_t orig_size, size_t size,
+ VkSystemAllocationScope alloc_scope);
void loader_log(const struct loader_instance *inst, VkFlags msg_type,
int32_t msg_code, const char *format, ...);
struct loader_layer_list *layer_list);
void loader_delete_layer_properties(const struct loader_instance *inst,
struct loader_layer_list *layer_list);
-bool loader_find_layer_name_array(const char *name, uint32_t layer_count,
- const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]);
+bool loader_find_layer_name_array(
+ const char *name, uint32_t layer_count,
+ const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]);
VkResult loader_expand_layer_names(
- struct loader_instance *inst, const char *key_name,
- uint32_t expand_count,
+ struct loader_instance *inst, const char *key_name, uint32_t expand_count,
const char expand_names[][VK_MAX_EXTENSION_NAME_SIZE],
uint32_t *layer_count, char const *const **ppp_layer_names);
void loader_init_std_validation_props(struct loader_layer_properties *props);
const enum layer_type type, const struct loader_layer_list *search_list,
struct loader_layer_list *found_list);
void loader_scanned_icd_clear(const struct loader_instance *inst,
- struct loader_icd_libs *icd_libs);
+ struct loader_icd_tramp_list *icd_tramp_list);
VkResult loader_icd_scan(const struct loader_instance *inst,
- struct loader_icd_libs *icds);
+ struct loader_icd_tramp_list *icd_tramp_list);
void loader_layer_scan(const struct loader_instance *inst,
struct loader_layer_list *instance_layers);
void loader_implicit_layer_scan(const struct loader_instance *inst,
struct loader_layer_list *instance_layers);
VkResult loader_get_icd_loader_instance_extensions(
- const struct loader_instance *inst, struct loader_icd_libs *icd_libs,
+ const struct loader_instance *inst,
+ struct loader_icd_tramp_list *icd_tramp_list,
struct loader_extension_list *inst_exts);
-struct loader_icd *loader_get_icd_and_device(const VkDevice device,
- struct loader_device **found_dev,
- uint32_t *icd_index);
+struct loader_icd_term *
+loader_get_icd_and_device(const VkDevice device,
+ struct loader_device **found_dev,
+ uint32_t *icd_index);
void loader_init_dispatch_dev_ext(struct loader_instance *inst,
struct loader_device *dev);
void *loader_dev_ext_gpa(struct loader_instance *inst, const char *funcName);
void *loader_get_dev_ext_trampoline(uint32_t index);
-void loader_override_terminating_device_proc(VkDevice device, struct loader_dev_dispatch_table *disp_table);
+void loader_override_terminating_device_proc(
+ VkDevice device, struct loader_dev_dispatch_table *disp_table);
struct loader_instance *loader_get_instance(const VkInstance instance);
void loader_deactivate_layers(const struct loader_instance *instance,
struct loader_device *device,
struct loader_layer_list *list);
struct loader_device *
-loader_create_logical_device(const struct loader_instance *inst, const VkAllocationCallbacks *pAllocator);
+loader_create_logical_device(const struct loader_instance *inst,
+ const VkAllocationCallbacks *pAllocator);
void loader_add_logical_device(const struct loader_instance *inst,
- struct loader_icd *icd,
+ struct loader_icd_term *icd_term,
struct loader_device *found_dev);
void loader_remove_logical_device(const struct loader_instance *inst,
- struct loader_icd *icd,
+ struct loader_icd_term *icd_term,
struct loader_device *found_dev,
const VkAllocationCallbacks *pAllocator);
-// NOTE: Outside of loader, this entry-point is only proivided for error cleanup.
+// NOTE: Outside of loader, this entry-point is only proivided for error
+// cleanup.
void loader_destroy_logical_device(const struct loader_instance *inst,
struct loader_device *dev,
const VkAllocationCallbacks *pAllocator);
static VkResult vkDevExtError(VkDevice dev) {
struct loader_device *found_dev;
- struct loader_icd *icd = loader_get_icd_and_device(dev, &found_dev, NULL);
+ struct loader_icd_term *icd_term =
+ loader_get_icd_and_device(dev, &found_dev, NULL);
- if (icd)
- loader_log(icd->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+ if (icd_term)
+ loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"Bad destination in loader trampoline dispatch,"
"Are layers and extensions that you are calling enabled?");
return VK_ERROR_EXTENSION_NOT_PRESENT;
struct loader_extension_list *global_ext_list = NULL;
struct loader_layer_list instance_layers;
struct loader_extension_list local_ext_list;
- struct loader_icd_libs icd_libs;
+ struct loader_icd_tramp_list icd_tramp_list;
uint32_t copy_size;
VkResult res = VK_SUCCESS;
}
} else {
/* Scan/discover all ICD libraries */
- memset(&icd_libs, 0, sizeof(struct loader_icd_libs));
- res = loader_icd_scan(NULL, &icd_libs);
+ memset(&icd_tramp_list, 0, sizeof(struct loader_icd_tramp_list));
+ res = loader_icd_scan(NULL, &icd_tramp_list);
if (VK_SUCCESS != res) {
goto out;
}
/* get extensions from all ICD's, merge so no duplicates */
- res = loader_get_icd_loader_instance_extensions(NULL, &icd_libs,
+ res = loader_get_icd_loader_instance_extensions(NULL, &icd_tramp_list,
&local_ext_list);
if (VK_SUCCESS != res) {
goto out;
}
- loader_scanned_icd_clear(NULL, &icd_libs);
+ loader_scanned_icd_clear(NULL, &icd_tramp_list);
// Append implicit layers.
loader_implicit_layer_scan(NULL, &instance_layers);
}
out:
- loader_destroy_generic_list(NULL, (struct loader_generic_list *)&local_ext_list);
+ loader_destroy_generic_list(NULL,
+ (struct loader_generic_list *)&local_ext_list);
loader_delete_layer_properties(NULL, &instance_layers);
return res;
}
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
-vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount,
- VkLayerProperties *pProperties) {
+LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
+ uint32_t *pPropertyCount, VkLayerProperties *pProperties) {
struct loader_layer_list instance_layer_list;
tls_instance = NULL;
}
/* Scan/discover all ICD libraries */
- memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs));
- res = loader_icd_scan(ptr_instance, &ptr_instance->icd_libs);
+ memset(&ptr_instance->icd_tramp_list, 0,
+ sizeof(ptr_instance->icd_tramp_list));
+ res = loader_icd_scan(ptr_instance, &ptr_instance->icd_tramp_list);
if (res != VK_SUCCESS) {
goto out;
}
/* get extensions from all ICD's, merge so no duplicates, then validate */
res = loader_get_icd_loader_instance_extensions(
- ptr_instance, &ptr_instance->icd_libs, &ptr_instance->ext_list);
+ ptr_instance, &ptr_instance->icd_tramp_list, &ptr_instance->ext_list);
if (res != VK_SUCCESS) {
goto out;
}
&ici);
loader_delete_layer_properties(ptr_instance,
&ptr_instance->instance_layer_list);
- loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
+ loader_scanned_icd_clear(ptr_instance,
+ &ptr_instance->icd_tramp_list);
loader_destroy_generic_list(
ptr_instance,
(struct loader_generic_list *)&ptr_instance->ext_list);
loader_deactivate_layers(ptr_instance, NULL,
&ptr_instance->activated_layer_list);
- if (ptr_instance->phys_devs) {
- loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs);
+ if (ptr_instance->phys_devs_tramp) {
+ loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_tramp);
}
if (callback_setup) {
util_DestroyDebugReportCallbacks(ptr_instance, pAllocator,
? inst->total_gpu_count
: *pPhysicalDeviceCount;
*pPhysicalDeviceCount = count;
- if (!inst->phys_devs) {
- inst->phys_devs =
+ if (NULL == inst->phys_devs_tramp) {
+ inst->phys_devs_tramp =
(struct loader_physical_device_tramp *)loader_instance_heap_alloc(
inst, inst->total_gpu_count *
sizeof(struct loader_physical_device_tramp),
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
}
- if (!inst->phys_devs) {
+ if (NULL == inst->phys_devs_tramp) {
loader_platform_thread_unlock_mutex(&loader_lock);
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
for (i = 0; i < count; i++) {
// initialize the loader's physicalDevice object
- loader_set_dispatch((void *)&inst->phys_devs[i], inst->disp);
- inst->phys_devs[i].this_instance = inst;
- inst->phys_devs[i].phys_dev = pPhysicalDevices[i];
+ loader_set_dispatch((void *)&inst->phys_devs_tramp[i], inst->disp);
+ inst->phys_devs_tramp[i].this_instance = inst;
+ inst->phys_devs_tramp[i].phys_dev = pPhysicalDevices[i];
// copy wrapped object into Application provided array
- pPhysicalDevices[i] = (VkPhysicalDevice)&inst->phys_devs[i];
+ pPhysicalDevices[i] = (VkPhysicalDevice)&inst->phys_devs_tramp[i];
}
loader_platform_thread_unlock_mutex(&loader_lock);
return res;
}
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures *pFeatures) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
+ VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) {
const VkLayerInstanceDispatchTable *disp;
VkPhysicalDevice unwrapped_phys_dev =
loader_unwrap_physical_device(physicalDevice);
disp->GetPhysicalDeviceFeatures(unwrapped_phys_dev, pFeatures);
}
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties *pFormatInfo) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
+ VkPhysicalDevice physicalDevice, VkFormat format,
+ VkFormatProperties *pFormatInfo) {
const VkLayerInstanceDispatchTable *disp;
VkPhysicalDevice unwrapped_pd =
loader_unwrap_physical_device(physicalDevice);
pImageFormatProperties);
}
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties *pProperties) {
+LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
+ VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) {
const VkLayerInstanceDispatchTable *disp;
VkPhysicalDevice unwrapped_phys_dev =
loader_unwrap_physical_device(physicalDevice);
loader_platform_thread_lock_mutex(&loader_lock);
- struct loader_icd *icd = loader_get_icd_and_device(device, &dev, NULL);
- const struct loader_instance *inst = icd->this_instance;
+ struct loader_icd_term *icd_term =
+ loader_get_icd_and_device(device, &dev, NULL);
+ const struct loader_instance *inst = icd_term->this_instance;
disp = loader_get_dispatch(device);
disp->DestroyDevice(device, pAllocator);
dev->device = NULL;
- loader_remove_logical_device(inst, icd, dev, pAllocator);
+ loader_remove_logical_device(inst, icd_term, dev, pAllocator);
loader_platform_thread_unlock_mutex(&loader_lock);
}
i++) {
loader_find_layer_name_add_list(
NULL, std_validation_names[i],
- VK_LAYER_TYPE_INSTANCE_EXPLICIT, &inst->instance_layer_list,
- &local_list);
+ VK_LAYER_TYPE_INSTANCE_EXPLICIT,
+ &inst->instance_layer_list, &local_list);
}
for (uint32_t i = 0; i < local_list.count; i++) {
struct loader_device_extension_list *ext_list =
if (NULL != icd_surface) {
if (NULL != icd_surface->real_icd_surfaces) {
uint32_t i = 0;
- for (struct loader_icd *icd = ptr_instance->icds; icd != NULL;
- icd = icd->next, i++) {
- if (ptr_instance->icd_libs.list[i].interface_version >=
+ for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next, i++) {
+ if (icd_term->scanned_icd->interface_version >=
ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
- if (NULL != icd->DestroySurfaceKHR &&
+ if (NULL != icd_term->DestroySurfaceKHR &&
NULL != (void *)icd_surface->real_icd_surfaces[i]) {
- icd->DestroySurfaceKHR(
- icd->instance, icd_surface->real_icd_surfaces[i],
- pAllocator);
+ icd_term->DestroySurfaceKHR(
+ icd_term->instance,
+ icd_surface->real_icd_surfaces[i], pAllocator);
icd_surface->real_icd_surfaces[i] = (VkSurfaceKHR)NULL;
}
} else {
VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceSupportKHR(
VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
VkSurfaceKHR surface, VkBool32 *pSupported) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_surface_enabled) {
loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"VK_KHR_VK_KHR_surface extension not enabled. "
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
assert(pSupported &&
"GetPhysicalDeviceSurfaceSupportKHR: Error, null pSupported");
*pSupported = false;
- assert(icd->GetPhysicalDeviceSurfaceSupportKHR &&
+ assert(icd_term->GetPhysicalDeviceSurfaceSupportKHR &&
"loader: null GetPhysicalDeviceSurfaceSupportKHR ICD pointer");
VkIcdSurface *icd_surface = (VkIcdSurface *)(surface);
if (NULL != icd_surface->real_icd_surfaces &&
- NULL != (void *)icd_surface->real_icd_surfaces[phys_dev->icd_index]) {
- return icd->GetPhysicalDeviceSurfaceSupportKHR(
- phys_dev->phys_dev, queueFamilyIndex,
- icd_surface->real_icd_surfaces[phys_dev->icd_index], pSupported);
+ NULL !=
+ (void *)icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
+ return icd_term->GetPhysicalDeviceSurfaceSupportKHR(
+ phys_dev_term->phys_dev, queueFamilyIndex,
+ icd_surface->real_icd_surfaces[phys_dev_term->icd_index],
+ pSupported);
}
- return icd->GetPhysicalDeviceSurfaceSupportKHR(
- phys_dev->phys_dev, queueFamilyIndex, surface, pSupported);
+ return icd_term->GetPhysicalDeviceSurfaceSupportKHR(
+ phys_dev_term->phys_dev, queueFamilyIndex, surface, pSupported);
}
// This is the trampoline entrypoint for GetPhysicalDeviceSurfaceCapabilitiesKHR
terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR(
VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_surface_enabled) {
loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"VK_KHR_surface extension not enabled. "
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
assert(pSurfaceCapabilities && "GetPhysicalDeviceSurfaceCapabilitiesKHR: "
"Error, null pSurfaceCapabilities");
- assert(icd->GetPhysicalDeviceSurfaceCapabilitiesKHR &&
+ assert(icd_term->GetPhysicalDeviceSurfaceCapabilitiesKHR &&
"loader: null GetPhysicalDeviceSurfaceCapabilitiesKHR ICD pointer");
VkIcdSurface *icd_surface = (VkIcdSurface *)(surface);
if (NULL != icd_surface->real_icd_surfaces &&
- NULL != (void *)icd_surface->real_icd_surfaces[phys_dev->icd_index]) {
- return icd->GetPhysicalDeviceSurfaceCapabilitiesKHR(
- phys_dev->phys_dev,
- icd_surface->real_icd_surfaces[phys_dev->icd_index],
+ NULL !=
+ (void *)icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
+ return icd_term->GetPhysicalDeviceSurfaceCapabilitiesKHR(
+ phys_dev_term->phys_dev,
+ icd_surface->real_icd_surfaces[phys_dev_term->icd_index],
pSurfaceCapabilities);
}
- return icd->GetPhysicalDeviceSurfaceCapabilitiesKHR(
- phys_dev->phys_dev, surface, pSurfaceCapabilities);
+ return icd_term->GetPhysicalDeviceSurfaceCapabilitiesKHR(
+ phys_dev_term->phys_dev, surface, pSurfaceCapabilities);
}
// This is the trampoline entrypoint for GetPhysicalDeviceSurfaceFormatsKHR
VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormatsKHR(
VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_surface_enabled) {
loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"VK_KHR_surface extension not enabled. "
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
assert(
pSurfaceFormatCount &&
"GetPhysicalDeviceSurfaceFormatsKHR: Error, null pSurfaceFormatCount");
- assert(icd->GetPhysicalDeviceSurfaceFormatsKHR &&
+ assert(icd_term->GetPhysicalDeviceSurfaceFormatsKHR &&
"loader: null GetPhysicalDeviceSurfaceFormatsKHR ICD pointer");
VkIcdSurface *icd_surface = (VkIcdSurface *)(surface);
if (NULL != icd_surface->real_icd_surfaces &&
- NULL != (void *)icd_surface->real_icd_surfaces[phys_dev->icd_index]) {
- return icd->GetPhysicalDeviceSurfaceFormatsKHR(
- phys_dev->phys_dev,
- icd_surface->real_icd_surfaces[phys_dev->icd_index],
+ NULL !=
+ (void *)icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
+ return icd_term->GetPhysicalDeviceSurfaceFormatsKHR(
+ phys_dev_term->phys_dev,
+ icd_surface->real_icd_surfaces[phys_dev_term->icd_index],
pSurfaceFormatCount, pSurfaceFormats);
}
- return icd->GetPhysicalDeviceSurfaceFormatsKHR(
- phys_dev->phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats);
+ return icd_term->GetPhysicalDeviceSurfaceFormatsKHR(
+ phys_dev_term->phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats);
}
// This is the trampoline entrypoint for GetPhysicalDeviceSurfacePresentModesKHR
terminator_GetPhysicalDeviceSurfacePresentModesKHR(
VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_surface_enabled) {
loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"VK_KHR_surface extension not enabled. "
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
assert(pPresentModeCount && "GetPhysicalDeviceSurfacePresentModesKHR: "
"Error, null pPresentModeCount");
- assert(icd->GetPhysicalDeviceSurfacePresentModesKHR &&
+ assert(icd_term->GetPhysicalDeviceSurfacePresentModesKHR &&
"loader: null GetPhysicalDeviceSurfacePresentModesKHR ICD pointer");
VkIcdSurface *icd_surface = (VkIcdSurface *)(surface);
if (NULL != icd_surface->real_icd_surfaces &&
- NULL != (void *)icd_surface->real_icd_surfaces[phys_dev->icd_index]) {
- return icd->GetPhysicalDeviceSurfacePresentModesKHR(
- phys_dev->phys_dev,
- icd_surface->real_icd_surfaces[phys_dev->icd_index],
+ NULL !=
+ (void *)icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
+ return icd_term->GetPhysicalDeviceSurfacePresentModesKHR(
+ phys_dev_term->phys_dev,
+ icd_surface->real_icd_surfaces[phys_dev_term->icd_index],
pPresentModeCount, pPresentModes);
}
- return icd->GetPhysicalDeviceSurfacePresentModesKHR(
- phys_dev->phys_dev, surface, pPresentModeCount, pPresentModes);
+ return icd_term->GetPhysicalDeviceSurfacePresentModesKHR(
+ phys_dev_term->phys_dev, surface, pPresentModeCount, pPresentModes);
}
// Functions for the VK_KHR_swapchain extension:
const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
uint32_t icd_index = 0;
struct loader_device *dev;
- struct loader_icd *icd =
+ struct loader_icd_term *icd_term =
loader_get_icd_and_device(device, &dev, &icd_index);
- if (NULL != icd && NULL != icd->CreateSwapchainKHR) {
+ if (NULL != icd_term && NULL != icd_term->CreateSwapchainKHR) {
VkIcdSurface *icd_surface = (VkIcdSurface *)(pCreateInfo->surface);
if (NULL != icd_surface->real_icd_surfaces) {
if (NULL != (void *)icd_surface->real_icd_surfaces[icd_index]) {
sizeof(VkSwapchainCreateInfoKHR));
pCreateCopy->surface =
icd_surface->real_icd_surfaces[icd_index];
- return icd->CreateSwapchainKHR(device, pCreateCopy, pAllocator,
- pSwapchain);
+ return icd_term->CreateSwapchainKHR(device, pCreateCopy,
+ pAllocator, pSwapchain);
}
}
- return icd->CreateSwapchainKHR(device, pCreateInfo, pAllocator,
- pSwapchain);
+ return icd_term->CreateSwapchainKHR(device, pCreateInfo, pAllocator,
+ pSwapchain);
}
return VK_SUCCESS;
}
pIcdSurface->win_surf.hwnd = pCreateInfo->hwnd;
// Loop through each ICD and determine if they need to create a surface
- for (struct loader_icd *icd = ptr_instance->icds; icd != NULL;
- icd = icd->next, i++) {
- if (ptr_instance->icd_libs.list[i].interface_version >=
+ for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next, i++) {
+ if (icd_term->scanned_icd->interface_version >=
ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
- if (NULL != icd->CreateWin32SurfaceKHR) {
- vkRes = icd->CreateWin32SurfaceKHR(
- icd->instance, pCreateInfo, pAllocator,
+ if (NULL != icd_term->CreateWin32SurfaceKHR) {
+ vkRes = icd_term->CreateWin32SurfaceKHR(
+ icd_term->instance, pCreateInfo, pAllocator,
&pIcdSurface->real_icd_surfaces[i]);
if (VK_SUCCESS != vkRes) {
goto out;
if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
if (NULL != pIcdSurface->real_icd_surfaces) {
i = 0;
- for (struct loader_icd *icd = ptr_instance->icds; icd != NULL;
- icd = icd->next, i++) {
+ for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next, i++) {
if (NULL != (void *)pIcdSurface->real_icd_surfaces[i] &&
- NULL != icd->DestroySurfaceKHR) {
- icd->DestroySurfaceKHR(icd->instance,
- pIcdSurface->real_icd_surfaces[i],
- pAllocator);
+ NULL != icd_term->DestroySurfaceKHR) {
+ icd_term->DestroySurfaceKHR(
+ icd_term->instance, pIcdSurface->real_icd_surfaces[i],
+ pAllocator);
}
}
loader_instance_heap_free(ptr_instance,
terminator_GetPhysicalDeviceWin32PresentationSupportKHR(
VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) {
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_win32_surface_enabled) {
loader_log(
ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
- assert(icd->GetPhysicalDeviceWin32PresentationSupportKHR &&
+ assert(icd_term->GetPhysicalDeviceWin32PresentationSupportKHR &&
"loader: null GetPhysicalDeviceWin32PresentationSupportKHR ICD "
"pointer");
- return icd->GetPhysicalDeviceWin32PresentationSupportKHR(phys_dev->phys_dev,
- queueFamilyIndex);
+ return icd_term->GetPhysicalDeviceWin32PresentationSupportKHR(
+ phys_dev_term->phys_dev, queueFamilyIndex);
}
#endif // VK_USE_PLATFORM_WIN32_KHR
pIcdSurface->mir_surf.mirSurface = pCreateInfo->mirSurface;
// Loop through each ICD and determine if they need to create a surface
- for (struct loader_icd *icd = ptr_instance->icds; icd != NULL;
- icd = icd->next, i++) {
- if (ptr_instance->icd_libs.list[i].interface_version >=
+ for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next, i++) {
+ if (icd_term->scanned_icd->interface_version >=
ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
- if (NULL != icd->CreateMirSurfaceKHR) {
- vkRes = icd->CreateMirSurfaceKHR(
- icd->instance, pCreateInfo, pAllocator,
+ if (NULL != icd_term->CreateMirSurfaceKHR) {
+ vkRes = icd_term->CreateMirSurfaceKHR(
+ icd_term->instance, pCreateInfo, pAllocator,
&pIcdSurface->real_icd_surfaces[i]);
if (VK_SUCCESS != vkRes) {
goto out;
if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
if (NULL != pIcdSurface->real_icd_surfaces) {
i = 0;
- for (struct loader_icd *icd = ptr_instance->icds; icd != NULL;
- icd = icd->next, i++) {
+ for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next, i++) {
if (NULL != pIcdSurface->real_icd_surfaces[i] &&
- NULL != icd->DestroySurfaceKHR) {
- icd->DestroySurfaceKHR(icd->instance,
- pIcdSurface->real_icd_surfaces[i],
- pAllocator);
+ NULL != icd_term->DestroySurfaceKHR) {
+ icd_term->DestroySurfaceKHR(
+ icd_term->instance, pIcdSurface->real_icd_surfaces[i],
+ pAllocator);
}
}
loader_instance_heap_free(ptr_instance,
terminator_GetPhysicalDeviceMirPresentationSupportKHR(
VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
MirConnection *connection) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_mir_surface_enabled) {
loader_log(
ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
assert(
- icd->GetPhysicalDeviceMirPresentationSupportKHR &&
+ icd_term->GetPhysicalDeviceMirPresentationSupportKHR &&
"loader: null GetPhysicalDeviceMirPresentationSupportKHR ICD pointer");
- return icd->GetPhysicalDeviceMirPresentationSupportKHR(
- phys_dev->phys_dev, queueFamilyIndex, connection);
+ return icd_term->GetPhysicalDeviceMirPresentationSupportKHR(
+ phys_dev_term->phys_dev, queueFamilyIndex, connection);
}
#endif // VK_USE_PLATFORM_MIR_KHR
pIcdSurface->wayland_surf.surface = pCreateInfo->surface;
// Loop through each ICD and determine if they need to create a surface
- for (struct loader_icd *icd = ptr_instance->icds; icd != NULL;
- icd = icd->next, i++) {
- if (ptr_instance->icd_libs.list[i].interface_version >=
+ for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next, i++) {
+ if (icd_term->scanned_icd->interface_version >=
ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
- if (NULL != icd->CreateWaylandSurfaceKHR) {
- vkRes = icd->CreateWaylandSurfaceKHR(
- icd->instance, pCreateInfo, pAllocator,
+ if (NULL != icd_term->CreateWaylandSurfaceKHR) {
+ vkRes = icd_term->CreateWaylandSurfaceKHR(
+ icd_term->instance, pCreateInfo, pAllocator,
&pIcdSurface->real_icd_surfaces[i]);
if (VK_SUCCESS != vkRes) {
goto out;
if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
if (NULL != pIcdSurface->real_icd_surfaces) {
i = 0;
- for (struct loader_icd *icd = ptr_instance->icds; icd != NULL;
- icd = icd->next, i++) {
+ for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next, i++) {
if (NULL != pIcdSurface->real_icd_surfaces[i] &&
- NULL != icd->DestroySurfaceKHR) {
- icd->DestroySurfaceKHR(icd->instance,
- pIcdSurface->real_icd_surfaces[i],
- pAllocator);
+ NULL != icd_term->DestroySurfaceKHR) {
+ icd_term->DestroySurfaceKHR(
+ icd_term->instance, pIcdSurface->real_icd_surfaces[i],
+ pAllocator);
}
}
loader_instance_heap_free(ptr_instance,
terminator_GetPhysicalDeviceWaylandPresentationSupportKHR(
VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
struct wl_display *display) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_wayland_surface_enabled) {
loader_log(
ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
- assert(icd->GetPhysicalDeviceWaylandPresentationSupportKHR &&
+ assert(icd_term->GetPhysicalDeviceWaylandPresentationSupportKHR &&
"loader: null GetPhysicalDeviceWaylandPresentationSupportKHR ICD "
"pointer");
- return icd->GetPhysicalDeviceWaylandPresentationSupportKHR(
- phys_dev->phys_dev, queueFamilyIndex, display);
+ return icd_term->GetPhysicalDeviceWaylandPresentationSupportKHR(
+ phys_dev_term->phys_dev, queueFamilyIndex, display);
}
#endif // VK_USE_PLATFORM_WAYLAND_KHR
pIcdSurface->xcb_surf.window = pCreateInfo->window;
// Loop through each ICD and determine if they need to create a surface
- for (struct loader_icd *icd = ptr_instance->icds; icd != NULL;
- icd = icd->next, i++) {
- if (ptr_instance->icd_libs.list[i].interface_version >=
+ for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next, i++) {
+ if (icd_term->scanned_icd->interface_version >=
ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
- if (NULL != icd->CreateXcbSurfaceKHR) {
- vkRes = icd->CreateXcbSurfaceKHR(
- icd->instance, pCreateInfo, pAllocator,
+ if (NULL != icd_term->CreateXcbSurfaceKHR) {
+ vkRes = icd_term->CreateXcbSurfaceKHR(
+ icd_term->instance, pCreateInfo, pAllocator,
&pIcdSurface->real_icd_surfaces[i]);
if (VK_SUCCESS != vkRes) {
goto out;
if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
if (NULL != pIcdSurface->real_icd_surfaces) {
i = 0;
- for (struct loader_icd *icd = ptr_instance->icds; icd != NULL;
- icd = icd->next, i++) {
+ for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next, i++) {
if (NULL != pIcdSurface->real_icd_surfaces[i] &&
- NULL != icd->DestroySurfaceKHR) {
- icd->DestroySurfaceKHR(icd->instance,
- pIcdSurface->real_icd_surfaces[i],
- pAllocator);
+ NULL != icd_term->DestroySurfaceKHR) {
+ icd_term->DestroySurfaceKHR(
+ icd_term->instance, pIcdSurface->real_icd_surfaces[i],
+ pAllocator);
}
}
loader_instance_heap_free(ptr_instance,
terminator_GetPhysicalDeviceXcbPresentationSupportKHR(
VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
xcb_connection_t *connection, xcb_visualid_t visual_id) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_xcb_surface_enabled) {
loader_log(
ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
assert(
- icd->GetPhysicalDeviceXcbPresentationSupportKHR &&
+ icd_term->GetPhysicalDeviceXcbPresentationSupportKHR &&
"loader: null GetPhysicalDeviceXcbPresentationSupportKHR ICD pointer");
- return icd->GetPhysicalDeviceXcbPresentationSupportKHR(
- phys_dev->phys_dev, queueFamilyIndex, connection, visual_id);
+ return icd_term->GetPhysicalDeviceXcbPresentationSupportKHR(
+ phys_dev_term->phys_dev, queueFamilyIndex, connection, visual_id);
}
#endif // VK_USE_PLATFORM_XCB_KHR
pIcdSurface->xlib_surf.window = pCreateInfo->window;
// Loop through each ICD and determine if they need to create a surface
- for (struct loader_icd *icd = ptr_instance->icds; icd != NULL;
- icd = icd->next, i++) {
- if (ptr_instance->icd_libs.list[i].interface_version >=
+ for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next, i++) {
+ if (icd_term->scanned_icd->interface_version >=
ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
- if (NULL != icd->CreateXlibSurfaceKHR) {
- vkRes = icd->CreateXlibSurfaceKHR(
- icd->instance, pCreateInfo, pAllocator,
+ if (NULL != icd_term->CreateXlibSurfaceKHR) {
+ vkRes = icd_term->CreateXlibSurfaceKHR(
+ icd_term->instance, pCreateInfo, pAllocator,
&pIcdSurface->real_icd_surfaces[i]);
if (VK_SUCCESS != vkRes) {
goto out;
if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
if (NULL != pIcdSurface->real_icd_surfaces) {
i = 0;
- for (struct loader_icd *icd = ptr_instance->icds; icd != NULL;
- icd = icd->next, i++) {
+ for (struct loader_icd_term *icd_term = ptr_instance->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next, i++) {
if (NULL != pIcdSurface->real_icd_surfaces[i] &&
- NULL != icd->DestroySurfaceKHR) {
- icd->DestroySurfaceKHR(icd->instance,
- pIcdSurface->real_icd_surfaces[i],
- pAllocator);
+ NULL != icd_term->DestroySurfaceKHR) {
+ icd_term->DestroySurfaceKHR(
+ icd_term->instance, pIcdSurface->real_icd_surfaces[i],
+ pAllocator);
}
}
loader_instance_heap_free(ptr_instance,
terminator_GetPhysicalDeviceXlibPresentationSupportKHR(
VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display *dpy,
VisualID visualID) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_xlib_surface_enabled) {
loader_log(
ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
assert(
- icd->GetPhysicalDeviceXlibPresentationSupportKHR &&
+ icd_term->GetPhysicalDeviceXlibPresentationSupportKHR &&
"loader: null GetPhysicalDeviceXlibPresentationSupportKHR ICD pointer");
- return icd->GetPhysicalDeviceXlibPresentationSupportKHR(
- phys_dev->phys_dev, queueFamilyIndex, dpy, visualID);
+ return icd_term->GetPhysicalDeviceXlibPresentationSupportKHR(
+ phys_dev_term->phys_dev, queueFamilyIndex, dpy, visualID);
}
#endif // VK_USE_PLATFORM_XLIB_KHR
VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(
VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
VkDisplayPropertiesKHR *pProperties) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_display_enabled) {
loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"VK_KHR_display extension not enabled. "
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
- assert(icd->GetPhysicalDeviceDisplayPropertiesKHR &&
+ assert(icd_term->GetPhysicalDeviceDisplayPropertiesKHR &&
"loader: null GetPhysicalDeviceDisplayPropertiesKHR ICD pointer");
- return icd->GetPhysicalDeviceDisplayPropertiesKHR(
- phys_dev->phys_dev, pPropertyCount, pProperties);
+ return icd_term->GetPhysicalDeviceDisplayPropertiesKHR(
+ phys_dev_term->phys_dev, pPropertyCount, pProperties);
}
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR(
VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
VkDisplayPlanePropertiesKHR *pProperties) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_display_enabled) {
loader_log(
ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
assert(
- icd->GetPhysicalDeviceDisplayPlanePropertiesKHR &&
+ icd_term->GetPhysicalDeviceDisplayPlanePropertiesKHR &&
"loader: null GetPhysicalDeviceDisplayPlanePropertiesKHR ICD pointer");
- return icd->GetPhysicalDeviceDisplayPlanePropertiesKHR(
- phys_dev->phys_dev, pPropertyCount, pProperties);
+ return icd_term->GetPhysicalDeviceDisplayPlanePropertiesKHR(
+ phys_dev_term->phys_dev, pPropertyCount, pProperties);
}
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneSupportedDisplaysKHR(
VkPhysicalDevice physicalDevice, uint32_t planeIndex,
uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_display_enabled) {
loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"VK_KHR_display extension not enabled. "
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
- assert(icd->GetDisplayPlaneSupportedDisplaysKHR &&
+ assert(icd_term->GetDisplayPlaneSupportedDisplaysKHR &&
"loader: null GetDisplayPlaneSupportedDisplaysKHR ICD pointer");
- return icd->GetDisplayPlaneSupportedDisplaysKHR(
- phys_dev->phys_dev, planeIndex, pDisplayCount, pDisplays);
+ return icd_term->GetDisplayPlaneSupportedDisplaysKHR(
+ phys_dev_term->phys_dev, planeIndex, pDisplayCount, pDisplays);
}
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayModePropertiesKHR(
VkPhysicalDevice physicalDevice, VkDisplayKHR display,
uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_display_enabled) {
loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"VK_KHR_display extension not enabled. "
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
- assert(icd->GetDisplayModePropertiesKHR &&
+ assert(icd_term->GetDisplayModePropertiesKHR &&
"loader: null GetDisplayModePropertiesKHR ICD pointer");
- return icd->GetDisplayModePropertiesKHR(phys_dev->phys_dev, display,
- pPropertyCount, pProperties);
+ return icd_term->GetDisplayModePropertiesKHR(
+ phys_dev_term->phys_dev, display, pPropertyCount, pProperties);
}
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
VkPhysicalDevice physicalDevice, VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_display_enabled) {
loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"VK_KHR_display extension not enabled. "
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
- assert(icd->CreateDisplayModeKHR &&
+ assert(icd_term->CreateDisplayModeKHR &&
"loader: null CreateDisplayModeKHR ICD pointer");
- return icd->CreateDisplayModeKHR(phys_dev->phys_dev, display, pCreateInfo,
- pAllocator, pMode);
+ return icd_term->CreateDisplayModeKHR(phys_dev_term->phys_dev, display,
+ pCreateInfo, pAllocator, pMode);
}
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilitiesKHR(
VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex,
VkDisplayPlaneCapabilitiesKHR *pCapabilities) {
+
// First, check to ensure the appropriate extension was enabled:
- struct loader_physical_device *phys_dev =
- (struct loader_physical_device *)physicalDevice;
+ struct loader_physical_device_term *phys_dev_term =
+ (struct loader_physical_device_term *)physicalDevice;
+ struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
struct loader_instance *ptr_instance =
- (struct loader_instance *)phys_dev->this_icd->this_instance;
+ (struct loader_instance *)icd_term->this_instance;
if (!ptr_instance->wsi_display_enabled) {
loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
"VK_KHR_display extension not enabled. "
}
// Next, if so, proceed with the implementation of this function:
- struct loader_icd *icd = phys_dev->this_icd;
-
- assert(icd->GetDisplayPlaneCapabilitiesKHR &&
+ assert(icd_term->GetDisplayPlaneCapabilitiesKHR &&
"loader: null GetDisplayPlaneCapabilitiesKHR ICD pointer");
- return icd->GetDisplayPlaneCapabilitiesKHR(phys_dev->phys_dev, mode,
- planeIndex, pCapabilities);
+ return icd_term->GetDisplayPlaneCapabilitiesKHR(
+ phys_dev_term->phys_dev, mode, planeIndex, pCapabilities);
}
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
pIcdSurface->display_surf.imageExtent = pCreateInfo->imageExtent;
// Loop through each ICD and determine if they need to create a surface
- for (struct loader_icd *icd = inst->icds; icd != NULL;
- icd = icd->next, i++) {
- if (inst->icd_libs.list[i].interface_version >=
+ for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term != NULL;
+ icd_term = icd_term->next, i++) {
+ if (icd_term->scanned_icd->interface_version >=
ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
- if (NULL != icd->CreateDisplayPlaneSurfaceKHR) {
- vkRes = icd->CreateDisplayPlaneSurfaceKHR(
- icd->instance, pCreateInfo, pAllocator,
+ if (NULL != icd_term->CreateDisplayPlaneSurfaceKHR) {
+ vkRes = icd_term->CreateDisplayPlaneSurfaceKHR(
+ icd_term->instance, pCreateInfo, pAllocator,
&pIcdSurface->real_icd_surfaces[i]);
if (VK_SUCCESS != vkRes) {
goto out;
if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
if (NULL != pIcdSurface->real_icd_surfaces) {
i = 0;
- for (struct loader_icd *icd = inst->icds; icd != NULL;
- icd = icd->next, i++) {
+ for (struct loader_icd_term *icd_term = inst->icd_terms;
+ icd_term != NULL; icd_term = icd_term->next, i++) {
if (NULL != (void *)pIcdSurface->real_icd_surfaces[i] &&
- NULL != icd->DestroySurfaceKHR) {
- icd->DestroySurfaceKHR(icd->instance,
- pIcdSurface->real_icd_surfaces[i],
- pAllocator);
+ NULL != icd_term->DestroySurfaceKHR) {
+ icd_term->DestroySurfaceKHR(
+ icd_term->instance, pIcdSurface->real_icd_surfaces[i],
+ pAllocator);
}
}
loader_instance_heap_free(inst, pIcdSurface->real_icd_surfaces);
projects / platform / upstream / Vulkan-LoaderAndValidationLayers.git / commitdiff