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
19#include <algorithm>
20#include <array>
21#include <inttypes.h>
22#include <stdlib.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};
42
43struct VkQueue_T {
44    hwvulkan_dispatch_t dispatch;
45};
46
47struct VkCommandBuffer_T {
48    hwvulkan_dispatch_t dispatch;
49};
50
51namespace {
52// Handles for non-dispatchable objects are either pointers, or arbitrary
53// 64-bit non-zero values. We only use pointers when we need to keep state for
54// the object even in a null driver. For the rest, we form a handle as:
55//   [63:63] = 1 to distinguish from pointer handles*
56//   [62:56] = non-zero handle type enum value
57//   [55: 0] = per-handle-type incrementing counter
58// * This works because virtual addresses with the high bit set are reserved
59// for kernel data in all ABIs we run on.
60//
61// We never reclaim handles on vkDestroy*. It's not even necessary for us to
62// have distinct handles for live objects, and practically speaking we won't
63// ever create 2^56 objects of the same type from a single VkDevice in a null
64// driver.
65//
66// Using a namespace here instead of 'enum class' since we want scoped
67// constants but also want implicit conversions to integral types.
68namespace HandleType {
69enum Enum {
70    kBufferView,
71    kDebugReportCallbackEXT,
72    kDescriptorPool,
73    kDescriptorSet,
74    kDescriptorSetLayout,
75    kEvent,
76    kFence,
77    kFramebuffer,
78    kImageView,
79    kPipeline,
80    kPipelineCache,
81    kPipelineLayout,
82    kQueryPool,
83    kRenderPass,
84    kSampler,
85    kSemaphore,
86    kShaderModule,
87
88    kNumTypes
89};
90}  // namespace HandleType
91
92const VkDeviceSize kMaxDeviceMemory = 0x10000000;  // 256 MiB, arbitrary
93
94}  // anonymous namespace
95
96struct VkDevice_T {
97    hwvulkan_dispatch_t dispatch;
98    VkAllocationCallbacks allocator;
99    VkInstance_T* instance;
100    VkQueue_T queue;
101    std::array<uint64_t, HandleType::kNumTypes> next_handle;
102};
103
104// -----------------------------------------------------------------------------
105// Declare HAL_MODULE_INFO_SYM early so it can be referenced by nulldrv_device
106// later.
107
108namespace {
109int OpenDevice(const hw_module_t* module, const char* id, hw_device_t** device);
110hw_module_methods_t nulldrv_module_methods = {.open = OpenDevice};
111}  // namespace
112
113#pragma clang diagnostic push
114#pragma clang diagnostic ignored "-Wmissing-variable-declarations"
115__attribute__((visibility("default"))) hwvulkan_module_t HAL_MODULE_INFO_SYM = {
116    .common =
117        {
118            .tag = HARDWARE_MODULE_TAG,
119            .module_api_version = HWVULKAN_MODULE_API_VERSION_0_1,
120            .hal_api_version = HARDWARE_HAL_API_VERSION,
121            .id = HWVULKAN_HARDWARE_MODULE_ID,
122            .name = "Null Vulkan Driver",
123            .author = "The Android Open Source Project",
124            .methods = &nulldrv_module_methods,
125        },
126};
127#pragma clang diagnostic pop
128
129// -----------------------------------------------------------------------------
130
131namespace {
132
133int CloseDevice(struct hw_device_t* /*device*/) {
134    // nothing to do - opening a device doesn't allocate any resources
135    return 0;
136}
137
138hwvulkan_device_t nulldrv_device = {
139    .common =
140        {
141            .tag = HARDWARE_DEVICE_TAG,
142            .version = HWVULKAN_DEVICE_API_VERSION_0_1,
143            .module = &HAL_MODULE_INFO_SYM.common,
144            .close = CloseDevice,
145        },
146    .EnumerateInstanceExtensionProperties =
147        EnumerateInstanceExtensionProperties,
148    .CreateInstance = CreateInstance,
149    .GetInstanceProcAddr = GetInstanceProcAddr};
150
151int OpenDevice(const hw_module_t* /*module*/,
152               const char* id,
153               hw_device_t** device) {
154    if (strcmp(id, HWVULKAN_DEVICE_0) == 0) {
155        *device = &nulldrv_device.common;
156        return 0;
157    }
158    return -ENOENT;
159}
160
161VkInstance_T* GetInstanceFromPhysicalDevice(
162    VkPhysicalDevice_T* physical_device) {
163    return reinterpret_cast<VkInstance_T*>(
164        reinterpret_cast<uintptr_t>(physical_device) -
165        offsetof(VkInstance_T, physical_device));
166}
167
168uint64_t AllocHandle(uint64_t type, uint64_t* next_handle) {
169    const uint64_t kHandleMask = (UINT64_C(1) << 56) - 1;
170    ALOGE_IF(*next_handle == kHandleMask,
171             "non-dispatchable handles of type=%" PRIu64
172             " are about to overflow",
173             type);
174    return (UINT64_C(1) << 63) | ((type & 0x7) << 56) |
175           ((*next_handle)++ & kHandleMask);
176}
177
178template <class Handle>
179Handle AllocHandle(VkInstance instance, HandleType::Enum type) {
180    return reinterpret_cast<Handle>(
181        AllocHandle(type, &instance->next_callback_handle));
182}
183
184template <class Handle>
185Handle AllocHandle(VkDevice device, HandleType::Enum type) {
186    return reinterpret_cast<Handle>(
187        AllocHandle(type, &device->next_handle[type]));
188}
189
190VKAPI_ATTR void* DefaultAllocate(void*,
191                                 size_t size,
192                                 size_t alignment,
193                                 VkSystemAllocationScope) {
194    void* ptr = nullptr;
195    // Vulkan requires 'alignment' to be a power of two, but posix_memalign
196    // additionally requires that it be at least sizeof(void*).
197    int ret = posix_memalign(&ptr, std::max(alignment, sizeof(void*)), size);
198    return ret == 0 ? ptr : nullptr;
199}
200
201VKAPI_ATTR void* DefaultReallocate(void*,
202                                   void* ptr,
203                                   size_t size,
204                                   size_t alignment,
205                                   VkSystemAllocationScope) {
206    if (size == 0) {
207        free(ptr);
208        return nullptr;
209    }
210
211    // TODO(jessehall): Right now we never shrink allocations; if the new
212    // request is smaller than the existing chunk, we just continue using it.
213    // The null driver never reallocs, so this doesn't matter. If that changes,
214    // or if this code is copied into some other project, this should probably
215    // have a heuristic to allocate-copy-free when doing so will save "enough"
216    // space.
217    size_t old_size = ptr ? malloc_usable_size(ptr) : 0;
218    if (size <= old_size)
219        return ptr;
220
221    void* new_ptr = nullptr;
222    if (posix_memalign(&new_ptr, std::max(alignment, sizeof(void*)), size) != 0)
223        return nullptr;
224    if (ptr) {
225        memcpy(new_ptr, ptr, std::min(old_size, size));
226        free(ptr);
227    }
228    return new_ptr;
229}
230
231VKAPI_ATTR void DefaultFree(void*, void* ptr) {
232    free(ptr);
233}
234
235const VkAllocationCallbacks kDefaultAllocCallbacks = {
236    .pUserData = nullptr,
237    .pfnAllocation = DefaultAllocate,
238    .pfnReallocation = DefaultReallocate,
239    .pfnFree = DefaultFree,
240};
241
242}  // namespace
243
244namespace null_driver {
245
246#define DEFINE_OBJECT_HANDLE_CONVERSION(T)              \
247    T* Get##T##FromHandle(Vk##T h);                     \
248    T* Get##T##FromHandle(Vk##T h) {                    \
249        return reinterpret_cast<T*>(uintptr_t(h));      \
250    }                                                   \
251    Vk##T GetHandleTo##T(const T* obj);                 \
252    Vk##T GetHandleTo##T(const T* obj) {                \
253        return Vk##T(reinterpret_cast<uintptr_t>(obj)); \
254    }
255
256// -----------------------------------------------------------------------------
257// Global
258
259VKAPI_ATTR
260VkResult EnumerateInstanceExtensionProperties(
261    const char* layer_name,
262    uint32_t* count,
263    VkExtensionProperties* properties) {
264    if (layer_name) {
265        ALOGW(
266            "Driver vkEnumerateInstanceExtensionProperties shouldn't be called "
267            "with a layer name ('%s')",
268            layer_name);
269    }
270
271// NOTE: Change this to zero to report and extension, which can be useful
272// for testing changes to the loader.
273#if 1
274    (void)properties;  // unused
275    *count = 0;
276    return VK_SUCCESS;
277#else
278    const VkExtensionProperties kExtensions[] = {
279        {VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}};
280    const uint32_t kExtensionsCount =
281        sizeof(kExtensions) / sizeof(kExtensions[0]);
282
283    if (!properties || *count > kExtensionsCount)
284        *count = kExtensionsCount;
285    if (properties)
286        std::copy(kExtensions, kExtensions + *count, properties);
287    return *count < kExtensionsCount ? VK_INCOMPLETE : VK_SUCCESS;
288#endif
289}
290
291VKAPI_ATTR
292VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
293                        const VkAllocationCallbacks* allocator,
294                        VkInstance* out_instance) {
295    if (!allocator)
296        allocator = &kDefaultAllocCallbacks;
297
298    VkInstance_T* instance =
299        static_cast<VkInstance_T*>(allocator->pfnAllocation(
300            allocator->pUserData, sizeof(VkInstance_T), alignof(VkInstance_T),
301            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE));
302    if (!instance)
303        return VK_ERROR_OUT_OF_HOST_MEMORY;
304
305    instance->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
306    instance->allocator = *allocator;
307    instance->physical_device.dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
308    instance->next_callback_handle = 0;
309
310    for (uint32_t i = 0; i < create_info->enabledExtensionCount; i++) {
311        if (strcmp(create_info->ppEnabledExtensionNames[i],
312                   VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0) {
313            ALOGV("instance extension '%s' requested",
314                  create_info->ppEnabledExtensionNames[i]);
315        } else {
316            ALOGW("unsupported extension '%s' requested",
317                  create_info->ppEnabledExtensionNames[i]);
318        }
319    }
320
321    *out_instance = instance;
322    return VK_SUCCESS;
323}
324
325VKAPI_ATTR
326PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name) {
327    return instance ? GetInstanceProcAddr(name) : GetGlobalProcAddr(name);
328}
329
330VKAPI_ATTR
331PFN_vkVoidFunction GetDeviceProcAddr(VkDevice, const char* name) {
332    return GetInstanceProcAddr(name);
333}
334
335// -----------------------------------------------------------------------------
336// Instance
337
338void DestroyInstance(VkInstance instance,
339                     const VkAllocationCallbacks* /*allocator*/) {
340    instance->allocator.pfnFree(instance->allocator.pUserData, instance);
341}
342
343// -----------------------------------------------------------------------------
344// PhysicalDevice
345
346VkResult EnumeratePhysicalDevices(VkInstance instance,
347                                  uint32_t* physical_device_count,
348                                  VkPhysicalDevice* physical_devices) {
349    if (physical_devices && *physical_device_count >= 1)
350        physical_devices[0] = &instance->physical_device;
351    *physical_device_count = 1;
352    return VK_SUCCESS;
353}
354
355VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice /*gpu*/,
356                                        uint32_t* count,
357                                        VkLayerProperties* /*properties*/) {
358    ALOGW("Driver vkEnumerateDeviceLayerProperties shouldn't be called");
359    *count = 0;
360    return VK_SUCCESS;
361}
362
363VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice /*gpu*/,
364                                            const char* layer_name,
365                                            uint32_t* count,
366                                            VkExtensionProperties* properties) {
367    if (layer_name) {
368        ALOGW(
369            "Driver vkEnumerateDeviceExtensionProperties shouldn't be called "
370            "with a layer name ('%s')",
371            layer_name);
372        *count = 0;
373        return VK_SUCCESS;
374    }
375
376    const VkExtensionProperties kExtensions[] = {
377        {VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME,
378         VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION}};
379    const uint32_t kExtensionsCount =
380        sizeof(kExtensions) / sizeof(kExtensions[0]);
381
382    if (!properties || *count > kExtensionsCount)
383        *count = kExtensionsCount;
384    if (properties)
385        std::copy(kExtensions, kExtensions + *count, properties);
386    return *count < kExtensionsCount ? VK_INCOMPLETE : VK_SUCCESS;
387}
388
389void GetPhysicalDeviceProperties(VkPhysicalDevice,
390                                 VkPhysicalDeviceProperties* properties) {
391    properties->apiVersion = VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION);
392    properties->driverVersion = VK_MAKE_VERSION(0, 0, 1);
393    properties->vendorID = 0;
394    properties->deviceID = 0;
395    properties->deviceType = VK_PHYSICAL_DEVICE_TYPE_OTHER;
396    strcpy(properties->deviceName, "Android Vulkan Null Driver");
397    memset(properties->pipelineCacheUUID, 0,
398           sizeof(properties->pipelineCacheUUID));
399    properties->limits = VkPhysicalDeviceLimits{
400        4096,     // maxImageDimension1D
401        4096,     // maxImageDimension2D
402        256,      // maxImageDimension3D
403        4096,     // maxImageDimensionCube
404        256,      // maxImageArrayLayers
405        65536,    // maxTexelBufferElements
406        16384,    // maxUniformBufferRange
407        1 << 27,  // maxStorageBufferRange
408        128,      // maxPushConstantsSize
409        4096,     // maxMemoryAllocationCount
410        4000,     // maxSamplerAllocationCount
411        1,        // bufferImageGranularity
412        0,        // sparseAddressSpaceSize
413        4,        // maxBoundDescriptorSets
414        16,       // maxPerStageDescriptorSamplers
415        12,       // maxPerStageDescriptorUniformBuffers
416        4,        // maxPerStageDescriptorStorageBuffers
417        16,       // maxPerStageDescriptorSampledImages
418        4,        // maxPerStageDescriptorStorageImages
419        4,        // maxPerStageDescriptorInputAttachments
420        128,      // maxPerStageResources
421        96,       // maxDescriptorSetSamplers
422        72,       // maxDescriptorSetUniformBuffers
423        8,        // maxDescriptorSetUniformBuffersDynamic
424        24,       // maxDescriptorSetStorageBuffers
425        4,        // maxDescriptorSetStorageBuffersDynamic
426        96,       // maxDescriptorSetSampledImages
427        24,       // maxDescriptorSetStorageImages
428        4,        // maxDescriptorSetInputAttachments
429        16,       // maxVertexInputAttributes
430        16,       // maxVertexInputBindings
431        2047,     // maxVertexInputAttributeOffset
432        2048,     // maxVertexInputBindingStride
433        64,       // maxVertexOutputComponents
434        0,        // maxTessellationGenerationLevel
435        0,        // maxTessellationPatchSize
436        0,        // maxTessellationControlPerVertexInputComponents
437        0,        // maxTessellationControlPerVertexOutputComponents
438        0,        // maxTessellationControlPerPatchOutputComponents
439        0,        // maxTessellationControlTotalOutputComponents
440        0,        // maxTessellationEvaluationInputComponents
441        0,        // maxTessellationEvaluationOutputComponents
442        0,        // maxGeometryShaderInvocations
443        0,        // maxGeometryInputComponents
444        0,        // maxGeometryOutputComponents
445        0,        // maxGeometryOutputVertices
446        0,        // maxGeometryTotalOutputComponents
447        64,       // maxFragmentInputComponents
448        4,        // maxFragmentOutputAttachments
449        0,        // maxFragmentDualSrcAttachments
450        4,        // maxFragmentCombinedOutputResources
451        16384,    // maxComputeSharedMemorySize
452        {65536, 65536, 65536},  // maxComputeWorkGroupCount[3]
453        128,                    // maxComputeWorkGroupInvocations
454        {128, 128, 64},         // maxComputeWorkGroupSize[3]
455        4,                      // subPixelPrecisionBits
456        4,                      // subTexelPrecisionBits
457        4,                      // mipmapPrecisionBits
458        UINT32_MAX,             // maxDrawIndexedIndexValue
459        1,                      // maxDrawIndirectCount
460        2,                      // maxSamplerLodBias
461        1,                      // maxSamplerAnisotropy
462        1,                      // maxViewports
463        {4096, 4096},           // maxViewportDimensions[2]
464        {-8192.0f, 8191.0f},    // viewportBoundsRange[2]
465        0,                      // viewportSubPixelBits
466        64,                     // minMemoryMapAlignment
467        256,                    // minTexelBufferOffsetAlignment
468        256,                    // minUniformBufferOffsetAlignment
469        256,                    // minStorageBufferOffsetAlignment
470        -8,                     // minTexelOffset
471        7,                      // maxTexelOffset
472        0,                      // minTexelGatherOffset
473        0,                      // maxTexelGatherOffset
474        0.0f,                   // minInterpolationOffset
475        0.0f,                   // maxInterpolationOffset
476        0,                      // subPixelInterpolationOffsetBits
477        4096,                   // maxFramebufferWidth
478        4096,                   // maxFramebufferHeight
479        256,                    // maxFramebufferLayers
480        VK_SAMPLE_COUNT_1_BIT |
481            VK_SAMPLE_COUNT_4_BIT,  // framebufferColorSampleCounts
482        VK_SAMPLE_COUNT_1_BIT |
483            VK_SAMPLE_COUNT_4_BIT,  // framebufferDepthSampleCounts
484        VK_SAMPLE_COUNT_1_BIT |
485            VK_SAMPLE_COUNT_4_BIT,  // framebufferStencilSampleCounts
486        VK_SAMPLE_COUNT_1_BIT |
487            VK_SAMPLE_COUNT_4_BIT,  // framebufferNoAttachmentsSampleCounts
488        4,                          // maxColorAttachments
489        VK_SAMPLE_COUNT_1_BIT |
490            VK_SAMPLE_COUNT_4_BIT,  // sampledImageColorSampleCounts
491        VK_SAMPLE_COUNT_1_BIT,      // sampledImageIntegerSampleCounts
492        VK_SAMPLE_COUNT_1_BIT |
493            VK_SAMPLE_COUNT_4_BIT,  // sampledImageDepthSampleCounts
494        VK_SAMPLE_COUNT_1_BIT |
495            VK_SAMPLE_COUNT_4_BIT,  // sampledImageStencilSampleCounts
496        VK_SAMPLE_COUNT_1_BIT,      // storageImageSampleCounts
497        1,                          // maxSampleMaskWords
498        VK_TRUE,                    // timestampComputeAndGraphics
499        1,                          // timestampPeriod
500        0,                          // maxClipDistances
501        0,                          // maxCullDistances
502        0,                          // maxCombinedClipAndCullDistances
503        2,                          // discreteQueuePriorities
504        {1.0f, 1.0f},               // pointSizeRange[2]
505        {1.0f, 1.0f},               // lineWidthRange[2]
506        0.0f,                       // pointSizeGranularity
507        0.0f,                       // lineWidthGranularity
508        VK_TRUE,                    // strictLines
509        VK_TRUE,                    // standardSampleLocations
510        1,                          // optimalBufferCopyOffsetAlignment
511        1,                          // optimalBufferCopyRowPitchAlignment
512        64,                         // nonCoherentAtomSize
513    };
514}
515
516void GetPhysicalDeviceQueueFamilyProperties(
517    VkPhysicalDevice,
518    uint32_t* count,
519    VkQueueFamilyProperties* properties) {
520    if (!properties || *count > 1)
521        *count = 1;
522    if (properties && *count == 1) {
523        properties->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT |
524                                 VK_QUEUE_TRANSFER_BIT;
525        properties->queueCount = 1;
526        properties->timestampValidBits = 64;
527        properties->minImageTransferGranularity = VkExtent3D{1, 1, 1};
528    }
529}
530
531void GetPhysicalDeviceMemoryProperties(
532    VkPhysicalDevice,
533    VkPhysicalDeviceMemoryProperties* properties) {
534    properties->memoryTypeCount = 1;
535    properties->memoryTypes[0].propertyFlags =
536        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
537        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
538        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
539        VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
540    properties->memoryTypes[0].heapIndex = 0;
541    properties->memoryHeapCount = 1;
542    properties->memoryHeaps[0].size = kMaxDeviceMemory;
543    properties->memoryHeaps[0].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
544}
545
546void GetPhysicalDeviceFeatures(VkPhysicalDevice /*gpu*/,
547                               VkPhysicalDeviceFeatures* features) {
548    *features = VkPhysicalDeviceFeatures{
549        VK_TRUE,   // robustBufferAccess
550        VK_FALSE,  // fullDrawIndexUint32
551        VK_FALSE,  // imageCubeArray
552        VK_FALSE,  // independentBlend
553        VK_FALSE,  // geometryShader
554        VK_FALSE,  // tessellationShader
555        VK_FALSE,  // sampleRateShading
556        VK_FALSE,  // dualSrcBlend
557        VK_FALSE,  // logicOp
558        VK_FALSE,  // multiDrawIndirect
559        VK_FALSE,  // drawIndirectFirstInstance
560        VK_FALSE,  // depthClamp
561        VK_FALSE,  // depthBiasClamp
562        VK_FALSE,  // fillModeNonSolid
563        VK_FALSE,  // depthBounds
564        VK_FALSE,  // wideLines
565        VK_FALSE,  // largePoints
566        VK_FALSE,  // alphaToOne
567        VK_FALSE,  // multiViewport
568        VK_FALSE,  // samplerAnisotropy
569        VK_FALSE,  // textureCompressionETC2
570        VK_FALSE,  // textureCompressionASTC_LDR
571        VK_FALSE,  // textureCompressionBC
572        VK_FALSE,  // occlusionQueryPrecise
573        VK_FALSE,  // pipelineStatisticsQuery
574        VK_FALSE,  // vertexPipelineStoresAndAtomics
575        VK_FALSE,  // fragmentStoresAndAtomics
576        VK_FALSE,  // shaderTessellationAndGeometryPointSize
577        VK_FALSE,  // shaderImageGatherExtended
578        VK_FALSE,  // shaderStorageImageExtendedFormats
579        VK_FALSE,  // shaderStorageImageMultisample
580        VK_FALSE,  // shaderStorageImageReadWithoutFormat
581        VK_FALSE,  // shaderStorageImageWriteWithoutFormat
582        VK_FALSE,  // shaderUniformBufferArrayDynamicIndexing
583        VK_FALSE,  // shaderSampledImageArrayDynamicIndexing
584        VK_FALSE,  // shaderStorageBufferArrayDynamicIndexing
585        VK_FALSE,  // shaderStorageImageArrayDynamicIndexing
586        VK_FALSE,  // shaderClipDistance
587        VK_FALSE,  // shaderCullDistance
588        VK_FALSE,  // shaderFloat64
589        VK_FALSE,  // shaderInt64
590        VK_FALSE,  // shaderInt16
591        VK_FALSE,  // shaderResourceResidency
592        VK_FALSE,  // shaderResourceMinLod
593        VK_FALSE,  // sparseBinding
594        VK_FALSE,  // sparseResidencyBuffer
595        VK_FALSE,  // sparseResidencyImage2D
596        VK_FALSE,  // sparseResidencyImage3D
597        VK_FALSE,  // sparseResidency2Samples
598        VK_FALSE,  // sparseResidency4Samples
599        VK_FALSE,  // sparseResidency8Samples
600        VK_FALSE,  // sparseResidency16Samples
601        VK_FALSE,  // sparseResidencyAliased
602        VK_FALSE,  // variableMultisampleRate
603        VK_FALSE,  // inheritedQueries
604    };
605}
606
607// -----------------------------------------------------------------------------
608// Device
609
610VkResult CreateDevice(VkPhysicalDevice physical_device,
611                      const VkDeviceCreateInfo* create_info,
612                      const VkAllocationCallbacks* allocator,
613                      VkDevice* out_device) {
614    VkInstance_T* instance = GetInstanceFromPhysicalDevice(physical_device);
615    if (!allocator)
616        allocator = &instance->allocator;
617    VkDevice_T* device = static_cast<VkDevice_T*>(allocator->pfnAllocation(
618        allocator->pUserData, sizeof(VkDevice_T), alignof(VkDevice_T),
619        VK_SYSTEM_ALLOCATION_SCOPE_DEVICE));
620    if (!device)
621        return VK_ERROR_OUT_OF_HOST_MEMORY;
622
623    device->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
624    device->allocator = *allocator;
625    device->instance = instance;
626    device->queue.dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
627    std::fill(device->next_handle.begin(), device->next_handle.end(),
628              UINT64_C(0));
629
630    for (uint32_t i = 0; i < create_info->enabledExtensionCount; i++) {
631        if (strcmp(create_info->ppEnabledExtensionNames[i],
632                   VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME) == 0) {
633            ALOGV("Enabling " VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME);
634        }
635    }
636
637    *out_device = device;
638    return VK_SUCCESS;
639}
640
641void DestroyDevice(VkDevice device,
642                   const VkAllocationCallbacks* /*allocator*/) {
643    if (!device)
644        return;
645    device->allocator.pfnFree(device->allocator.pUserData, device);
646}
647
648void GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
649    *queue = &device->queue;
650}
651
652// -----------------------------------------------------------------------------
653// CommandPool
654
655struct CommandPool {
656    typedef VkCommandPool HandleType;
657    VkAllocationCallbacks allocator;
658};
659DEFINE_OBJECT_HANDLE_CONVERSION(CommandPool)
660
661VkResult CreateCommandPool(VkDevice device,
662                           const VkCommandPoolCreateInfo* /*create_info*/,
663                           const VkAllocationCallbacks* allocator,
664                           VkCommandPool* cmd_pool) {
665    if (!allocator)
666        allocator = &device->allocator;
667    CommandPool* pool = static_cast<CommandPool*>(allocator->pfnAllocation(
668        allocator->pUserData, sizeof(CommandPool), alignof(CommandPool),
669        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
670    if (!pool)
671        return VK_ERROR_OUT_OF_HOST_MEMORY;
672    pool->allocator = *allocator;
673    *cmd_pool = GetHandleToCommandPool(pool);
674    return VK_SUCCESS;
675}
676
677void DestroyCommandPool(VkDevice /*device*/,
678                        VkCommandPool cmd_pool,
679                        const VkAllocationCallbacks* /*allocator*/) {
680    CommandPool* pool = GetCommandPoolFromHandle(cmd_pool);
681    pool->allocator.pfnFree(pool->allocator.pUserData, pool);
682}
683
684// -----------------------------------------------------------------------------
685// CmdBuffer
686
687VkResult AllocateCommandBuffers(VkDevice /*device*/,
688                                const VkCommandBufferAllocateInfo* alloc_info,
689                                VkCommandBuffer* cmdbufs) {
690    VkResult result = VK_SUCCESS;
691    CommandPool& pool = *GetCommandPoolFromHandle(alloc_info->commandPool);
692    std::fill(cmdbufs, cmdbufs + alloc_info->commandBufferCount, nullptr);
693    for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
694        cmdbufs[i] =
695            static_cast<VkCommandBuffer_T*>(pool.allocator.pfnAllocation(
696                pool.allocator.pUserData, sizeof(VkCommandBuffer_T),
697                alignof(VkCommandBuffer_T), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
698        if (!cmdbufs[i]) {
699            result = VK_ERROR_OUT_OF_HOST_MEMORY;
700            break;
701        }
702        cmdbufs[i]->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
703    }
704    if (result != VK_SUCCESS) {
705        for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
706            if (!cmdbufs[i])
707                break;
708            pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
709        }
710    }
711    return result;
712}
713
714void FreeCommandBuffers(VkDevice /*device*/,
715                        VkCommandPool cmd_pool,
716                        uint32_t count,
717                        const VkCommandBuffer* cmdbufs) {
718    CommandPool& pool = *GetCommandPoolFromHandle(cmd_pool);
719    for (uint32_t i = 0; i < count; i++)
720        pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
721}
722
723// -----------------------------------------------------------------------------
724// DeviceMemory
725
726struct DeviceMemory {
727    typedef VkDeviceMemory HandleType;
728    VkDeviceSize size;
729    alignas(16) uint8_t data[0];
730};
731DEFINE_OBJECT_HANDLE_CONVERSION(DeviceMemory)
732
733VkResult AllocateMemory(VkDevice device,
734                        const VkMemoryAllocateInfo* alloc_info,
735                        const VkAllocationCallbacks* allocator,
736                        VkDeviceMemory* mem_handle) {
737    if (SIZE_MAX - sizeof(DeviceMemory) <= alloc_info->allocationSize)
738        return VK_ERROR_OUT_OF_HOST_MEMORY;
739    if (!allocator)
740        allocator = &device->allocator;
741
742    size_t size = sizeof(DeviceMemory) + size_t(alloc_info->allocationSize);
743    DeviceMemory* mem = static_cast<DeviceMemory*>(allocator->pfnAllocation(
744        allocator->pUserData, size, alignof(DeviceMemory),
745        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
746    if (!mem)
747        return VK_ERROR_OUT_OF_HOST_MEMORY;
748    mem->size = size;
749    *mem_handle = GetHandleToDeviceMemory(mem);
750    return VK_SUCCESS;
751}
752
753void FreeMemory(VkDevice device,
754                VkDeviceMemory mem_handle,
755                const VkAllocationCallbacks* allocator) {
756    if (!allocator)
757        allocator = &device->allocator;
758    DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
759    allocator->pfnFree(allocator->pUserData, mem);
760}
761
762VkResult MapMemory(VkDevice,
763                   VkDeviceMemory mem_handle,
764                   VkDeviceSize offset,
765                   VkDeviceSize,
766                   VkMemoryMapFlags,
767                   void** out_ptr) {
768    DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
769    *out_ptr = &mem->data[0] + offset;
770    return VK_SUCCESS;
771}
772
773// -----------------------------------------------------------------------------
774// Buffer
775
776struct Buffer {
777    typedef VkBuffer HandleType;
778    VkDeviceSize size;
779};
780DEFINE_OBJECT_HANDLE_CONVERSION(Buffer)
781
782VkResult CreateBuffer(VkDevice device,
783                      const VkBufferCreateInfo* create_info,
784                      const VkAllocationCallbacks* allocator,
785                      VkBuffer* buffer_handle) {
786    ALOGW_IF(create_info->size > kMaxDeviceMemory,
787             "CreateBuffer: requested size 0x%" PRIx64
788             " exceeds max device memory size 0x%" PRIx64,
789             create_info->size, kMaxDeviceMemory);
790    if (!allocator)
791        allocator = &device->allocator;
792    Buffer* buffer = static_cast<Buffer*>(allocator->pfnAllocation(
793        allocator->pUserData, sizeof(Buffer), alignof(Buffer),
794        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
795    if (!buffer)
796        return VK_ERROR_OUT_OF_HOST_MEMORY;
797    buffer->size = create_info->size;
798    *buffer_handle = GetHandleToBuffer(buffer);
799    return VK_SUCCESS;
800}
801
802void GetBufferMemoryRequirements(VkDevice,
803                                 VkBuffer buffer_handle,
804                                 VkMemoryRequirements* requirements) {
805    Buffer* buffer = GetBufferFromHandle(buffer_handle);
806    requirements->size = buffer->size;
807    requirements->alignment = 16;  // allow fast Neon/SSE memcpy
808    requirements->memoryTypeBits = 0x1;
809}
810
811void DestroyBuffer(VkDevice device,
812                   VkBuffer buffer_handle,
813                   const VkAllocationCallbacks* allocator) {
814    if (!allocator)
815        allocator = &device->allocator;
816    Buffer* buffer = GetBufferFromHandle(buffer_handle);
817    allocator->pfnFree(allocator->pUserData, buffer);
818}
819
820// -----------------------------------------------------------------------------
821// Image
822
823struct Image {
824    typedef VkImage HandleType;
825    VkDeviceSize size;
826};
827DEFINE_OBJECT_HANDLE_CONVERSION(Image)
828
829VkResult CreateImage(VkDevice device,
830                     const VkImageCreateInfo* create_info,
831                     const VkAllocationCallbacks* allocator,
832                     VkImage* image_handle) {
833    if (create_info->imageType != VK_IMAGE_TYPE_2D ||
834        create_info->format != VK_FORMAT_R8G8B8A8_UNORM ||
835        create_info->mipLevels != 1) {
836        ALOGE("CreateImage: not yet implemented: type=%d format=%d mips=%u",
837              create_info->imageType, create_info->format,
838              create_info->mipLevels);
839        return VK_ERROR_OUT_OF_HOST_MEMORY;
840    }
841
842    VkDeviceSize size =
843        VkDeviceSize(create_info->extent.width * create_info->extent.height) *
844        create_info->arrayLayers * create_info->samples * 4u;
845    ALOGW_IF(size > kMaxDeviceMemory,
846             "CreateImage: image size 0x%" PRIx64
847             " exceeds max device memory size 0x%" PRIx64,
848             size, kMaxDeviceMemory);
849
850    if (!allocator)
851        allocator = &device->allocator;
852    Image* image = static_cast<Image*>(allocator->pfnAllocation(
853        allocator->pUserData, sizeof(Image), alignof(Image),
854        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
855    if (!image)
856        return VK_ERROR_OUT_OF_HOST_MEMORY;
857    image->size = size;
858    *image_handle = GetHandleToImage(image);
859    return VK_SUCCESS;
860}
861
862void GetImageMemoryRequirements(VkDevice,
863                                VkImage image_handle,
864                                VkMemoryRequirements* requirements) {
865    Image* image = GetImageFromHandle(image_handle);
866    requirements->size = image->size;
867    requirements->alignment = 16;  // allow fast Neon/SSE memcpy
868    requirements->memoryTypeBits = 0x1;
869}
870
871void DestroyImage(VkDevice device,
872                  VkImage image_handle,
873                  const VkAllocationCallbacks* allocator) {
874    if (!allocator)
875        allocator = &device->allocator;
876    Image* image = GetImageFromHandle(image_handle);
877    allocator->pfnFree(allocator->pUserData, image);
878}
879
880VkResult GetSwapchainGrallocUsageANDROID(VkDevice,
881                                         VkFormat,
882                                         VkImageUsageFlags,
883                                         int* grallocUsage) {
884    // The null driver never reads or writes the gralloc buffer
885    *grallocUsage = 0;
886    return VK_SUCCESS;
887}
888
889VkResult AcquireImageANDROID(VkDevice,
890                             VkImage,
891                             int fence,
892                             VkSemaphore,
893                             VkFence) {
894    close(fence);
895    return VK_SUCCESS;
896}
897
898VkResult QueueSignalReleaseImageANDROID(VkQueue,
899                                        uint32_t,
900                                        const VkSemaphore*,
901                                        VkImage,
902                                        int* fence) {
903    *fence = -1;
904    return VK_SUCCESS;
905}
906
907// -----------------------------------------------------------------------------
908// No-op types
909
910VkResult CreateBufferView(VkDevice device,
911                          const VkBufferViewCreateInfo*,
912                          const VkAllocationCallbacks* /*allocator*/,
913                          VkBufferView* view) {
914    *view = AllocHandle<VkBufferView>(device, HandleType::kBufferView);
915    return VK_SUCCESS;
916}
917
918VkResult CreateDescriptorPool(VkDevice device,
919                              const VkDescriptorPoolCreateInfo*,
920                              const VkAllocationCallbacks* /*allocator*/,
921                              VkDescriptorPool* pool) {
922    *pool = AllocHandle<VkDescriptorPool>(device, HandleType::kDescriptorPool);
923    return VK_SUCCESS;
924}
925
926VkResult AllocateDescriptorSets(VkDevice device,
927                                const VkDescriptorSetAllocateInfo* alloc_info,
928                                VkDescriptorSet* descriptor_sets) {
929    for (uint32_t i = 0; i < alloc_info->descriptorSetCount; i++)
930        descriptor_sets[i] =
931            AllocHandle<VkDescriptorSet>(device, HandleType::kDescriptorSet);
932    return VK_SUCCESS;
933}
934
935VkResult CreateDescriptorSetLayout(VkDevice device,
936                                   const VkDescriptorSetLayoutCreateInfo*,
937                                   const VkAllocationCallbacks* /*allocator*/,
938                                   VkDescriptorSetLayout* layout) {
939    *layout = AllocHandle<VkDescriptorSetLayout>(
940        device, HandleType::kDescriptorSetLayout);
941    return VK_SUCCESS;
942}
943
944VkResult CreateEvent(VkDevice device,
945                     const VkEventCreateInfo*,
946                     const VkAllocationCallbacks* /*allocator*/,
947                     VkEvent* event) {
948    *event = AllocHandle<VkEvent>(device, HandleType::kEvent);
949    return VK_SUCCESS;
950}
951
952VkResult CreateFence(VkDevice device,
953                     const VkFenceCreateInfo*,
954                     const VkAllocationCallbacks* /*allocator*/,
955                     VkFence* fence) {
956    *fence = AllocHandle<VkFence>(device, HandleType::kFence);
957    return VK_SUCCESS;
958}
959
960VkResult CreateFramebuffer(VkDevice device,
961                           const VkFramebufferCreateInfo*,
962                           const VkAllocationCallbacks* /*allocator*/,
963                           VkFramebuffer* framebuffer) {
964    *framebuffer = AllocHandle<VkFramebuffer>(device, HandleType::kFramebuffer);
965    return VK_SUCCESS;
966}
967
968VkResult CreateImageView(VkDevice device,
969                         const VkImageViewCreateInfo*,
970                         const VkAllocationCallbacks* /*allocator*/,
971                         VkImageView* view) {
972    *view = AllocHandle<VkImageView>(device, HandleType::kImageView);
973    return VK_SUCCESS;
974}
975
976VkResult CreateGraphicsPipelines(VkDevice device,
977                                 VkPipelineCache,
978                                 uint32_t count,
979                                 const VkGraphicsPipelineCreateInfo*,
980                                 const VkAllocationCallbacks* /*allocator*/,
981                                 VkPipeline* pipelines) {
982    for (uint32_t i = 0; i < count; i++)
983        pipelines[i] = AllocHandle<VkPipeline>(device, HandleType::kPipeline);
984    return VK_SUCCESS;
985}
986
987VkResult CreateComputePipelines(VkDevice device,
988                                VkPipelineCache,
989                                uint32_t count,
990                                const VkComputePipelineCreateInfo*,
991                                const VkAllocationCallbacks* /*allocator*/,
992                                VkPipeline* pipelines) {
993    for (uint32_t i = 0; i < count; i++)
994        pipelines[i] = AllocHandle<VkPipeline>(device, HandleType::kPipeline);
995    return VK_SUCCESS;
996}
997
998VkResult CreatePipelineCache(VkDevice device,
999                             const VkPipelineCacheCreateInfo*,
1000                             const VkAllocationCallbacks* /*allocator*/,
1001                             VkPipelineCache* cache) {
1002    *cache = AllocHandle<VkPipelineCache>(device, HandleType::kPipelineCache);
1003    return VK_SUCCESS;
1004}
1005
1006VkResult CreatePipelineLayout(VkDevice device,
1007                              const VkPipelineLayoutCreateInfo*,
1008                              const VkAllocationCallbacks* /*allocator*/,
1009                              VkPipelineLayout* layout) {
1010    *layout =
1011        AllocHandle<VkPipelineLayout>(device, HandleType::kPipelineLayout);
1012    return VK_SUCCESS;
1013}
1014
1015VkResult CreateQueryPool(VkDevice device,
1016                         const VkQueryPoolCreateInfo*,
1017                         const VkAllocationCallbacks* /*allocator*/,
1018                         VkQueryPool* pool) {
1019    *pool = AllocHandle<VkQueryPool>(device, HandleType::kQueryPool);
1020    return VK_SUCCESS;
1021}
1022
1023VkResult CreateRenderPass(VkDevice device,
1024                          const VkRenderPassCreateInfo*,
1025                          const VkAllocationCallbacks* /*allocator*/,
1026                          VkRenderPass* renderpass) {
1027    *renderpass = AllocHandle<VkRenderPass>(device, HandleType::kRenderPass);
1028    return VK_SUCCESS;
1029}
1030
1031VkResult CreateSampler(VkDevice device,
1032                       const VkSamplerCreateInfo*,
1033                       const VkAllocationCallbacks* /*allocator*/,
1034                       VkSampler* sampler) {
1035    *sampler = AllocHandle<VkSampler>(device, HandleType::kSampler);
1036    return VK_SUCCESS;
1037}
1038
1039VkResult CreateSemaphore(VkDevice device,
1040                         const VkSemaphoreCreateInfo*,
1041                         const VkAllocationCallbacks* /*allocator*/,
1042                         VkSemaphore* semaphore) {
1043    *semaphore = AllocHandle<VkSemaphore>(device, HandleType::kSemaphore);
1044    return VK_SUCCESS;
1045}
1046
1047VkResult CreateShaderModule(VkDevice device,
1048                            const VkShaderModuleCreateInfo*,
1049                            const VkAllocationCallbacks* /*allocator*/,
1050                            VkShaderModule* module) {
1051    *module = AllocHandle<VkShaderModule>(device, HandleType::kShaderModule);
1052    return VK_SUCCESS;
1053}
1054
1055VkResult CreateDebugReportCallbackEXT(VkInstance instance,
1056                                      const VkDebugReportCallbackCreateInfoEXT*,
1057                                      const VkAllocationCallbacks*,
1058                                      VkDebugReportCallbackEXT* callback) {
1059    *callback = AllocHandle<VkDebugReportCallbackEXT>(
1060        instance, HandleType::kDebugReportCallbackEXT);
1061    return VK_SUCCESS;
1062}
1063
1064// -----------------------------------------------------------------------------
1065// No-op entrypoints
1066
1067// clang-format off
1068#pragma clang diagnostic push
1069#pragma clang diagnostic ignored "-Wunused-parameter"
1070
1071void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
1072    ALOGV("TODO: vk%s", __FUNCTION__);
1073}
1074
1075VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
1076    ALOGV("TODO: vk%s", __FUNCTION__);
1077    return VK_SUCCESS;
1078}
1079
1080VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
1081    ALOGV("TODO: vk%s", __FUNCTION__);
1082    return VK_SUCCESS;
1083}
1084
1085VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence) {
1086    return VK_SUCCESS;
1087}
1088
1089VkResult QueueWaitIdle(VkQueue queue) {
1090    ALOGV("TODO: vk%s", __FUNCTION__);
1091    return VK_SUCCESS;
1092}
1093
1094VkResult DeviceWaitIdle(VkDevice device) {
1095    ALOGV("TODO: vk%s", __FUNCTION__);
1096    return VK_SUCCESS;
1097}
1098
1099void UnmapMemory(VkDevice device, VkDeviceMemory mem) {
1100}
1101
1102VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
1103    ALOGV("TODO: vk%s", __FUNCTION__);
1104    return VK_SUCCESS;
1105}
1106
1107VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
1108    ALOGV("TODO: vk%s", __FUNCTION__);
1109    return VK_SUCCESS;
1110}
1111
1112void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
1113    ALOGV("TODO: vk%s", __FUNCTION__);
1114}
1115
1116VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) {
1117    return VK_SUCCESS;
1118}
1119
1120VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset) {
1121    return VK_SUCCESS;
1122}
1123
1124void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
1125    ALOGV("TODO: vk%s", __FUNCTION__);
1126}
1127
1128void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
1129    ALOGV("TODO: vk%s", __FUNCTION__);
1130}
1131
1132VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
1133    ALOGV("TODO: vk%s", __FUNCTION__);
1134    return VK_SUCCESS;
1135}
1136
1137void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* allocator) {
1138}
1139
1140VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
1141    return VK_SUCCESS;
1142}
1143
1144VkResult GetFenceStatus(VkDevice device, VkFence fence) {
1145    ALOGV("TODO: vk%s", __FUNCTION__);
1146    return VK_SUCCESS;
1147}
1148
1149VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
1150    return VK_SUCCESS;
1151}
1152
1153void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* allocator) {
1154}
1155
1156void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* allocator) {
1157}
1158
1159VkResult GetEventStatus(VkDevice device, VkEvent event) {
1160    ALOGV("TODO: vk%s", __FUNCTION__);
1161    return VK_SUCCESS;
1162}
1163
1164VkResult SetEvent(VkDevice device, VkEvent event) {
1165    ALOGV("TODO: vk%s", __FUNCTION__);
1166    return VK_SUCCESS;
1167}
1168
1169VkResult ResetEvent(VkDevice device, VkEvent event) {
1170    ALOGV("TODO: vk%s", __FUNCTION__);
1171    return VK_SUCCESS;
1172}
1173
1174void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* allocator) {
1175}
1176
1177VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
1178    ALOGV("TODO: vk%s", __FUNCTION__);
1179    return VK_SUCCESS;
1180}
1181
1182void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* allocator) {
1183}
1184
1185void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
1186    ALOGV("TODO: vk%s", __FUNCTION__);
1187}
1188
1189void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* allocator) {
1190}
1191
1192void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator) {
1193}
1194
1195void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator) {
1196}
1197
1198VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
1199    ALOGV("TODO: vk%s", __FUNCTION__);
1200    return VK_SUCCESS;
1201}
1202
1203VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
1204    ALOGV("TODO: vk%s", __FUNCTION__);
1205    return VK_SUCCESS;
1206}
1207
1208void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* allocator) {
1209}
1210
1211void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* allocator) {
1212}
1213
1214void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* allocator) {
1215}
1216
1217void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* allocator) {
1218}
1219
1220void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* allocator) {
1221}
1222
1223VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
1224    ALOGV("TODO: vk%s", __FUNCTION__);
1225    return VK_SUCCESS;
1226}
1227
1228void UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
1229    ALOGV("TODO: vk%s", __FUNCTION__);
1230}
1231
1232VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) {
1233    ALOGV("TODO: vk%s", __FUNCTION__);
1234    return VK_SUCCESS;
1235}
1236
1237void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* allocator) {
1238}
1239
1240void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* allocator) {
1241}
1242
1243void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
1244    ALOGV("TODO: vk%s", __FUNCTION__);
1245}
1246
1247VkResult ResetCommandPool(VkDevice device, VkCommandPool cmdPool, VkCommandPoolResetFlags flags) {
1248    ALOGV("TODO: vk%s", __FUNCTION__);
1249    return VK_SUCCESS;
1250}
1251
1252VkResult BeginCommandBuffer(VkCommandBuffer cmdBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
1253    return VK_SUCCESS;
1254}
1255
1256VkResult EndCommandBuffer(VkCommandBuffer cmdBuffer) {
1257    return VK_SUCCESS;
1258}
1259
1260VkResult ResetCommandBuffer(VkCommandBuffer cmdBuffer, VkCommandBufferResetFlags flags) {
1261    ALOGV("TODO: vk%s", __FUNCTION__);
1262    return VK_SUCCESS;
1263}
1264
1265void CmdBindPipeline(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
1266}
1267
1268void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
1269}
1270
1271void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
1272}
1273
1274void CmdSetLineWidth(VkCommandBuffer cmdBuffer, float lineWidth) {
1275}
1276
1277void CmdSetDepthBias(VkCommandBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) {
1278}
1279
1280void CmdSetBlendConstants(VkCommandBuffer cmdBuffer, const float blendConst[4]) {
1281}
1282
1283void CmdSetDepthBounds(VkCommandBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) {
1284}
1285
1286void CmdSetStencilCompareMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
1287}
1288
1289void CmdSetStencilWriteMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
1290}
1291
1292void CmdSetStencilReference(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
1293}
1294
1295void CmdBindDescriptorSets(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
1296}
1297
1298void CmdBindIndexBuffer(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
1299}
1300
1301void CmdBindVertexBuffers(VkCommandBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
1302}
1303
1304void CmdDraw(VkCommandBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
1305}
1306
1307void CmdDrawIndexed(VkCommandBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
1308}
1309
1310void CmdDrawIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
1311}
1312
1313void CmdDrawIndexedIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
1314}
1315
1316void CmdDispatch(VkCommandBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) {
1317}
1318
1319void CmdDispatchIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) {
1320}
1321
1322void CmdCopyBuffer(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
1323}
1324
1325void CmdCopyImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
1326}
1327
1328void CmdBlitImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
1329}
1330
1331void CmdCopyBufferToImage(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
1332}
1333
1334void CmdCopyImageToBuffer(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
1335}
1336
1337void CmdUpdateBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) {
1338}
1339
1340void CmdFillBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {
1341}
1342
1343void CmdClearColorImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
1344}
1345
1346void CmdClearDepthStencilImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
1347}
1348
1349void CmdClearAttachments(VkCommandBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
1350}
1351
1352void CmdResolveImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
1353}
1354
1355void CmdSetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
1356}
1357
1358void CmdResetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
1359}
1360
1361void 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) {
1362}
1363
1364void 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) {
1365}
1366
1367void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
1368}
1369
1370void CmdEndQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
1371}
1372
1373void CmdResetQueryPool(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
1374}
1375
1376void CmdWriteTimestamp(VkCommandBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
1377}
1378
1379void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
1380}
1381
1382void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
1383}
1384
1385void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
1386}
1387
1388void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkSubpassContents contents) {
1389}
1390
1391void CmdEndRenderPass(VkCommandBuffer cmdBuffer) {
1392}
1393
1394void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers) {
1395}
1396
1397void DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) {
1398}
1399
1400void DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) {
1401}
1402
1403#pragma clang diagnostic pop
1404// clang-format on
1405
1406}  // namespace null_driver
1407