1 /*
2 * Copyright (c) 2015-2016 The Khronos Group Inc.
3 * Copyright (c) 2015-2016 Valve Corporation
4 * Copyright (c) 2015-2016 LunarG, Inc.
5 * Copyright (c) 2015-2016 Google, Inc.
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * Author: Mark Lobodzinski <mark@lunarg.com>
20 * Author: Tobin Ehlis <tobine@google.com>
21 * Author: Courtney Goeltzenleuchter <courtneygo@google.com>
22 * Author: Jon Ashburn <jon@lunarg.com>
23 * Author: Mike Stroyan <stroyan@google.com>
24 * Author: Tony Barbour <tony@LunarG.com>
25 */
26
27 #include "vk_loader_platform.h"
28 #include "vulkan/vulkan.h"
29
30 #include <cinttypes>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34
35 #include <unordered_map>
36
37 #include "vk_layer_config.h"
38 #include "vk_layer_data.h"
39 #include "vk_layer_logging.h"
40 #include "vk_layer_table.h"
41 #include "vulkan/vk_layer.h"
42
43 #include "object_tracker.h"
44
45 #include "vk_validation_error_messages.h"
46
47 namespace object_tracker {
48
InitObjectTracker(layer_data * my_data,const VkAllocationCallbacks * pAllocator)49 static void InitObjectTracker(layer_data *my_data, const VkAllocationCallbacks *pAllocator) {
50
51 layer_debug_actions(my_data->report_data, my_data->logging_callback, pAllocator, "lunarg_object_tracker");
52 }
53
54 // Add new queue to head of global queue list
AddQueueInfo(VkDevice device,uint32_t queue_node_index,VkQueue queue)55 static void AddQueueInfo(VkDevice device, uint32_t queue_node_index, VkQueue queue) {
56 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
57 auto queueItem = device_data->queue_info_map.find(queue);
58 if (queueItem == device_data->queue_info_map.end()) {
59 OT_QUEUE_INFO *p_queue_info = new OT_QUEUE_INFO;
60 if (p_queue_info != NULL) {
61 memset(p_queue_info, 0, sizeof(OT_QUEUE_INFO));
62 p_queue_info->queue = queue;
63 p_queue_info->queue_node_index = queue_node_index;
64 device_data->queue_info_map[queue] = p_queue_info;
65 } else {
66 log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
67 reinterpret_cast<uint64_t>(queue), __LINE__, OBJTRACK_INTERNAL_ERROR, LayerName,
68 "ERROR: VK_ERROR_OUT_OF_HOST_MEMORY -- could not allocate memory for Queue Information");
69 }
70 }
71 }
72
73 // Destroy memRef lists and free all memory
DestroyQueueDataStructures(VkDevice device)74 static void DestroyQueueDataStructures(VkDevice device) {
75 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
76
77 for (auto queue_item : device_data->queue_info_map) {
78 delete queue_item.second;
79 }
80 device_data->queue_info_map.clear();
81
82 // Destroy the items in the queue map
83 auto queue = device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT].begin();
84 while (queue != device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT].end()) {
85 uint32_t obj_index = queue->second->object_type;
86 assert(device_data->num_total_objects > 0);
87 device_data->num_total_objects--;
88 assert(device_data->num_objects[obj_index] > 0);
89 device_data->num_objects[obj_index]--;
90 log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, queue->second->object_type, queue->second->handle,
91 __LINE__, OBJTRACK_NONE, LayerName,
92 "OBJ_STAT Destroy Queue obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " Queue objs).",
93 queue->second->handle, device_data->num_total_objects, device_data->num_objects[obj_index]);
94 delete queue->second;
95 queue = device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT].erase(queue);
96 }
97 }
98
99 // Check Queue type flags for selected queue operations
ValidateQueueFlags(VkQueue queue,const char * function)100 static void ValidateQueueFlags(VkQueue queue, const char *function) {
101 layer_data *device_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
102 auto queue_item = device_data->queue_info_map.find(queue);
103 if (queue_item != device_data->queue_info_map.end()) {
104 OT_QUEUE_INFO *pQueueInfo = queue_item->second;
105 if (pQueueInfo != NULL) {
106 layer_data *instance_data = get_my_data_ptr(get_dispatch_key(device_data->physical_device), layer_data_map);
107 if ((instance_data->queue_family_properties[pQueueInfo->queue_node_index].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) ==
108 0) {
109 log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
110 reinterpret_cast<uint64_t>(queue), __LINE__, OBJTRACK_UNKNOWN_OBJECT, LayerName,
111 "Attempting %s on a non-memory-management capable queue -- VK_QUEUE_SPARSE_BINDING_BIT not set", function);
112 }
113 }
114 }
115 }
116
AllocateCommandBuffer(VkDevice device,const VkCommandPool command_pool,const VkCommandBuffer command_buffer,VkDebugReportObjectTypeEXT object_type,VkCommandBufferLevel level)117 static void AllocateCommandBuffer(VkDevice device, const VkCommandPool command_pool, const VkCommandBuffer command_buffer,
118 VkDebugReportObjectTypeEXT object_type, VkCommandBufferLevel level) {
119 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
120
121 log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, object_type, reinterpret_cast<const uint64_t>(command_buffer),
122 __LINE__, OBJTRACK_NONE, LayerName, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++,
123 string_VkDebugReportObjectTypeEXT(object_type), reinterpret_cast<const uint64_t>(command_buffer));
124
125 OBJTRACK_NODE *pNewObjNode = new OBJTRACK_NODE;
126 pNewObjNode->object_type = object_type;
127 pNewObjNode->handle = reinterpret_cast<const uint64_t>(command_buffer);
128 pNewObjNode->parent_object = reinterpret_cast<const uint64_t &>(command_pool);
129 if (level == VK_COMMAND_BUFFER_LEVEL_SECONDARY) {
130 pNewObjNode->status = OBJSTATUS_COMMAND_BUFFER_SECONDARY;
131 } else {
132 pNewObjNode->status = OBJSTATUS_NONE;
133 }
134 device_data->object_map[object_type][reinterpret_cast<const uint64_t>(command_buffer)] = pNewObjNode;
135 device_data->num_objects[object_type]++;
136 device_data->num_total_objects++;
137 }
138
ValidateCommandBuffer(VkDevice device,VkCommandPool command_pool,VkCommandBuffer command_buffer)139 static bool ValidateCommandBuffer(VkDevice device, VkCommandPool command_pool, VkCommandBuffer command_buffer) {
140 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
141 bool skip_call = false;
142 uint64_t object_handle = reinterpret_cast<uint64_t>(command_buffer);
143 if (device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT].find(object_handle) !=
144 device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT].end()) {
145 OBJTRACK_NODE *pNode =
146 device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT][reinterpret_cast<uint64_t>(command_buffer)];
147
148 if (pNode->parent_object != reinterpret_cast<uint64_t &>(command_pool)) {
149 skip_call |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->object_type, object_handle,
150 __LINE__, OBJTRACK_COMMAND_POOL_MISMATCH, LayerName,
151 "FreeCommandBuffers is attempting to free Command Buffer 0x%" PRIxLEAST64
152 " belonging to Command Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 ").",
153 reinterpret_cast<uint64_t>(command_buffer), pNode->parent_object,
154 reinterpret_cast<uint64_t &>(command_pool));
155 }
156 } else {
157 skip_call |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, object_handle,
158 __LINE__, OBJTRACK_NONE, LayerName, "Unable to remove command buffer obj 0x%" PRIxLEAST64
159 ". Was it created? Has it already been destroyed?",
160 object_handle);
161 }
162 return skip_call;
163 }
164
AllocateDescriptorSet(VkDevice device,VkDescriptorPool descriptor_pool,VkDescriptorSet descriptor_set,VkDebugReportObjectTypeEXT object_type)165 static void AllocateDescriptorSet(VkDevice device, VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set,
166 VkDebugReportObjectTypeEXT object_type) {
167 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
168
169 log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, object_type,
170 reinterpret_cast<uint64_t &>(descriptor_set), __LINE__, OBJTRACK_NONE, LayerName,
171 "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++, object_name[object_type],
172 reinterpret_cast<uint64_t &>(descriptor_set));
173
174 OBJTRACK_NODE *pNewObjNode = new OBJTRACK_NODE;
175 pNewObjNode->object_type = object_type;
176 pNewObjNode->status = OBJSTATUS_NONE;
177 pNewObjNode->handle = reinterpret_cast<uint64_t &>(descriptor_set);
178 pNewObjNode->parent_object = reinterpret_cast<uint64_t &>(descriptor_pool);
179 device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT][reinterpret_cast<uint64_t &>(descriptor_set)] =
180 pNewObjNode;
181 device_data->num_objects[object_type]++;
182 device_data->num_total_objects++;
183 }
184
ValidateDescriptorSet(VkDevice device,VkDescriptorPool descriptor_pool,VkDescriptorSet descriptor_set)185 static bool ValidateDescriptorSet(VkDevice device, VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set) {
186 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
187 bool skip_call = false;
188 uint64_t object_handle = reinterpret_cast<uint64_t &>(descriptor_set);
189 auto dsItem = device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT].find(object_handle);
190 if (dsItem != device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT].end()) {
191 OBJTRACK_NODE *pNode = dsItem->second;
192
193 if (pNode->parent_object != reinterpret_cast<uint64_t &>(descriptor_pool)) {
194 skip_call |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->object_type, object_handle,
195 __LINE__, OBJTRACK_DESCRIPTOR_POOL_MISMATCH, LayerName,
196 "FreeDescriptorSets is attempting to free descriptorSet 0x%" PRIxLEAST64
197 " belonging to Descriptor Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 ").",
198 reinterpret_cast<uint64_t &>(descriptor_set), pNode->parent_object,
199 reinterpret_cast<uint64_t &>(descriptor_pool));
200 }
201 } else {
202 skip_call |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, object_handle,
203 __LINE__, OBJTRACK_NONE, LayerName, "Unable to remove descriptor set obj 0x%" PRIxLEAST64
204 ". Was it created? Has it already been destroyed?",
205 object_handle);
206 }
207 return skip_call;
208 }
209
CreateQueue(VkDevice device,VkQueue vkObj,VkDebugReportObjectTypeEXT object_type)210 static void CreateQueue(VkDevice device, VkQueue vkObj, VkDebugReportObjectTypeEXT object_type) {
211 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
212
213 log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, object_type, reinterpret_cast<uint64_t>(vkObj), __LINE__,
214 OBJTRACK_NONE, LayerName, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++,
215 object_name[object_type], reinterpret_cast<uint64_t>(vkObj));
216
217 OBJTRACK_NODE *p_obj_node = NULL;
218 auto queue_item = device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT].find(reinterpret_cast<uint64_t>(vkObj));
219 if (queue_item == device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT].end()) {
220 p_obj_node = new OBJTRACK_NODE;
221 device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT][reinterpret_cast<uint64_t>(vkObj)] = p_obj_node;
222 device_data->num_objects[object_type]++;
223 device_data->num_total_objects++;
224 } else {
225 p_obj_node = queue_item->second;
226 }
227 p_obj_node->object_type = object_type;
228 p_obj_node->status = OBJSTATUS_NONE;
229 p_obj_node->handle = reinterpret_cast<uint64_t>(vkObj);
230 }
231
CreateSwapchainImageObject(VkDevice dispatchable_object,VkImage swapchain_image,VkSwapchainKHR swapchain)232 static void CreateSwapchainImageObject(VkDevice dispatchable_object, VkImage swapchain_image, VkSwapchainKHR swapchain) {
233 layer_data *device_data = get_my_data_ptr(get_dispatch_key(dispatchable_object), layer_data_map);
234 log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
235 reinterpret_cast<uint64_t &>(swapchain_image), __LINE__, OBJTRACK_NONE, LayerName,
236 "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++, "SwapchainImage",
237 reinterpret_cast<uint64_t &>(swapchain_image));
238
239 OBJTRACK_NODE *pNewObjNode = new OBJTRACK_NODE;
240 pNewObjNode->object_type = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT;
241 pNewObjNode->status = OBJSTATUS_NONE;
242 pNewObjNode->handle = reinterpret_cast<uint64_t &>(swapchain_image);
243 pNewObjNode->parent_object = reinterpret_cast<uint64_t &>(swapchain);
244 device_data->swapchainImageMap[reinterpret_cast<uint64_t &>(swapchain_image)] = pNewObjNode;
245 }
246
247 template<typename T>
handle_value(T handle)248 uint64_t handle_value(T handle) {
249 return reinterpret_cast<uint64_t &>(handle);
250 }
251 template<typename T>
handle_value(T * handle)252 uint64_t handle_value(T *handle) {
253 return reinterpret_cast<uint64_t>(handle);
254 }
255
256 template <typename T1, typename T2>
CreateObject(T1 dispatchable_object,T2 object,VkDebugReportObjectTypeEXT object_type,const VkAllocationCallbacks * pAllocator)257 static void CreateObject(T1 dispatchable_object, T2 object, VkDebugReportObjectTypeEXT object_type, const VkAllocationCallbacks *pAllocator) {
258 layer_data *instance_data = get_my_data_ptr(get_dispatch_key(dispatchable_object), layer_data_map);
259
260 auto object_handle = handle_value(object);
261 bool custom_allocator = pAllocator != nullptr;
262
263 log_msg(instance_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, object_type, object_handle,
264 __LINE__, OBJTRACK_NONE, LayerName, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++,
265 object_name[object_type], object_handle);
266
267 OBJTRACK_NODE *pNewObjNode = new OBJTRACK_NODE;
268 pNewObjNode->object_type = object_type;
269 pNewObjNode->status = custom_allocator ? OBJSTATUS_CUSTOM_ALLOCATOR : OBJSTATUS_NONE;
270 pNewObjNode->handle = object_handle;
271 instance_data->object_map[object_type][object_handle] = pNewObjNode;
272 instance_data->num_objects[object_type]++;
273 instance_data->num_total_objects++;
274 }
275
276 template <typename T1, typename T2>
DestroyObject(T1 dispatchable_object,T2 object,VkDebugReportObjectTypeEXT object_type,const VkAllocationCallbacks * pAllocator)277 static void DestroyObject(T1 dispatchable_object, T2 object, VkDebugReportObjectTypeEXT object_type, const VkAllocationCallbacks *pAllocator) {
278 layer_data *device_data = get_my_data_ptr(get_dispatch_key(dispatchable_object), layer_data_map);
279
280 auto object_handle = handle_value(object);
281 bool custom_allocator = pAllocator != nullptr;
282
283 auto item = device_data->object_map[object_type].find(object_handle);
284 if (item != device_data->object_map[object_type].end()) {
285
286 OBJTRACK_NODE *pNode = item->second;
287 assert(device_data->num_total_objects > 0);
288 device_data->num_total_objects--;
289 assert(device_data->num_objects[pNode->object_type] > 0);
290 device_data->num_objects[pNode->object_type]--;
291
292 log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->object_type, object_handle, __LINE__,
293 OBJTRACK_NONE, LayerName,
294 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).",
295 object_name[pNode->object_type], reinterpret_cast<uint64_t &>(object), device_data->num_total_objects,
296 device_data->num_objects[pNode->object_type], object_name[pNode->object_type]);
297
298 auto allocated_with_custom = (pNode->status & OBJSTATUS_CUSTOM_ALLOCATOR) ? true : false;
299 if (custom_allocator ^ allocated_with_custom) {
300 log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle, __LINE__,
301 OBJTRACK_ALLOCATOR_MISMATCH, LayerName,
302 "Custom allocator %sspecified while destroying %s obj 0x%" PRIxLEAST64 " but %sspecified at creation",
303 (custom_allocator ? "" : "not "), object_name[object_type], object_handle,
304 (allocated_with_custom ? "" : "not "));
305 }
306
307 delete pNode;
308 device_data->object_map[object_type].erase(item);
309 } else {
310 log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, object_handle, __LINE__,
311 OBJTRACK_UNKNOWN_OBJECT, LayerName,
312 "Unable to remove %s obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",
313 object_name[object_type], object_handle);
314 }
315 }
316
317 template <typename T1, typename T2>
ValidateObject(T1 dispatchable_object,T2 object,VkDebugReportObjectTypeEXT object_type,bool null_allowed,int error_code=-1)318 static bool ValidateObject(T1 dispatchable_object, T2 object, VkDebugReportObjectTypeEXT object_type, bool null_allowed,
319 int error_code = -1) {
320 if (null_allowed && (object == VK_NULL_HANDLE)) {
321 return false;
322 }
323 auto object_handle = handle_value(object);
324
325 layer_data *device_data = get_my_data_ptr(get_dispatch_key(dispatchable_object), layer_data_map);
326 if (device_data->object_map[object_type].find(object_handle) == device_data->object_map[object_type].end()) {
327 // If object is an image, also look for it in the swapchain image map
328 if ((object_type != VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT) ||
329 (device_data->swapchainImageMap.find(object_handle) == device_data->swapchainImageMap.end())) {
330 const char *error_msg = (error_code == -1) ? "" : validation_error_map[error_code];
331 return log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle, __LINE__,
332 error_code, LayerName, "Invalid %s Object 0x%" PRIxLEAST64 ". %s", object_name[object_type],
333 object_handle, error_msg);
334 }
335 }
336 return false;
337 }
338
DeviceReportUndestroyedObjects(VkDevice device,VkDebugReportObjectTypeEXT object_type)339 static void DeviceReportUndestroyedObjects(VkDevice device, VkDebugReportObjectTypeEXT object_type) {
340 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
341 for (auto item = device_data->object_map[object_type].begin(); item != device_data->object_map[object_type].end();) {
342 OBJTRACK_NODE *object_info = item->second;
343 log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_info->object_type, object_info->handle, __LINE__,
344 OBJTRACK_OBJECT_LEAK, LayerName,
345 "OBJ ERROR : For device 0x%" PRIxLEAST64 ", %s object 0x%" PRIxLEAST64 " has not been destroyed.",
346 reinterpret_cast<uint64_t>(device), object_name[object_type], object_info->handle);
347 item = device_data->object_map[object_type].erase(item);
348 }
349 }
350
DestroyInstance(VkInstance instance,const VkAllocationCallbacks * pAllocator)351 VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
352 std::unique_lock<std::mutex> lock(global_lock);
353
354 dispatch_key key = get_dispatch_key(instance);
355 layer_data *instance_data = get_my_data_ptr(key, layer_data_map);
356
357 // Enable the temporary callback(s) here to catch cleanup issues:
358 bool callback_setup = false;
359 if (instance_data->num_tmp_callbacks > 0) {
360 if (!layer_enable_tmp_callbacks(instance_data->report_data, instance_data->num_tmp_callbacks,
361 instance_data->tmp_dbg_create_infos, instance_data->tmp_callbacks)) {
362 callback_setup = true;
363 }
364 }
365
366 ValidateObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, true, VALIDATION_ERROR_00021);
367
368 DestroyObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, pAllocator);
369 // Report any remaining objects in LL
370
371 for (auto iit = instance_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT].begin();
372 iit != instance_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT].end();) {
373 OBJTRACK_NODE *pNode = iit->second;
374
375 VkDevice device = reinterpret_cast<VkDevice>(pNode->handle);
376
377 log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->object_type, pNode->handle, __LINE__,
378 OBJTRACK_OBJECT_LEAK, LayerName, "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.",
379 string_VkDebugReportObjectTypeEXT(pNode->object_type), pNode->handle);
380 // Semaphore:
381 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT);
382 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT);
383 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT);
384 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT);
385 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT);
386 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
387 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT);
388 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT);
389 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT);
390 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT);
391 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT);
392 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT);
393 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT);
394 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT);
395 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT);
396 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT);
397 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT);
398 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT);
399 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT);
400 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT);
401 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT);
402 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT);
403 // DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT);
404 }
405 instance_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT].clear();
406
407 VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance);
408 pInstanceTable->DestroyInstance(instance, pAllocator);
409
410 // Disable and cleanup the temporary callback(s):
411 if (callback_setup) {
412 layer_disable_tmp_callbacks(instance_data->report_data, instance_data->num_tmp_callbacks, instance_data->tmp_callbacks);
413 }
414 if (instance_data->num_tmp_callbacks > 0) {
415 layer_free_tmp_callbacks(instance_data->tmp_dbg_create_infos, instance_data->tmp_callbacks);
416 instance_data->num_tmp_callbacks = 0;
417 }
418
419 // Clean up logging callback, if any
420 while (instance_data->logging_callback.size() > 0) {
421 VkDebugReportCallbackEXT callback = instance_data->logging_callback.back();
422 layer_destroy_msg_callback(instance_data->report_data, callback, pAllocator);
423 instance_data->logging_callback.pop_back();
424 }
425
426 layer_debug_report_destroy_instance(instance_data->report_data);
427 layer_data_map.erase(key);
428
429 instanceExtMap.erase(pInstanceTable);
430 lock.unlock();
431 ot_instance_table_map.erase(key);
432 }
433
DestroyDevice(VkDevice device,const VkAllocationCallbacks * pAllocator)434 VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
435
436 std::unique_lock<std::mutex> lock(global_lock);
437 ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, true, VALIDATION_ERROR_00052);
438 DestroyObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, pAllocator);
439
440 // Report any remaining objects associated with this VkDevice object in LL
441 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT);
442 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT);
443 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT);
444 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT);
445 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
446 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT);
447 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT);
448 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT);
449 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT);
450 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT);
451 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT);
452 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT);
453 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT);
454 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT);
455 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT);
456 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT);
457 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT);
458 // DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT);
459 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT);
460 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT);
461 // DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT);
462 DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT);
463 // DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT);
464
465 // Clean up Queue's MemRef Linked Lists
466 DestroyQueueDataStructures(device);
467
468 lock.unlock();
469
470 dispatch_key key = get_dispatch_key(device);
471 VkLayerDispatchTable *pDisp = get_dispatch_table(ot_device_table_map, device);
472 pDisp->DestroyDevice(device, pAllocator);
473 ot_device_table_map.erase(key);
474 }
475
GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures)476 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) {
477 bool skip_call = false;
478 {
479 std::lock_guard<std::mutex> lock(global_lock);
480 skip_call |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false,
481 VALIDATION_ERROR_01679);
482 }
483 if (skip_call) {
484 return;
485 }
486 get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
487 }
488
GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties)489 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
490 VkFormatProperties *pFormatProperties) {
491 bool skip_call = false;
492 {
493 std::lock_guard<std::mutex> lock(global_lock);
494 skip_call |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false,
495 VALIDATION_ERROR_01683);
496 }
497 if (skip_call) {
498 return;
499 }
500 get_dispatch_table(ot_instance_table_map, physicalDevice)
501 ->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
502 }
503
GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties)504 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
505 VkImageType type, VkImageTiling tiling,
506 VkImageUsageFlags usage, VkImageCreateFlags flags,
507 VkImageFormatProperties *pImageFormatProperties) {
508 bool skip_call = false;
509 {
510 std::lock_guard<std::mutex> lock(global_lock);
511 skip_call |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false,
512 VALIDATION_ERROR_01686);
513 }
514 if (skip_call) {
515 return VK_ERROR_VALIDATION_FAILED_EXT;
516 }
517 VkResult result =
518 get_dispatch_table(ot_instance_table_map, physicalDevice)
519 ->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
520 return result;
521 }
522
GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties)523 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) {
524 bool skip_call = false;
525 {
526 std::lock_guard<std::mutex> lock(global_lock);
527 skip_call |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false,
528 VALIDATION_ERROR_00026);
529 }
530 if (skip_call) {
531 return;
532 }
533 get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties);
534 }
535
GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties)536 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
537 VkPhysicalDeviceMemoryProperties *pMemoryProperties) {
538 bool skip_call = false;
539 {
540 std::lock_guard<std::mutex> lock(global_lock);
541 skip_call |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false,
542 VALIDATION_ERROR_00609);
543 }
544 if (skip_call) {
545 return;
546 }
547 get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
548 }
549
550 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *pName);
551
552 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *pName);
553
554 VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount,
555 VkExtensionProperties *pProperties);
556
557 VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties);
558
559 VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
560 VkLayerProperties *pProperties);
561
QueueSubmit(VkQueue queue,uint32_t submitCount,const VkSubmitInfo * pSubmits,VkFence fence)562 VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) {
563 bool skip_call = false;
564 {
565 std::lock_guard<std::mutex> lock(global_lock);
566 skip_call |= ValidateObject(queue, fence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, true, VALIDATION_ERROR_00130);
567 if (pSubmits) {
568 for (uint32_t idx0 = 0; idx0 < submitCount; ++idx0) {
569 if (pSubmits[idx0].pCommandBuffers) {
570 for (uint32_t idx1 = 0; idx1 < pSubmits[idx0].commandBufferCount; ++idx1) {
571 skip_call |= ValidateObject(queue, pSubmits[idx0].pCommandBuffers[idx1],
572 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false, VALIDATION_ERROR_00149);
573 }
574 }
575 if (pSubmits[idx0].pSignalSemaphores) {
576 for (uint32_t idx2 = 0; idx2 < pSubmits[idx0].signalSemaphoreCount; ++idx2) {
577 skip_call |= ValidateObject(queue, pSubmits[idx0].pSignalSemaphores[idx2],
578 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, false, VALIDATION_ERROR_00150);
579 }
580 }
581 if (pSubmits[idx0].pWaitSemaphores) {
582 for (uint32_t idx3 = 0; idx3 < pSubmits[idx0].waitSemaphoreCount; ++idx3) {
583 skip_call |= ValidateObject(queue, pSubmits[idx0].pWaitSemaphores[idx3],
584 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, false, VALIDATION_ERROR_00146);
585 }
586 }
587 }
588 }
589 if (queue) {
590 skip_call |= ValidateObject(queue, queue, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, false, VALIDATION_ERROR_00128);
591 }
592 }
593 if (skip_call) {
594 return VK_ERROR_VALIDATION_FAILED_EXT;
595 }
596 VkResult result = get_dispatch_table(ot_device_table_map, queue)->QueueSubmit(queue, submitCount, pSubmits, fence);
597 return result;
598 }
599
QueueWaitIdle(VkQueue queue)600 VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(VkQueue queue) {
601 bool skip_call = false;
602 {
603 std::lock_guard<std::mutex> lock(global_lock);
604 skip_call |= ValidateObject(queue, queue, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, false, VALIDATION_ERROR_00317);
605 }
606 if (skip_call) {
607 return VK_ERROR_VALIDATION_FAILED_EXT;
608 }
609 VkResult result = get_dispatch_table(ot_device_table_map, queue)->QueueWaitIdle(queue);
610 return result;
611 }
612
DeviceWaitIdle(VkDevice device)613 VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(VkDevice device) {
614 bool skip_call = false;
615 {
616 std::lock_guard<std::mutex> lock(global_lock);
617 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00318);
618 }
619 if (skip_call) {
620 return VK_ERROR_VALIDATION_FAILED_EXT;
621 }
622 VkResult result = get_dispatch_table(ot_device_table_map, device)->DeviceWaitIdle(device);
623 return result;
624 }
625
AllocateMemory(VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory)626 VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
627 const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) {
628 bool skip_call = false;
629 {
630 std::lock_guard<std::mutex> lock(global_lock);
631 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00612);
632 }
633 if (skip_call) {
634 return VK_ERROR_VALIDATION_FAILED_EXT;
635 }
636 VkResult result = get_dispatch_table(ot_device_table_map, device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
637 {
638 std::lock_guard<std::mutex> lock(global_lock);
639 if (result == VK_SUCCESS) {
640 CreateObject(device, *pMemory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, pAllocator);
641 }
642 }
643 return result;
644 }
645
FlushMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)646 VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
647 const VkMappedMemoryRange *pMemoryRanges) {
648 bool skip_call = false;
649 {
650 std::lock_guard<std::mutex> lock(global_lock);
651 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00635);
652 if (pMemoryRanges) {
653 for (uint32_t idx0 = 0; idx0 < memoryRangeCount; ++idx0) {
654 if (pMemoryRanges[idx0].memory) {
655 skip_call |= ValidateObject(device, pMemoryRanges[idx0].memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
656 false, VALIDATION_ERROR_00648);
657 }
658 }
659 }
660 }
661 if (skip_call) {
662 return VK_ERROR_VALIDATION_FAILED_EXT;
663 }
664 VkResult result =
665 get_dispatch_table(ot_device_table_map, device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
666 return result;
667 }
668
InvalidateMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges)669 VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
670 const VkMappedMemoryRange *pMemoryRanges) {
671 bool skip_call = false;
672 {
673 std::lock_guard<std::mutex> lock(global_lock);
674 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00638);
675 if (pMemoryRanges) {
676 for (uint32_t idx0 = 0; idx0 < memoryRangeCount; ++idx0) {
677 if (pMemoryRanges[idx0].memory) {
678 skip_call |= ValidateObject(device, pMemoryRanges[idx0].memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
679 false, VALIDATION_ERROR_00648);
680 }
681 }
682 }
683 }
684 if (skip_call) {
685 return VK_ERROR_VALIDATION_FAILED_EXT;
686 }
687 VkResult result =
688 get_dispatch_table(ot_device_table_map, device)->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
689 return result;
690 }
691
GetDeviceMemoryCommitment(VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes)692 VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
693 VkDeviceSize *pCommittedMemoryInBytes) {
694 bool skip_call = false;
695 {
696 std::lock_guard<std::mutex> lock(global_lock);
697 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00654);
698 skip_call |= ValidateObject(device, memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, false, VALIDATION_ERROR_00655);
699 }
700 if (skip_call) {
701 return;
702 }
703 get_dispatch_table(ot_device_table_map, device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
704 }
705
BindBufferMemory(VkDevice device,VkBuffer buffer,VkDeviceMemory memory,VkDeviceSize memoryOffset)706 VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
707 VkDeviceSize memoryOffset) {
708 bool skip_call = false;
709 {
710 std::lock_guard<std::mutex> lock(global_lock);
711 skip_call |= ValidateObject(device, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_00799);
712 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00798);
713 skip_call |= ValidateObject(device, memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, false, VALIDATION_ERROR_00800);
714 }
715 if (skip_call) {
716 return VK_ERROR_VALIDATION_FAILED_EXT;
717 }
718 VkResult result = get_dispatch_table(ot_device_table_map, device)->BindBufferMemory(device, buffer, memory, memoryOffset);
719 return result;
720 }
721
BindImageMemory(VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset)722 VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
723 bool skip_call = false;
724 {
725 std::lock_guard<std::mutex> lock(global_lock);
726 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00807);
727 skip_call |= ValidateObject(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_00808);
728 skip_call |= ValidateObject(device, memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, false, VALIDATION_ERROR_00809);
729 }
730 if (skip_call) {
731 return VK_ERROR_VALIDATION_FAILED_EXT;
732 }
733 VkResult result = get_dispatch_table(ot_device_table_map, device)->BindImageMemory(device, image, memory, memoryOffset);
734 return result;
735 }
736
GetBufferMemoryRequirements(VkDevice device,VkBuffer buffer,VkMemoryRequirements * pMemoryRequirements)737 VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
738 VkMemoryRequirements *pMemoryRequirements) {
739 bool skip_call = false;
740 {
741 std::lock_guard<std::mutex> lock(global_lock);
742 skip_call |= ValidateObject(device, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_00784);
743 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00783);
744 }
745 if (skip_call) {
746 return;
747 }
748 get_dispatch_table(ot_device_table_map, device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
749 }
750
GetImageMemoryRequirements(VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements)751 VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) {
752 bool skip_call = false;
753 {
754 std::lock_guard<std::mutex> lock(global_lock);
755 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00787);
756 skip_call |= ValidateObject(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_00788);
757 }
758 if (skip_call) {
759 return;
760 }
761 get_dispatch_table(ot_device_table_map, device)->GetImageMemoryRequirements(device, image, pMemoryRequirements);
762 }
763
GetImageSparseMemoryRequirements(VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements)764 VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
765 VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
766 bool skip_call = false;
767 {
768 std::lock_guard<std::mutex> lock(global_lock);
769 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_01610);
770 skip_call |= ValidateObject(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_01611);
771 }
772 if (skip_call) {
773 return;
774 }
775 get_dispatch_table(ot_device_table_map, device)
776 ->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
777 }
778
GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties)779 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
780 VkImageType type, VkSampleCountFlagBits samples,
781 VkImageUsageFlags usage, VkImageTiling tiling,
782 uint32_t *pPropertyCount,
783 VkSparseImageFormatProperties *pProperties) {
784 bool skip_call = false;
785 {
786 std::lock_guard<std::mutex> lock(global_lock);
787 skip_call |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false,
788 VALIDATION_ERROR_01601);
789 }
790 if (skip_call) {
791 return;
792 }
793 get_dispatch_table(ot_instance_table_map, physicalDevice)
794 ->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount,
795 pProperties);
796 }
797
CreateFence(VkDevice device,const VkFenceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence)798 VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
799 const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
800 bool skip_call = false;
801 {
802 std::lock_guard<std::mutex> lock(global_lock);
803 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00166);
804 }
805 if (skip_call) {
806 return VK_ERROR_VALIDATION_FAILED_EXT;
807 }
808 VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateFence(device, pCreateInfo, pAllocator, pFence);
809 {
810 std::lock_guard<std::mutex> lock(global_lock);
811 if (result == VK_SUCCESS) {
812 CreateObject(device, *pFence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, pAllocator);
813 }
814 }
815 return result;
816 }
817
DestroyFence(VkDevice device,VkFence fence,const VkAllocationCallbacks * pAllocator)818 VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) {
819 bool skip_call = false;
820 {
821 std::lock_guard<std::mutex> lock(global_lock);
822 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00176);
823 skip_call |= ValidateObject(device, fence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, true, VALIDATION_ERROR_00177);
824 }
825 if (skip_call) {
826 return;
827 }
828 {
829 std::lock_guard<std::mutex> lock(global_lock);
830 DestroyObject(device, fence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, pAllocator);
831 }
832 get_dispatch_table(ot_device_table_map, device)->DestroyFence(device, fence, pAllocator);
833 }
834
ResetFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences)835 VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) {
836 bool skip_call = false;
837 {
838 std::lock_guard<std::mutex> lock(global_lock);
839 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00184);
840 if (pFences) {
841 for (uint32_t idx0 = 0; idx0 < fenceCount; ++idx0) {
842 skip_call |=
843 ValidateObject(device, pFences[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, false, VALIDATION_ERROR_00187);
844 }
845 }
846 }
847 if (skip_call) {
848 return VK_ERROR_VALIDATION_FAILED_EXT;
849 }
850 VkResult result = get_dispatch_table(ot_device_table_map, device)->ResetFences(device, fenceCount, pFences);
851 return result;
852 }
853
GetFenceStatus(VkDevice device,VkFence fence)854 VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence) {
855 bool skip_call = false;
856 {
857 std::lock_guard<std::mutex> lock(global_lock);
858 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00180);
859 skip_call |= ValidateObject(device, fence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, false, VALIDATION_ERROR_00181);
860 }
861 if (skip_call) {
862 return VK_ERROR_VALIDATION_FAILED_EXT;
863 }
864 VkResult result = get_dispatch_table(ot_device_table_map, device)->GetFenceStatus(device, fence);
865 return result;
866 }
867
WaitForFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences,VkBool32 waitAll,uint64_t timeout)868 VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll,
869 uint64_t timeout) {
870 bool skip_call = false;
871 {
872 std::lock_guard<std::mutex> lock(global_lock);
873 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00188);
874 if (pFences) {
875 for (uint32_t idx0 = 0; idx0 < fenceCount; ++idx0) {
876 skip_call |=
877 ValidateObject(device, pFences[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, false, VALIDATION_ERROR_00191);
878 }
879 }
880 }
881 if (skip_call) {
882 return VK_ERROR_VALIDATION_FAILED_EXT;
883 }
884 VkResult result = get_dispatch_table(ot_device_table_map, device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
885 return result;
886 }
887
CreateSemaphore(VkDevice device,const VkSemaphoreCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSemaphore * pSemaphore)888 VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
889 const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) {
890 bool skip_call = false;
891 {
892 std::lock_guard<std::mutex> lock(global_lock);
893 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00192);
894 }
895 if (skip_call) {
896 return VK_ERROR_VALIDATION_FAILED_EXT;
897 }
898 VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
899 {
900 std::lock_guard<std::mutex> lock(global_lock);
901 if (result == VK_SUCCESS) {
902 CreateObject(device, *pSemaphore, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, pAllocator);
903 }
904 }
905 return result;
906 }
907
DestroySemaphore(VkDevice device,VkSemaphore semaphore,const VkAllocationCallbacks * pAllocator)908 VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) {
909 bool skip_call = false;
910 {
911 std::lock_guard<std::mutex> lock(global_lock);
912 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00202);
913 skip_call |= ValidateObject(device, semaphore, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, true, VALIDATION_ERROR_00203);
914 }
915 if (skip_call) {
916 return;
917 }
918 {
919 std::lock_guard<std::mutex> lock(global_lock);
920 DestroyObject(device, semaphore, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, pAllocator);
921 }
922 get_dispatch_table(ot_device_table_map, device)->DestroySemaphore(device, semaphore, pAllocator);
923 }
924
CreateEvent(VkDevice device,const VkEventCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkEvent * pEvent)925 VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
926 const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
927 bool skip_call = false;
928 {
929 std::lock_guard<std::mutex> lock(global_lock);
930 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00206);
931 }
932 if (skip_call) {
933 return VK_ERROR_VALIDATION_FAILED_EXT;
934 }
935 VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
936 {
937 std::lock_guard<std::mutex> lock(global_lock);
938 if (result == VK_SUCCESS) {
939 CreateObject(device, *pEvent, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, pAllocator);
940 }
941 }
942 return result;
943 }
944
DestroyEvent(VkDevice device,VkEvent event,const VkAllocationCallbacks * pAllocator)945 VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) {
946 bool skip_call = false;
947 {
948 std::lock_guard<std::mutex> lock(global_lock);
949 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00216);
950 skip_call |= ValidateObject(device, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, true, VALIDATION_ERROR_00217);
951 }
952 if (skip_call) {
953 return;
954 }
955 {
956 std::lock_guard<std::mutex> lock(global_lock);
957 DestroyObject(device, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, pAllocator);
958 }
959 get_dispatch_table(ot_device_table_map, device)->DestroyEvent(device, event, pAllocator);
960 }
961
GetEventStatus(VkDevice device,VkEvent event)962 VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(VkDevice device, VkEvent event) {
963 bool skip_call = false;
964 {
965 std::lock_guard<std::mutex> lock(global_lock);
966 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00220);
967 skip_call |= ValidateObject(device, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false, VALIDATION_ERROR_00221);
968 }
969 if (skip_call) {
970 return VK_ERROR_VALIDATION_FAILED_EXT;
971 }
972 VkResult result = get_dispatch_table(ot_device_table_map, device)->GetEventStatus(device, event);
973 return result;
974 }
975
SetEvent(VkDevice device,VkEvent event)976 VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event) {
977 bool skip_call = false;
978 {
979 std::lock_guard<std::mutex> lock(global_lock);
980 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00223);
981 skip_call |= ValidateObject(device, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false, VALIDATION_ERROR_00224);
982 }
983 if (skip_call) {
984 return VK_ERROR_VALIDATION_FAILED_EXT;
985 }
986 VkResult result = get_dispatch_table(ot_device_table_map, device)->SetEvent(device, event);
987 return result;
988 }
989
ResetEvent(VkDevice device,VkEvent event)990 VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(VkDevice device, VkEvent event) {
991 bool skip_call = false;
992 {
993 std::lock_guard<std::mutex> lock(global_lock);
994 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00227);
995 skip_call |= ValidateObject(device, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false, VALIDATION_ERROR_00228);
996 }
997 if (skip_call) {
998 return VK_ERROR_VALIDATION_FAILED_EXT;
999 }
1000 VkResult result = get_dispatch_table(ot_device_table_map, device)->ResetEvent(device, event);
1001 return result;
1002 }
1003
CreateQueryPool(VkDevice device,const VkQueryPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkQueryPool * pQueryPool)1004 VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
1005 const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) {
1006 bool skip_call = false;
1007 {
1008 std::lock_guard<std::mutex> lock(global_lock);
1009 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_01002);
1010 }
1011 if (skip_call) {
1012 return VK_ERROR_VALIDATION_FAILED_EXT;
1013 }
1014 VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
1015 {
1016 std::lock_guard<std::mutex> lock(global_lock);
1017 if (result == VK_SUCCESS) {
1018 CreateObject(device, *pQueryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, pAllocator);
1019 }
1020 }
1021 return result;
1022 }
1023
DestroyQueryPool(VkDevice device,VkQueryPool queryPool,const VkAllocationCallbacks * pAllocator)1024 VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) {
1025 bool skip_call = false;
1026 {
1027 std::lock_guard<std::mutex> lock(global_lock);
1028 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_01015);
1029 skip_call |= ValidateObject(device, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, true, VALIDATION_ERROR_01016);
1030 }
1031 if (skip_call) {
1032 return;
1033 }
1034 {
1035 std::lock_guard<std::mutex> lock(global_lock);
1036 DestroyObject(device, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, pAllocator);
1037 }
1038 get_dispatch_table(ot_device_table_map, device)->DestroyQueryPool(device, queryPool, pAllocator);
1039 }
1040
GetQueryPoolResults(VkDevice device,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,size_t dataSize,void * pData,VkDeviceSize stride,VkQueryResultFlags flags)1041 VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount,
1042 size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags) {
1043 bool skip_call = false;
1044 {
1045 std::lock_guard<std::mutex> lock(global_lock);
1046 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_01054);
1047 skip_call |= ValidateObject(device, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false, VALIDATION_ERROR_01055);
1048 }
1049 if (skip_call) {
1050 return VK_ERROR_VALIDATION_FAILED_EXT;
1051 }
1052 VkResult result = get_dispatch_table(ot_device_table_map, device)
1053 ->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
1054 return result;
1055 }
1056
CreateBuffer(VkDevice device,const VkBufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBuffer * pBuffer)1057 VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
1058 const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
1059 bool skip_call = false;
1060 {
1061 std::lock_guard<std::mutex> lock(global_lock);
1062 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00659);
1063 }
1064 if (skip_call) {
1065 return VK_ERROR_VALIDATION_FAILED_EXT;
1066 }
1067 VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
1068 {
1069 std::lock_guard<std::mutex> lock(global_lock);
1070 if (result == VK_SUCCESS) {
1071 CreateObject(device, *pBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, pAllocator);
1072 }
1073 }
1074 return result;
1075 }
1076
DestroyBuffer(VkDevice device,VkBuffer buffer,const VkAllocationCallbacks * pAllocator)1077 VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) {
1078 bool skip_call = false;
1079 {
1080 std::lock_guard<std::mutex> lock(global_lock);
1081 skip_call |= ValidateObject(device, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, true, VALIDATION_ERROR_00680);
1082 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00679);
1083 }
1084 if (skip_call) {
1085 return;
1086 }
1087 {
1088 std::lock_guard<std::mutex> lock(global_lock);
1089 DestroyObject(device, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, pAllocator);
1090 }
1091 get_dispatch_table(ot_device_table_map, device)->DestroyBuffer(device, buffer, pAllocator);
1092 }
1093
CreateBufferView(VkDevice device,const VkBufferViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBufferView * pView)1094 VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
1095 const VkAllocationCallbacks *pAllocator, VkBufferView *pView) {
1096 bool skip_call = false;
1097 {
1098 std::lock_guard<std::mutex> lock(global_lock);
1099 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00683);
1100 if (pCreateInfo) {
1101 skip_call |=
1102 ValidateObject(device, pCreateInfo->buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_00699);
1103 }
1104 }
1105 if (skip_call) {
1106 return VK_ERROR_VALIDATION_FAILED_EXT;
1107 }
1108 VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateBufferView(device, pCreateInfo, pAllocator, pView);
1109 {
1110 std::lock_guard<std::mutex> lock(global_lock);
1111 if (result == VK_SUCCESS) {
1112 CreateObject(device, *pView, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, pAllocator);
1113 }
1114 }
1115 return result;
1116 }
1117
DestroyBufferView(VkDevice device,VkBufferView bufferView,const VkAllocationCallbacks * pAllocator)1118 VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) {
1119 bool skip_call = false;
1120 {
1121 std::lock_guard<std::mutex> lock(global_lock);
1122 skip_call |= ValidateObject(device, bufferView, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, true, VALIDATION_ERROR_00705);
1123 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00704);
1124 }
1125 if (skip_call) {
1126 return;
1127 }
1128 {
1129 std::lock_guard<std::mutex> lock(global_lock);
1130 DestroyObject(device, bufferView, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, pAllocator);
1131 }
1132 get_dispatch_table(ot_device_table_map, device)->DestroyBufferView(device, bufferView, pAllocator);
1133 }
1134
CreateImage(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage)1135 VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
1136 const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
1137 bool skip_call = false;
1138 {
1139 std::lock_guard<std::mutex> lock(global_lock);
1140 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00709);
1141 }
1142 if (skip_call) {
1143 return VK_ERROR_VALIDATION_FAILED_EXT;
1144 }
1145 VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateImage(device, pCreateInfo, pAllocator, pImage);
1146 {
1147 std::lock_guard<std::mutex> lock(global_lock);
1148 if (result == VK_SUCCESS) {
1149 CreateObject(device, *pImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, pAllocator);
1150 }
1151 }
1152 return result;
1153 }
1154
DestroyImage(VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator)1155 VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
1156 bool skip_call = false;
1157 {
1158 std::lock_guard<std::mutex> lock(global_lock);
1159 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00746);
1160 skip_call |= ValidateObject(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, true, VALIDATION_ERROR_00747);
1161 }
1162 if (skip_call) {
1163 return;
1164 }
1165 {
1166 std::lock_guard<std::mutex> lock(global_lock);
1167 DestroyObject(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, pAllocator);
1168 }
1169 get_dispatch_table(ot_device_table_map, device)->DestroyImage(device, image, pAllocator);
1170 }
1171
GetImageSubresourceLayout(VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout)1172 VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource,
1173 VkSubresourceLayout *pLayout) {
1174 bool skip_call = false;
1175 {
1176 std::lock_guard<std::mutex> lock(global_lock);
1177 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00734);
1178 skip_call |= ValidateObject(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_00735);
1179 }
1180 if (skip_call) {
1181 return;
1182 }
1183 get_dispatch_table(ot_device_table_map, device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
1184 }
1185
CreateImageView(VkDevice device,const VkImageViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImageView * pView)1186 VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
1187 const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
1188 bool skip_call = false;
1189 {
1190 std::lock_guard<std::mutex> lock(global_lock);
1191 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00750);
1192 if (pCreateInfo) {
1193 skip_call |=
1194 ValidateObject(device, pCreateInfo->image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_00763);
1195 }
1196 }
1197 if (skip_call) {
1198 return VK_ERROR_VALIDATION_FAILED_EXT;
1199 }
1200 VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateImageView(device, pCreateInfo, pAllocator, pView);
1201 {
1202 std::lock_guard<std::mutex> lock(global_lock);
1203 if (result == VK_SUCCESS) {
1204 CreateObject(device, *pView, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, pAllocator);
1205 }
1206 }
1207 return result;
1208 }
1209
DestroyImageView(VkDevice device,VkImageView imageView,const VkAllocationCallbacks * pAllocator)1210 VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) {
1211 bool skip_call = false;
1212 {
1213 std::lock_guard<std::mutex> lock(global_lock);
1214 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00779);
1215 skip_call |= ValidateObject(device, imageView, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, true, VALIDATION_ERROR_00780);
1216 }
1217 if (skip_call) {
1218 return;
1219 }
1220 {
1221 std::lock_guard<std::mutex> lock(global_lock);
1222 DestroyObject(device, imageView, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, pAllocator);
1223 }
1224 get_dispatch_table(ot_device_table_map, device)->DestroyImageView(device, imageView, pAllocator);
1225 }
1226
CreateShaderModule(VkDevice device,const VkShaderModuleCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkShaderModule * pShaderModule)1227 VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo,
1228 const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule) {
1229 bool skip_call = false;
1230 {
1231 std::lock_guard<std::mutex> lock(global_lock);
1232 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00466);
1233 }
1234 if (skip_call) {
1235 return VK_ERROR_VALIDATION_FAILED_EXT;
1236 }
1237 VkResult result =
1238 get_dispatch_table(ot_device_table_map, device)->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
1239 {
1240 std::lock_guard<std::mutex> lock(global_lock);
1241 if (result == VK_SUCCESS) {
1242 CreateObject(device, *pShaderModule, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, pAllocator);
1243 }
1244 }
1245 return result;
1246 }
1247
DestroyShaderModule(VkDevice device,VkShaderModule shaderModule,const VkAllocationCallbacks * pAllocator)1248 VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
1249 const VkAllocationCallbacks *pAllocator) {
1250 bool skip_call = false;
1251 {
1252 std::lock_guard<std::mutex> lock(global_lock);
1253 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00481);
1254 skip_call |=
1255 ValidateObject(device, shaderModule, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, true, VALIDATION_ERROR_00482);
1256 }
1257 if (skip_call) {
1258 return;
1259 }
1260 {
1261 std::lock_guard<std::mutex> lock(global_lock);
1262 DestroyObject(device, shaderModule, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, pAllocator);
1263 }
1264 get_dispatch_table(ot_device_table_map, device)->DestroyShaderModule(device, shaderModule, pAllocator);
1265 }
1266
CreatePipelineCache(VkDevice device,const VkPipelineCacheCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineCache * pPipelineCache)1267 VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo,
1268 const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache) {
1269 bool skip_call = false;
1270 {
1271 std::lock_guard<std::mutex> lock(global_lock);
1272 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00562);
1273 }
1274 if (skip_call) {
1275 return VK_ERROR_VALIDATION_FAILED_EXT;
1276 }
1277 VkResult result =
1278 get_dispatch_table(ot_device_table_map, device)->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
1279 {
1280 std::lock_guard<std::mutex> lock(global_lock);
1281 if (result == VK_SUCCESS) {
1282 CreateObject(device, *pPipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, pAllocator);
1283 }
1284 }
1285 return result;
1286 }
1287
DestroyPipelineCache(VkDevice device,VkPipelineCache pipelineCache,const VkAllocationCallbacks * pAllocator)1288 VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
1289 const VkAllocationCallbacks *pAllocator) {
1290 bool skip_call = false;
1291 {
1292 std::lock_guard<std::mutex> lock(global_lock);
1293 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00585);
1294 skip_call |=
1295 ValidateObject(device, pipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, true, VALIDATION_ERROR_00586);
1296 }
1297 if (skip_call) {
1298 return;
1299 }
1300 {
1301 std::lock_guard<std::mutex> lock(global_lock);
1302 DestroyObject(device, pipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, pAllocator);
1303 }
1304 get_dispatch_table(ot_device_table_map, device)->DestroyPipelineCache(device, pipelineCache, pAllocator);
1305 }
1306
GetPipelineCacheData(VkDevice device,VkPipelineCache pipelineCache,size_t * pDataSize,void * pData)1307 VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize,
1308 void *pData) {
1309 bool skip_call = false;
1310 {
1311 std::lock_guard<std::mutex> lock(global_lock);
1312 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00578);
1313 skip_call |=
1314 ValidateObject(device, pipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, false, VALIDATION_ERROR_00579);
1315 }
1316 if (skip_call) {
1317 return VK_ERROR_VALIDATION_FAILED_EXT;
1318 }
1319 VkResult result =
1320 get_dispatch_table(ot_device_table_map, device)->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
1321 return result;
1322 }
1323
MergePipelineCaches(VkDevice device,VkPipelineCache dstCache,uint32_t srcCacheCount,const VkPipelineCache * pSrcCaches)1324 VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount,
1325 const VkPipelineCache *pSrcCaches) {
1326 bool skip_call = false;
1327 {
1328 std::lock_guard<std::mutex> lock(global_lock);
1329 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00572);
1330 skip_call |=
1331 ValidateObject(device, dstCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, false, VALIDATION_ERROR_00573);
1332 if (pSrcCaches) {
1333 for (uint32_t idx0 = 0; idx0 < srcCacheCount; ++idx0) {
1334 skip_call |= ValidateObject(device, pSrcCaches[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, false,
1335 VALIDATION_ERROR_00577);
1336 }
1337 }
1338 }
1339 if (skip_call) {
1340 return VK_ERROR_VALIDATION_FAILED_EXT;
1341 }
1342 VkResult result =
1343 get_dispatch_table(ot_device_table_map, device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
1344 return result;
1345 }
1346
DestroyPipeline(VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator)1347 VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) {
1348 bool skip_call = false;
1349 {
1350 std::lock_guard<std::mutex> lock(global_lock);
1351 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00558);
1352 skip_call |= ValidateObject(device, pipeline, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, true, VALIDATION_ERROR_00559);
1353 }
1354 if (skip_call) {
1355 return;
1356 }
1357 {
1358 std::lock_guard<std::mutex> lock(global_lock);
1359 DestroyObject(device, pipeline, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, pAllocator);
1360 }
1361 get_dispatch_table(ot_device_table_map, device)->DestroyPipeline(device, pipeline, pAllocator);
1362 }
1363
CreatePipelineLayout(VkDevice device,const VkPipelineLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineLayout * pPipelineLayout)1364 VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo,
1365 const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout) {
1366 bool skip_call = false;
1367 {
1368 std::lock_guard<std::mutex> lock(global_lock);
1369 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00861);
1370 if (pCreateInfo) {
1371 if (pCreateInfo->pSetLayouts) {
1372 for (uint32_t idx0 = 0; idx0 < pCreateInfo->setLayoutCount; ++idx0) {
1373 skip_call |=
1374 ValidateObject(device, pCreateInfo->pSetLayouts[idx0],
1375 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, false, VALIDATION_ERROR_00875);
1376 }
1377 }
1378 }
1379 }
1380 if (skip_call) {
1381 return VK_ERROR_VALIDATION_FAILED_EXT;
1382 }
1383 VkResult result =
1384 get_dispatch_table(ot_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
1385 {
1386 std::lock_guard<std::mutex> lock(global_lock);
1387 if (result == VK_SUCCESS) {
1388 CreateObject(device, *pPipelineLayout, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, pAllocator);
1389 }
1390 }
1391 return result;
1392 }
1393
DestroyPipelineLayout(VkDevice device,VkPipelineLayout pipelineLayout,const VkAllocationCallbacks * pAllocator)1394 VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
1395 const VkAllocationCallbacks *pAllocator) {
1396 bool skip_call = false;
1397 {
1398 std::lock_guard<std::mutex> lock(global_lock);
1399 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00885);
1400 skip_call |=
1401 ValidateObject(device, pipelineLayout, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, true, VALIDATION_ERROR_00886);
1402 }
1403 if (skip_call) {
1404 return;
1405 }
1406 {
1407 std::lock_guard<std::mutex> lock(global_lock);
1408 DestroyObject(device, pipelineLayout, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, pAllocator);
1409 }
1410 get_dispatch_table(ot_device_table_map, device)->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
1411 }
1412
CreateSampler(VkDevice device,const VkSamplerCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSampler * pSampler)1413 VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
1414 const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) {
1415 bool skip_call = false;
1416 {
1417 std::lock_guard<std::mutex> lock(global_lock);
1418 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00812);
1419 }
1420 if (skip_call) {
1421 return VK_ERROR_VALIDATION_FAILED_EXT;
1422 }
1423 VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
1424 {
1425 std::lock_guard<std::mutex> lock(global_lock);
1426 if (result == VK_SUCCESS) {
1427 CreateObject(device, *pSampler, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, pAllocator);
1428 }
1429 }
1430 return result;
1431 }
1432
DestroySampler(VkDevice device,VkSampler sampler,const VkAllocationCallbacks * pAllocator)1433 VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) {
1434 bool skip_call = false;
1435 {
1436 std::lock_guard<std::mutex> lock(global_lock);
1437 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00840);
1438 skip_call |= ValidateObject(device, sampler, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, true, VALIDATION_ERROR_00841);
1439 }
1440 if (skip_call) {
1441 return;
1442 }
1443 {
1444 std::lock_guard<std::mutex> lock(global_lock);
1445 DestroyObject(device, sampler, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, pAllocator);
1446 }
1447 get_dispatch_table(ot_device_table_map, device)->DestroySampler(device, sampler, pAllocator);
1448 }
1449
CreateDescriptorSetLayout(VkDevice device,const VkDescriptorSetLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorSetLayout * pSetLayout)1450 VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
1451 const VkAllocationCallbacks *pAllocator,
1452 VkDescriptorSetLayout *pSetLayout) {
1453 bool skip_call = false;
1454 {
1455 std::lock_guard<std::mutex> lock(global_lock);
1456 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00844);
1457 if (pCreateInfo) {
1458 if (pCreateInfo->pBindings) {
1459 for (uint32_t idx0 = 0; idx0 < pCreateInfo->bindingCount; ++idx0) {
1460 if ((pCreateInfo->pBindings[idx0].descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) ||
1461 (pCreateInfo->pBindings[idx0].descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)) {
1462 if (pCreateInfo->pBindings[idx0].pImmutableSamplers) {
1463 for (uint32_t idx1 = 0; idx1 < pCreateInfo->pBindings[idx0].descriptorCount; ++idx1) {
1464 skip_call |= ValidateObject(device, pCreateInfo->pBindings[idx0].pImmutableSamplers[idx1],
1465 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, false, VALIDATION_ERROR_00852);
1466 }
1467 }
1468 }
1469 }
1470 }
1471 }
1472 }
1473 if (skip_call) {
1474 return VK_ERROR_VALIDATION_FAILED_EXT;
1475 }
1476 VkResult result =
1477 get_dispatch_table(ot_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
1478 {
1479 std::lock_guard<std::mutex> lock(global_lock);
1480 if (result == VK_SUCCESS) {
1481 CreateObject(device, *pSetLayout, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, pAllocator);
1482 }
1483 }
1484 return result;
1485 }
1486
DestroyDescriptorSetLayout(VkDevice device,VkDescriptorSetLayout descriptorSetLayout,const VkAllocationCallbacks * pAllocator)1487 VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
1488 const VkAllocationCallbacks *pAllocator) {
1489 bool skip_call = false;
1490 {
1491 std::lock_guard<std::mutex> lock(global_lock);
1492 skip_call |= ValidateObject(device, descriptorSetLayout, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, true,
1493 VALIDATION_ERROR_00858);
1494 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00857);
1495 }
1496 if (skip_call) {
1497 return;
1498 }
1499 {
1500 std::lock_guard<std::mutex> lock(global_lock);
1501 DestroyObject(device, descriptorSetLayout, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, pAllocator);
1502 }
1503 get_dispatch_table(ot_device_table_map, device)->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
1504 }
1505
CreateDescriptorPool(VkDevice device,const VkDescriptorPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorPool * pDescriptorPool)1506 VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo,
1507 const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) {
1508 bool skip_call = false;
1509 {
1510 std::lock_guard<std::mutex> lock(global_lock);
1511 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00889);
1512 }
1513 if (skip_call) {
1514 return VK_ERROR_VALIDATION_FAILED_EXT;
1515 }
1516 VkResult result =
1517 get_dispatch_table(ot_device_table_map, device)->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
1518 {
1519 std::lock_guard<std::mutex> lock(global_lock);
1520 if (result == VK_SUCCESS) {
1521 CreateObject(device, *pDescriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, pAllocator);
1522 }
1523 }
1524 return result;
1525 }
1526
ResetDescriptorPool(VkDevice device,VkDescriptorPool descriptorPool,VkDescriptorPoolResetFlags flags)1527 VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
1528 VkDescriptorPoolResetFlags flags) {
1529 bool skip_call = false;
1530 std::unique_lock<std::mutex> lock(global_lock);
1531 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
1532 skip_call |=
1533 ValidateObject(device, descriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, false, VALIDATION_ERROR_00930);
1534 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00929);
1535 if (skip_call) {
1536 return VK_ERROR_VALIDATION_FAILED_EXT;
1537 }
1538 // A DescriptorPool's descriptor sets are implicitly deleted when the pool is reset.
1539 // Remove this pool's descriptor sets from our descriptorSet map.
1540 auto itr = device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT].begin();
1541 while (itr != device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT].end()) {
1542 OBJTRACK_NODE *pNode = (*itr).second;
1543 auto del_itr = itr++;
1544 if (pNode->parent_object == reinterpret_cast<uint64_t &>(descriptorPool)) {
1545 DestroyObject(device, (VkDescriptorSet)((*del_itr).first),
1546 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, nullptr);
1547 }
1548 }
1549 lock.unlock();
1550 VkResult result = get_dispatch_table(ot_device_table_map, device)->ResetDescriptorPool(device, descriptorPool, flags);
1551 return result;
1552 }
1553
UpdateDescriptorSets(VkDevice device,uint32_t descriptorWriteCount,const VkWriteDescriptorSet * pDescriptorWrites,uint32_t descriptorCopyCount,const VkCopyDescriptorSet * pDescriptorCopies)1554 VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
1555 const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount,
1556 const VkCopyDescriptorSet *pDescriptorCopies) {
1557 bool skip_call = false;
1558 {
1559 std::lock_guard<std::mutex> lock(global_lock);
1560 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00933);
1561 if (pDescriptorCopies) {
1562 for (uint32_t idx0 = 0; idx0 < descriptorCopyCount; ++idx0) {
1563 if (pDescriptorCopies[idx0].dstSet) {
1564 skip_call |= ValidateObject(device, pDescriptorCopies[idx0].dstSet,
1565 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, false, VALIDATION_ERROR_00972);
1566 }
1567 if (pDescriptorCopies[idx0].srcSet) {
1568 skip_call |= ValidateObject(device, pDescriptorCopies[idx0].srcSet,
1569 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, false, VALIDATION_ERROR_00971);
1570 }
1571 }
1572 }
1573 if (pDescriptorWrites) {
1574 for (uint32_t idx1 = 0; idx1 < descriptorWriteCount; ++idx1) {
1575 if (pDescriptorWrites[idx1].dstSet) {
1576 skip_call |= ValidateObject(device, pDescriptorWrites[idx1].dstSet,
1577 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, false, VALIDATION_ERROR_00955);
1578 }
1579 if ((pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) ||
1580 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)) {
1581 for (uint32_t idx2 = 0; idx2 < pDescriptorWrites[idx1].descriptorCount; ++idx2) {
1582 skip_call |= ValidateObject(device, pDescriptorWrites[idx1].pTexelBufferView[idx2],
1583 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, false, VALIDATION_ERROR_00940);
1584 }
1585 }
1586 if ((pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) ||
1587 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) ||
1588 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) ||
1589 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)) {
1590 for (uint32_t idx3 = 0; idx3 < pDescriptorWrites[idx1].descriptorCount; ++idx3) {
1591 if (pDescriptorWrites[idx1].pImageInfo[idx3].imageView) {
1592 skip_call |= ValidateObject(device, pDescriptorWrites[idx1].pImageInfo[idx3].imageView,
1593 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, false, VALIDATION_ERROR_00943);
1594 }
1595 }
1596 }
1597 if ((pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) ||
1598 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) ||
1599 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) ||
1600 (pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) {
1601 for (uint32_t idx4 = 0; idx4 < pDescriptorWrites[idx1].descriptorCount; ++idx4) {
1602 if (pDescriptorWrites[idx1].pBufferInfo[idx4].buffer) {
1603 skip_call |= ValidateObject(device, pDescriptorWrites[idx1].pBufferInfo[idx4].buffer,
1604 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_00962);
1605 }
1606 }
1607 }
1608 }
1609 }
1610 }
1611 if (skip_call) {
1612 return;
1613 }
1614 get_dispatch_table(ot_device_table_map, device)
1615 ->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
1616 }
1617
CreateFramebuffer(VkDevice device,const VkFramebufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFramebuffer * pFramebuffer)1618 VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
1619 const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer) {
1620 bool skip_call = false;
1621 {
1622 std::lock_guard<std::mutex> lock(global_lock);
1623 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00400);
1624 if (pCreateInfo) {
1625 if (pCreateInfo->pAttachments) {
1626 for (uint32_t idx0 = 0; idx0 < pCreateInfo->attachmentCount; ++idx0) {
1627 skip_call |= ValidateObject(device, pCreateInfo->pAttachments[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
1628 false, VALIDATION_ERROR_00420);
1629 }
1630 }
1631 if (pCreateInfo->renderPass) {
1632 skip_call |= ValidateObject(device, pCreateInfo->renderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, false,
1633 VALIDATION_ERROR_00419);
1634 }
1635 }
1636 }
1637 if (skip_call) {
1638 return VK_ERROR_VALIDATION_FAILED_EXT;
1639 }
1640 VkResult result =
1641 get_dispatch_table(ot_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
1642 {
1643 std::lock_guard<std::mutex> lock(global_lock);
1644 if (result == VK_SUCCESS) {
1645 CreateObject(device, *pFramebuffer, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, pAllocator);
1646 }
1647 }
1648 return result;
1649 }
1650
DestroyFramebuffer(VkDevice device,VkFramebuffer framebuffer,const VkAllocationCallbacks * pAllocator)1651 VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) {
1652 bool skip_call = false;
1653 {
1654 std::lock_guard<std::mutex> lock(global_lock);
1655 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00425);
1656 skip_call |= ValidateObject(device, framebuffer, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, true, VALIDATION_ERROR_00426);
1657 }
1658 if (skip_call) {
1659 return;
1660 }
1661 {
1662 std::lock_guard<std::mutex> lock(global_lock);
1663 DestroyObject(device, framebuffer, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, pAllocator);
1664 }
1665 get_dispatch_table(ot_device_table_map, device)->DestroyFramebuffer(device, framebuffer, pAllocator);
1666 }
1667
CreateRenderPass(VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass)1668 VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
1669 const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) {
1670 bool skip_call = false;
1671 {
1672 std::lock_guard<std::mutex> lock(global_lock);
1673 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00319);
1674 }
1675 if (skip_call) {
1676 return VK_ERROR_VALIDATION_FAILED_EXT;
1677 }
1678 VkResult result =
1679 get_dispatch_table(ot_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
1680 {
1681 std::lock_guard<std::mutex> lock(global_lock);
1682 if (result == VK_SUCCESS) {
1683 CreateObject(device, *pRenderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, pAllocator);
1684 }
1685 }
1686 return result;
1687 }
1688
DestroyRenderPass(VkDevice device,VkRenderPass renderPass,const VkAllocationCallbacks * pAllocator)1689 VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) {
1690 bool skip_call = false;
1691 {
1692 std::lock_guard<std::mutex> lock(global_lock);
1693 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00396);
1694 skip_call |= ValidateObject(device, renderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, true, VALIDATION_ERROR_00397);
1695 }
1696 if (skip_call) {
1697 return;
1698 }
1699 {
1700 std::lock_guard<std::mutex> lock(global_lock);
1701 DestroyObject(device, renderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, pAllocator);
1702 }
1703 get_dispatch_table(ot_device_table_map, device)->DestroyRenderPass(device, renderPass, pAllocator);
1704 }
1705
GetRenderAreaGranularity(VkDevice device,VkRenderPass renderPass,VkExtent2D * pGranularity)1706 VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity) {
1707 bool skip_call = false;
1708 {
1709 std::lock_guard<std::mutex> lock(global_lock);
1710 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00449);
1711 skip_call |= ValidateObject(device, renderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, false, VALIDATION_ERROR_00450);
1712 }
1713 if (skip_call) {
1714 return;
1715 }
1716 get_dispatch_table(ot_device_table_map, device)->GetRenderAreaGranularity(device, renderPass, pGranularity);
1717 }
1718
CreateCommandPool(VkDevice device,const VkCommandPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkCommandPool * pCommandPool)1719 VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
1720 const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool) {
1721 bool skip_call = false;
1722 {
1723 std::lock_guard<std::mutex> lock(global_lock);
1724 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00064);
1725 }
1726 if (skip_call) {
1727 return VK_ERROR_VALIDATION_FAILED_EXT;
1728 }
1729 VkResult result =
1730 get_dispatch_table(ot_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
1731 {
1732 std::lock_guard<std::mutex> lock(global_lock);
1733 if (result == VK_SUCCESS) {
1734 CreateObject(device, *pCommandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, pAllocator);
1735 }
1736 }
1737 return result;
1738 }
1739
ResetCommandPool(VkDevice device,VkCommandPool commandPool,VkCommandPoolResetFlags flags)1740 VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
1741 bool skip_call = false;
1742 {
1743 std::lock_guard<std::mutex> lock(global_lock);
1744 skip_call |=
1745 ValidateObject(device, commandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, false, VALIDATION_ERROR_00074);
1746 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00073);
1747 }
1748 if (skip_call) {
1749 return VK_ERROR_VALIDATION_FAILED_EXT;
1750 }
1751 VkResult result = get_dispatch_table(ot_device_table_map, device)->ResetCommandPool(device, commandPool, flags);
1752 return result;
1753 }
1754
BeginCommandBuffer(VkCommandBuffer command_buffer,const VkCommandBufferBeginInfo * begin_info)1755 VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer command_buffer, const VkCommandBufferBeginInfo *begin_info) {
1756 layer_data *device_data = get_my_data_ptr(get_dispatch_key(command_buffer), layer_data_map);
1757 bool skip_call = false;
1758 {
1759 std::lock_guard<std::mutex> lock(global_lock);
1760 skip_call |= ValidateObject(command_buffer, command_buffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1761 VALIDATION_ERROR_00108);
1762 if (begin_info) {
1763 OBJTRACK_NODE *pNode =
1764 device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT][reinterpret_cast<const uint64_t>(command_buffer)];
1765 if ((begin_info->pInheritanceInfo) && (pNode->status & OBJSTATUS_COMMAND_BUFFER_SECONDARY)) {
1766 skip_call |= ValidateObject(command_buffer, begin_info->pInheritanceInfo->framebuffer,
1767 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, true);
1768 skip_call |= ValidateObject(command_buffer, begin_info->pInheritanceInfo->renderPass,
1769 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, true);
1770 }
1771 }
1772 }
1773 if (skip_call) {
1774 return VK_ERROR_VALIDATION_FAILED_EXT;
1775 }
1776 VkResult result = get_dispatch_table(ot_device_table_map, command_buffer)->BeginCommandBuffer(command_buffer, begin_info);
1777 return result;
1778 }
1779
EndCommandBuffer(VkCommandBuffer commandBuffer)1780 VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) {
1781 bool skip_call = false;
1782 {
1783 std::lock_guard<std::mutex> lock(global_lock);
1784 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1785 VALIDATION_ERROR_00125);
1786 }
1787 if (skip_call) {
1788 return VK_ERROR_VALIDATION_FAILED_EXT;
1789 }
1790 VkResult result = get_dispatch_table(ot_device_table_map, commandBuffer)->EndCommandBuffer(commandBuffer);
1791 return result;
1792 }
1793
ResetCommandBuffer(VkCommandBuffer commandBuffer,VkCommandBufferResetFlags flags)1794 VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
1795 bool skip_call = false;
1796 {
1797 std::lock_guard<std::mutex> lock(global_lock);
1798 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1799 VALIDATION_ERROR_00090);
1800 }
1801 if (skip_call) {
1802 return VK_ERROR_VALIDATION_FAILED_EXT;
1803 }
1804 VkResult result = get_dispatch_table(ot_device_table_map, commandBuffer)->ResetCommandBuffer(commandBuffer, flags);
1805 return result;
1806 }
1807
CmdBindPipeline(VkCommandBuffer commandBuffer,VkPipelineBindPoint pipelineBindPoint,VkPipeline pipeline)1808 VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
1809 VkPipeline pipeline) {
1810 bool skip_call = false;
1811 {
1812 std::lock_guard<std::mutex> lock(global_lock);
1813 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1814 VALIDATION_ERROR_00599);
1815 skip_call |=
1816 ValidateObject(commandBuffer, pipeline, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, false, VALIDATION_ERROR_00601);
1817 }
1818 if (skip_call) {
1819 return;
1820 }
1821 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
1822 }
1823
CmdSetViewport(VkCommandBuffer commandBuffer,uint32_t firstViewport,uint32_t viewportCount,const VkViewport * pViewports)1824 VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount,
1825 const VkViewport *pViewports) {
1826 bool skip_call = false;
1827 {
1828 std::lock_guard<std::mutex> lock(global_lock);
1829 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1830 VALIDATION_ERROR_01443);
1831 }
1832 if (skip_call) {
1833 return;
1834 }
1835 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
1836 }
1837
CmdSetScissor(VkCommandBuffer commandBuffer,uint32_t firstScissor,uint32_t scissorCount,const VkRect2D * pScissors)1838 VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount,
1839 const VkRect2D *pScissors) {
1840 bool skip_call = false;
1841 {
1842 std::lock_guard<std::mutex> lock(global_lock);
1843 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1844 VALIDATION_ERROR_01492);
1845 }
1846 if (skip_call) {
1847 return;
1848 }
1849 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
1850 }
1851
CmdSetLineWidth(VkCommandBuffer commandBuffer,float lineWidth)1852 VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
1853 bool skip_call = false;
1854 {
1855 std::lock_guard<std::mutex> lock(global_lock);
1856 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1857 VALIDATION_ERROR_01478);
1858 }
1859 if (skip_call) {
1860 return;
1861 }
1862 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetLineWidth(commandBuffer, lineWidth);
1863 }
1864
CmdSetDepthBias(VkCommandBuffer commandBuffer,float depthBiasConstantFactor,float depthBiasClamp,float depthBiasSlopeFactor)1865 VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp,
1866 float depthBiasSlopeFactor) {
1867 bool skip_call = false;
1868 {
1869 std::lock_guard<std::mutex> lock(global_lock);
1870 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1871 VALIDATION_ERROR_01483);
1872 }
1873 if (skip_call) {
1874 return;
1875 }
1876 get_dispatch_table(ot_device_table_map, commandBuffer)
1877 ->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
1878 }
1879
CmdSetBlendConstants(VkCommandBuffer commandBuffer,const float blendConstants[4])1880 VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
1881 bool skip_call = false;
1882 {
1883 std::lock_guard<std::mutex> lock(global_lock);
1884 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1885 VALIDATION_ERROR_01551);
1886 }
1887 if (skip_call) {
1888 return;
1889 }
1890 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants);
1891 }
1892
CmdSetDepthBounds(VkCommandBuffer commandBuffer,float minDepthBounds,float maxDepthBounds)1893 VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
1894 bool skip_call = false;
1895 {
1896 std::lock_guard<std::mutex> lock(global_lock);
1897 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1898 VALIDATION_ERROR_01507);
1899 }
1900 if (skip_call) {
1901 return;
1902 }
1903 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
1904 }
1905
CmdSetStencilCompareMask(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,uint32_t compareMask)1906 VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
1907 uint32_t compareMask) {
1908 bool skip_call = false;
1909 {
1910 std::lock_guard<std::mutex> lock(global_lock);
1911 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1912 VALIDATION_ERROR_01515);
1913 }
1914 if (skip_call) {
1915 return;
1916 }
1917 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
1918 }
1919
CmdSetStencilWriteMask(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,uint32_t writeMask)1920 VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
1921 bool skip_call = false;
1922 {
1923 std::lock_guard<std::mutex> lock(global_lock);
1924 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1925 VALIDATION_ERROR_01521);
1926 }
1927 if (skip_call) {
1928 return;
1929 }
1930 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
1931 }
1932
CmdSetStencilReference(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,uint32_t reference)1933 VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
1934 bool skip_call = false;
1935 {
1936 std::lock_guard<std::mutex> lock(global_lock);
1937 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1938 VALIDATION_ERROR_01527);
1939 }
1940 if (skip_call) {
1941 return;
1942 }
1943 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, reference);
1944 }
1945
CmdBindDescriptorSets(VkCommandBuffer commandBuffer,VkPipelineBindPoint pipelineBindPoint,VkPipelineLayout layout,uint32_t firstSet,uint32_t descriptorSetCount,const VkDescriptorSet * pDescriptorSets,uint32_t dynamicOffsetCount,const uint32_t * pDynamicOffsets)1946 VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
1947 VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount,
1948 const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount,
1949 const uint32_t *pDynamicOffsets) {
1950 bool skip_call = false;
1951 {
1952 std::lock_guard<std::mutex> lock(global_lock);
1953 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1954 VALIDATION_ERROR_00979);
1955 skip_call |=
1956 ValidateObject(commandBuffer, layout, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, false, VALIDATION_ERROR_00981);
1957 if (pDescriptorSets) {
1958 for (uint32_t idx0 = 0; idx0 < descriptorSetCount; ++idx0) {
1959 skip_call |= ValidateObject(commandBuffer, pDescriptorSets[idx0],
1960 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, false);
1961 }
1962 }
1963 }
1964 if (skip_call) {
1965 return;
1966 }
1967 get_dispatch_table(ot_device_table_map, commandBuffer)
1968 ->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets,
1969 dynamicOffsetCount, pDynamicOffsets);
1970 }
1971
CmdBindIndexBuffer(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkIndexType indexType)1972 VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
1973 VkIndexType indexType) {
1974 bool skip_call = false;
1975 {
1976 std::lock_guard<std::mutex> lock(global_lock);
1977 skip_call |= ValidateObject(commandBuffer, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_01354);
1978 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1979 VALIDATION_ERROR_01353);
1980 }
1981 if (skip_call) {
1982 return;
1983 }
1984 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
1985 }
1986
CmdBindVertexBuffers(VkCommandBuffer commandBuffer,uint32_t firstBinding,uint32_t bindingCount,const VkBuffer * pBuffers,const VkDeviceSize * pOffsets)1987 VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
1988 const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) {
1989 bool skip_call = false;
1990 {
1991 std::lock_guard<std::mutex> lock(global_lock);
1992 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
1993 VALIDATION_ERROR_01419);
1994 if (pBuffers) {
1995 for (uint32_t idx0 = 0; idx0 < bindingCount; ++idx0) {
1996 skip_call |=
1997 ValidateObject(commandBuffer, pBuffers[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false);
1998 }
1999 }
2000 }
2001 if (skip_call) {
2002 return;
2003 }
2004 get_dispatch_table(ot_device_table_map, commandBuffer)
2005 ->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
2006 }
2007
CmdDraw(VkCommandBuffer commandBuffer,uint32_t vertexCount,uint32_t instanceCount,uint32_t firstVertex,uint32_t firstInstance)2008 VKAPI_ATTR void VKAPI_CALL CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
2009 uint32_t firstVertex, uint32_t firstInstance) {
2010 bool skip_call = false;
2011 {
2012 std::lock_guard<std::mutex> lock(global_lock);
2013 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2014 VALIDATION_ERROR_01362);
2015 }
2016 if (skip_call) {
2017 return;
2018 }
2019 get_dispatch_table(ot_device_table_map, commandBuffer)
2020 ->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
2021 }
2022
CmdDrawIndexed(VkCommandBuffer commandBuffer,uint32_t indexCount,uint32_t instanceCount,uint32_t firstIndex,int32_t vertexOffset,uint32_t firstInstance)2023 VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
2024 uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
2025 bool skip_call = false;
2026 {
2027 std::lock_guard<std::mutex> lock(global_lock);
2028 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2029 VALIDATION_ERROR_01369);
2030 }
2031 if (skip_call) {
2032 return;
2033 }
2034 get_dispatch_table(ot_device_table_map, commandBuffer)
2035 ->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
2036 }
2037
CmdDrawIndirect(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,uint32_t drawCount,uint32_t stride)2038 VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount,
2039 uint32_t stride) {
2040 bool skip_call = false;
2041 {
2042 std::lock_guard<std::mutex> lock(global_lock);
2043 skip_call |= ValidateObject(commandBuffer, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_01378);
2044 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2045 VALIDATION_ERROR_01377);
2046 }
2047 if (skip_call) {
2048 return;
2049 }
2050 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
2051 }
2052
CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,uint32_t drawCount,uint32_t stride)2053 VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
2054 uint32_t drawCount, uint32_t stride) {
2055 bool skip_call = false;
2056 {
2057 std::lock_guard<std::mutex> lock(global_lock);
2058 skip_call |= ValidateObject(commandBuffer, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_01390);
2059 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2060 VALIDATION_ERROR_01389);
2061 }
2062 if (skip_call) {
2063 return;
2064 }
2065 get_dispatch_table(ot_device_table_map, commandBuffer)
2066 ->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
2067 }
2068
CmdDispatch(VkCommandBuffer commandBuffer,uint32_t x,uint32_t y,uint32_t z)2069 VKAPI_ATTR void VKAPI_CALL CmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
2070 bool skip_call = false;
2071 {
2072 std::lock_guard<std::mutex> lock(global_lock);
2073 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2074 VALIDATION_ERROR_01559);
2075 }
2076 if (skip_call) {
2077 return;
2078 }
2079 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDispatch(commandBuffer, x, y, z);
2080 }
2081
CmdDispatchIndirect(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset)2082 VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
2083 bool skip_call = false;
2084 {
2085 std::lock_guard<std::mutex> lock(global_lock);
2086 skip_call |= ValidateObject(commandBuffer, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_01566);
2087 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2088 VALIDATION_ERROR_01565);
2089 }
2090 if (skip_call) {
2091 return;
2092 }
2093 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDispatchIndirect(commandBuffer, buffer, offset);
2094 }
2095
CmdCopyBuffer(VkCommandBuffer commandBuffer,VkBuffer srcBuffer,VkBuffer dstBuffer,uint32_t regionCount,const VkBufferCopy * pRegions)2096 VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
2097 uint32_t regionCount, const VkBufferCopy *pRegions) {
2098 bool skip_call = false;
2099 {
2100 std::lock_guard<std::mutex> lock(global_lock);
2101 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2102 VALIDATION_ERROR_01166);
2103 skip_call |=
2104 ValidateObject(commandBuffer, dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_01168);
2105 skip_call |=
2106 ValidateObject(commandBuffer, srcBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_01167);
2107 }
2108 if (skip_call) {
2109 return;
2110 }
2111 get_dispatch_table(ot_device_table_map, commandBuffer)
2112 ->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
2113 }
2114
CmdCopyImage(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkImageCopy * pRegions)2115 VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
2116 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
2117 const VkImageCopy *pRegions) {
2118 bool skip_call = false;
2119 {
2120 std::lock_guard<std::mutex> lock(global_lock);
2121 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2122 VALIDATION_ERROR_01186);
2123 skip_call |= ValidateObject(commandBuffer, dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_01189);
2124 skip_call |= ValidateObject(commandBuffer, srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_01187);
2125 }
2126 if (skip_call) {
2127 return;
2128 }
2129 get_dispatch_table(ot_device_table_map, commandBuffer)
2130 ->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
2131 }
2132
CmdBlitImage(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkImageBlit * pRegions,VkFilter filter)2133 VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
2134 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
2135 const VkImageBlit *pRegions, VkFilter filter) {
2136 bool skip_call = false;
2137 {
2138 std::lock_guard<std::mutex> lock(global_lock);
2139 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2140 VALIDATION_ERROR_01291);
2141 skip_call |= ValidateObject(commandBuffer, dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_01294);
2142 skip_call |= ValidateObject(commandBuffer, srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_01292);
2143 }
2144 if (skip_call) {
2145 return;
2146 }
2147 get_dispatch_table(ot_device_table_map, commandBuffer)
2148 ->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
2149 }
2150
CmdCopyBufferToImage(VkCommandBuffer commandBuffer,VkBuffer srcBuffer,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkBufferImageCopy * pRegions)2151 VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
2152 VkImageLayout dstImageLayout, uint32_t regionCount,
2153 const VkBufferImageCopy *pRegions) {
2154 bool skip_call = false;
2155 {
2156 std::lock_guard<std::mutex> lock(global_lock);
2157 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2158 VALIDATION_ERROR_01235);
2159 skip_call |= ValidateObject(commandBuffer, dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_01237);
2160 skip_call |=
2161 ValidateObject(commandBuffer, srcBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_01236);
2162 }
2163 if (skip_call) {
2164 return;
2165 }
2166 get_dispatch_table(ot_device_table_map, commandBuffer)
2167 ->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
2168 }
2169
CmdCopyImageToBuffer(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkBuffer dstBuffer,uint32_t regionCount,const VkBufferImageCopy * pRegions)2170 VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
2171 VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
2172 bool skip_call = false;
2173 {
2174 std::lock_guard<std::mutex> lock(global_lock);
2175 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2176 VALIDATION_ERROR_01253);
2177 skip_call |=
2178 ValidateObject(commandBuffer, dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_01256);
2179 skip_call |= ValidateObject(commandBuffer, srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_01254);
2180 }
2181 if (skip_call) {
2182 return;
2183 }
2184 get_dispatch_table(ot_device_table_map, commandBuffer)
2185 ->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
2186 }
2187
CmdUpdateBuffer(VkCommandBuffer commandBuffer,VkBuffer dstBuffer,VkDeviceSize dstOffset,VkDeviceSize dataSize,const uint32_t * pData)2188 VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
2189 VkDeviceSize dataSize, const uint32_t *pData) {
2190 bool skip_call = false;
2191 {
2192 std::lock_guard<std::mutex> lock(global_lock);
2193 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2194 VALIDATION_ERROR_01150);
2195 skip_call |=
2196 ValidateObject(commandBuffer, dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_01151);
2197 }
2198 if (skip_call) {
2199 return;
2200 }
2201 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
2202 }
2203
CmdFillBuffer(VkCommandBuffer commandBuffer,VkBuffer dstBuffer,VkDeviceSize dstOffset,VkDeviceSize size,uint32_t data)2204 VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
2205 VkDeviceSize size, uint32_t data) {
2206 bool skip_call = false;
2207 {
2208 std::lock_guard<std::mutex> lock(global_lock);
2209 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2210 VALIDATION_ERROR_01138);
2211 skip_call |=
2212 ValidateObject(commandBuffer, dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_01139);
2213 }
2214 if (skip_call) {
2215 return;
2216 }
2217 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
2218 }
2219
CmdClearColorImage(VkCommandBuffer commandBuffer,VkImage image,VkImageLayout imageLayout,const VkClearColorValue * pColor,uint32_t rangeCount,const VkImageSubresourceRange * pRanges)2220 VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
2221 const VkClearColorValue *pColor, uint32_t rangeCount,
2222 const VkImageSubresourceRange *pRanges) {
2223 bool skip_call = false;
2224 {
2225 std::lock_guard<std::mutex> lock(global_lock);
2226 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2227 VALIDATION_ERROR_01089);
2228 skip_call |= ValidateObject(commandBuffer, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_01090);
2229 }
2230 if (skip_call) {
2231 return;
2232 }
2233 get_dispatch_table(ot_device_table_map, commandBuffer)
2234 ->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
2235 }
2236
CmdClearDepthStencilImage(VkCommandBuffer commandBuffer,VkImage image,VkImageLayout imageLayout,const VkClearDepthStencilValue * pDepthStencil,uint32_t rangeCount,const VkImageSubresourceRange * pRanges)2237 VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
2238 const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
2239 const VkImageSubresourceRange *pRanges) {
2240 bool skip_call = false;
2241 {
2242 std::lock_guard<std::mutex> lock(global_lock);
2243 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2244 VALIDATION_ERROR_01104);
2245 skip_call |= ValidateObject(commandBuffer, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_01105);
2246 }
2247 if (skip_call) {
2248 return;
2249 }
2250 get_dispatch_table(ot_device_table_map, commandBuffer)
2251 ->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
2252 }
2253
CmdClearAttachments(VkCommandBuffer commandBuffer,uint32_t attachmentCount,const VkClearAttachment * pAttachments,uint32_t rectCount,const VkClearRect * pRects)2254 VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
2255 const VkClearAttachment *pAttachments, uint32_t rectCount,
2256 const VkClearRect *pRects) {
2257 bool skip_call = false;
2258 {
2259 std::lock_guard<std::mutex> lock(global_lock);
2260 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2261 VALIDATION_ERROR_01117);
2262 }
2263 if (skip_call) {
2264 return;
2265 }
2266 get_dispatch_table(ot_device_table_map, commandBuffer)
2267 ->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
2268 }
2269
CmdResolveImage(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkImageResolve * pRegions)2270 VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
2271 VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
2272 const VkImageResolve *pRegions) {
2273 bool skip_call = false;
2274 {
2275 std::lock_guard<std::mutex> lock(global_lock);
2276 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2277 VALIDATION_ERROR_01327);
2278 skip_call |= ValidateObject(commandBuffer, dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_01330);
2279 skip_call |= ValidateObject(commandBuffer, srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_01328);
2280 }
2281 if (skip_call) {
2282 return;
2283 }
2284 get_dispatch_table(ot_device_table_map, commandBuffer)
2285 ->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
2286 }
2287
CmdSetEvent(VkCommandBuffer commandBuffer,VkEvent event,VkPipelineStageFlags stageMask)2288 VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
2289 bool skip_call = false;
2290 {
2291 std::lock_guard<std::mutex> lock(global_lock);
2292 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2293 VALIDATION_ERROR_00232);
2294 skip_call |= ValidateObject(commandBuffer, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false, VALIDATION_ERROR_00233);
2295 }
2296 if (skip_call) {
2297 return;
2298 }
2299 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetEvent(commandBuffer, event, stageMask);
2300 }
2301
CmdResetEvent(VkCommandBuffer commandBuffer,VkEvent event,VkPipelineStageFlags stageMask)2302 VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
2303 bool skip_call = false;
2304 {
2305 std::lock_guard<std::mutex> lock(global_lock);
2306 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2307 VALIDATION_ERROR_00243);
2308 skip_call |= ValidateObject(commandBuffer, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false, VALIDATION_ERROR_00244);
2309 }
2310 if (skip_call) {
2311 return;
2312 }
2313 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdResetEvent(commandBuffer, event, stageMask);
2314 }
2315
CmdWaitEvents(VkCommandBuffer commandBuffer,uint32_t eventCount,const VkEvent * pEvents,VkPipelineStageFlags srcStageMask,VkPipelineStageFlags dstStageMask,uint32_t memoryBarrierCount,const VkMemoryBarrier * pMemoryBarriers,uint32_t bufferMemoryBarrierCount,const VkBufferMemoryBarrier * pBufferMemoryBarriers,uint32_t imageMemoryBarrierCount,const VkImageMemoryBarrier * pImageMemoryBarriers)2316 VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents,
2317 VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
2318 uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
2319 uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
2320 uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) {
2321 bool skip_call = false;
2322 {
2323 std::lock_guard<std::mutex> lock(global_lock);
2324 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2325 VALIDATION_ERROR_00252);
2326 if (pBufferMemoryBarriers) {
2327 for (uint32_t idx0 = 0; idx0 < bufferMemoryBarrierCount; ++idx0) {
2328 if (pBufferMemoryBarriers[idx0].buffer) {
2329 skip_call |= ValidateObject(commandBuffer, pBufferMemoryBarriers[idx0].buffer,
2330 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_00259);
2331 }
2332 }
2333 }
2334 if (pEvents) {
2335 for (uint32_t idx1 = 0; idx1 < eventCount; ++idx1) {
2336 skip_call |= ValidateObject(commandBuffer, pEvents[idx1], VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, false,
2337 VALIDATION_ERROR_00253);
2338 }
2339 }
2340 if (pImageMemoryBarriers) {
2341 for (uint32_t idx2 = 0; idx2 < imageMemoryBarrierCount; ++idx2) {
2342 if (pImageMemoryBarriers[idx2].image) {
2343 skip_call |= ValidateObject(commandBuffer, pImageMemoryBarriers[idx2].image,
2344 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_00260);
2345 }
2346 }
2347 }
2348 }
2349 if (skip_call) {
2350 return;
2351 }
2352 get_dispatch_table(ot_device_table_map, commandBuffer)
2353 ->CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers,
2354 bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
2355 }
2356
CmdPipelineBarrier(VkCommandBuffer commandBuffer,VkPipelineStageFlags srcStageMask,VkPipelineStageFlags dstStageMask,VkDependencyFlags dependencyFlags,uint32_t memoryBarrierCount,const VkMemoryBarrier * pMemoryBarriers,uint32_t bufferMemoryBarrierCount,const VkBufferMemoryBarrier * pBufferMemoryBarriers,uint32_t imageMemoryBarrierCount,const VkImageMemoryBarrier * pImageMemoryBarriers)2357 VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
2358 VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
2359 uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
2360 uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
2361 uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) {
2362 bool skip_call = false;
2363 {
2364 std::lock_guard<std::mutex> lock(global_lock);
2365 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2366 VALIDATION_ERROR_00270);
2367 if (pBufferMemoryBarriers) {
2368 for (uint32_t idx0 = 0; idx0 < bufferMemoryBarrierCount; ++idx0) {
2369 if (pBufferMemoryBarriers[idx0].buffer) {
2370 skip_call |= ValidateObject(commandBuffer, pBufferMemoryBarriers[idx0].buffer,
2371 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_00277);
2372 }
2373 }
2374 }
2375 if (pImageMemoryBarriers) {
2376 for (uint32_t idx1 = 0; idx1 < imageMemoryBarrierCount; ++idx1) {
2377 if (pImageMemoryBarriers[idx1].image) {
2378 skip_call |= ValidateObject(commandBuffer, pImageMemoryBarriers[idx1].image,
2379 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false, VALIDATION_ERROR_00278);
2380 }
2381 }
2382 }
2383 }
2384 if (skip_call) {
2385 return;
2386 }
2387 get_dispatch_table(ot_device_table_map, commandBuffer)
2388 ->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers,
2389 bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
2390 }
2391
CmdBeginQuery(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t query,VkQueryControlFlags flags)2392 VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
2393 VkQueryControlFlags flags) {
2394 bool skip_call = false;
2395 {
2396 std::lock_guard<std::mutex> lock(global_lock);
2397 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2398 VALIDATION_ERROR_01035);
2399 skip_call |=
2400 ValidateObject(commandBuffer, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false, VALIDATION_ERROR_01036);
2401 }
2402 if (skip_call) {
2403 return;
2404 }
2405 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdBeginQuery(commandBuffer, queryPool, query, flags);
2406 }
2407
CmdEndQuery(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t query)2408 VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
2409 bool skip_call = false;
2410 {
2411 std::lock_guard<std::mutex> lock(global_lock);
2412 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2413 VALIDATION_ERROR_01043);
2414 skip_call |=
2415 ValidateObject(commandBuffer, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false, VALIDATION_ERROR_01044);
2416 }
2417 if (skip_call) {
2418 return;
2419 }
2420 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdEndQuery(commandBuffer, queryPool, query);
2421 }
2422
CmdResetQueryPool(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount)2423 VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
2424 uint32_t queryCount) {
2425 bool skip_call = false;
2426 {
2427 std::lock_guard<std::mutex> lock(global_lock);
2428 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2429 VALIDATION_ERROR_01021);
2430 skip_call |=
2431 ValidateObject(commandBuffer, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false, VALIDATION_ERROR_01022);
2432 }
2433 if (skip_call) {
2434 return;
2435 }
2436 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
2437 }
2438
CmdWriteTimestamp(VkCommandBuffer commandBuffer,VkPipelineStageFlagBits pipelineStage,VkQueryPool queryPool,uint32_t query)2439 VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
2440 VkQueryPool queryPool, uint32_t query) {
2441 bool skip_call = false;
2442 {
2443 std::lock_guard<std::mutex> lock(global_lock);
2444 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2445 VALIDATION_ERROR_01078);
2446 skip_call |=
2447 ValidateObject(commandBuffer, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false, VALIDATION_ERROR_01080);
2448 }
2449 if (skip_call) {
2450 return;
2451 }
2452 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
2453 }
2454
CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,VkBuffer dstBuffer,VkDeviceSize dstOffset,VkDeviceSize stride,VkQueryResultFlags flags)2455 VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
2456 uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
2457 VkDeviceSize stride, VkQueryResultFlags flags) {
2458 bool skip_call = false;
2459 {
2460 std::lock_guard<std::mutex> lock(global_lock);
2461 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2462 VALIDATION_ERROR_01068);
2463 skip_call |=
2464 ValidateObject(commandBuffer, dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false, VALIDATION_ERROR_01070);
2465 skip_call |=
2466 ValidateObject(commandBuffer, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, false, VALIDATION_ERROR_01069);
2467 }
2468 if (skip_call) {
2469 return;
2470 }
2471 get_dispatch_table(ot_device_table_map, commandBuffer)
2472 ->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
2473 }
2474
CmdPushConstants(VkCommandBuffer commandBuffer,VkPipelineLayout layout,VkShaderStageFlags stageFlags,uint32_t offset,uint32_t size,const void * pValues)2475 VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags,
2476 uint32_t offset, uint32_t size, const void *pValues) {
2477 bool skip_call = false;
2478 {
2479 std::lock_guard<std::mutex> lock(global_lock);
2480 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2481 VALIDATION_ERROR_00993);
2482 skip_call |=
2483 ValidateObject(commandBuffer, layout, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, false, VALIDATION_ERROR_00994);
2484 }
2485 if (skip_call) {
2486 return;
2487 }
2488 get_dispatch_table(ot_device_table_map, commandBuffer)
2489 ->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
2490 }
2491
CmdBeginRenderPass(VkCommandBuffer commandBuffer,const VkRenderPassBeginInfo * pRenderPassBegin,VkSubpassContents contents)2492 VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
2493 VkSubpassContents contents) {
2494 bool skip_call = false;
2495 {
2496 std::lock_guard<std::mutex> lock(global_lock);
2497 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2498 VALIDATION_ERROR_00435);
2499 if (pRenderPassBegin) {
2500 skip_call |= ValidateObject(commandBuffer, pRenderPassBegin->framebuffer,
2501 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, false);
2502 skip_call |= ValidateObject(commandBuffer, pRenderPassBegin->renderPass,
2503 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, false);
2504 }
2505 }
2506 if (skip_call) {
2507 return;
2508 }
2509 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
2510 }
2511
CmdNextSubpass(VkCommandBuffer commandBuffer,VkSubpassContents contents)2512 VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
2513 bool skip_call = false;
2514 {
2515 std::lock_guard<std::mutex> lock(global_lock);
2516 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2517 VALIDATION_ERROR_00454);
2518 }
2519 if (skip_call) {
2520 return;
2521 }
2522 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdNextSubpass(commandBuffer, contents);
2523 }
2524
CmdEndRenderPass(VkCommandBuffer commandBuffer)2525 VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer) {
2526 bool skip_call = false;
2527 {
2528 std::lock_guard<std::mutex> lock(global_lock);
2529 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2530 VALIDATION_ERROR_00461);
2531 }
2532 if (skip_call) {
2533 return;
2534 }
2535 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdEndRenderPass(commandBuffer);
2536 }
2537
CmdExecuteCommands(VkCommandBuffer commandBuffer,uint32_t commandBufferCount,const VkCommandBuffer * pCommandBuffers)2538 VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
2539 const VkCommandBuffer *pCommandBuffers) {
2540 bool skip_call = false;
2541 {
2542 std::lock_guard<std::mutex> lock(global_lock);
2543 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
2544 VALIDATION_ERROR_00159);
2545 if (pCommandBuffers) {
2546 for (uint32_t idx0 = 0; idx0 < commandBufferCount; ++idx0) {
2547 skip_call |= ValidateObject(commandBuffer, pCommandBuffers[idx0], VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2548 false, VALIDATION_ERROR_00160);
2549 }
2550 }
2551 }
2552 if (skip_call) {
2553 return;
2554 }
2555 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
2556 }
2557
DestroySurfaceKHR(VkInstance instance,VkSurfaceKHR surface,const VkAllocationCallbacks * pAllocator)2558 VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) {
2559 bool skip_call = false;
2560 {
2561 std::lock_guard<std::mutex> lock(global_lock);
2562 skip_call |= ValidateObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false);
2563 skip_call |= ValidateObject(instance, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false);
2564 }
2565 if (skip_call) {
2566 return;
2567 }
2568 {
2569 std::lock_guard<std::mutex> lock(global_lock);
2570 DestroyObject(instance, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, pAllocator);
2571 }
2572 get_dispatch_table(ot_instance_table_map, instance)->DestroySurfaceKHR(instance, surface, pAllocator);
2573 }
2574
GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,VkSurfaceKHR surface,VkBool32 * pSupported)2575 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
2576 VkSurfaceKHR surface, VkBool32 *pSupported) {
2577 bool skip_call = false;
2578 {
2579 std::lock_guard<std::mutex> lock(global_lock);
2580 skip_call |=
2581 ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false);
2582 skip_call |= ValidateObject(physicalDevice, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false);
2583 }
2584 if (skip_call) {
2585 return VK_ERROR_VALIDATION_FAILED_EXT;
2586 }
2587 VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)
2588 ->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
2589 return result;
2590 }
2591
GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,VkSurfaceCapabilitiesKHR * pSurfaceCapabilities)2592 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
2593 VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
2594 bool skip_call = false;
2595 {
2596 std::lock_guard<std::mutex> lock(global_lock);
2597 skip_call |=
2598 ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false);
2599 skip_call |= ValidateObject(physicalDevice, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false);
2600 }
2601 if (skip_call) {
2602 return VK_ERROR_VALIDATION_FAILED_EXT;
2603 }
2604 VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)
2605 ->GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
2606 return result;
2607 }
2608
GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,uint32_t * pSurfaceFormatCount,VkSurfaceFormatKHR * pSurfaceFormats)2609 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
2610 uint32_t *pSurfaceFormatCount,
2611 VkSurfaceFormatKHR *pSurfaceFormats) {
2612 bool skip_call = false;
2613 {
2614 std::lock_guard<std::mutex> lock(global_lock);
2615 skip_call |=
2616 ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false);
2617 skip_call |= ValidateObject(physicalDevice, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false);
2618 }
2619 if (skip_call) {
2620 return VK_ERROR_VALIDATION_FAILED_EXT;
2621 }
2622 VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)
2623 ->GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
2624 return result;
2625 }
2626
GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,uint32_t * pPresentModeCount,VkPresentModeKHR * pPresentModes)2627 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
2628 uint32_t *pPresentModeCount,
2629 VkPresentModeKHR *pPresentModes) {
2630 bool skip_call = false;
2631 {
2632 std::lock_guard<std::mutex> lock(global_lock);
2633 skip_call |=
2634 ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false);
2635 skip_call |= ValidateObject(physicalDevice, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false);
2636 }
2637 if (skip_call) {
2638 return VK_ERROR_VALIDATION_FAILED_EXT;
2639 }
2640 VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)
2641 ->GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
2642 return result;
2643 }
2644
CreateSwapchainKHR(VkDevice device,const VkSwapchainCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSwapchainKHR * pSwapchain)2645 VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
2646 const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
2647 bool skip_call = false;
2648 {
2649 std::lock_guard<std::mutex> lock(global_lock);
2650 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
2651 if (pCreateInfo) {
2652 skip_call |= ValidateObject(device, pCreateInfo->oldSwapchain,
2653 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, true);
2654 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
2655 skip_call |= ValidateObject(device_data->physical_device, pCreateInfo->surface,
2656 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false);
2657 }
2658 }
2659 if (skip_call) {
2660 return VK_ERROR_VALIDATION_FAILED_EXT;
2661 }
2662 VkResult result =
2663 get_dispatch_table(ot_device_table_map, device)->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
2664 {
2665 std::lock_guard<std::mutex> lock(global_lock);
2666 if (result == VK_SUCCESS) {
2667 CreateObject(device, *pSwapchain, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, pAllocator);
2668 }
2669 }
2670 return result;
2671 }
2672
AcquireNextImageKHR(VkDevice device,VkSwapchainKHR swapchain,uint64_t timeout,VkSemaphore semaphore,VkFence fence,uint32_t * pImageIndex)2673 VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
2674 VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) {
2675 bool skip_call = false;
2676 {
2677 std::lock_guard<std::mutex> lock(global_lock);
2678 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
2679 skip_call |= ValidateObject(device, fence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, true);
2680 skip_call |= ValidateObject(device, semaphore, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, true);
2681 skip_call |= ValidateObject(device, swapchain, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, false);
2682 }
2683 if (skip_call) {
2684 return VK_ERROR_VALIDATION_FAILED_EXT;
2685 }
2686 VkResult result = get_dispatch_table(ot_device_table_map, device)
2687 ->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
2688 return result;
2689 }
2690
QueuePresentKHR(VkQueue queue,const VkPresentInfoKHR * pPresentInfo)2691 VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {
2692 bool skip_call = false;
2693 {
2694 std::lock_guard<std::mutex> lock(global_lock);
2695 if (pPresentInfo) {
2696 if (pPresentInfo->pSwapchains) {
2697 for (uint32_t idx0 = 0; idx0 < pPresentInfo->swapchainCount; ++idx0) {
2698 skip_call |= ValidateObject(queue, pPresentInfo->pSwapchains[idx0],
2699 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, false);
2700 }
2701 }
2702 if (pPresentInfo->pWaitSemaphores) {
2703 for (uint32_t idx1 = 0; idx1 < pPresentInfo->waitSemaphoreCount; ++idx1) {
2704 skip_call |= ValidateObject(queue, pPresentInfo->pWaitSemaphores[idx1],
2705 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, false);
2706 }
2707 }
2708 }
2709 skip_call |= ValidateObject(queue, queue, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, false);
2710 }
2711 if (skip_call) {
2712 return VK_ERROR_VALIDATION_FAILED_EXT;
2713 }
2714 VkResult result = get_dispatch_table(ot_device_table_map, queue)->QueuePresentKHR(queue, pPresentInfo);
2715 return result;
2716 }
2717
2718 #ifdef VK_USE_PLATFORM_WIN32_KHR
CreateWin32SurfaceKHR(VkInstance instance,const VkWin32SurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface)2719 VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
2720 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
2721 bool skip_call = false;
2722 {
2723 std::lock_guard<std::mutex> lock(global_lock);
2724 skip_call |= ValidateObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false);
2725 }
2726 if (skip_call) {
2727 return VK_ERROR_VALIDATION_FAILED_EXT;
2728 }
2729 VkResult result =
2730 get_dispatch_table(ot_instance_table_map, instance)->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
2731 {
2732 std::lock_guard<std::mutex> lock(global_lock);
2733 if (result == VK_SUCCESS) {
2734 CreateObject(instance, *pSurface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, pAllocator);
2735 }
2736 }
2737 return result;
2738 }
2739
GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex)2740 VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
2741 uint32_t queueFamilyIndex) {
2742 bool skip_call = false;
2743 {
2744 std::lock_guard<std::mutex> lock(global_lock);
2745 skip_call |=
2746 ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false);
2747 }
2748 if (skip_call) {
2749 return VK_FALSE;
2750 }
2751 VkBool32 result = get_dispatch_table(ot_instance_table_map, physicalDevice)
2752 ->GetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
2753 return result;
2754 }
2755 #endif // VK_USE_PLATFORM_WIN32_KHR
2756
2757 #ifdef VK_USE_PLATFORM_XCB_KHR
CreateXcbSurfaceKHR(VkInstance instance,const VkXcbSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface)2758 VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
2759 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
2760 bool skip_call = false;
2761 {
2762 std::lock_guard<std::mutex> lock(global_lock);
2763 skip_call |= ValidateObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false);
2764 }
2765 if (skip_call) {
2766 return VK_ERROR_VALIDATION_FAILED_EXT;
2767 }
2768 VkResult result =
2769 get_dispatch_table(ot_instance_table_map, instance)->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
2770 {
2771 std::lock_guard<std::mutex> lock(global_lock);
2772 if (result == VK_SUCCESS) {
2773 CreateObject(instance, *pSurface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, pAllocator);
2774 }
2775 }
2776 return result;
2777 }
2778
GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,xcb_connection_t * connection,xcb_visualid_t visual_id)2779 VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
2780 uint32_t queueFamilyIndex, xcb_connection_t *connection,
2781 xcb_visualid_t visual_id) {
2782 bool skip_call = false;
2783 {
2784 std::lock_guard<std::mutex> lock(global_lock);
2785 skip_call |=
2786 ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false);
2787 }
2788 if (skip_call) {
2789 return VK_FALSE;
2790 }
2791 VkBool32 result = get_dispatch_table(ot_instance_table_map, physicalDevice)
2792 ->GetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id);
2793 return result;
2794 }
2795 #endif // VK_USE_PLATFORM_XCB_KHR
2796
2797 #ifdef VK_USE_PLATFORM_XLIB_KHR
CreateXlibSurfaceKHR(VkInstance instance,const VkXlibSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface)2798 VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
2799 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
2800 bool skip_call = false;
2801 {
2802 std::lock_guard<std::mutex> lock(global_lock);
2803 skip_call |= ValidateObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false);
2804 }
2805 if (skip_call) {
2806 return VK_ERROR_VALIDATION_FAILED_EXT;
2807 }
2808 VkResult result =
2809 get_dispatch_table(ot_instance_table_map, instance)->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
2810 {
2811 std::lock_guard<std::mutex> lock(global_lock);
2812 if (result == VK_SUCCESS) {
2813 CreateObject(instance, *pSurface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, pAllocator);
2814 }
2815 }
2816 return result;
2817 }
2818
GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,Display * dpy,VisualID visualID)2819 VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
2820 uint32_t queueFamilyIndex, Display *dpy,
2821 VisualID visualID) {
2822 bool skip_call = false;
2823 {
2824 std::lock_guard<std::mutex> lock(global_lock);
2825 skip_call |=
2826 ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false);
2827 }
2828 if (skip_call) {
2829 return VK_FALSE;
2830 }
2831 VkBool32 result = get_dispatch_table(ot_instance_table_map, physicalDevice)
2832 ->GetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID);
2833 return result;
2834 }
2835 #endif // VK_USE_PLATFORM_XLIB_KHR
2836
2837 #ifdef VK_USE_PLATFORM_MIR_KHR
CreateMirSurfaceKHR(VkInstance instance,const VkMirSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface)2838 VKAPI_ATTR VkResult VKAPI_CALL CreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo,
2839 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
2840 bool skip_call = false;
2841 {
2842 std::lock_guard<std::mutex> lock(global_lock);
2843 skip_call |= ValidateObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false);
2844 }
2845 if (skip_call) {
2846 return VK_ERROR_VALIDATION_FAILED_EXT;
2847 }
2848 VkResult result =
2849 get_dispatch_table(ot_instance_table_map, instance)->CreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
2850 {
2851 std::lock_guard<std::mutex> lock(global_lock);
2852 if (result == VK_SUCCESS) {
2853 CreateObject(instance, *pSurface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, pAllocator);
2854 }
2855 }
2856 return result;
2857 }
2858
GetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,MirConnection * connection)2859 VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice,
2860 uint32_t queueFamilyIndex, MirConnection *connection) {
2861 bool skip_call = false;
2862 {
2863 std::lock_guard<std::mutex> lock(global_lock);
2864 skip_call |=
2865 ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false);
2866 }
2867 if (skip_call) {
2868 return VK_FALSE;
2869 }
2870 VkBool32 result = get_dispatch_table(ot_instance_table_map, physicalDevice)
2871 ->GetPhysicalDeviceMirPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection);
2872 return result;
2873 }
2874 #endif // VK_USE_PLATFORM_MIR_KHR
2875
2876 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
CreateWaylandSurfaceKHR(VkInstance instance,const VkWaylandSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface)2877 VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
2878 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
2879 bool skip_call = false;
2880 {
2881 std::lock_guard<std::mutex> lock(global_lock);
2882 skip_call |= ValidateObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false);
2883 }
2884 if (skip_call) {
2885 return VK_ERROR_VALIDATION_FAILED_EXT;
2886 }
2887 VkResult result =
2888 get_dispatch_table(ot_instance_table_map, instance)->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
2889 {
2890 std::lock_guard<std::mutex> lock(global_lock);
2891 if (result == VK_SUCCESS) {
2892 CreateObject(instance, *pSurface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, pAllocator);
2893 }
2894 }
2895 return result;
2896 }
2897
GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,struct wl_display * display)2898 VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
2899 uint32_t queueFamilyIndex,
2900 struct wl_display *display) {
2901 bool skip_call = false;
2902 {
2903 std::lock_guard<std::mutex> lock(global_lock);
2904 skip_call |=
2905 ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false);
2906 }
2907 if (skip_call) {
2908 return VK_FALSE;
2909 }
2910 VkBool32 result = get_dispatch_table(ot_instance_table_map, physicalDevice)
2911 ->GetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display);
2912 return result;
2913 }
2914 #endif // VK_USE_PLATFORM_WAYLAND_KHR
2915
2916 #ifdef VK_USE_PLATFORM_ANDROID_KHR
CreateAndroidSurfaceKHR(VkInstance instance,const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface)2917 VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR *pCreateInfo,
2918 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
2919 bool skip_call = false;
2920 {
2921 std::lock_guard<std::mutex> lock(global_lock);
2922 skip_call |= ValidateObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false);
2923 }
2924 if (skip_call) {
2925 return VK_ERROR_VALIDATION_FAILED_EXT;
2926 }
2927 VkResult result =
2928 get_dispatch_table(ot_instance_table_map, instance)->CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
2929 {
2930 std::lock_guard<std::mutex> lock(global_lock);
2931 if (result == VK_SUCCESS) {
2932 CreateObject(instance, *pSurface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, pAllocator);
2933 }
2934 }
2935 return result;
2936 }
2937 #endif // VK_USE_PLATFORM_ANDROID_KHR
2938
CreateSharedSwapchainsKHR(VkDevice device,uint32_t swapchainCount,const VkSwapchainCreateInfoKHR * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkSwapchainKHR * pSwapchains)2939 VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
2940 const VkSwapchainCreateInfoKHR *pCreateInfos,
2941 const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) {
2942 bool skip_call = false;
2943 uint32_t i = 0;
2944 {
2945 std::lock_guard<std::mutex> lock(global_lock);
2946 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
2947 if (NULL != pCreateInfos) {
2948 for (i = 0; i < swapchainCount; i++) {
2949 skip_call |= ValidateObject(device, pCreateInfos[i].oldSwapchain,
2950 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, true);
2951 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
2952 skip_call |= ValidateObject(device_data->physical_device, pCreateInfos[i].surface,
2953 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false);
2954 }
2955 }
2956 }
2957 if (skip_call) {
2958 return VK_ERROR_VALIDATION_FAILED_EXT;
2959 }
2960 VkResult result =
2961 get_dispatch_table(ot_device_table_map, device)->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
2962 {
2963 std::lock_guard<std::mutex> lock(global_lock);
2964 if (result == VK_SUCCESS) {
2965 for (i = 0; i < swapchainCount; i++) {
2966 CreateObject(device, pSwapchains[i], VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, pAllocator);
2967 }
2968 }
2969 }
2970 return result;
2971 }
2972
CreateDebugReportCallbackEXT(VkInstance instance,const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDebugReportCallbackEXT * pCallback)2973 VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance,
2974 const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
2975 const VkAllocationCallbacks *pAllocator,
2976 VkDebugReportCallbackEXT *pCallback) {
2977 VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance);
2978 VkResult result = pInstanceTable->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
2979 if (VK_SUCCESS == result) {
2980 layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
2981 result = layer_create_msg_callback(instance_data->report_data, false, pCreateInfo, pAllocator, pCallback);
2982 CreateObject(instance, *pCallback, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, pAllocator);
2983 }
2984 return result;
2985 }
2986
DestroyDebugReportCallbackEXT(VkInstance instance,VkDebugReportCallbackEXT msgCallback,const VkAllocationCallbacks * pAllocator)2987 VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
2988 const VkAllocationCallbacks *pAllocator) {
2989 VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance);
2990 pInstanceTable->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
2991 layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
2992 layer_destroy_msg_callback(instance_data->report_data, msgCallback, pAllocator);
2993 DestroyObject(instance, msgCallback, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, pAllocator);
2994 }
2995
DebugReportMessageEXT(VkInstance instance,VkDebugReportFlagsEXT flags,VkDebugReportObjectTypeEXT objType,uint64_t object,size_t location,int32_t msgCode,const char * pLayerPrefix,const char * pMsg)2996 VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
2997 VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
2998 int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
2999 VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance);
3000 pInstanceTable->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
3001 }
3002
3003 static const VkExtensionProperties instance_extensions[] = {{VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}};
3004
3005 static const VkLayerProperties globalLayerProps = {"VK_LAYER_LUNARG_object_tracker",
3006 VK_LAYER_API_VERSION, // specVersion
3007 1, // implementationVersion
3008 "LunarG Validation Layer"};
3009
EnumerateInstanceLayerProperties(uint32_t * pCount,VkLayerProperties * pProperties)3010 VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
3011 return util_GetLayerProperties(1, &globalLayerProps, pCount, pProperties);
3012 }
3013
EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,uint32_t * pCount,VkLayerProperties * pProperties)3014 VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
3015 VkLayerProperties *pProperties) {
3016 return util_GetLayerProperties(1, &globalLayerProps, pCount, pProperties);
3017 }
3018
EnumerateInstanceExtensionProperties(const char * pLayerName,uint32_t * pCount,VkExtensionProperties * pProperties)3019 VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,
3020 VkExtensionProperties *pProperties) {
3021 if (pLayerName && !strcmp(pLayerName, globalLayerProps.layerName))
3022 return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties);
3023
3024 return VK_ERROR_LAYER_NOT_PRESENT;
3025 }
3026
EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pCount,VkExtensionProperties * pProperties)3027 VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName,
3028 uint32_t *pCount, VkExtensionProperties *pProperties) {
3029 if (pLayerName && !strcmp(pLayerName, globalLayerProps.layerName))
3030 return util_GetExtensionProperties(0, nullptr, pCount, pProperties);
3031
3032 assert(physicalDevice);
3033 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(ot_instance_table_map, physicalDevice);
3034 return pTable->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
3035 }
3036
InterceptMsgCallbackGetProcAddrCommand(const char * name,VkInstance instance)3037 static inline PFN_vkVoidFunction InterceptMsgCallbackGetProcAddrCommand(const char *name, VkInstance instance) {
3038 layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
3039 return debug_report_get_instance_proc_addr(instance_data->report_data, name);
3040 }
3041
InterceptWsiEnabledCommand(const char * name,VkInstance instance)3042 static inline PFN_vkVoidFunction InterceptWsiEnabledCommand(const char *name, VkInstance instance) {
3043 VkLayerInstanceDispatchTable *pTable = get_dispatch_table(ot_instance_table_map, instance);
3044 if (instanceExtMap.size() == 0 || !instanceExtMap[pTable].wsi_enabled)
3045 return nullptr;
3046
3047 if (!strcmp("vkDestroySurfaceKHR", name))
3048 return reinterpret_cast<PFN_vkVoidFunction>(DestroySurfaceKHR);
3049 if (!strcmp("vkGetPhysicalDeviceSurfaceSupportKHR", name))
3050 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceSupportKHR);
3051 if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", name))
3052 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceCapabilitiesKHR);
3053 if (!strcmp("vkGetPhysicalDeviceSurfaceFormatsKHR", name))
3054 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceFormatsKHR);
3055 if (!strcmp("vkGetPhysicalDeviceSurfacePresentModesKHR", name))
3056 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfacePresentModesKHR);
3057
3058 #ifdef VK_USE_PLATFORM_WIN32_KHR
3059 if ((instanceExtMap[pTable].win32_enabled == true) && !strcmp("vkCreateWin32SurfaceKHR", name))
3060 return reinterpret_cast<PFN_vkVoidFunction>(CreateWin32SurfaceKHR);
3061 if ((instanceExtMap[pTable].win32_enabled == true) && !strcmp("vkGetPhysicalDeviceWin32PresentationSupportKHR", name))
3062 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceWin32PresentationSupportKHR);
3063 #endif // VK_USE_PLATFORM_WIN32_KHR
3064 #ifdef VK_USE_PLATFORM_XCB_KHR
3065 if ((instanceExtMap[pTable].xcb_enabled == true) && !strcmp("vkCreateXcbSurfaceKHR", name))
3066 return reinterpret_cast<PFN_vkVoidFunction>(CreateXcbSurfaceKHR);
3067 if ((instanceExtMap[pTable].xcb_enabled == true) && !strcmp("vkGetPhysicalDeviceXcbPresentationSupportKHR", name))
3068 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceXcbPresentationSupportKHR);
3069 #endif // VK_USE_PLATFORM_XCB_KHR
3070 #ifdef VK_USE_PLATFORM_XLIB_KHR
3071 if ((instanceExtMap[pTable].xlib_enabled == true) && !strcmp("vkCreateXlibSurfaceKHR", name))
3072 return reinterpret_cast<PFN_vkVoidFunction>(CreateXlibSurfaceKHR);
3073 if ((instanceExtMap[pTable].xlib_enabled == true) && !strcmp("vkGetPhysicalDeviceXlibPresentationSupportKHR", name))
3074 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceXlibPresentationSupportKHR);
3075 #endif // VK_USE_PLATFORM_XLIB_KHR
3076 #ifdef VK_USE_PLATFORM_MIR_KHR
3077 if ((instanceExtMap[pTable].mir_enabled == true) && !strcmp("vkCreateMirSurfaceKHR", name))
3078 return reinterpret_cast<PFN_vkVoidFunction>(CreateMirSurfaceKHR);
3079 if ((instanceExtMap[pTable].mir_enabled == true) && !strcmp("vkGetPhysicalDeviceMirPresentationSupportKHR", name))
3080 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceMirPresentationSupportKHR);
3081 #endif // VK_USE_PLATFORM_MIR_KHR
3082 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
3083 if ((instanceExtMap[pTable].wayland_enabled == true) && !strcmp("vkCreateWaylandSurfaceKHR", name))
3084 return reinterpret_cast<PFN_vkVoidFunction>(CreateWaylandSurfaceKHR);
3085 if ((instanceExtMap[pTable].wayland_enabled == true) && !strcmp("vkGetPhysicalDeviceWaylandPresentationSupportKHR", name))
3086 return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceWaylandPresentationSupportKHR);
3087 #endif // VK_USE_PLATFORM_WAYLAND_KHR
3088 #ifdef VK_USE_PLATFORM_ANDROID_KHR
3089 if ((instanceExtMap[pTable].android_enabled == true) && !strcmp("vkCreateAndroidSurfaceKHR", name))
3090 return reinterpret_cast<PFN_vkVoidFunction>(CreateAndroidSurfaceKHR);
3091 #endif // VK_USE_PLATFORM_ANDROID_KHR
3092
3093 return nullptr;
3094 }
3095
CheckDeviceRegisterExtensions(const VkDeviceCreateInfo * pCreateInfo,VkDevice device)3096 static void CheckDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo, VkDevice device) {
3097 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
3098 device_data->wsi_enabled = false;
3099 device_data->wsi_display_swapchain_enabled = false;
3100 device_data->objtrack_extensions_enabled = false;
3101
3102 for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
3103 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
3104 device_data->wsi_enabled = true;
3105 }
3106 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME) == 0) {
3107 device_data->wsi_display_swapchain_enabled = true;
3108 }
3109 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], "OBJTRACK_EXTENSIONS") == 0) {
3110 device_data->objtrack_extensions_enabled = true;
3111 }
3112 }
3113 }
3114
CheckInstanceRegisterExtensions(const VkInstanceCreateInfo * pCreateInfo,VkInstance instance)3115 static void CheckInstanceRegisterExtensions(const VkInstanceCreateInfo *pCreateInfo, VkInstance instance) {
3116 VkLayerInstanceDispatchTable *pDisp = get_dispatch_table(ot_instance_table_map, instance);
3117
3118
3119 instanceExtMap[pDisp] = {};
3120
3121 for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
3122 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0) {
3123 instanceExtMap[pDisp].wsi_enabled = true;
3124 }
3125 #ifdef VK_USE_PLATFORM_XLIB_KHR
3126 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XLIB_SURFACE_EXTENSION_NAME) == 0) {
3127 instanceExtMap[pDisp].xlib_enabled = true;
3128 }
3129 #endif
3130 #ifdef VK_USE_PLATFORM_XCB_KHR
3131 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XCB_SURFACE_EXTENSION_NAME) == 0) {
3132 instanceExtMap[pDisp].xcb_enabled = true;
3133 }
3134 #endif
3135 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
3136 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0) {
3137 instanceExtMap[pDisp].wayland_enabled = true;
3138 }
3139 #endif
3140 #ifdef VK_USE_PLATFORM_MIR_KHR
3141 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_MIR_SURFACE_EXTENSION_NAME) == 0) {
3142 instanceExtMap[pDisp].mir_enabled = true;
3143 }
3144 #endif
3145 #ifdef VK_USE_PLATFORM_ANDROID_KHR
3146 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0) {
3147 instanceExtMap[pDisp].android_enabled = true;
3148 }
3149 #endif
3150 #ifdef VK_USE_PLATFORM_WIN32_KHR
3151 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WIN32_SURFACE_EXTENSION_NAME) == 0) {
3152 instanceExtMap[pDisp].win32_enabled = true;
3153 }
3154 #endif
3155 }
3156 }
3157
CreateDevice(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice)3158 VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
3159 const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
3160 std::lock_guard<std::mutex> lock(global_lock);
3161 layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
3162 VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
3163
3164 assert(chain_info->u.pLayerInfo);
3165 PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
3166 PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
3167 PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(phy_dev_data->instance, "vkCreateDevice");
3168 if (fpCreateDevice == NULL) {
3169 return VK_ERROR_INITIALIZATION_FAILED;
3170 }
3171
3172 // Advance the link info for the next element on the chain
3173 chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
3174
3175 VkResult result = fpCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
3176 if (result != VK_SUCCESS) {
3177 return result;
3178 }
3179
3180 layer_data *device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
3181 device_data->report_data = layer_debug_report_create_device(phy_dev_data->report_data, *pDevice);
3182
3183 // Add link back to physDev
3184 device_data->physical_device = physicalDevice;
3185
3186 initDeviceTable(*pDevice, fpGetDeviceProcAddr, ot_device_table_map);
3187
3188 CheckDeviceRegisterExtensions(pCreateInfo, *pDevice);
3189 CreateObject(*pDevice, *pDevice, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, pAllocator);
3190
3191 return result;
3192 }
3193
GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties)3194 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
3195 uint32_t *pQueueFamilyPropertyCount,
3196 VkQueueFamilyProperties *pQueueFamilyProperties) {
3197 get_dispatch_table(ot_instance_table_map, physicalDevice)
3198 ->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
3199 std::lock_guard<std::mutex> lock(global_lock);
3200 if (pQueueFamilyProperties != NULL) {
3201 layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
3202 for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) {
3203 instance_data->queue_family_properties.emplace_back(pQueueFamilyProperties[i]);
3204 }
3205 }
3206 }
3207
CreateInstance(const VkInstanceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkInstance * pInstance)3208 VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
3209 VkInstance *pInstance) {
3210 VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
3211
3212 assert(chain_info->u.pLayerInfo);
3213 PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
3214 PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance");
3215 if (fpCreateInstance == NULL) {
3216 return VK_ERROR_INITIALIZATION_FAILED;
3217 }
3218
3219 // Advance the link info for the next element on the chain
3220 chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
3221
3222 VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
3223 if (result != VK_SUCCESS) {
3224 return result;
3225 }
3226
3227 layer_data *instance_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
3228 instance_data->instance = *pInstance;
3229 initInstanceTable(*pInstance, fpGetInstanceProcAddr, ot_instance_table_map);
3230 VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, *pInstance);
3231
3232 // Look for one or more debug report create info structures, and copy the
3233 // callback(s) for each one found (for use by vkDestroyInstance)
3234 layer_copy_tmp_callbacks(pCreateInfo->pNext, &instance_data->num_tmp_callbacks, &instance_data->tmp_dbg_create_infos,
3235 &instance_data->tmp_callbacks);
3236
3237 instance_data->report_data = debug_report_create_instance(pInstanceTable, *pInstance, pCreateInfo->enabledExtensionCount,
3238 pCreateInfo->ppEnabledExtensionNames);
3239
3240 InitObjectTracker(instance_data, pAllocator);
3241 CheckInstanceRegisterExtensions(pCreateInfo, *pInstance);
3242
3243 CreateObject(*pInstance, *pInstance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, pAllocator);
3244
3245 return result;
3246 }
3247
EnumeratePhysicalDevices(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices)3248 VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
3249 VkPhysicalDevice *pPhysicalDevices) {
3250 bool skip_call = VK_FALSE;
3251 std::unique_lock<std::mutex> lock(global_lock);
3252 skip_call |= ValidateObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false, VALIDATION_ERROR_00023);
3253 lock.unlock();
3254 if (skip_call) {
3255 return VK_ERROR_VALIDATION_FAILED_EXT;
3256 }
3257 VkResult result = get_dispatch_table(ot_instance_table_map, instance)
3258 ->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
3259 lock.lock();
3260 if (result == VK_SUCCESS) {
3261 if (pPhysicalDevices) {
3262 for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) {
3263 CreateObject(instance, pPhysicalDevices[i], VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, nullptr);
3264 }
3265 }
3266 }
3267 lock.unlock();
3268 return result;
3269 }
3270
GetDeviceQueue(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue)3271 VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) {
3272 std::unique_lock<std::mutex> lock(global_lock);
3273 ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00062);
3274 lock.unlock();
3275
3276 get_dispatch_table(ot_device_table_map, device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
3277
3278 lock.lock();
3279
3280 CreateQueue(device, *pQueue, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT);
3281 AddQueueInfo(device, queueFamilyIndex, *pQueue);
3282 }
3283
FreeMemory(VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator)3284 VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator) {
3285 bool skip = false;
3286 std::unique_lock<std::mutex> lock(global_lock);
3287 skip |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00621);
3288 skip |= ValidateObject(device, memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, true, VALIDATION_ERROR_00622);
3289 lock.unlock();
3290 if (!skip) {
3291 get_dispatch_table(ot_device_table_map, device)->FreeMemory(device, memory, pAllocator);
3292
3293 lock.lock();
3294 DestroyObject(device, memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, pAllocator);
3295 }
3296 }
3297
MapMemory(VkDevice device,VkDeviceMemory memory,VkDeviceSize offset,VkDeviceSize size,VkMemoryMapFlags flags,void ** ppData)3298 VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size,
3299 VkMemoryMapFlags flags, void **ppData) {
3300 bool skip_call = VK_FALSE;
3301 std::unique_lock<std::mutex> lock(global_lock);
3302 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00631);
3303 lock.unlock();
3304 if (skip_call == VK_TRUE) {
3305 return VK_ERROR_VALIDATION_FAILED_EXT;
3306 }
3307 VkResult result = get_dispatch_table(ot_device_table_map, device)->MapMemory(device, memory, offset, size, flags, ppData);
3308 return result;
3309 }
3310
UnmapMemory(VkDevice device,VkDeviceMemory memory)3311 VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory memory) {
3312 bool skip_call = VK_FALSE;
3313 std::unique_lock<std::mutex> lock(global_lock);
3314 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00650);
3315 lock.unlock();
3316 if (skip_call == VK_TRUE) {
3317 return;
3318 }
3319
3320 get_dispatch_table(ot_device_table_map, device)->UnmapMemory(device, memory);
3321 }
QueueBindSparse(VkQueue queue,uint32_t bindInfoCount,const VkBindSparseInfo * pBindInfo,VkFence fence)3322 VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo,
3323 VkFence fence) {
3324 std::unique_lock<std::mutex> lock(global_lock);
3325 ValidateQueueFlags(queue, "QueueBindSparse");
3326
3327 for (uint32_t i = 0; i < bindInfoCount; i++) {
3328 for (uint32_t j = 0; j < pBindInfo[i].bufferBindCount; j++)
3329 ValidateObject(queue, pBindInfo[i].pBufferBinds[j].buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
3330 false);
3331 for (uint32_t j = 0; j < pBindInfo[i].imageOpaqueBindCount; j++)
3332 ValidateObject(queue, pBindInfo[i].pImageOpaqueBinds[j].image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
3333 false);
3334 for (uint32_t j = 0; j < pBindInfo[i].imageBindCount; j++)
3335 ValidateObject(queue, pBindInfo[i].pImageBinds[j].image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, false);
3336 }
3337 lock.unlock();
3338
3339 VkResult result = get_dispatch_table(ot_device_table_map, queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
3340 return result;
3341 }
3342
AllocateCommandBuffers(VkDevice device,const VkCommandBufferAllocateInfo * pAllocateInfo,VkCommandBuffer * pCommandBuffers)3343 VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo,
3344 VkCommandBuffer *pCommandBuffers) {
3345 bool skip_call = VK_FALSE;
3346 std::unique_lock<std::mutex> lock(global_lock);
3347 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00084);
3348 skip_call |= ValidateObject(device, pAllocateInfo->commandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, false,
3349 VALIDATION_ERROR_00090);
3350 lock.unlock();
3351
3352 if (skip_call) {
3353 return VK_ERROR_VALIDATION_FAILED_EXT;
3354 }
3355
3356 VkResult result =
3357 get_dispatch_table(ot_device_table_map, device)->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
3358
3359 lock.lock();
3360 for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) {
3361 AllocateCommandBuffer(device, pAllocateInfo->commandPool, pCommandBuffers[i],
3362 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, pAllocateInfo->level);
3363 }
3364 lock.unlock();
3365
3366 return result;
3367 }
3368
AllocateDescriptorSets(VkDevice device,const VkDescriptorSetAllocateInfo * pAllocateInfo,VkDescriptorSet * pDescriptorSets)3369 VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo,
3370 VkDescriptorSet *pDescriptorSets) {
3371 bool skip_call = VK_FALSE;
3372 std::unique_lock<std::mutex> lock(global_lock);
3373 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00908);
3374 skip_call |= ValidateObject(device, pAllocateInfo->descriptorPool,
3375 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, false);
3376 for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
3377 skip_call |= ValidateObject(device, pAllocateInfo->pSetLayouts[i],
3378 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, false);
3379 }
3380 lock.unlock();
3381 if (skip_call) {
3382 return VK_ERROR_VALIDATION_FAILED_EXT;
3383 }
3384
3385 VkResult result =
3386 get_dispatch_table(ot_device_table_map, device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
3387
3388 if (VK_SUCCESS == result) {
3389 lock.lock();
3390 for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
3391 AllocateDescriptorSet(device, pAllocateInfo->descriptorPool, pDescriptorSets[i],
3392 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT);
3393 }
3394 lock.unlock();
3395 }
3396
3397 return result;
3398 }
3399
FreeCommandBuffers(VkDevice device,VkCommandPool commandPool,uint32_t commandBufferCount,const VkCommandBuffer * pCommandBuffers)3400 VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
3401 const VkCommandBuffer *pCommandBuffers) {
3402 bool skip_call = false;
3403 std::unique_lock<std::mutex> lock(global_lock);
3404 ValidateObject(device, commandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, false, VALIDATION_ERROR_00099);
3405 ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00098);
3406 for (uint32_t i = 0; i < commandBufferCount; i++) {
3407 skip_call |= ValidateCommandBuffer(device, commandPool, pCommandBuffers[i]);
3408 }
3409
3410 for (uint32_t i = 0; i < commandBufferCount; i++) {
3411 DestroyObject(device, pCommandBuffers[i], VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, nullptr);
3412 }
3413
3414 lock.unlock();
3415 if (!skip_call) {
3416 get_dispatch_table(ot_device_table_map, device)
3417 ->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
3418 }
3419 }
DestroySwapchainKHR(VkDevice device,VkSwapchainKHR swapchain,const VkAllocationCallbacks * pAllocator)3420 VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
3421 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
3422 std::unique_lock<std::mutex> lock(global_lock);
3423 // A swapchain's images are implicitly deleted when the swapchain is deleted.
3424 // Remove this swapchain's images from our map of such images.
3425 std::unordered_map<uint64_t, OBJTRACK_NODE *>::iterator itr = device_data->swapchainImageMap.begin();
3426 while (itr != device_data->swapchainImageMap.end()) {
3427 OBJTRACK_NODE *pNode = (*itr).second;
3428 if (pNode->parent_object == reinterpret_cast<uint64_t &>(swapchain)) {
3429 delete pNode;
3430 auto delete_item = itr++;
3431 device_data->swapchainImageMap.erase(delete_item);
3432 } else {
3433 ++itr;
3434 }
3435 }
3436 DestroyObject(device, swapchain, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, pAllocator);
3437 lock.unlock();
3438
3439 get_dispatch_table(ot_device_table_map, device)->DestroySwapchainKHR(device, swapchain, pAllocator);
3440 }
3441
FreeDescriptorSets(VkDevice device,VkDescriptorPool descriptorPool,uint32_t descriptorSetCount,const VkDescriptorSet * pDescriptorSets)3442 VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount,
3443 const VkDescriptorSet *pDescriptorSets) {
3444 bool skip_call = false;
3445 VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
3446 std::unique_lock<std::mutex> lock(global_lock);
3447 skip_call |=
3448 ValidateObject(device, descriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, false, VALIDATION_ERROR_00924);
3449 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00923);
3450 for (uint32_t i = 0; i < descriptorSetCount; i++) {
3451 skip_call |= ValidateDescriptorSet(device, descriptorPool, pDescriptorSets[i]);
3452 }
3453
3454 for (uint32_t i = 0; i < descriptorSetCount; i++) {
3455 DestroyObject(device, pDescriptorSets[i], VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, nullptr);
3456 }
3457
3458 lock.unlock();
3459 if (!skip_call) {
3460 result = get_dispatch_table(ot_device_table_map, device)
3461 ->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
3462 }
3463 return result;
3464 }
3465
DestroyDescriptorPool(VkDevice device,VkDescriptorPool descriptorPool,const VkAllocationCallbacks * pAllocator)3466 VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
3467 const VkAllocationCallbacks *pAllocator) {
3468 bool skip_call = VK_FALSE;
3469 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
3470 std::unique_lock<std::mutex> lock(global_lock);
3471 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00904);
3472 skip_call |=
3473 ValidateObject(device, descriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, true, VALIDATION_ERROR_00905);
3474 lock.unlock();
3475 if (skip_call) {
3476 return;
3477 }
3478 // A DescriptorPool's descriptor sets are implicitly deleted when the pool is deleted.
3479 // Remove this pool's descriptor sets from our descriptorSet map.
3480 lock.lock();
3481 std::unordered_map<uint64_t, OBJTRACK_NODE *>::iterator itr =
3482 device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT].begin();
3483 while (itr != device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT].end()) {
3484 OBJTRACK_NODE *pNode = (*itr).second;
3485 auto del_itr = itr++;
3486 if (pNode->parent_object == reinterpret_cast<uint64_t &>(descriptorPool)) {
3487 DestroyObject(device, (VkDescriptorSet)((*del_itr).first),
3488 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, nullptr);
3489 }
3490 }
3491 DestroyObject(device, descriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, pAllocator);
3492 lock.unlock();
3493 get_dispatch_table(ot_device_table_map, device)->DestroyDescriptorPool(device, descriptorPool, pAllocator);
3494 }
3495
DestroyCommandPool(VkDevice device,VkCommandPool commandPool,const VkAllocationCallbacks * pAllocator)3496 VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) {
3497 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
3498 bool skip_call = false;
3499 std::unique_lock<std::mutex> lock(global_lock);
3500 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00080);
3501 skip_call |= ValidateObject(device, commandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, true, VALIDATION_ERROR_00081);
3502 lock.unlock();
3503 if (skip_call) {
3504 return;
3505 }
3506 lock.lock();
3507 // A CommandPool's command buffers are implicitly deleted when the pool is deleted.
3508 // Remove this pool's cmdBuffers from our cmd buffer map.
3509 auto itr = device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT].begin();
3510 auto del_itr = itr;
3511 while (itr != device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT].end()) {
3512 OBJTRACK_NODE *pNode = (*itr).second;
3513 del_itr = itr++;
3514 if (pNode->parent_object == reinterpret_cast<uint64_t &>(commandPool)) {
3515 skip_call |= ValidateCommandBuffer(device, commandPool, reinterpret_cast<VkCommandBuffer>((*del_itr).first));
3516 DestroyObject(device, reinterpret_cast<VkCommandBuffer>((*del_itr).first),
3517 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, nullptr);
3518 }
3519 }
3520 DestroyObject(device, commandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, pAllocator);
3521 lock.unlock();
3522 get_dispatch_table(ot_device_table_map, device)->DestroyCommandPool(device, commandPool, pAllocator);
3523 }
3524
GetSwapchainImagesKHR(VkDevice device,VkSwapchainKHR swapchain,uint32_t * pSwapchainImageCount,VkImage * pSwapchainImages)3525 VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount,
3526 VkImage *pSwapchainImages) {
3527 bool skip_call = VK_FALSE;
3528 std::unique_lock<std::mutex> lock(global_lock);
3529 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
3530 lock.unlock();
3531 if (skip_call) {
3532 return VK_ERROR_VALIDATION_FAILED_EXT;
3533 }
3534 VkResult result = get_dispatch_table(ot_device_table_map, device)
3535 ->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
3536 if (pSwapchainImages != NULL) {
3537 lock.lock();
3538 for (uint32_t i = 0; i < *pSwapchainImageCount; i++) {
3539 CreateSwapchainImageObject(device, pSwapchainImages[i], swapchain);
3540 }
3541 lock.unlock();
3542 }
3543 return result;
3544 }
3545
CreateGraphicsPipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)3546 VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
3547 const VkGraphicsPipelineCreateInfo *pCreateInfos,
3548 const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
3549 bool skip_call = VK_FALSE;
3550 std::unique_lock<std::mutex> lock(global_lock);
3551 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00519);
3552 if (pCreateInfos) {
3553 for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
3554 if (pCreateInfos[idx0].basePipelineHandle) {
3555 skip_call |= ValidateObject(device, pCreateInfos[idx0].basePipelineHandle,
3556 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, true);
3557 }
3558 if (pCreateInfos[idx0].layout) {
3559 skip_call |= ValidateObject(device, pCreateInfos[idx0].layout,
3560 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, false);
3561 }
3562 if (pCreateInfos[idx0].pStages) {
3563 for (uint32_t idx1 = 0; idx1 < pCreateInfos[idx0].stageCount; ++idx1) {
3564 if (pCreateInfos[idx0].pStages[idx1].module) {
3565 skip_call |= ValidateObject(device, pCreateInfos[idx0].pStages[idx1].module,
3566 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, false);
3567 }
3568 }
3569 }
3570 if (pCreateInfos[idx0].renderPass) {
3571 skip_call |= ValidateObject(device, pCreateInfos[idx0].renderPass,
3572 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, false);
3573 }
3574 }
3575 }
3576 if (pipelineCache) {
3577 skip_call |=
3578 ValidateObject(device, pipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, true, VALIDATION_ERROR_00520);
3579 }
3580 lock.unlock();
3581 if (skip_call) {
3582 return VK_ERROR_VALIDATION_FAILED_EXT;
3583 }
3584 VkResult result = get_dispatch_table(ot_device_table_map, device)
3585 ->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3586 lock.lock();
3587 if (result == VK_SUCCESS) {
3588 for (uint32_t idx2 = 0; idx2 < createInfoCount; ++idx2) {
3589 CreateObject(device, pPipelines[idx2], VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, pAllocator);
3590 }
3591 }
3592 lock.unlock();
3593 return result;
3594 }
3595
CreateComputePipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines)3596 VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
3597 const VkComputePipelineCreateInfo *pCreateInfos,
3598 const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
3599 bool skip_call = VK_FALSE;
3600 std::unique_lock<std::mutex> lock(global_lock);
3601 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00486);
3602 if (pCreateInfos) {
3603 for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
3604 if (pCreateInfos[idx0].basePipelineHandle) {
3605 skip_call |= ValidateObject(device, pCreateInfos[idx0].basePipelineHandle,
3606 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, true);
3607 }
3608 if (pCreateInfos[idx0].layout) {
3609 skip_call |= ValidateObject(device, pCreateInfos[idx0].layout,
3610 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, false);
3611 }
3612 if (pCreateInfos[idx0].stage.module) {
3613 skip_call |= ValidateObject(device, pCreateInfos[idx0].stage.module,
3614 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, false);
3615 }
3616 }
3617 }
3618 if (pipelineCache) {
3619 skip_call |=
3620 ValidateObject(device, pipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, true, VALIDATION_ERROR_00487);
3621 }
3622 lock.unlock();
3623 if (skip_call) {
3624 return VK_ERROR_VALIDATION_FAILED_EXT;
3625 }
3626 VkResult result = get_dispatch_table(ot_device_table_map, device)
3627 ->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
3628 lock.lock();
3629 if (result == VK_SUCCESS) {
3630 for (uint32_t idx1 = 0; idx1 < createInfoCount; ++idx1) {
3631 CreateObject(device, pPipelines[idx1], VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, pAllocator);
3632 }
3633 }
3634 lock.unlock();
3635 return result;
3636 }
3637
3638 // VK_EXT_debug_marker Extension
DebugMarkerSetObjectTagEXT(VkDevice device,VkDebugMarkerObjectTagInfoEXT * pTagInfo)3639 VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo) {
3640 bool skip_call = VK_FALSE;
3641 std::unique_lock<std::mutex> lock(global_lock);
3642 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
3643 lock.unlock();
3644 if (skip_call) {
3645 return VK_ERROR_VALIDATION_FAILED_EXT;
3646 }
3647 VkResult result = get_dispatch_table(ot_device_table_map, device)->DebugMarkerSetObjectTagEXT(device, pTagInfo);
3648 return result;
3649 }
3650
DebugMarkerSetObjectNameEXT(VkDevice device,VkDebugMarkerObjectNameInfoEXT * pNameInfo)3651 VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo) {
3652 bool skip_call = VK_FALSE;
3653 std::unique_lock<std::mutex> lock(global_lock);
3654 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
3655 lock.unlock();
3656 if (skip_call) {
3657 return VK_ERROR_VALIDATION_FAILED_EXT;
3658 }
3659 VkResult result = get_dispatch_table(ot_device_table_map, device)->DebugMarkerSetObjectNameEXT(device, pNameInfo);
3660 return result;
3661 }
3662
CmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer,VkDebugMarkerMarkerInfoEXT * pMarkerInfo)3663 VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT *pMarkerInfo) {
3664 bool skip_call = VK_FALSE;
3665 std::unique_lock<std::mutex> lock(global_lock);
3666 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false);
3667 lock.unlock();
3668 if (!skip_call) {
3669 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
3670 }
3671 }
3672
CmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)3673 VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) {
3674 bool skip_call = VK_FALSE;
3675 std::unique_lock<std::mutex> lock(global_lock);
3676 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false);
3677 lock.unlock();
3678 if (!skip_call) {
3679 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDebugMarkerEndEXT(commandBuffer);
3680 }
3681 }
3682
CmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer,VkDebugMarkerMarkerInfoEXT * pMarkerInfo)3683 VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT *pMarkerInfo) {
3684 bool skip_call = VK_FALSE;
3685 std::unique_lock<std::mutex> lock(global_lock);
3686 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false);
3687 lock.unlock();
3688 if (!skip_call) {
3689 get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
3690 }
3691 }
3692
3693 // VK_NV_external_memory_capabilities Extension
GetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkExternalMemoryHandleTypeFlagsNV externalHandleType,VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties)3694 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV(
3695 VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage,
3696 VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType,
3697 VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) {
3698
3699 bool skip_call = false;
3700 {
3701 std::lock_guard<std::mutex> lock(global_lock);
3702 skip_call |= ValidateObject(physicalDevice, physicalDevice, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, false);
3703 }
3704 if (skip_call) {
3705 return VK_ERROR_VALIDATION_FAILED_EXT;
3706 }
3707 VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)
3708 ->GetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags,
3709 externalHandleType, pExternalImageFormatProperties);
3710 return result;
3711 }
3712
3713 #ifdef VK_USE_PLATFORM_WIN32_KHR
3714 // VK_NV_external_memory_win32 Extension
GetMemoryWin32HandleNV(VkDevice device,VkDeviceMemory memory,VkExternalMemoryHandleTypeFlagsNV handleType,HANDLE * pHandle)3715 VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory,
3716 VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle) {
3717 bool skip_call = VK_FALSE;
3718 std::unique_lock<std::mutex> lock(global_lock);
3719 skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
3720 skip_call |= ValidateObject(device, memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, false);
3721 lock.unlock();
3722 if (skip_call) {
3723 return VK_ERROR_VALIDATION_FAILED_EXT;
3724 }
3725 VkResult result = get_dispatch_table(ot_device_table_map, device)->GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
3726 return result;
3727 }
3728 #endif // VK_USE_PLATFORM_WIN32_KHR
3729
3730 // VK_AMD_draw_indirect_count Extension
CmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride)3731 VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
3732 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
3733 uint32_t stride) {
3734 bool skip_call = VK_FALSE;
3735 std::unique_lock<std::mutex> lock(global_lock);
3736 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
3737 skip_call |= ValidateObject(commandBuffer, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false);
3738 lock.unlock();
3739 if (!skip_call) {
3740 get_dispatch_table(ot_device_table_map, commandBuffer)
3741 ->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
3742 }
3743 }
3744
CmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride)3745 VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
3746 VkBuffer countBuffer, VkDeviceSize countBufferOffset,
3747 uint32_t maxDrawCount, uint32_t stride) {
3748 bool skip_call = VK_FALSE;
3749 std::unique_lock<std::mutex> lock(global_lock);
3750 skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false);
3751 skip_call |= ValidateObject(commandBuffer, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, false);
3752 lock.unlock();
3753 if (!skip_call) {
3754 get_dispatch_table(ot_device_table_map, commandBuffer)
3755 ->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
3756 }
3757 }
3758
3759
InterceptCoreDeviceCommand(const char * name)3760 static inline PFN_vkVoidFunction InterceptCoreDeviceCommand(const char *name) {
3761 if (!name || name[0] != 'v' || name[1] != 'k')
3762 return NULL;
3763
3764 name += 2;
3765 if (!strcmp(name, "GetDeviceProcAddr"))
3766 return (PFN_vkVoidFunction)GetDeviceProcAddr;
3767 if (!strcmp(name, "DestroyDevice"))
3768 return (PFN_vkVoidFunction)DestroyDevice;
3769 if (!strcmp(name, "GetDeviceQueue"))
3770 return (PFN_vkVoidFunction)GetDeviceQueue;
3771 if (!strcmp(name, "QueueSubmit"))
3772 return (PFN_vkVoidFunction)QueueSubmit;
3773 if (!strcmp(name, "QueueWaitIdle"))
3774 return (PFN_vkVoidFunction)QueueWaitIdle;
3775 if (!strcmp(name, "DeviceWaitIdle"))
3776 return (PFN_vkVoidFunction)DeviceWaitIdle;
3777 if (!strcmp(name, "AllocateMemory"))
3778 return (PFN_vkVoidFunction)AllocateMemory;
3779 if (!strcmp(name, "FreeMemory"))
3780 return (PFN_vkVoidFunction)FreeMemory;
3781 if (!strcmp(name, "MapMemory"))
3782 return (PFN_vkVoidFunction)MapMemory;
3783 if (!strcmp(name, "UnmapMemory"))
3784 return (PFN_vkVoidFunction)UnmapMemory;
3785 if (!strcmp(name, "FlushMappedMemoryRanges"))
3786 return (PFN_vkVoidFunction)FlushMappedMemoryRanges;
3787 if (!strcmp(name, "InvalidateMappedMemoryRanges"))
3788 return (PFN_vkVoidFunction)InvalidateMappedMemoryRanges;
3789 if (!strcmp(name, "GetDeviceMemoryCommitment"))
3790 return (PFN_vkVoidFunction)GetDeviceMemoryCommitment;
3791 if (!strcmp(name, "BindBufferMemory"))
3792 return (PFN_vkVoidFunction)BindBufferMemory;
3793 if (!strcmp(name, "BindImageMemory"))
3794 return (PFN_vkVoidFunction)BindImageMemory;
3795 if (!strcmp(name, "GetBufferMemoryRequirements"))
3796 return (PFN_vkVoidFunction)GetBufferMemoryRequirements;
3797 if (!strcmp(name, "GetImageMemoryRequirements"))
3798 return (PFN_vkVoidFunction)GetImageMemoryRequirements;
3799 if (!strcmp(name, "GetImageSparseMemoryRequirements"))
3800 return (PFN_vkVoidFunction)GetImageSparseMemoryRequirements;
3801 if (!strcmp(name, "QueueBindSparse"))
3802 return (PFN_vkVoidFunction)QueueBindSparse;
3803 if (!strcmp(name, "CreateFence"))
3804 return (PFN_vkVoidFunction)CreateFence;
3805 if (!strcmp(name, "DestroyFence"))
3806 return (PFN_vkVoidFunction)DestroyFence;
3807 if (!strcmp(name, "ResetFences"))
3808 return (PFN_vkVoidFunction)ResetFences;
3809 if (!strcmp(name, "GetFenceStatus"))
3810 return (PFN_vkVoidFunction)GetFenceStatus;
3811 if (!strcmp(name, "WaitForFences"))
3812 return (PFN_vkVoidFunction)WaitForFences;
3813 if (!strcmp(name, "CreateSemaphore"))
3814 return (PFN_vkVoidFunction)CreateSemaphore;
3815 if (!strcmp(name, "DestroySemaphore"))
3816 return (PFN_vkVoidFunction)DestroySemaphore;
3817 if (!strcmp(name, "CreateEvent"))
3818 return (PFN_vkVoidFunction)CreateEvent;
3819 if (!strcmp(name, "DestroyEvent"))
3820 return (PFN_vkVoidFunction)DestroyEvent;
3821 if (!strcmp(name, "GetEventStatus"))
3822 return (PFN_vkVoidFunction)GetEventStatus;
3823 if (!strcmp(name, "SetEvent"))
3824 return (PFN_vkVoidFunction)SetEvent;
3825 if (!strcmp(name, "ResetEvent"))
3826 return (PFN_vkVoidFunction)ResetEvent;
3827 if (!strcmp(name, "CreateQueryPool"))
3828 return (PFN_vkVoidFunction)CreateQueryPool;
3829 if (!strcmp(name, "DestroyQueryPool"))
3830 return (PFN_vkVoidFunction)DestroyQueryPool;
3831 if (!strcmp(name, "GetQueryPoolResults"))
3832 return (PFN_vkVoidFunction)GetQueryPoolResults;
3833 if (!strcmp(name, "CreateBuffer"))
3834 return (PFN_vkVoidFunction)CreateBuffer;
3835 if (!strcmp(name, "DestroyBuffer"))
3836 return (PFN_vkVoidFunction)DestroyBuffer;
3837 if (!strcmp(name, "CreateBufferView"))
3838 return (PFN_vkVoidFunction)CreateBufferView;
3839 if (!strcmp(name, "DestroyBufferView"))
3840 return (PFN_vkVoidFunction)DestroyBufferView;
3841 if (!strcmp(name, "CreateImage"))
3842 return (PFN_vkVoidFunction)CreateImage;
3843 if (!strcmp(name, "DestroyImage"))
3844 return (PFN_vkVoidFunction)DestroyImage;
3845 if (!strcmp(name, "GetImageSubresourceLayout"))
3846 return (PFN_vkVoidFunction)GetImageSubresourceLayout;
3847 if (!strcmp(name, "CreateImageView"))
3848 return (PFN_vkVoidFunction)CreateImageView;
3849 if (!strcmp(name, "DestroyImageView"))
3850 return (PFN_vkVoidFunction)DestroyImageView;
3851 if (!strcmp(name, "CreateShaderModule"))
3852 return (PFN_vkVoidFunction)CreateShaderModule;
3853 if (!strcmp(name, "DestroyShaderModule"))
3854 return (PFN_vkVoidFunction)DestroyShaderModule;
3855 if (!strcmp(name, "CreatePipelineCache"))
3856 return (PFN_vkVoidFunction)CreatePipelineCache;
3857 if (!strcmp(name, "DestroyPipelineCache"))
3858 return (PFN_vkVoidFunction)DestroyPipelineCache;
3859 if (!strcmp(name, "GetPipelineCacheData"))
3860 return (PFN_vkVoidFunction)GetPipelineCacheData;
3861 if (!strcmp(name, "MergePipelineCaches"))
3862 return (PFN_vkVoidFunction)MergePipelineCaches;
3863 if (!strcmp(name, "CreateGraphicsPipelines"))
3864 return (PFN_vkVoidFunction)CreateGraphicsPipelines;
3865 if (!strcmp(name, "CreateComputePipelines"))
3866 return (PFN_vkVoidFunction)CreateComputePipelines;
3867 if (!strcmp(name, "DestroyPipeline"))
3868 return (PFN_vkVoidFunction)DestroyPipeline;
3869 if (!strcmp(name, "CreatePipelineLayout"))
3870 return (PFN_vkVoidFunction)CreatePipelineLayout;
3871 if (!strcmp(name, "DestroyPipelineLayout"))
3872 return (PFN_vkVoidFunction)DestroyPipelineLayout;
3873 if (!strcmp(name, "CreateSampler"))
3874 return (PFN_vkVoidFunction)CreateSampler;
3875 if (!strcmp(name, "DestroySampler"))
3876 return (PFN_vkVoidFunction)DestroySampler;
3877 if (!strcmp(name, "CreateDescriptorSetLayout"))
3878 return (PFN_vkVoidFunction)CreateDescriptorSetLayout;
3879 if (!strcmp(name, "DestroyDescriptorSetLayout"))
3880 return (PFN_vkVoidFunction)DestroyDescriptorSetLayout;
3881 if (!strcmp(name, "CreateDescriptorPool"))
3882 return (PFN_vkVoidFunction)CreateDescriptorPool;
3883 if (!strcmp(name, "DestroyDescriptorPool"))
3884 return (PFN_vkVoidFunction)DestroyDescriptorPool;
3885 if (!strcmp(name, "ResetDescriptorPool"))
3886 return (PFN_vkVoidFunction)ResetDescriptorPool;
3887 if (!strcmp(name, "AllocateDescriptorSets"))
3888 return (PFN_vkVoidFunction)AllocateDescriptorSets;
3889 if (!strcmp(name, "FreeDescriptorSets"))
3890 return (PFN_vkVoidFunction)FreeDescriptorSets;
3891 if (!strcmp(name, "UpdateDescriptorSets"))
3892 return (PFN_vkVoidFunction)UpdateDescriptorSets;
3893 if (!strcmp(name, "CreateFramebuffer"))
3894 return (PFN_vkVoidFunction)CreateFramebuffer;
3895 if (!strcmp(name, "DestroyFramebuffer"))
3896 return (PFN_vkVoidFunction)DestroyFramebuffer;
3897 if (!strcmp(name, "CreateRenderPass"))
3898 return (PFN_vkVoidFunction)CreateRenderPass;
3899 if (!strcmp(name, "DestroyRenderPass"))
3900 return (PFN_vkVoidFunction)DestroyRenderPass;
3901 if (!strcmp(name, "GetRenderAreaGranularity"))
3902 return (PFN_vkVoidFunction)GetRenderAreaGranularity;
3903 if (!strcmp(name, "CreateCommandPool"))
3904 return (PFN_vkVoidFunction)CreateCommandPool;
3905 if (!strcmp(name, "DestroyCommandPool"))
3906 return (PFN_vkVoidFunction)DestroyCommandPool;
3907 if (!strcmp(name, "ResetCommandPool"))
3908 return (PFN_vkVoidFunction)ResetCommandPool;
3909 if (!strcmp(name, "AllocateCommandBuffers"))
3910 return (PFN_vkVoidFunction)AllocateCommandBuffers;
3911 if (!strcmp(name, "FreeCommandBuffers"))
3912 return (PFN_vkVoidFunction)FreeCommandBuffers;
3913 if (!strcmp(name, "BeginCommandBuffer"))
3914 return (PFN_vkVoidFunction)BeginCommandBuffer;
3915 if (!strcmp(name, "EndCommandBuffer"))
3916 return (PFN_vkVoidFunction)EndCommandBuffer;
3917 if (!strcmp(name, "ResetCommandBuffer"))
3918 return (PFN_vkVoidFunction)ResetCommandBuffer;
3919 if (!strcmp(name, "CmdBindPipeline"))
3920 return (PFN_vkVoidFunction)CmdBindPipeline;
3921 if (!strcmp(name, "CmdSetViewport"))
3922 return (PFN_vkVoidFunction)CmdSetViewport;
3923 if (!strcmp(name, "CmdSetScissor"))
3924 return (PFN_vkVoidFunction)CmdSetScissor;
3925 if (!strcmp(name, "CmdSetLineWidth"))
3926 return (PFN_vkVoidFunction)CmdSetLineWidth;
3927 if (!strcmp(name, "CmdSetDepthBias"))
3928 return (PFN_vkVoidFunction)CmdSetDepthBias;
3929 if (!strcmp(name, "CmdSetBlendConstants"))
3930 return (PFN_vkVoidFunction)CmdSetBlendConstants;
3931 if (!strcmp(name, "CmdSetDepthBounds"))
3932 return (PFN_vkVoidFunction)CmdSetDepthBounds;
3933 if (!strcmp(name, "CmdSetStencilCompareMask"))
3934 return (PFN_vkVoidFunction)CmdSetStencilCompareMask;
3935 if (!strcmp(name, "CmdSetStencilWriteMask"))
3936 return (PFN_vkVoidFunction)CmdSetStencilWriteMask;
3937 if (!strcmp(name, "CmdSetStencilReference"))
3938 return (PFN_vkVoidFunction)CmdSetStencilReference;
3939 if (!strcmp(name, "CmdBindDescriptorSets"))
3940 return (PFN_vkVoidFunction)CmdBindDescriptorSets;
3941 if (!strcmp(name, "CmdBindIndexBuffer"))
3942 return (PFN_vkVoidFunction)CmdBindIndexBuffer;
3943 if (!strcmp(name, "CmdBindVertexBuffers"))
3944 return (PFN_vkVoidFunction)CmdBindVertexBuffers;
3945 if (!strcmp(name, "CmdDraw"))
3946 return (PFN_vkVoidFunction)CmdDraw;
3947 if (!strcmp(name, "CmdDrawIndexed"))
3948 return (PFN_vkVoidFunction)CmdDrawIndexed;
3949 if (!strcmp(name, "CmdDrawIndirect"))
3950 return (PFN_vkVoidFunction)CmdDrawIndirect;
3951 if (!strcmp(name, "CmdDrawIndexedIndirect"))
3952 return (PFN_vkVoidFunction)CmdDrawIndexedIndirect;
3953 if (!strcmp(name, "CmdDispatch"))
3954 return (PFN_vkVoidFunction)CmdDispatch;
3955 if (!strcmp(name, "CmdDispatchIndirect"))
3956 return (PFN_vkVoidFunction)CmdDispatchIndirect;
3957 if (!strcmp(name, "CmdCopyBuffer"))
3958 return (PFN_vkVoidFunction)CmdCopyBuffer;
3959 if (!strcmp(name, "CmdCopyImage"))
3960 return (PFN_vkVoidFunction)CmdCopyImage;
3961 if (!strcmp(name, "CmdBlitImage"))
3962 return (PFN_vkVoidFunction)CmdBlitImage;
3963 if (!strcmp(name, "CmdCopyBufferToImage"))
3964 return (PFN_vkVoidFunction)CmdCopyBufferToImage;
3965 if (!strcmp(name, "CmdCopyImageToBuffer"))
3966 return (PFN_vkVoidFunction)CmdCopyImageToBuffer;
3967 if (!strcmp(name, "CmdUpdateBuffer"))
3968 return (PFN_vkVoidFunction)CmdUpdateBuffer;
3969 if (!strcmp(name, "CmdFillBuffer"))
3970 return (PFN_vkVoidFunction)CmdFillBuffer;
3971 if (!strcmp(name, "CmdClearColorImage"))
3972 return (PFN_vkVoidFunction)CmdClearColorImage;
3973 if (!strcmp(name, "CmdClearDepthStencilImage"))
3974 return (PFN_vkVoidFunction)CmdClearDepthStencilImage;
3975 if (!strcmp(name, "CmdClearAttachments"))
3976 return (PFN_vkVoidFunction)CmdClearAttachments;
3977 if (!strcmp(name, "CmdResolveImage"))
3978 return (PFN_vkVoidFunction)CmdResolveImage;
3979 if (!strcmp(name, "CmdSetEvent"))
3980 return (PFN_vkVoidFunction)CmdSetEvent;
3981 if (!strcmp(name, "CmdResetEvent"))
3982 return (PFN_vkVoidFunction)CmdResetEvent;
3983 if (!strcmp(name, "CmdWaitEvents"))
3984 return (PFN_vkVoidFunction)CmdWaitEvents;
3985 if (!strcmp(name, "CmdPipelineBarrier"))
3986 return (PFN_vkVoidFunction)CmdPipelineBarrier;
3987 if (!strcmp(name, "CmdBeginQuery"))
3988 return (PFN_vkVoidFunction)CmdBeginQuery;
3989 if (!strcmp(name, "CmdEndQuery"))
3990 return (PFN_vkVoidFunction)CmdEndQuery;
3991 if (!strcmp(name, "CmdResetQueryPool"))
3992 return (PFN_vkVoidFunction)CmdResetQueryPool;
3993 if (!strcmp(name, "CmdWriteTimestamp"))
3994 return (PFN_vkVoidFunction)CmdWriteTimestamp;
3995 if (!strcmp(name, "CmdCopyQueryPoolResults"))
3996 return (PFN_vkVoidFunction)CmdCopyQueryPoolResults;
3997 if (!strcmp(name, "CmdPushConstants"))
3998 return (PFN_vkVoidFunction)CmdPushConstants;
3999 if (!strcmp(name, "CmdBeginRenderPass"))
4000 return (PFN_vkVoidFunction)CmdBeginRenderPass;
4001 if (!strcmp(name, "CmdNextSubpass"))
4002 return (PFN_vkVoidFunction)CmdNextSubpass;
4003 if (!strcmp(name, "CmdEndRenderPass"))
4004 return (PFN_vkVoidFunction)CmdEndRenderPass;
4005 if (!strcmp(name, "CmdExecuteCommands"))
4006 return (PFN_vkVoidFunction)CmdExecuteCommands;
4007 if (!strcmp(name, "DebugMarkerSetObjectTagEXT"))
4008 return (PFN_vkVoidFunction)DebugMarkerSetObjectTagEXT;
4009 if (!strcmp(name, "DebugMarkerSetObjectNameEXT"))
4010 return (PFN_vkVoidFunction)DebugMarkerSetObjectNameEXT;
4011 if (!strcmp(name, "CmdDebugMarkerBeginEXT"))
4012 return (PFN_vkVoidFunction)CmdDebugMarkerBeginEXT;
4013 if (!strcmp(name, "CmdDebugMarkerEndEXT"))
4014 return (PFN_vkVoidFunction)CmdDebugMarkerEndEXT;
4015 if (!strcmp(name, "CmdDebugMarkerInsertEXT"))
4016 return (PFN_vkVoidFunction)CmdDebugMarkerInsertEXT;
4017 #ifdef VK_USE_PLATFORM_WIN32_KHR
4018 if (!strcmp(name, "GetMemoryWin32HandleNV"))
4019 return (PFN_vkVoidFunction)GetMemoryWin32HandleNV;
4020 #endif // VK_USE_PLATFORM_WIN32_KHR
4021 if (!strcmp(name, "CmdDrawIndirectCountAMD"))
4022 return (PFN_vkVoidFunction)CmdDrawIndirectCountAMD;
4023 if (!strcmp(name, "CmdDrawIndexedIndirectCountAMD"))
4024 return (PFN_vkVoidFunction)CmdDrawIndexedIndirectCountAMD;
4025
4026 return NULL;
4027 }
InterceptCoreInstanceCommand(const char * name)4028 static inline PFN_vkVoidFunction InterceptCoreInstanceCommand(const char *name) {
4029 if (!name || name[0] != 'v' || name[1] != 'k')
4030 return NULL;
4031
4032 name += 2;
4033 if (!strcmp(name, "CreateInstance"))
4034 return (PFN_vkVoidFunction)CreateInstance;
4035 if (!strcmp(name, "DestroyInstance"))
4036 return (PFN_vkVoidFunction)DestroyInstance;
4037 if (!strcmp(name, "EnumeratePhysicalDevices"))
4038 return (PFN_vkVoidFunction)EnumeratePhysicalDevices;
4039 if (!strcmp(name, "GetPhysicalDeviceFeatures"))
4040 return (PFN_vkVoidFunction)GetPhysicalDeviceFeatures;
4041 if (!strcmp(name, "GetPhysicalDeviceFormatProperties"))
4042 return (PFN_vkVoidFunction)GetPhysicalDeviceFormatProperties;
4043 if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties"))
4044 return (PFN_vkVoidFunction)GetPhysicalDeviceImageFormatProperties;
4045 if (!strcmp(name, "GetPhysicalDeviceProperties"))
4046 return (PFN_vkVoidFunction)GetPhysicalDeviceProperties;
4047 if (!strcmp(name, "GetPhysicalDeviceQueueFamilyProperties"))
4048 return (PFN_vkVoidFunction)GetPhysicalDeviceQueueFamilyProperties;
4049 if (!strcmp(name, "GetPhysicalDeviceMemoryProperties"))
4050 return (PFN_vkVoidFunction)GetPhysicalDeviceMemoryProperties;
4051 if (!strcmp(name, "GetInstanceProcAddr"))
4052 return (PFN_vkVoidFunction)GetInstanceProcAddr;
4053 if (!strcmp(name, "CreateDevice"))
4054 return (PFN_vkVoidFunction)CreateDevice;
4055 if (!strcmp(name, "EnumerateInstanceExtensionProperties"))
4056 return (PFN_vkVoidFunction)EnumerateInstanceExtensionProperties;
4057 if (!strcmp(name, "EnumerateInstanceLayerProperties"))
4058 return (PFN_vkVoidFunction)EnumerateInstanceLayerProperties;
4059 if (!strcmp(name, "EnumerateDeviceLayerProperties"))
4060 return (PFN_vkVoidFunction)EnumerateDeviceLayerProperties;
4061 if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties"))
4062 return (PFN_vkVoidFunction)GetPhysicalDeviceSparseImageFormatProperties;
4063 if (!strcmp(name, "GetPhysicalDeviceExternalImageFormatPropertiesNV"))
4064 return (PFN_vkVoidFunction)GetPhysicalDeviceExternalImageFormatPropertiesNV;
4065
4066 return NULL;
4067 }
4068
InterceptWsiEnabledCommand(const char * name,VkDevice device)4069 static inline PFN_vkVoidFunction InterceptWsiEnabledCommand(const char *name, VkDevice device) {
4070 if (device) {
4071 layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
4072
4073 if (device_data->wsi_enabled) {
4074 if (!strcmp("vkCreateSwapchainKHR", name))
4075 return reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR);
4076 if (!strcmp("vkDestroySwapchainKHR", name))
4077 return reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR);
4078 if (!strcmp("vkGetSwapchainImagesKHR", name))
4079 return reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR);
4080 if (!strcmp("vkAcquireNextImageKHR", name))
4081 return reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR);
4082 if (!strcmp("vkQueuePresentKHR", name))
4083 return reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR);
4084 }
4085
4086 if (device_data->wsi_display_swapchain_enabled) {
4087 if (!strcmp("vkCreateSharedSwapchainsKHR", name)) {
4088 return reinterpret_cast<PFN_vkVoidFunction>(CreateSharedSwapchainsKHR);
4089 }
4090 }
4091 }
4092
4093 return nullptr;
4094 }
4095
GetDeviceProcAddr(VkDevice device,const char * funcName)4096 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) {
4097 PFN_vkVoidFunction addr;
4098 addr = InterceptCoreDeviceCommand(funcName);
4099 if (addr) {
4100 return addr;
4101 }
4102 assert(device);
4103
4104 addr = InterceptWsiEnabledCommand(funcName, device);
4105 if (addr) {
4106 return addr;
4107 }
4108 if (get_dispatch_table(ot_device_table_map, device)->GetDeviceProcAddr == NULL) {
4109 return NULL;
4110 }
4111 return get_dispatch_table(ot_device_table_map, device)->GetDeviceProcAddr(device, funcName);
4112 }
4113
GetInstanceProcAddr(VkInstance instance,const char * funcName)4114 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) {
4115 PFN_vkVoidFunction addr;
4116 addr = InterceptCoreInstanceCommand(funcName);
4117 if (!addr) {
4118 addr = InterceptCoreDeviceCommand(funcName);
4119 }
4120 if (!addr) {
4121 addr = InterceptWsiEnabledCommand(funcName, VkDevice(VK_NULL_HANDLE));
4122 }
4123 if (addr) {
4124 return addr;
4125 }
4126 assert(instance);
4127
4128 addr = InterceptMsgCallbackGetProcAddrCommand(funcName, instance);
4129 if (addr) {
4130 return addr;
4131 }
4132 addr = InterceptWsiEnabledCommand(funcName, instance);
4133 if (addr) {
4134 return addr;
4135 }
4136 if (get_dispatch_table(ot_instance_table_map, instance)->GetInstanceProcAddr == NULL) {
4137 return NULL;
4138 }
4139 return get_dispatch_table(ot_instance_table_map, instance)->GetInstanceProcAddr(instance, funcName);
4140 }
4141
4142 } // namespace object_tracker
4143
4144 // vk_layer_logging.h expects these to be defined
vkCreateDebugReportCallbackEXT(VkInstance instance,const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDebugReportCallbackEXT * pMsgCallback)4145 VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance,
4146 const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
4147 const VkAllocationCallbacks *pAllocator,
4148 VkDebugReportCallbackEXT *pMsgCallback) {
4149 return object_tracker::CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
4150 }
4151
vkDestroyDebugReportCallbackEXT(VkInstance instance,VkDebugReportCallbackEXT msgCallback,const VkAllocationCallbacks * pAllocator)4152 VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
4153 const VkAllocationCallbacks *pAllocator) {
4154 object_tracker::DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
4155 }
4156
vkDebugReportMessageEXT(VkInstance instance,VkDebugReportFlagsEXT flags,VkDebugReportObjectTypeEXT objType,uint64_t object,size_t location,int32_t msgCode,const char * pLayerPrefix,const char * pMsg)4157 VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
4158 VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
4159 int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
4160 object_tracker::DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
4161 }
4162
4163 // Loader-layer interface v0, just wrappers since there is only a layer
vkEnumerateInstanceExtensionProperties(const char * pLayerName,uint32_t * pCount,VkExtensionProperties * pProperties)4164 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,
4165 VkExtensionProperties *pProperties) {
4166 return object_tracker::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
4167 }
4168
vkEnumerateInstanceLayerProperties(uint32_t * pCount,VkLayerProperties * pProperties)4169 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount,
4170 VkLayerProperties *pProperties) {
4171 return object_tracker::EnumerateInstanceLayerProperties(pCount, pProperties);
4172 }
4173
vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,uint32_t * pCount,VkLayerProperties * pProperties)4174 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
4175 VkLayerProperties *pProperties) {
4176 // The layer command handles VK_NULL_HANDLE just fine internally
4177 assert(physicalDevice == VK_NULL_HANDLE);
4178 return object_tracker::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties);
4179 }
4180
vkGetDeviceProcAddr(VkDevice dev,const char * funcName)4181 VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) {
4182 return object_tracker::GetDeviceProcAddr(dev, funcName);
4183 }
4184
vkGetInstanceProcAddr(VkInstance instance,const char * funcName)4185 VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) {
4186 return object_tracker::GetInstanceProcAddr(instance, funcName);
4187 }
4188
vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pCount,VkExtensionProperties * pProperties)4189 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
4190 const char *pLayerName, uint32_t *pCount,
4191 VkExtensionProperties *pProperties) {
4192 // The layer command handles VK_NULL_HANDLE just fine internally
4193 assert(physicalDevice == VK_NULL_HANDLE);
4194 return object_tracker::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties);
4195 }
4196