null_driver.cpp revision 57f7f8c140c4b665f05c17866ebf201e9f4f46a4 
1/*
2 * Copyright 2015 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#include <hardware/hwvulkan.h>
18#include <vulkan/vk_ext_debug_report.h>
19
20#include <algorithm>
21#include <array>
22#include <inttypes.h>
23#include <string.h>
24
25#include <log/log.h>
26#include <utils/Errors.h>
27
28#include "null_driver_gen.h"
29
30using namespace null_driver;
31
32struct VkPhysicalDevice_T {
33    hwvulkan_dispatch_t dispatch;
34};
35
36struct VkInstance_T {
37    hwvulkan_dispatch_t dispatch;
38    VkAllocationCallbacks allocator;
39    VkPhysicalDevice_T physical_device;
40    uint64_t next_callback_handle;
41    bool debug_report_enabled;
42};
43
44struct VkQueue_T {
45    hwvulkan_dispatch_t dispatch;
46};
47
48struct VkCommandBuffer_T {
49    hwvulkan_dispatch_t dispatch;
50};
51
52namespace {
53// Handles for non-dispatchable objects are either pointers, or arbitrary
54// 64-bit non-zero values. We only use pointers when we need to keep state for
55// the object even in a null driver. For the rest, we form a handle as:
56//   [63:63] = 1 to distinguish from pointer handles*
57//   [62:56] = non-zero handle type enum value
58//   [55: 0] = per-handle-type incrementing counter
59// * This works because virtual addresses with the high bit set are reserved
60// for kernel data in all ABIs we run on.
61//
62// We never reclaim handles on vkDestroy*. It's not even necessary for us to
63// have distinct handles for live objects, and practically speaking we won't
64// ever create 2^56 objects of the same type from a single VkDevice in a null
65// driver.
66//
67// Using a namespace here instead of 'enum class' since we want scoped
68// constants but also want implicit conversions to integral types.
69namespace HandleType {
70enum Enum {
71    kBufferView,
72    kDebugReportCallbackEXT,
73    kDescriptorPool,
74    kDescriptorSet,
75    kDescriptorSetLayout,
76    kEvent,
77    kFence,
78    kFramebuffer,
79    kImageView,
80    kPipeline,
81    kPipelineCache,
82    kPipelineLayout,
83    kQueryPool,
84    kRenderPass,
85    kSampler,
86    kSemaphore,
87    kShaderModule,
88
89    kNumTypes
90};
91}  // namespace HandleType
92
93const VkDeviceSize kMaxDeviceMemory = VkDeviceSize(INTPTR_MAX) + 1;
94
95}  // anonymous namespace
96
97struct VkDevice_T {
98    hwvulkan_dispatch_t dispatch;
99    VkAllocationCallbacks allocator;
100    VkInstance_T* instance;
101    VkQueue_T queue;
102    std::array<uint64_t, HandleType::kNumTypes> next_handle;
103};
104
105// -----------------------------------------------------------------------------
106// Declare HAL_MODULE_INFO_SYM early so it can be referenced by nulldrv_device
107// later.
108
109namespace {
110int OpenDevice(const hw_module_t* module, const char* id, hw_device_t** device);
111hw_module_methods_t nulldrv_module_methods = {.open = OpenDevice};
112}  // namespace
113
114#pragma clang diagnostic push
115#pragma clang diagnostic ignored "-Wmissing-variable-declarations"
116__attribute__((visibility("default"))) hwvulkan_module_t HAL_MODULE_INFO_SYM = {
117    .common =
118        {
119            .tag = HARDWARE_MODULE_TAG,
120            .module_api_version = HWVULKAN_MODULE_API_VERSION_0_1,
121            .hal_api_version = HARDWARE_HAL_API_VERSION,
122            .id = HWVULKAN_HARDWARE_MODULE_ID,
123            .name = "Null Vulkan Driver",
124            .author = "The Android Open Source Project",
125            .methods = &nulldrv_module_methods,
126        },
127};
128#pragma clang diagnostic pop
129
130// -----------------------------------------------------------------------------
131
132namespace {
133
134int CloseDevice(struct hw_device_t* /*device*/) {
135    // nothing to do - opening a device doesn't allocate any resources
136    return 0;
137}
138
139hwvulkan_device_t nulldrv_device = {
140    .common =
141        {
142            .tag = HARDWARE_DEVICE_TAG,
143            .version = HWVULKAN_DEVICE_API_VERSION_0_1,
144            .module = &HAL_MODULE_INFO_SYM.common,
145            .close = CloseDevice,
146        },
147    .EnumerateInstanceExtensionProperties =
148        EnumerateInstanceExtensionProperties,
149    .CreateInstance = CreateInstance,
150    .GetInstanceProcAddr = GetInstanceProcAddr};
151
152int OpenDevice(const hw_module_t* /*module*/,
153               const char* id,
154               hw_device_t** device) {
155    if (strcmp(id, HWVULKAN_DEVICE_0) == 0) {
156        *device = &nulldrv_device.common;
157        return 0;
158    }
159    return -ENOENT;
160}
161
162VkInstance_T* GetInstanceFromPhysicalDevice(
163    VkPhysicalDevice_T* physical_device) {
164    return reinterpret_cast<VkInstance_T*>(
165        reinterpret_cast<uintptr_t>(physical_device) -
166        offsetof(VkInstance_T, physical_device));
167}
168
169uint64_t AllocHandle(uint64_t type, uint64_t* next_handle) {
170    const uint64_t kHandleMask = (UINT64_C(1) << 56) - 1;
171    ALOGE_IF(*next_handle == kHandleMask,
172             "non-dispatchable handles of type=%" PRIu64
173             " are about to overflow",
174             type);
175    return (UINT64_C(1) << 63) | ((type & 0x7) << 56) |
176           ((*next_handle)++ & kHandleMask);
177}
178
179template <class Handle>
180Handle AllocHandle(VkInstance instance, HandleType::Enum type) {
181    return reinterpret_cast<Handle>(
182        AllocHandle(type, &instance->next_callback_handle));
183}
184
185template <class Handle>
186Handle AllocHandle(VkDevice device, HandleType::Enum type) {
187    return reinterpret_cast<Handle>(
188        AllocHandle(type, &device->next_handle[type]));
189}
190
191}  // namespace
192
193namespace null_driver {
194
195#define DEFINE_OBJECT_HANDLE_CONVERSION(T)              \
196    T* Get##T##FromHandle(Vk##T h);                     \
197    T* Get##T##FromHandle(Vk##T h) {                    \
198        return reinterpret_cast<T*>(uintptr_t(h));      \
199    }                                                   \
200    Vk##T GetHandleTo##T(const T* obj);                 \
201    Vk##T GetHandleTo##T(const T* obj) {                \
202        return Vk##T(reinterpret_cast<uintptr_t>(obj)); \
203    }
204
205// -----------------------------------------------------------------------------
206// Global
207
208VKAPI_ATTR
209VkResult EnumerateInstanceExtensionProperties(
210    const char* layer_name,
211    uint32_t* count,
212    VkExtensionProperties* properties) {
213    if (layer_name) {
214        ALOGW(
215            "Driver vkEnumerateInstanceExtensionProperties shouldn't be called "
216            "with a layer name ('%s')",
217            layer_name);
218        *count = 0;
219        return VK_SUCCESS;
220    }
221
222    const VkExtensionProperties kExtensions[] = {
223        {VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}};
224    const uint32_t kExtensionsCount =
225        sizeof(kExtensions) / sizeof(kExtensions[0]);
226
227    if (!properties || *count > kExtensionsCount)
228        *count = kExtensionsCount;
229    if (properties)
230        std::copy(kExtensions, kExtensions + *count, properties);
231    return *count < kExtensionsCount ? VK_INCOMPLETE : VK_SUCCESS;
232}
233
234VKAPI_ATTR
235VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
236                        const VkAllocationCallbacks* allocator,
237                        VkInstance* out_instance) {
238    // Assume the loader provided alloc callbacks even if the app didn't.
239    ALOG_ASSERT(
240        allocator,
241        "Missing alloc callbacks, loader or app should have provided them");
242
243    VkInstance_T* instance =
244        static_cast<VkInstance_T*>(allocator->pfnAllocation(
245            allocator->pUserData, sizeof(VkInstance_T), alignof(VkInstance_T),
246            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE));
247    if (!instance)
248        return VK_ERROR_OUT_OF_HOST_MEMORY;
249
250    instance->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
251    instance->allocator = *allocator;
252    instance->physical_device.dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
253    instance->next_callback_handle = 0;
254    instance->debug_report_enabled = false;
255
256    for (uint32_t i = 0; i < create_info->enabledExtensionCount; i++) {
257        if (strcmp(create_info->ppEnabledExtensionNames[i],
258                   VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0) {
259            ALOGV("Enabling " VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
260            instance->debug_report_enabled = true;
261        }
262    }
263
264    *out_instance = instance;
265    return VK_SUCCESS;
266}
267
268VKAPI_ATTR
269PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
270    return instance ? GetInstanceProcAddr(name) : GetGlobalProcAddr(name);
271}
272
273VKAPI_ATTR
274PFN_vkVoidFunction GetDeviceProcAddr(VkDevice, const char* name) {
275    return GetInstanceProcAddr(name);
276}
277
278// -----------------------------------------------------------------------------
279// Instance
280
281void DestroyInstance(VkInstance instance,
282                     const VkAllocationCallbacks* /*allocator*/) {
283    instance->allocator.pfnFree(instance->allocator.pUserData, instance);
284}
285
286// -----------------------------------------------------------------------------
287// PhysicalDevice
288
289VkResult EnumeratePhysicalDevices(VkInstance instance,
290                                  uint32_t* physical_device_count,
291                                  VkPhysicalDevice* physical_devices) {
292    if (physical_devices && *physical_device_count >= 1)
293        physical_devices[0] = &instance->physical_device;
294    *physical_device_count = 1;
295    return VK_SUCCESS;
296}
297
298VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice /*gpu*/,
299                                        uint32_t* count,
300                                        VkLayerProperties* /*properties*/) {
301    ALOGW("Driver vkEnumerateDeviceLayerProperties shouldn't be called");
302    *count = 0;
303    return VK_SUCCESS;
304}
305
306VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice /*gpu*/,
307                                            const char* layer_name,
308                                            uint32_t* count,
309                                            VkExtensionProperties* properties) {
310    if (layer_name) {
311        ALOGW(
312            "Driver vkEnumerateDeviceExtensionProperties shouldn't be called "
313            "with a layer name ('%s')",
314            layer_name);
315        *count = 0;
316        return VK_SUCCESS;
317    }
318
319    const VkExtensionProperties kExtensions[] = {
320        {VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME,
321         VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION}};
322    const uint32_t kExtensionsCount =
323        sizeof(kExtensions) / sizeof(kExtensions[0]);
324
325    if (!properties || *count > kExtensionsCount)
326        *count = kExtensionsCount;
327    if (properties)
328        std::copy(kExtensions, kExtensions + *count, properties);
329    return *count < kExtensionsCount ? VK_INCOMPLETE : VK_SUCCESS;
330}
331
332void GetPhysicalDeviceProperties(VkPhysicalDevice,
333                                 VkPhysicalDeviceProperties* properties) {
334    properties->apiVersion = VK_API_VERSION;
335    properties->driverVersion = VK_MAKE_VERSION(0, 0, 1);
336    properties->vendorID = 0;
337    properties->deviceID = 0;
338    properties->deviceType = VK_PHYSICAL_DEVICE_TYPE_OTHER;
339    strcpy(properties->deviceName, "Android Vulkan Null Driver");
340    memset(properties->pipelineCacheUUID, 0,
341           sizeof(properties->pipelineCacheUUID));
342}
343
344void GetPhysicalDeviceQueueFamilyProperties(
345    VkPhysicalDevice,
346    uint32_t* count,
347    VkQueueFamilyProperties* properties) {
348    if (!properties || *count > 1)
349        *count = 1;
350    if (properties && *count == 1) {
351        properties->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT |
352                                 VK_QUEUE_TRANSFER_BIT;
353        properties->queueCount = 1;
354        properties->timestampValidBits = 64;
355        properties->minImageTransferGranularity = VkExtent3D{1, 1, 1};
356    }
357}
358
359void GetPhysicalDeviceMemoryProperties(
360    VkPhysicalDevice,
361    VkPhysicalDeviceMemoryProperties* properties) {
362    properties->memoryTypeCount = 1;
363    properties->memoryTypes[0].propertyFlags =
364        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
365        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
366        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
367        VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
368    properties->memoryTypes[0].heapIndex = 0;
369    properties->memoryHeapCount = 1;
370    properties->memoryHeaps[0].size = kMaxDeviceMemory;
371    properties->memoryHeaps[0].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
372}
373
374// -----------------------------------------------------------------------------
375// Device
376
377VkResult CreateDevice(VkPhysicalDevice physical_device,
378                      const VkDeviceCreateInfo*,
379                      const VkAllocationCallbacks* allocator,
380                      VkDevice* out_device) {
381    VkInstance_T* instance = GetInstanceFromPhysicalDevice(physical_device);
382    if (!allocator)
383        allocator = &instance->allocator;
384    VkDevice_T* device = static_cast<VkDevice_T*>(allocator->pfnAllocation(
385        allocator->pUserData, sizeof(VkDevice_T), alignof(VkDevice_T),
386        VK_SYSTEM_ALLOCATION_SCOPE_DEVICE));
387    if (!device)
388        return VK_ERROR_OUT_OF_HOST_MEMORY;
389
390    device->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
391    device->allocator = *allocator;
392    device->instance = instance;
393    device->queue.dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
394    std::fill(device->next_handle.begin(), device->next_handle.end(),
395              UINT64_C(0));
396
397    *out_device = device;
398    return VK_SUCCESS;
399}
400
401void DestroyDevice(VkDevice device,
402                   const VkAllocationCallbacks* /*allocator*/) {
403    if (!device)
404        return;
405    device->allocator.pfnFree(device->allocator.pUserData, device);
406}
407
408void GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
409    *queue = &device->queue;
410}
411
412// -----------------------------------------------------------------------------
413// CommandPool
414
415struct CommandPool {
416    typedef VkCommandPool HandleType;
417    VkAllocationCallbacks allocator;
418};
419DEFINE_OBJECT_HANDLE_CONVERSION(CommandPool)
420
421VkResult CreateCommandPool(VkDevice device,
422                           const VkCommandPoolCreateInfo* /*create_info*/,
423                           const VkAllocationCallbacks* allocator,
424                           VkCommandPool* cmd_pool) {
425    if (!allocator)
426        allocator = &device->allocator;
427    CommandPool* pool = static_cast<CommandPool*>(allocator->pfnAllocation(
428        allocator->pUserData, sizeof(CommandPool), alignof(CommandPool),
429        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
430    if (!pool)
431        return VK_ERROR_OUT_OF_HOST_MEMORY;
432    pool->allocator = *allocator;
433    *cmd_pool = GetHandleToCommandPool(pool);
434    return VK_SUCCESS;
435}
436
437void DestroyCommandPool(VkDevice /*device*/,
438                        VkCommandPool cmd_pool,
439                        const VkAllocationCallbacks* /*allocator*/) {
440    CommandPool* pool = GetCommandPoolFromHandle(cmd_pool);
441    pool->allocator.pfnFree(pool->allocator.pUserData, pool);
442}
443
444// -----------------------------------------------------------------------------
445// CmdBuffer
446
447VkResult AllocateCommandBuffers(VkDevice /*device*/,
448                                const VkCommandBufferAllocateInfo* alloc_info,
449                                VkCommandBuffer* cmdbufs) {
450    VkResult result = VK_SUCCESS;
451    CommandPool& pool = *GetCommandPoolFromHandle(alloc_info->commandPool);
452    std::fill(cmdbufs, cmdbufs + alloc_info->commandBufferCount, nullptr);
453    for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
454        cmdbufs[i] =
455            static_cast<VkCommandBuffer_T*>(pool.allocator.pfnAllocation(
456                pool.allocator.pUserData, sizeof(VkCommandBuffer_T),
457                alignof(VkCommandBuffer_T), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
458        if (!cmdbufs[i]) {
459            result = VK_ERROR_OUT_OF_HOST_MEMORY;
460            break;
461        }
462        cmdbufs[i]->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
463    }
464    if (result != VK_SUCCESS) {
465        for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
466            if (!cmdbufs[i])
467                break;
468            pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
469        }
470    }
471    return result;
472}
473
474void FreeCommandBuffers(VkDevice /*device*/,
475                        VkCommandPool cmd_pool,
476                        uint32_t count,
477                        const VkCommandBuffer* cmdbufs) {
478    CommandPool& pool = *GetCommandPoolFromHandle(cmd_pool);
479    for (uint32_t i = 0; i < count; i++)
480        pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
481}
482
483// -----------------------------------------------------------------------------
484// DeviceMemory
485
486struct DeviceMemory {
487    typedef VkDeviceMemory HandleType;
488    VkDeviceSize size;
489    alignas(16) uint8_t data[0];
490};
491DEFINE_OBJECT_HANDLE_CONVERSION(DeviceMemory)
492
493VkResult AllocateMemory(VkDevice device,
494                        const VkMemoryAllocateInfo* alloc_info,
495                        const VkAllocationCallbacks* allocator,
496                        VkDeviceMemory* mem_handle) {
497    if (SIZE_MAX - sizeof(DeviceMemory) <= alloc_info->allocationSize)
498        return VK_ERROR_OUT_OF_HOST_MEMORY;
499    if (!allocator)
500        allocator = &device->allocator;
501
502    size_t size = sizeof(DeviceMemory) + size_t(alloc_info->allocationSize);
503    DeviceMemory* mem = static_cast<DeviceMemory*>(allocator->pfnAllocation(
504        allocator->pUserData, size, alignof(DeviceMemory),
505        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
506    if (!mem)
507        return VK_ERROR_OUT_OF_HOST_MEMORY;
508    mem->size = size;
509    *mem_handle = GetHandleToDeviceMemory(mem);
510    return VK_SUCCESS;
511}
512
513void FreeMemory(VkDevice device,
514                VkDeviceMemory mem_handle,
515                const VkAllocationCallbacks* allocator) {
516    if (!allocator)
517        allocator = &device->allocator;
518    DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
519    allocator->pfnFree(allocator->pUserData, mem);
520}
521
522VkResult MapMemory(VkDevice,
523                   VkDeviceMemory mem_handle,
524                   VkDeviceSize offset,
525                   VkDeviceSize,
526                   VkMemoryMapFlags,
527                   void** out_ptr) {
528    DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
529    *out_ptr = &mem->data[0] + offset;
530    return VK_SUCCESS;
531}
532
533// -----------------------------------------------------------------------------
534// Buffer
535
536struct Buffer {
537    typedef VkBuffer HandleType;
538    VkDeviceSize size;
539};
540DEFINE_OBJECT_HANDLE_CONVERSION(Buffer)
541
542VkResult CreateBuffer(VkDevice device,
543                      const VkBufferCreateInfo* create_info,
544                      const VkAllocationCallbacks* allocator,
545                      VkBuffer* buffer_handle) {
546    ALOGW_IF(create_info->size > kMaxDeviceMemory,
547             "CreateBuffer: requested size 0x%" PRIx64
548             " exceeds max device memory size 0x%" PRIx64,
549             create_info->size, kMaxDeviceMemory);
550    if (!allocator)
551        allocator = &device->allocator;
552    Buffer* buffer = static_cast<Buffer*>(allocator->pfnAllocation(
553        allocator->pUserData, sizeof(Buffer), alignof(Buffer),
554        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
555    if (!buffer)
556        return VK_ERROR_OUT_OF_HOST_MEMORY;
557    buffer->size = create_info->size;
558    *buffer_handle = GetHandleToBuffer(buffer);
559    return VK_SUCCESS;
560}
561
562void GetBufferMemoryRequirements(VkDevice,
563                                 VkBuffer buffer_handle,
564                                 VkMemoryRequirements* requirements) {
565    Buffer* buffer = GetBufferFromHandle(buffer_handle);
566    requirements->size = buffer->size;
567    requirements->alignment = 16;  // allow fast Neon/SSE memcpy
568    requirements->memoryTypeBits = 0x1;
569}
570
571void DestroyBuffer(VkDevice device,
572                   VkBuffer buffer_handle,
573                   const VkAllocationCallbacks* allocator) {
574    if (!allocator)
575        allocator = &device->allocator;
576    Buffer* buffer = GetBufferFromHandle(buffer_handle);
577    allocator->pfnFree(allocator->pUserData, buffer);
578}
579
580// -----------------------------------------------------------------------------
581// Image
582
583struct Image {
584    typedef VkImage HandleType;
585    VkDeviceSize size;
586};
587DEFINE_OBJECT_HANDLE_CONVERSION(Image)
588
589VkResult CreateImage(VkDevice device,
590                     const VkImageCreateInfo* create_info,
591                     const VkAllocationCallbacks* allocator,
592                     VkImage* image_handle) {
593    if (create_info->imageType != VK_IMAGE_TYPE_2D ||
594        create_info->format != VK_FORMAT_R8G8B8A8_UNORM ||
595        create_info->mipLevels != 1) {
596        ALOGE("CreateImage: not yet implemented: type=%d format=%d mips=%u",
597              create_info->imageType, create_info->format,
598              create_info->mipLevels);
599        return VK_ERROR_OUT_OF_HOST_MEMORY;
600    }
601
602    VkDeviceSize size =
603        VkDeviceSize(create_info->extent.width * create_info->extent.height) *
604        create_info->arrayLayers * create_info->samples * 4u;
605    ALOGW_IF(size > kMaxDeviceMemory,
606             "CreateImage: image size 0x%" PRIx64
607             " exceeds max device memory size 0x%" PRIx64,
608             size, kMaxDeviceMemory);
609
610    if (!allocator)
611        allocator = &device->allocator;
612    Image* image = static_cast<Image*>(allocator->pfnAllocation(
613        allocator->pUserData, sizeof(Image), alignof(Image),
614        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
615    if (!image)
616        return VK_ERROR_OUT_OF_HOST_MEMORY;
617    image->size = size;
618    *image_handle = GetHandleToImage(image);
619    return VK_SUCCESS;
620}
621
622void GetImageMemoryRequirements(VkDevice,
623                                VkImage image_handle,
624                                VkMemoryRequirements* requirements) {
625    Image* image = GetImageFromHandle(image_handle);
626    requirements->size = image->size;
627    requirements->alignment = 16;  // allow fast Neon/SSE memcpy
628    requirements->memoryTypeBits = 0x1;
629}
630
631void DestroyImage(VkDevice device,
632                  VkImage image_handle,
633                  const VkAllocationCallbacks* allocator) {
634    if (!allocator)
635        allocator = &device->allocator;
636    Image* image = GetImageFromHandle(image_handle);
637    allocator->pfnFree(allocator->pUserData, image);
638}
639
640VkResult GetSwapchainGrallocUsageANDROID(VkDevice,
641                                         VkFormat,
642                                         VkImageUsageFlags,
643                                         int* grallocUsage) {
644    // The null driver never reads or writes the gralloc buffer
645    *grallocUsage = 0;
646    return VK_SUCCESS;
647}
648
649VkResult AcquireImageANDROID(VkDevice,
650                             VkImage,
651                             int fence,
652                             VkSemaphore,
653                             VkFence) {
654    close(fence);
655    return VK_SUCCESS;
656}
657
658VkResult QueueSignalReleaseImageANDROID(VkQueue,
659                                        uint32_t,
660                                        const VkSemaphore*,
661                                        VkImage,
662                                        int* fence) {
663    *fence = -1;
664    return VK_SUCCESS;
665}
666
667// -----------------------------------------------------------------------------
668// No-op types
669
670VkResult CreateBufferView(VkDevice device,
671                          const VkBufferViewCreateInfo*,
672                          const VkAllocationCallbacks* /*allocator*/,
673                          VkBufferView* view) {
674    *view = AllocHandle<VkBufferView>(device, HandleType::kBufferView);
675    return VK_SUCCESS;
676}
677
678VkResult CreateDescriptorPool(VkDevice device,
679                              const VkDescriptorPoolCreateInfo*,
680                              const VkAllocationCallbacks* /*allocator*/,
681                              VkDescriptorPool* pool) {
682    *pool = AllocHandle<VkDescriptorPool>(device, HandleType::kDescriptorPool);
683    return VK_SUCCESS;
684}
685
686VkResult AllocateDescriptorSets(VkDevice device,
687                                const VkDescriptorSetAllocateInfo* alloc_info,
688                                VkDescriptorSet* descriptor_sets) {
689    for (uint32_t i = 0; i < alloc_info->descriptorSetCount; i++)
690        descriptor_sets[i] =
691            AllocHandle<VkDescriptorSet>(device, HandleType::kDescriptorSet);
692    return VK_SUCCESS;
693}
694
695VkResult CreateDescriptorSetLayout(VkDevice device,
696                                   const VkDescriptorSetLayoutCreateInfo*,
697                                   const VkAllocationCallbacks* /*allocator*/,
698                                   VkDescriptorSetLayout* layout) {
699    *layout = AllocHandle<VkDescriptorSetLayout>(
700        device, HandleType::kDescriptorSetLayout);
701    return VK_SUCCESS;
702}
703
704VkResult CreateEvent(VkDevice device,
705                     const VkEventCreateInfo*,
706                     const VkAllocationCallbacks* /*allocator*/,
707                     VkEvent* event) {
708    *event = AllocHandle<VkEvent>(device, HandleType::kEvent);
709    return VK_SUCCESS;
710}
711
712VkResult CreateFence(VkDevice device,
713                     const VkFenceCreateInfo*,
714                     const VkAllocationCallbacks* /*allocator*/,
715                     VkFence* fence) {
716    *fence = AllocHandle<VkFence>(device, HandleType::kFence);
717    return VK_SUCCESS;
718}
719
720VkResult CreateFramebuffer(VkDevice device,
721                           const VkFramebufferCreateInfo*,
722                           const VkAllocationCallbacks* /*allocator*/,
723                           VkFramebuffer* framebuffer) {
724    *framebuffer = AllocHandle<VkFramebuffer>(device, HandleType::kFramebuffer);
725    return VK_SUCCESS;
726}
727
728VkResult CreateImageView(VkDevice device,
729                         const VkImageViewCreateInfo*,
730                         const VkAllocationCallbacks* /*allocator*/,
731                         VkImageView* view) {
732    *view = AllocHandle<VkImageView>(device, HandleType::kImageView);
733    return VK_SUCCESS;
734}
735
736VkResult CreateGraphicsPipelines(VkDevice device,
737                                 VkPipelineCache,
738                                 uint32_t count,
739                                 const VkGraphicsPipelineCreateInfo*,
740                                 const VkAllocationCallbacks* /*allocator*/,
741                                 VkPipeline* pipelines) {
742    for (uint32_t i = 0; i < count; i++)
743        pipelines[i] = AllocHandle<VkPipeline>(device, HandleType::kPipeline);
744    return VK_SUCCESS;
745}
746
747VkResult CreateComputePipelines(VkDevice device,
748                                VkPipelineCache,
749                                uint32_t count,
750                                const VkComputePipelineCreateInfo*,
751                                const VkAllocationCallbacks* /*allocator*/,
752                                VkPipeline* pipelines) {
753    for (uint32_t i = 0; i < count; i++)
754        pipelines[i] = AllocHandle<VkPipeline>(device, HandleType::kPipeline);
755    return VK_SUCCESS;
756}
757
758VkResult CreatePipelineCache(VkDevice device,
759                             const VkPipelineCacheCreateInfo*,
760                             const VkAllocationCallbacks* /*allocator*/,
761                             VkPipelineCache* cache) {
762    *cache = AllocHandle<VkPipelineCache>(device, HandleType::kPipelineCache);
763    return VK_SUCCESS;
764}
765
766VkResult CreatePipelineLayout(VkDevice device,
767                              const VkPipelineLayoutCreateInfo*,
768                              const VkAllocationCallbacks* /*allocator*/,
769                              VkPipelineLayout* layout) {
770    *layout =
771        AllocHandle<VkPipelineLayout>(device, HandleType::kPipelineLayout);
772    return VK_SUCCESS;
773}
774
775VkResult CreateQueryPool(VkDevice device,
776                         const VkQueryPoolCreateInfo*,
777                         const VkAllocationCallbacks* /*allocator*/,
778                         VkQueryPool* pool) {
779    *pool = AllocHandle<VkQueryPool>(device, HandleType::kQueryPool);
780    return VK_SUCCESS;
781}
782
783VkResult CreateRenderPass(VkDevice device,
784                          const VkRenderPassCreateInfo*,
785                          const VkAllocationCallbacks* /*allocator*/,
786                          VkRenderPass* renderpass) {
787    *renderpass = AllocHandle<VkRenderPass>(device, HandleType::kRenderPass);
788    return VK_SUCCESS;
789}
790
791VkResult CreateSampler(VkDevice device,
792                       const VkSamplerCreateInfo*,
793                       const VkAllocationCallbacks* /*allocator*/,
794                       VkSampler* sampler) {
795    *sampler = AllocHandle<VkSampler>(device, HandleType::kSampler);
796    return VK_SUCCESS;
797}
798
799VkResult CreateSemaphore(VkDevice device,
800                         const VkSemaphoreCreateInfo*,
801                         const VkAllocationCallbacks* /*allocator*/,
802                         VkSemaphore* semaphore) {
803    *semaphore = AllocHandle<VkSemaphore>(device, HandleType::kSemaphore);
804    return VK_SUCCESS;
805}
806
807VkResult CreateShaderModule(VkDevice device,
808                            const VkShaderModuleCreateInfo*,
809                            const VkAllocationCallbacks* /*allocator*/,
810                            VkShaderModule* module) {
811    *module = AllocHandle<VkShaderModule>(device, HandleType::kShaderModule);
812    return VK_SUCCESS;
813}
814
815VkResult CreateDebugReportCallbackEXT(VkInstance instance,
816                                      const VkDebugReportCallbackCreateInfoEXT*,
817                                      const VkAllocationCallbacks*,
818                                      VkDebugReportCallbackEXT* callback) {
819    *callback = AllocHandle<VkDebugReportCallbackEXT>(
820        instance, HandleType::kDebugReportCallbackEXT);
821    return VK_SUCCESS;
822}
823
824// -----------------------------------------------------------------------------
825// No-op entrypoints
826
827// clang-format off
828#pragma clang diagnostic push
829#pragma clang diagnostic ignored "-Wunused-parameter"
830
831void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
832    ALOGV("TODO: vk%s", __FUNCTION__);
833}
834
835void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
836    ALOGV("TODO: vk%s", __FUNCTION__);
837}
838
839VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
840    ALOGV("TODO: vk%s", __FUNCTION__);
841    return VK_SUCCESS;
842}
843
844VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
845    ALOGV("TODO: vk%s", __FUNCTION__);
846    return VK_SUCCESS;
847}
848
849VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence) {
850    return VK_SUCCESS;
851}
852
853VkResult QueueWaitIdle(VkQueue queue) {
854    ALOGV("TODO: vk%s", __FUNCTION__);
855    return VK_SUCCESS;
856}
857
858VkResult DeviceWaitIdle(VkDevice device) {
859    ALOGV("TODO: vk%s", __FUNCTION__);
860    return VK_SUCCESS;
861}
862
863void UnmapMemory(VkDevice device, VkDeviceMemory mem) {
864}
865
866VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
867    ALOGV("TODO: vk%s", __FUNCTION__);
868    return VK_SUCCESS;
869}
870
871VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
872    ALOGV("TODO: vk%s", __FUNCTION__);
873    return VK_SUCCESS;
874}
875
876void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
877    ALOGV("TODO: vk%s", __FUNCTION__);
878}
879
880VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) {
881    return VK_SUCCESS;
882}
883
884VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset) {
885    return VK_SUCCESS;
886}
887
888void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
889    ALOGV("TODO: vk%s", __FUNCTION__);
890}
891
892void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
893    ALOGV("TODO: vk%s", __FUNCTION__);
894}
895
896VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
897    ALOGV("TODO: vk%s", __FUNCTION__);
898    return VK_SUCCESS;
899}
900
901void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* allocator) {
902}
903
904VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
905    return VK_SUCCESS;
906}
907
908VkResult GetFenceStatus(VkDevice device, VkFence fence) {
909    ALOGV("TODO: vk%s", __FUNCTION__);
910    return VK_SUCCESS;
911}
912
913VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
914    return VK_SUCCESS;
915}
916
917void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* allocator) {
918}
919
920void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* allocator) {
921}
922
923VkResult GetEventStatus(VkDevice device, VkEvent event) {
924    ALOGV("TODO: vk%s", __FUNCTION__);
925    return VK_SUCCESS;
926}
927
928VkResult SetEvent(VkDevice device, VkEvent event) {
929    ALOGV("TODO: vk%s", __FUNCTION__);
930    return VK_SUCCESS;
931}
932
933VkResult ResetEvent(VkDevice device, VkEvent event) {
934    ALOGV("TODO: vk%s", __FUNCTION__);
935    return VK_SUCCESS;
936}
937
938void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* allocator) {
939}
940
941VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
942    ALOGV("TODO: vk%s", __FUNCTION__);
943    return VK_SUCCESS;
944}
945
946void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* allocator) {
947}
948
949void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
950    ALOGV("TODO: vk%s", __FUNCTION__);
951}
952
953void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* allocator) {
954}
955
956void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator) {
957}
958
959void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator) {
960}
961
962VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
963    ALOGV("TODO: vk%s", __FUNCTION__);
964    return VK_SUCCESS;
965}
966
967VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
968    ALOGV("TODO: vk%s", __FUNCTION__);
969    return VK_SUCCESS;
970}
971
972void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* allocator) {
973}
974
975void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* allocator) {
976}
977
978void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* allocator) {
979}
980
981void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* allocator) {
982}
983
984void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* allocator) {
985}
986
987VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
988    ALOGV("TODO: vk%s", __FUNCTION__);
989    return VK_SUCCESS;
990}
991
992void UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
993    ALOGV("TODO: vk%s", __FUNCTION__);
994}
995
996VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) {
997    ALOGV("TODO: vk%s", __FUNCTION__);
998    return VK_SUCCESS;
999}
1000
1001void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* allocator) {
1002}
1003
1004void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* allocator) {
1005}
1006
1007void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
1008    ALOGV("TODO: vk%s", __FUNCTION__);
1009}
1010
1011VkResult ResetCommandPool(VkDevice device, VkCommandPool cmdPool, VkCommandPoolResetFlags flags) {
1012    ALOGV("TODO: vk%s", __FUNCTION__);
1013    return VK_SUCCESS;
1014}
1015
1016VkResult BeginCommandBuffer(VkCommandBuffer cmdBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
1017    return VK_SUCCESS;
1018}
1019
1020VkResult EndCommandBuffer(VkCommandBuffer cmdBuffer) {
1021    return VK_SUCCESS;
1022}
1023
1024VkResult ResetCommandBuffer(VkCommandBuffer cmdBuffer, VkCommandBufferResetFlags flags) {
1025    ALOGV("TODO: vk%s", __FUNCTION__);
1026    return VK_SUCCESS;
1027}
1028
1029void CmdBindPipeline(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
1030}
1031
1032void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
1033}
1034
1035void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
1036}
1037
1038void CmdSetLineWidth(VkCommandBuffer cmdBuffer, float lineWidth) {
1039}
1040
1041void CmdSetDepthBias(VkCommandBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) {
1042}
1043
1044void CmdSetBlendConstants(VkCommandBuffer cmdBuffer, const float blendConst[4]) {
1045}
1046
1047void CmdSetDepthBounds(VkCommandBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) {
1048}
1049
1050void CmdSetStencilCompareMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
1051}
1052
1053void CmdSetStencilWriteMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
1054}
1055
1056void CmdSetStencilReference(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
1057}
1058
1059void CmdBindDescriptorSets(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
1060}
1061
1062void CmdBindIndexBuffer(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
1063}
1064
1065void CmdBindVertexBuffers(VkCommandBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
1066}
1067
1068void CmdDraw(VkCommandBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
1069}
1070
1071void CmdDrawIndexed(VkCommandBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
1072}
1073
1074void CmdDrawIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
1075}
1076
1077void CmdDrawIndexedIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
1078}
1079
1080void CmdDispatch(VkCommandBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) {
1081}
1082
1083void CmdDispatchIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) {
1084}
1085
1086void CmdCopyBuffer(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
1087}
1088
1089void CmdCopyImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
1090}
1091
1092void CmdBlitImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
1093}
1094
1095void CmdCopyBufferToImage(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
1096}
1097
1098void CmdCopyImageToBuffer(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
1099}
1100
1101void CmdUpdateBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) {
1102}
1103
1104void CmdFillBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {
1105}
1106
1107void CmdClearColorImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
1108}
1109
1110void CmdClearDepthStencilImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
1111}
1112
1113void CmdClearAttachments(VkCommandBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
1114}
1115
1116void CmdResolveImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
1117}
1118
1119void CmdSetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
1120}
1121
1122void CmdResetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
1123}
1124
1125void 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) {
1126}
1127
1128void 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) {
1129}
1130
1131void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
1132}
1133
1134void CmdEndQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
1135}
1136
1137void CmdResetQueryPool(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
1138}
1139
1140void CmdWriteTimestamp(VkCommandBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
1141}
1142
1143void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
1144}
1145
1146void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
1147}
1148
1149void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
1150}
1151
1152void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkSubpassContents contents) {
1153}
1154
1155void CmdEndRenderPass(VkCommandBuffer cmdBuffer) {
1156}
1157
1158void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers) {
1159}
1160
1161void DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) {
1162}
1163
1164void DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) {
1165}
1166
1167#pragma clang diagnostic pop
1168// clang-format on
1169
1170}  // namespace null_driver
1171