driver_gen.cpp revision 5948b3eae87af490b7cec36d043b5a9bca6de8c0 
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
25namespace vulkan {
26namespace driver {
27
28namespace {
29
30// clang-format off
31
32VKAPI_ATTR VkResult checkedCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
33    if (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) {
34        return CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
35    } else {
36        Logger(device).Err(device, "VK_KHR_swapchain not enabled. vkCreateSwapchainKHR not executed.");
37        return VK_SUCCESS;
38    }
39}
40
41VKAPI_ATTR void checkedDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {
42    if (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) {
43        DestroySwapchainKHR(device, swapchain, pAllocator);
44    } else {
45        Logger(device).Err(device, "VK_KHR_swapchain not enabled. vkDestroySwapchainKHR not executed.");
46    }
47}
48
49VKAPI_ATTR VkResult checkedGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
50    if (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) {
51        return GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
52    } else {
53        Logger(device).Err(device, "VK_KHR_swapchain not enabled. vkGetSwapchainImagesKHR not executed.");
54        return VK_SUCCESS;
55    }
56}
57
58VKAPI_ATTR VkResult checkedAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
59    if (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) {
60        return AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
61    } else {
62        Logger(device).Err(device, "VK_KHR_swapchain not enabled. vkAcquireNextImageKHR not executed.");
63        return VK_SUCCESS;
64    }
65}
66
67VKAPI_ATTR VkResult checkedQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
68    if (GetData(queue).hook_extensions[ProcHook::KHR_swapchain]) {
69        return QueuePresentKHR(queue, pPresentInfo);
70    } else {
71        Logger(queue).Err(queue, "VK_KHR_swapchain not enabled. vkQueuePresentKHR not executed.");
72        return VK_SUCCESS;
73    }
74}
75
76// clang-format on
77
78const ProcHook g_proc_hooks[] = {
79    // clang-format off
80    {
81        "vkAcquireImageANDROID",
82        ProcHook::DEVICE,
83        ProcHook::ANDROID_native_buffer,
84        nullptr,
85        nullptr,
86    },
87    {
88        "vkAcquireNextImageKHR",
89        ProcHook::DEVICE,
90        ProcHook::KHR_swapchain,
91        reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR),
92        reinterpret_cast<PFN_vkVoidFunction>(checkedAcquireNextImageKHR),
93    },
94    {
95        "vkAllocateCommandBuffers",
96        ProcHook::DEVICE,
97        ProcHook::EXTENSION_CORE,
98        reinterpret_cast<PFN_vkVoidFunction>(AllocateCommandBuffers),
99        nullptr,
100    },
101    {
102        "vkCreateAndroidSurfaceKHR",
103        ProcHook::INSTANCE,
104        ProcHook::KHR_android_surface,
105        reinterpret_cast<PFN_vkVoidFunction>(CreateAndroidSurfaceKHR),
106        nullptr,
107    },
108    {
109        "vkCreateDebugReportCallbackEXT",
110        ProcHook::INSTANCE,
111        ProcHook::EXT_debug_report,
112        reinterpret_cast<PFN_vkVoidFunction>(CreateDebugReportCallbackEXT),
113        nullptr,
114    },
115    {
116        "vkCreateDevice",
117        ProcHook::INSTANCE,
118        ProcHook::EXTENSION_CORE,
119        reinterpret_cast<PFN_vkVoidFunction>(CreateDevice),
120        nullptr,
121    },
122    {
123        "vkCreateInstance",
124        ProcHook::GLOBAL,
125        ProcHook::EXTENSION_CORE,
126        reinterpret_cast<PFN_vkVoidFunction>(CreateInstance),
127        nullptr,
128    },
129    {
130        "vkCreateSwapchainKHR",
131        ProcHook::DEVICE,
132        ProcHook::KHR_swapchain,
133        reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR),
134        reinterpret_cast<PFN_vkVoidFunction>(checkedCreateSwapchainKHR),
135    },
136    {
137        "vkDebugReportMessageEXT",
138        ProcHook::INSTANCE,
139        ProcHook::EXT_debug_report,
140        reinterpret_cast<PFN_vkVoidFunction>(DebugReportMessageEXT),
141        nullptr,
142    },
143    {
144        "vkDestroyDebugReportCallbackEXT",
145        ProcHook::INSTANCE,
146        ProcHook::EXT_debug_report,
147        reinterpret_cast<PFN_vkVoidFunction>(DestroyDebugReportCallbackEXT),
148        nullptr,
149    },
150    {
151        "vkDestroyDevice",
152        ProcHook::DEVICE,
153        ProcHook::EXTENSION_CORE,
154        reinterpret_cast<PFN_vkVoidFunction>(DestroyDevice),
155        nullptr,
156    },
157    {
158        "vkDestroyInstance",
159        ProcHook::INSTANCE,
160        ProcHook::EXTENSION_CORE,
161        reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance),
162        nullptr,
163    },
164    {
165        "vkDestroySurfaceKHR",
166        ProcHook::INSTANCE,
167        ProcHook::KHR_surface,
168        reinterpret_cast<PFN_vkVoidFunction>(DestroySurfaceKHR),
169        nullptr,
170    },
171    {
172        "vkDestroySwapchainKHR",
173        ProcHook::DEVICE,
174        ProcHook::KHR_swapchain,
175        reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR),
176        reinterpret_cast<PFN_vkVoidFunction>(checkedDestroySwapchainKHR),
177    },
178    {
179        "vkEnumerateDeviceExtensionProperties",
180        ProcHook::INSTANCE,
181        ProcHook::EXTENSION_CORE,
182        reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceExtensionProperties),
183        nullptr,
184    },
185    {
186        "vkEnumerateInstanceExtensionProperties",
187        ProcHook::GLOBAL,
188        ProcHook::EXTENSION_CORE,
189        reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties),
190        nullptr,
191    },
192    {
193        "vkEnumeratePhysicalDevices",
194        ProcHook::INSTANCE,
195        ProcHook::EXTENSION_CORE,
196        reinterpret_cast<PFN_vkVoidFunction>(EnumeratePhysicalDevices),
197        nullptr,
198    },
199    {
200        "vkGetDeviceProcAddr",
201        ProcHook::DEVICE,
202        ProcHook::EXTENSION_CORE,
203        reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr),
204        nullptr,
205    },
206    {
207        "vkGetDeviceQueue",
208        ProcHook::DEVICE,
209        ProcHook::EXTENSION_CORE,
210        reinterpret_cast<PFN_vkVoidFunction>(GetDeviceQueue),
211        nullptr,
212    },
213    {
214        "vkGetInstanceProcAddr",
215        ProcHook::INSTANCE,
216        ProcHook::EXTENSION_CORE,
217        reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr),
218        nullptr,
219    },
220    {
221        "vkGetPhysicalDeviceSurfaceCapabilitiesKHR",
222        ProcHook::INSTANCE,
223        ProcHook::KHR_surface,
224        reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceCapabilitiesKHR),
225        nullptr,
226    },
227    {
228        "vkGetPhysicalDeviceSurfaceFormatsKHR",
229        ProcHook::INSTANCE,
230        ProcHook::KHR_surface,
231        reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceFormatsKHR),
232        nullptr,
233    },
234    {
235        "vkGetPhysicalDeviceSurfacePresentModesKHR",
236        ProcHook::INSTANCE,
237        ProcHook::KHR_surface,
238        reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfacePresentModesKHR),
239        nullptr,
240    },
241    {
242        "vkGetPhysicalDeviceSurfaceSupportKHR",
243        ProcHook::INSTANCE,
244        ProcHook::KHR_surface,
245        reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceSupportKHR),
246        nullptr,
247    },
248    {
249        "vkGetSwapchainGrallocUsage2ANDROID",
250        ProcHook::DEVICE,
251        ProcHook::ANDROID_native_buffer,
252        nullptr,
253        nullptr,
254    },
255    {
256        "vkGetSwapchainGrallocUsageANDROID",
257        ProcHook::DEVICE,
258        ProcHook::ANDROID_native_buffer,
259        nullptr,
260        nullptr,
261    },
262    {
263        "vkGetSwapchainImagesKHR",
264        ProcHook::DEVICE,
265        ProcHook::KHR_swapchain,
266        reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR),
267        reinterpret_cast<PFN_vkVoidFunction>(checkedGetSwapchainImagesKHR),
268    },
269    {
270        "vkQueuePresentKHR",
271        ProcHook::DEVICE,
272        ProcHook::KHR_swapchain,
273        reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR),
274        reinterpret_cast<PFN_vkVoidFunction>(checkedQueuePresentKHR),
275    },
276    {
277        "vkQueueSignalReleaseImageANDROID",
278        ProcHook::DEVICE,
279        ProcHook::ANDROID_native_buffer,
280        nullptr,
281        nullptr,
282    },
283    // clang-format on
284};
285
286}  // anonymous
287
288const ProcHook* GetProcHook(const char* name) {
289    const auto& begin = g_proc_hooks;
290    const auto& end =
291        g_proc_hooks + sizeof(g_proc_hooks) / sizeof(g_proc_hooks[0]);
292    const auto hook = std::lower_bound(
293        begin, end, name,
294        [](const ProcHook& e, const char* n) { return strcmp(e.name, n) < 0; });
295    return (hook < end && strcmp(hook->name, name) == 0) ? hook : nullptr;
296}
297
298ProcHook::Extension GetProcHookExtension(const char* name) {
299    // clang-format off
300    if (strcmp(name, "VK_ANDROID_native_buffer") == 0) return ProcHook::ANDROID_native_buffer;
301    if (strcmp(name, "VK_EXT_debug_report") == 0) return ProcHook::EXT_debug_report;
302    if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface;
303    if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface;
304    if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain;
305    // clang-format on
306    return ProcHook::EXTENSION_UNKNOWN;
307}
308
309#define UNLIKELY(expr) __builtin_expect((expr), 0)
310
311#define INIT_PROC(required, obj, proc)                                 \
312    do {                                                               \
313        data.driver.proc =                                             \
314            reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \
315        if (UNLIKELY(required && !data.driver.proc)) {                 \
316            ALOGE("missing " #obj " proc: vk" #proc);                  \
317            success = false;                                           \
318        }                                                              \
319    } while (0)
320
321#define INIT_PROC_EXT(ext, required, obj, proc) \
322    do {                                        \
323        if (extensions[ProcHook::ext])          \
324            INIT_PROC(required, obj, proc);     \
325    } while (0)
326
327bool InitDriverTable(VkInstance instance,
328                     PFN_vkGetInstanceProcAddr get_proc,
329                     const std::bitset<ProcHook::EXTENSION_COUNT>& extensions) {
330    auto& data = GetData(instance);
331    bool success = true;
332
333    // clang-format off
334    INIT_PROC(true, instance, DestroyInstance);
335    INIT_PROC(true, instance, EnumeratePhysicalDevices);
336    INIT_PROC(true, instance, GetInstanceProcAddr);
337    INIT_PROC(true, instance, CreateDevice);
338    INIT_PROC(true, instance, EnumerateDeviceExtensionProperties);
339    INIT_PROC_EXT(EXT_debug_report, true, instance, CreateDebugReportCallbackEXT);
340    INIT_PROC_EXT(EXT_debug_report, true, instance, DestroyDebugReportCallbackEXT);
341    INIT_PROC_EXT(EXT_debug_report, true, instance, DebugReportMessageEXT);
342    // clang-format on
343
344    return success;
345}
346
347bool InitDriverTable(VkDevice dev,
348                     PFN_vkGetDeviceProcAddr get_proc,
349                     const std::bitset<ProcHook::EXTENSION_COUNT>& extensions) {
350    auto& data = GetData(dev);
351    bool success = true;
352
353    // clang-format off
354    INIT_PROC(true, dev, GetDeviceProcAddr);
355    INIT_PROC(true, dev, DestroyDevice);
356    INIT_PROC(true, dev, GetDeviceQueue);
357    INIT_PROC(true, dev, CreateImage);
358    INIT_PROC(true, dev, DestroyImage);
359    INIT_PROC(true, dev, AllocateCommandBuffers);
360    INIT_PROC_EXT(ANDROID_native_buffer, true, dev, GetSwapchainGrallocUsageANDROID);
361    INIT_PROC_EXT(ANDROID_native_buffer, false, dev, GetSwapchainGrallocUsage2ANDROID);
362    INIT_PROC_EXT(ANDROID_native_buffer, true, dev, AcquireImageANDROID);
363    INIT_PROC_EXT(ANDROID_native_buffer, true, dev, QueueSignalReleaseImageANDROID);
364    // clang-format on
365
366    return success;
367}
368
369}  // namespace driver
370}  // namespace vulkan
371
372// clang-format on
373