driver_gen.cpp revision 6a58a8a7813450038cb15575e3333b83f268c972
1/* 2 * Copyright 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17// WARNING: This file is generated. See ../README.md for instructions. 18 19#include <string.h> 20#include <algorithm> 21#include <log/log.h> 22 23#include "driver.h" 24#include "loader.h" 25 26namespace vulkan { 27namespace driver { 28 29namespace { 30 31// clang-format off 32 33VKAPI_ATTR void disabledDestroySurfaceKHR(VkInstance, VkSurfaceKHR, const VkAllocationCallbacks*) { 34 ALOGE("VK_KHR_surface not enabled. vkDestroySurfaceKHR not executed."); 35} 36 37VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice, uint32_t, VkSurfaceKHR, VkBool32*) { 38 ALOGE("VK_KHR_surface not enabled. vkGetPhysicalDeviceSurfaceSupportKHR not executed."); 39 return VK_SUCCESS; 40} 41 42VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice, VkSurfaceKHR, VkSurfaceCapabilitiesKHR*) { 43 ALOGE("VK_KHR_surface not enabled. vkGetPhysicalDeviceSurfaceCapabilitiesKHR not executed."); 44 return VK_SUCCESS; 45} 46 47VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice, VkSurfaceKHR, uint32_t*, VkSurfaceFormatKHR*) { 48 ALOGE("VK_KHR_surface not enabled. vkGetPhysicalDeviceSurfaceFormatsKHR not executed."); 49 return VK_SUCCESS; 50} 51 52VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice, VkSurfaceKHR, uint32_t*, VkPresentModeKHR*) { 53 ALOGE("VK_KHR_surface not enabled. vkGetPhysicalDeviceSurfacePresentModesKHR not executed."); 54 return VK_SUCCESS; 55} 56 57VKAPI_ATTR VkResult disabledCreateSwapchainKHR(VkDevice, const VkSwapchainCreateInfoKHR*, const VkAllocationCallbacks*, VkSwapchainKHR*) { 58 ALOGE("VK_KHR_swapchain not enabled. vkCreateSwapchainKHR not executed."); 59 return VK_SUCCESS; 60} 61 62VKAPI_ATTR VkResult checkedCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { 63 return (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) ? CreateSwapchainKHR_Bottom(device, pCreateInfo, pAllocator, pSwapchain) : disabledCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); 64} 65 66VKAPI_ATTR void disabledDestroySwapchainKHR(VkDevice, VkSwapchainKHR, const VkAllocationCallbacks*) { 67 ALOGE("VK_KHR_swapchain not enabled. vkDestroySwapchainKHR not executed."); 68} 69 70VKAPI_ATTR void checkedDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { 71 (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) ? DestroySwapchainKHR_Bottom(device, swapchain, pAllocator) : disabledDestroySwapchainKHR(device, swapchain, pAllocator); 72} 73 74VKAPI_ATTR VkResult disabledGetSwapchainImagesKHR(VkDevice, VkSwapchainKHR, uint32_t*, VkImage*) { 75 ALOGE("VK_KHR_swapchain not enabled. vkGetSwapchainImagesKHR not executed."); 76 return VK_SUCCESS; 77} 78 79VKAPI_ATTR VkResult checkedGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { 80 return (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) ? GetSwapchainImagesKHR_Bottom(device, swapchain, pSwapchainImageCount, pSwapchainImages) : disabledGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); 81} 82 83VKAPI_ATTR VkResult disabledAcquireNextImageKHR(VkDevice, VkSwapchainKHR, uint64_t, VkSemaphore, VkFence, uint32_t*) { 84 ALOGE("VK_KHR_swapchain not enabled. vkAcquireNextImageKHR not executed."); 85 return VK_SUCCESS; 86} 87 88VKAPI_ATTR VkResult checkedAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { 89 return (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) ? AcquireNextImageKHR_Bottom(device, swapchain, timeout, semaphore, fence, pImageIndex) : disabledAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); 90} 91 92VKAPI_ATTR VkResult disabledQueuePresentKHR(VkQueue, const VkPresentInfoKHR*) { 93 ALOGE("VK_KHR_swapchain not enabled. vkQueuePresentKHR not executed."); 94 return VK_SUCCESS; 95} 96 97VKAPI_ATTR VkResult checkedQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { 98 return (GetData(queue).hook_extensions[ProcHook::KHR_swapchain]) ? QueuePresentKHR_Bottom(queue, pPresentInfo) : disabledQueuePresentKHR(queue, pPresentInfo); 99} 100 101VKAPI_ATTR VkResult disabledCreateAndroidSurfaceKHR(VkInstance, const VkAndroidSurfaceCreateInfoKHR*, const VkAllocationCallbacks*, VkSurfaceKHR*) { 102 ALOGE("VK_KHR_android_surface not enabled. vkCreateAndroidSurfaceKHR not executed."); 103 return VK_SUCCESS; 104} 105 106VKAPI_ATTR VkResult disabledCreateDebugReportCallbackEXT(VkInstance, const VkDebugReportCallbackCreateInfoEXT*, const VkAllocationCallbacks*, VkDebugReportCallbackEXT*) { 107 ALOGE("VK_EXT_debug_report not enabled. vkCreateDebugReportCallbackEXT not executed."); 108 return VK_SUCCESS; 109} 110 111VKAPI_ATTR void disabledDestroyDebugReportCallbackEXT(VkInstance, VkDebugReportCallbackEXT, const VkAllocationCallbacks*) { 112 ALOGE("VK_EXT_debug_report not enabled. vkDestroyDebugReportCallbackEXT not executed."); 113} 114 115VKAPI_ATTR void disabledDebugReportMessageEXT(VkInstance, VkDebugReportFlagsEXT, VkDebugReportObjectTypeEXT, uint64_t, size_t, int32_t, const char*, const char*) { 116 ALOGE("VK_EXT_debug_report not enabled. vkDebugReportMessageEXT not executed."); 117} 118 119// clang-format on 120 121const ProcHook g_proc_hooks[] = { 122 // clang-format off 123 { 124 "vkAcquireImageANDROID", 125 ProcHook::DEVICE, 126 ProcHook::ANDROID_native_buffer, 127 nullptr, 128 nullptr, 129 nullptr, 130 }, 131 { 132 "vkAcquireNextImageKHR", 133 ProcHook::DEVICE, 134 ProcHook::KHR_swapchain, 135 reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR_Bottom), 136 reinterpret_cast<PFN_vkVoidFunction>(disabledAcquireNextImageKHR), 137 reinterpret_cast<PFN_vkVoidFunction>(checkedAcquireNextImageKHR), 138 }, 139 { 140 "vkAllocateCommandBuffers", 141 ProcHook::DEVICE, 142 ProcHook::EXTENSION_CORE, 143 reinterpret_cast<PFN_vkVoidFunction>(AllocateCommandBuffers), 144 nullptr, 145 nullptr, 146 }, 147 { 148 "vkCreateAndroidSurfaceKHR", 149 ProcHook::INSTANCE, 150 ProcHook::KHR_android_surface, 151 reinterpret_cast<PFN_vkVoidFunction>(CreateAndroidSurfaceKHR_Bottom), 152 reinterpret_cast<PFN_vkVoidFunction>(disabledCreateAndroidSurfaceKHR), 153 nullptr, 154 }, 155 { 156 "vkCreateDebugReportCallbackEXT", 157 ProcHook::INSTANCE, 158 ProcHook::EXT_debug_report, 159 reinterpret_cast<PFN_vkVoidFunction>(CreateDebugReportCallbackEXT_Bottom), 160 reinterpret_cast<PFN_vkVoidFunction>(disabledCreateDebugReportCallbackEXT), 161 nullptr, 162 }, 163 { 164 "vkCreateDevice", 165 ProcHook::INSTANCE, 166 ProcHook::EXTENSION_CORE, 167 reinterpret_cast<PFN_vkVoidFunction>(CreateDevice_Bottom), 168 nullptr, 169 nullptr, 170 }, 171 { 172 "vkCreateInstance", 173 ProcHook::GLOBAL, 174 ProcHook::EXTENSION_CORE, 175 reinterpret_cast<PFN_vkVoidFunction>(CreateInstance_Bottom), 176 nullptr, 177 nullptr, 178 }, 179 { 180 "vkCreateSwapchainKHR", 181 ProcHook::DEVICE, 182 ProcHook::KHR_swapchain, 183 reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR_Bottom), 184 reinterpret_cast<PFN_vkVoidFunction>(disabledCreateSwapchainKHR), 185 reinterpret_cast<PFN_vkVoidFunction>(checkedCreateSwapchainKHR), 186 }, 187 { 188 "vkDebugReportMessageEXT", 189 ProcHook::INSTANCE, 190 ProcHook::EXT_debug_report, 191 reinterpret_cast<PFN_vkVoidFunction>(DebugReportMessageEXT_Bottom), 192 reinterpret_cast<PFN_vkVoidFunction>(disabledDebugReportMessageEXT), 193 nullptr, 194 }, 195 { 196 "vkDestroyDebugReportCallbackEXT", 197 ProcHook::INSTANCE, 198 ProcHook::EXT_debug_report, 199 reinterpret_cast<PFN_vkVoidFunction>(DestroyDebugReportCallbackEXT_Bottom), 200 reinterpret_cast<PFN_vkVoidFunction>(disabledDestroyDebugReportCallbackEXT), 201 nullptr, 202 }, 203 { 204 "vkDestroyDevice", 205 ProcHook::DEVICE, 206 ProcHook::EXTENSION_CORE, 207 reinterpret_cast<PFN_vkVoidFunction>(DestroyDevice_Bottom), 208 nullptr, 209 nullptr, 210 }, 211 { 212 "vkDestroyInstance", 213 ProcHook::INSTANCE, 214 ProcHook::EXTENSION_CORE, 215 reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance_Bottom), 216 nullptr, 217 nullptr, 218 }, 219 { 220 "vkDestroySurfaceKHR", 221 ProcHook::INSTANCE, 222 ProcHook::KHR_surface, 223 reinterpret_cast<PFN_vkVoidFunction>(DestroySurfaceKHR_Bottom), 224 reinterpret_cast<PFN_vkVoidFunction>(disabledDestroySurfaceKHR), 225 nullptr, 226 }, 227 { 228 "vkDestroySwapchainKHR", 229 ProcHook::DEVICE, 230 ProcHook::KHR_swapchain, 231 reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR_Bottom), 232 reinterpret_cast<PFN_vkVoidFunction>(disabledDestroySwapchainKHR), 233 reinterpret_cast<PFN_vkVoidFunction>(checkedDestroySwapchainKHR), 234 }, 235 { 236 "vkEnumerateDeviceExtensionProperties", 237 ProcHook::INSTANCE, 238 ProcHook::EXTENSION_CORE, 239 reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceExtensionProperties_Bottom), 240 nullptr, 241 nullptr, 242 }, 243 { 244 "vkEnumerateInstanceExtensionProperties", 245 ProcHook::GLOBAL, 246 ProcHook::EXTENSION_CORE, 247 reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties), 248 nullptr, 249 nullptr, 250 }, 251 { 252 "vkEnumeratePhysicalDevices", 253 ProcHook::INSTANCE, 254 ProcHook::EXTENSION_CORE, 255 reinterpret_cast<PFN_vkVoidFunction>(EnumeratePhysicalDevices_Bottom), 256 nullptr, 257 nullptr, 258 }, 259 { 260 "vkGetDeviceProcAddr", 261 ProcHook::DEVICE, 262 ProcHook::EXTENSION_CORE, 263 reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr), 264 nullptr, 265 nullptr, 266 }, 267 { 268 "vkGetDeviceQueue", 269 ProcHook::DEVICE, 270 ProcHook::EXTENSION_CORE, 271 reinterpret_cast<PFN_vkVoidFunction>(GetDeviceQueue), 272 nullptr, 273 nullptr, 274 }, 275 { 276 "vkGetInstanceProcAddr", 277 ProcHook::INSTANCE, 278 ProcHook::EXTENSION_CORE, 279 reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr), 280 nullptr, 281 nullptr, 282 }, 283 { 284 "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", 285 ProcHook::INSTANCE, 286 ProcHook::KHR_surface, 287 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceCapabilitiesKHR_Bottom), 288 reinterpret_cast<PFN_vkVoidFunction>(disabledGetPhysicalDeviceSurfaceCapabilitiesKHR), 289 nullptr, 290 }, 291 { 292 "vkGetPhysicalDeviceSurfaceFormatsKHR", 293 ProcHook::INSTANCE, 294 ProcHook::KHR_surface, 295 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceFormatsKHR_Bottom), 296 reinterpret_cast<PFN_vkVoidFunction>(disabledGetPhysicalDeviceSurfaceFormatsKHR), 297 nullptr, 298 }, 299 { 300 "vkGetPhysicalDeviceSurfacePresentModesKHR", 301 ProcHook::INSTANCE, 302 ProcHook::KHR_surface, 303 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfacePresentModesKHR_Bottom), 304 reinterpret_cast<PFN_vkVoidFunction>(disabledGetPhysicalDeviceSurfacePresentModesKHR), 305 nullptr, 306 }, 307 { 308 "vkGetPhysicalDeviceSurfaceSupportKHR", 309 ProcHook::INSTANCE, 310 ProcHook::KHR_surface, 311 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceSupportKHR_Bottom), 312 reinterpret_cast<PFN_vkVoidFunction>(disabledGetPhysicalDeviceSurfaceSupportKHR), 313 nullptr, 314 }, 315 { 316 "vkGetSwapchainGrallocUsageANDROID", 317 ProcHook::DEVICE, 318 ProcHook::ANDROID_native_buffer, 319 nullptr, 320 nullptr, 321 nullptr, 322 }, 323 { 324 "vkGetSwapchainImagesKHR", 325 ProcHook::DEVICE, 326 ProcHook::KHR_swapchain, 327 reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR_Bottom), 328 reinterpret_cast<PFN_vkVoidFunction>(disabledGetSwapchainImagesKHR), 329 reinterpret_cast<PFN_vkVoidFunction>(checkedGetSwapchainImagesKHR), 330 }, 331 { 332 "vkQueuePresentKHR", 333 ProcHook::DEVICE, 334 ProcHook::KHR_swapchain, 335 reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR_Bottom), 336 reinterpret_cast<PFN_vkVoidFunction>(disabledQueuePresentKHR), 337 reinterpret_cast<PFN_vkVoidFunction>(checkedQueuePresentKHR), 338 }, 339 { 340 "vkQueueSignalReleaseImageANDROID", 341 ProcHook::DEVICE, 342 ProcHook::ANDROID_native_buffer, 343 nullptr, 344 nullptr, 345 nullptr, 346 }, 347 // clang-format on 348}; 349 350} // anonymous 351 352const ProcHook* GetProcHook(const char* name) { 353 const auto& begin = g_proc_hooks; 354 const auto& end = 355 g_proc_hooks + sizeof(g_proc_hooks) / sizeof(g_proc_hooks[0]); 356 const auto hook = std::lower_bound( 357 begin, end, name, 358 [](const ProcHook& e, const char* n) { return strcmp(e.name, n) < 0; }); 359 return (hook < end && strcmp(hook->name, name) == 0) ? hook : nullptr; 360} 361 362ProcHook::Extension GetProcHookExtension(const char* name) { 363 // clang-format off 364 if (strcmp(name, "VK_ANDROID_native_buffer") == 0) return ProcHook::ANDROID_native_buffer; 365 if (strcmp(name, "VK_EXT_debug_report") == 0) return ProcHook::EXT_debug_report; 366 if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface; 367 if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface; 368 if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain; 369 // clang-format on 370 return ProcHook::EXTENSION_UNKNOWN; 371} 372 373#define UNLIKELY(expr) __builtin_expect((expr), 0) 374 375#define INIT_PROC(obj, proc) \ 376 do { \ 377 data.driver.proc = \ 378 reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \ 379 if (UNLIKELY(!data.driver.proc)) { \ 380 ALOGE("missing " #obj " proc: vk" #proc); \ 381 success = false; \ 382 } \ 383 } while (0) 384 385#define INIT_PROC_EXT(ext, obj, proc) \ 386 do { \ 387 if (data.hal_extensions[ProcHook::ext]) \ 388 INIT_PROC(obj, proc); \ 389 } while (0) 390 391bool InitDriverTable(VkInstance instance, PFN_vkGetInstanceProcAddr get_proc) { 392 auto& data = GetData(instance); 393 bool success = true; 394 395 // clang-format off 396 INIT_PROC(instance, DestroyInstance); 397 INIT_PROC(instance, EnumeratePhysicalDevices); 398 INIT_PROC(instance, GetInstanceProcAddr); 399 INIT_PROC(instance, CreateDevice); 400 INIT_PROC(instance, EnumerateDeviceExtensionProperties); 401 INIT_PROC_EXT(EXT_debug_report, instance, CreateDebugReportCallbackEXT); 402 INIT_PROC_EXT(EXT_debug_report, instance, DestroyDebugReportCallbackEXT); 403 INIT_PROC_EXT(EXT_debug_report, instance, DebugReportMessageEXT); 404 // clang-format on 405 406 return success; 407} 408 409bool InitDriverTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc) { 410 auto& data = GetData(dev); 411 bool success = true; 412 413 // clang-format off 414 INIT_PROC(dev, GetDeviceProcAddr); 415 INIT_PROC(dev, DestroyDevice); 416 INIT_PROC(dev, GetDeviceQueue); 417 INIT_PROC(dev, CreateImage); 418 INIT_PROC(dev, DestroyImage); 419 INIT_PROC(dev, AllocateCommandBuffers); 420 INIT_PROC_EXT(ANDROID_native_buffer, dev, GetSwapchainGrallocUsageANDROID); 421 INIT_PROC_EXT(ANDROID_native_buffer, dev, AcquireImageANDROID); 422 INIT_PROC_EXT(ANDROID_native_buffer, dev, QueueSignalReleaseImageANDROID); 423 // clang-format on 424 425 return success; 426} 427 428} // namespace driver 429} // namespace vulkan 430 431// clang-format on 432