//
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// SystemInfo_vulkan.cpp: Generic vulkan implementation of SystemInfo.h
// TODO: Use VK_KHR_driver_properties. http://anglebug.com/42263671

#include "gpu_info_util/SystemInfo_vulkan.h"
#include "common/unsafe_buffers.h"

#include <vulkan/vulkan.h>
#include "gpu_info_util/SystemInfo_internal.h"

#include <algorithm>
#include <cstring>
#include <fstream>
#include <string>
#include <vector>

#include "common/angleutils.h"
#include "common/debug.h"
#include "common/platform_helpers.h"
#include "common/system_utils.h"
#include "common/vulkan/libvulkan_loader.h"

namespace angle
{
namespace
{
// Note: most drivers use VK_MAKE_API_VERSION to create the version.
VersionInfo ParseGenericDriverVersion(uint32_t driverVersion)
{
    VersionInfo version = {};

    version.major    = VK_API_VERSION_MAJOR(driverVersion);
    version.minor    = VK_API_VERSION_MINOR(driverVersion);
    version.subMinor = VK_API_VERSION_PATCH(driverVersion);

    return version;
}
}  // namespace

VersionInfo ParseAMDVulkanDriverVersion(uint32_t driverVersion)
{
    return ParseGenericDriverVersion(driverVersion);
}

VersionInfo ParseArmVulkanDriverVersion(uint32_t driverVersion)
{
    return ParseGenericDriverVersion(driverVersion);
}

VersionInfo ParseBroadcomVulkanDriverVersion(uint32_t driverVersion)
{
    return ParseGenericDriverVersion(driverVersion);
}

VersionInfo ParseSwiftShaderVulkanDriverVersion(uint32_t driverVersion)
{
    return ParseGenericDriverVersion(driverVersion);
}

VersionInfo ParseImaginationVulkanDriverVersion(uint32_t driverVersion)
{
    return ParseGenericDriverVersion(driverVersion);
}

VersionInfo ParseIntelWindowsVulkanDriverVersion(uint32_t driverVersion)
{
    VersionInfo version = {};

    // Windows Intel driver versions are built in the following format:
    //
    //     Major (18 bits) | Minor (14 bits)
    //
    version.major = driverVersion >> 14;
    version.minor = driverVersion & 0x3FFF;

    return version;
}

VersionInfo ParseKazanVulkanDriverVersion(uint32_t driverVersion)
{
    return ParseGenericDriverVersion(driverVersion);
}

VersionInfo ParseNvidiaVulkanDriverVersion(uint32_t driverVersion)
{
    VersionInfo version = {};

    version.major    = driverVersion >> 22;
    version.minor    = driverVersion >> 14 & 0xFF;
    version.subMinor = driverVersion >> 6 & 0xFF;
    version.patch    = driverVersion & 0x3F;

    return version;
}

VersionInfo ParseQualcommVulkanDriverVersion(uint32_t driverVersion)
{
    VersionInfo version = {};
    if ((driverVersion & 0x80000000) != 0)
    {
        // The major version of the new QCOM drivers seem to be 512. However, the value parsed from
        // the physical device properties shows this field as 0.
        version       = ParseGenericDriverVersion(driverVersion);
        version.major = 512;
        return version;
    }

    // Older drivers with an unknown format, consider them version 0.
    version.minor       = driverVersion;
    return version;
}

VersionInfo ParseSamsungVulkanDriverVersion(uint32_t driverVersion)
{
    return ParseGenericDriverVersion(driverVersion);
}

VersionInfo ParseVeriSiliconVulkanDriverVersion(uint32_t driverVersion)
{
    return ParseGenericDriverVersion(driverVersion);
}

VersionInfo ParseVivanteVulkanDriverVersion(uint32_t driverVersion)
{
    return ParseGenericDriverVersion(driverVersion);
}

VersionInfo ParseMesaVulkanDriverVersion(uint32_t driverVersion)
{
    return ParseGenericDriverVersion(driverVersion);
}

VersionInfo ParseMoltenVulkanDriverVersion(uint32_t driverVersion)
{
    // Note: MoltenVK formulates its version number as a decimal number like so:
    //     (major * 10000) + (minor * 100) + patch
    VersionInfo version = {};

    version.major = driverVersion / 10000;
    version.minor = (driverVersion / 100) % 100;
    version.patch = driverVersion % 100;

    return version;
}

VKAPI_ATTR VkBool32 VKAPI_CALL
VVLDebugUtilsMessenger(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
                       VkDebugUtilsMessageTypeFlagsEXT messageTypes,
                       const VkDebugUtilsMessengerCallbackDataEXT *callbackData,
                       void *userData)
{
    // VUID-VkDebugUtilsMessengerCallbackDataEXT-pMessage-parameter
    // pMessage must be a null-terminated UTF-8 string
    ASSERT(callbackData->pMessage != nullptr);

    // Log the validation error message
    std::ostringstream log;
    if (callbackData->pMessageIdName != nullptr)
    {
        log << "[ " << callbackData->pMessageIdName << " ] ";
    }
    log << callbackData->pMessage << std::endl;
    std::string msg = log.str();
    WARN() << msg;

    bool triggerAssert = (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) != 0;
    if (triggerAssert)
    {
        // Trigger assert when there is validation error, so we can catch it on bots.
        ASSERT(false);
    }

    return VK_FALSE;
}

constexpr const char *kVkKhronosValidationLayerName[] = {"VK_LAYER_KHRONOS_validation"};

bool HasKhronosValidationLayer(const std::vector<VkLayerProperties> &layerProps)
{
    for (const auto &layerProp : layerProps)
    {
        ASSERT(strlen(layerProp.layerName) < sizeof(layerProp.layerName));
        if (ANGLE_UNSAFE_TODO(strncmp(layerProp.layerName, kVkKhronosValidationLayerName[0],
                                      sizeof(layerProp.layerName))) == 0)
        {
            return true;
        }
    }

    WARN() << "Vulkan validation layers are missing";

    return false;
}

class VulkanLibrary final : NonCopyable
{
  public:
    VulkanLibrary() = default;

    ~VulkanLibrary()
    {
        if (mDebugUtilsMessenger)
        {
            mPfnDestroyDebugUtilsMessengerEXT(mInstance, mDebugUtilsMessenger, nullptr);
        }
        if (mInstance != VK_NULL_HANDLE)
        {
            mPfnDestroyInstance(mInstance, nullptr);
        }

        CloseSystemLibrary(mLibVulkan);
    }

    std::vector<std::string> GetInstanceExtensionNames() const
    {
        std::vector<std::string> extensionNames;

        if (!mPfnEnumerateInstanceExtensionProperties)
        {
            return extensionNames;
        }

        uint32_t extensionCount = 0;
        if (mPfnEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr) !=
            VK_SUCCESS)
        {
            return extensionNames;
        }

        std::vector<VkExtensionProperties> extensions(extensionCount);
        if (mPfnEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data()) !=
            VK_SUCCESS)
        {
            return extensionNames;
        }

        for (const auto &extension : extensions)
        {
            extensionNames.emplace_back(extension.extensionName);
        }

        std::sort(extensionNames.begin(), extensionNames.end());

        return extensionNames;
    }

    bool ExtensionFound(std::string const &needle, const std::vector<std::string> &haystack)
    {
        // NOTE: The list must be sorted.
        return std::binary_search(haystack.begin(), haystack.end(), needle);
    }

    VkInstance getVulkanInstance()
    {
        mLibVulkan = vk::OpenLibVulkan();
        if (!mLibVulkan)
        {
            // If Vulkan doesn't exist, bail-out early:
            return VK_NULL_HANDLE;
        }

        mPfnGetInstanceProcAddr =
            getProcWithDLSym<PFN_vkGetInstanceProcAddr>("vkGetInstanceProcAddr");
        if (!mPfnGetInstanceProcAddr)
        {
            return VK_NULL_HANDLE;
        }

        mPfnCreateInstance = getProcWithDLSym<PFN_vkCreateInstance>("vkCreateInstance");
        if (!mPfnCreateInstance)
        {
            return VK_NULL_HANDLE;
        }

        mPfnEnumerateInstanceLayerProperties =
            getProcWithDLSym<PFN_vkEnumerateInstanceLayerProperties>(
                "vkEnumerateInstanceLayerProperties");
        if (!mPfnEnumerateInstanceLayerProperties)
        {
            return VK_NULL_HANDLE;
        }

        mPfnEnumerateInstanceExtensionProperties =
            getProcWithDLSym<PFN_vkEnumerateInstanceExtensionProperties>(
                "vkEnumerateInstanceExtensionProperties");
        if (!mPfnEnumerateInstanceExtensionProperties)
        {
            return VK_NULL_HANDLE;
        }

        // Determine the available Vulkan instance version:
        uint32_t instanceVersion = VK_API_VERSION_1_0;
#if defined(VK_VERSION_1_1)
        PFN_vkEnumerateInstanceVersion pfnEnumerateInstanceVersion =
            getProcWithDLSym<PFN_vkEnumerateInstanceVersion>("vkEnumerateInstanceVersion");
        if (!pfnEnumerateInstanceVersion ||
            pfnEnumerateInstanceVersion(&instanceVersion) != VK_SUCCESS)
        {
            instanceVersion = VK_API_VERSION_1_0;
        }
#endif  // VK_VERSION_1_1

        std::vector<std::string> availableInstanceExtensions = GetInstanceExtensionNames();
        std::vector<const char *> enabledInstanceExtensions;

        bool hasPortabilityEnumeration = false;

        if (IsApple() && ExtensionFound(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME,
                                        availableInstanceExtensions))
        {
            // On iOS/macOS, there is no native Vulkan driver, so we need to
            // enable the portability enumeration extension to allow use of
            // MoltenVK.
            enabledInstanceExtensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
            hasPortabilityEnumeration = true;
        }

        // Enable vulkan validation layer
        bool enableValidationLayer = false;
        // Only enable validation layer when asserts are enabled
#if !defined(NDEBUG) || defined(ANGLE_ASSERT_ALWAYS_ON)
        uint32_t instanceLayerCount = 0;
        {
            mPfnEnumerateInstanceLayerProperties(&instanceLayerCount, nullptr);
        }
        std::vector<VkLayerProperties> instanceLayerProps(instanceLayerCount);
        if (instanceLayerCount > 0)
        {
            mPfnEnumerateInstanceLayerProperties(&instanceLayerCount, instanceLayerProps.data());
        }
        enableValidationLayer = HasKhronosValidationLayer(instanceLayerProps);
#endif
        bool hasDebugMessengerExtension = false;
        if (enableValidationLayer &&
            ExtensionFound(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, availableInstanceExtensions))
        {
            enabledInstanceExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
            hasDebugMessengerExtension = true;
        }

        // Create a Vulkan instance:
        VkApplicationInfo appInfo;
        appInfo.sType              = VK_STRUCTURE_TYPE_APPLICATION_INFO;
        appInfo.pNext              = nullptr;
        appInfo.pApplicationName   = "";
        appInfo.applicationVersion = 1;
        appInfo.pEngineName        = "";
        appInfo.engineVersion      = 1;
        appInfo.apiVersion         = instanceVersion;
        VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{};
        VkInstanceCreateInfo createInstanceInfo{};
        createInstanceInfo.sType               = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
        if (enableValidationLayer)
        {
            createInstanceInfo.enabledLayerCount   = 1;
            createInstanceInfo.ppEnabledLayerNames = kVkKhronosValidationLayerName;

            if (hasDebugMessengerExtension)
            {
                constexpr VkDebugUtilsMessageSeverityFlagsEXT kSeveritiesToLog =
                    VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT |
                    VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT;

                constexpr VkDebugUtilsMessageTypeFlagsEXT kMessagesToLog =
                    VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;

                debugCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
                debugCreateInfo.messageSeverity = kSeveritiesToLog;
                debugCreateInfo.messageType     = kMessagesToLog;
                debugCreateInfo.pfnUserCallback = &VVLDebugUtilsMessenger;
                debugCreateInfo.pUserData       = nullptr;
                createInstanceInfo.pNext        = &debugCreateInfo;
            }
        }
        createInstanceInfo.pApplicationInfo    = &appInfo;
        createInstanceInfo.enabledExtensionCount =
            static_cast<uint32_t>(enabledInstanceExtensions.size());
        createInstanceInfo.ppEnabledExtensionNames =
            enabledInstanceExtensions.empty() ? nullptr : enabledInstanceExtensions.data();

        if (hasPortabilityEnumeration)
        {
            createInstanceInfo.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
        }

        if (mPfnCreateInstance(&createInstanceInfo, nullptr, &mInstance) != VK_SUCCESS)
        {
            return VK_NULL_HANDLE;
        }

        mPfnDestroyInstance = getProcWithDLSym<PFN_vkDestroyInstance>("vkDestroyInstance");
        if (!mPfnDestroyInstance)
        {
            return VK_NULL_HANDLE;
        }

        mPfnEnumeratePhysicalDevices =
            getProcWithDLSym<PFN_vkEnumeratePhysicalDevices>("vkEnumeratePhysicalDevices");
        if (!mPfnEnumeratePhysicalDevices)
        {
            return VK_NULL_HANDLE;
        }

        mPfnGetPhysicalDeviceProperties =
            getProcWithDLSym<PFN_vkGetPhysicalDeviceProperties>("vkGetPhysicalDeviceProperties");
        if (!mPfnGetPhysicalDeviceProperties)
        {
            return VK_NULL_HANDLE;
        }

        // Even then vkEnumerateInstanceVersion() returns VK_API_VERSION_1_1 or higher,
        // mPfnGetPhysicalDeviceProperties2 can be still be nullptr if the actual vulkan device
        // doesn't support VK_API_VERSION_1_1.
        // Caller needs to check VkPhysicalDeviceProperties.apiVersion >= VK_API_VERSION_1_1 before
        // trying to access mPfnGetPhysicalDeviceProperties2.
        mPfnGetPhysicalDeviceProperties2 =
            getProcWithDLSym<PFN_vkGetPhysicalDeviceProperties2>("vkGetPhysicalDeviceProperties2");

        if (hasDebugMessengerExtension)
        {
            mPfnCreateDebugUtilsMessengerEXT =
                getProc<PFN_vkCreateDebugUtilsMessengerEXT>("vkCreateDebugUtilsMessengerEXT");

            mPfnDestroyDebugUtilsMessengerEXT =
                getProc<PFN_vkDestroyDebugUtilsMessengerEXT>("vkDestroyDebugUtilsMessengerEXT");
        }

        // Set up vulkan validation layer debug messenger to relay the VVL error to the callback
        // function VVLDebugUtilsMessenger.
        hasDebugMessengerExtension = hasDebugMessengerExtension &&
                                     mPfnCreateDebugUtilsMessengerEXT &&
                                     mPfnDestroyDebugUtilsMessengerEXT;
        if (hasDebugMessengerExtension)
        {
            ASSERT(debugCreateInfo.sType ==
                   VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT);
            mPfnCreateDebugUtilsMessengerEXT(mInstance, &debugCreateInfo, nullptr,
                                             &mDebugUtilsMessenger);
        }
        return mInstance;
    }

    template <typename Func>
    Func getProcWithDLSym(const char *fn) const
    {
        return reinterpret_cast<Func>(angle::GetLibrarySymbol(mLibVulkan, fn));
    }

    template <typename Func>
    Func getProc(const char *fn) const
    {
        if (mInstance == VK_NULL_HANDLE)
        {
            return (Func)mPfnGetInstanceProcAddr(NULL, fn);
        }
        else
        {
            return (Func)mPfnGetInstanceProcAddr(mInstance, fn);
        }
    }

    PFN_vkEnumeratePhysicalDevices getEnumeratePhysicalDevicesFunc()
    {
        return mPfnEnumeratePhysicalDevices;
    }

    PFN_vkGetPhysicalDeviceProperties getPhysicalDevicePropertiesFunc()
    {
        return mPfnGetPhysicalDeviceProperties;
    }

    PFN_vkGetPhysicalDeviceProperties2 getPhysicalDeviceProperties2Func()
    {
        return mPfnGetPhysicalDeviceProperties2;
    }

  private:
    void *mLibVulkan     = nullptr;
    VkInstance mInstance = VK_NULL_HANDLE;
    VkDebugUtilsMessengerEXT mDebugUtilsMessenger = VK_NULL_HANDLE;
    PFN_vkGetInstanceProcAddr mPfnGetInstanceProcAddr                           = nullptr;
    PFN_vkCreateInstance mPfnCreateInstance                                     = nullptr;
    PFN_vkDestroyInstance mPfnDestroyInstance                                   = nullptr;
    PFN_vkEnumerateInstanceLayerProperties mPfnEnumerateInstanceLayerProperties = nullptr;
    PFN_vkEnumerateInstanceExtensionProperties mPfnEnumerateInstanceExtensionProperties = nullptr;
    PFN_vkEnumeratePhysicalDevices mPfnEnumeratePhysicalDevices                         = nullptr;
    PFN_vkGetPhysicalDeviceProperties mPfnGetPhysicalDeviceProperties                   = nullptr;
    PFN_vkGetPhysicalDeviceProperties2 mPfnGetPhysicalDeviceProperties2                 = nullptr;
    PFN_vkCreateDebugUtilsMessengerEXT mPfnCreateDebugUtilsMessengerEXT                 = nullptr;
    PFN_vkDestroyDebugUtilsMessengerEXT mPfnDestroyDebugUtilsMessengerEXT               = nullptr;
};

ANGLE_FORMAT_PRINTF(1, 2)
std::string FormatString(const char *fmt, ...)
{
    va_list vararg;
    va_start(vararg, fmt);

    std::vector<char> buffer;
    size_t len = ANGLE_UNSAFE_TODO(FormatStringIntoVector(fmt, vararg, buffer));
    va_end(vararg);

    return std::string(&buffer[0], len);
}

bool GetSystemInfoVulkan(SystemInfo *info)
{
    return GetSystemInfoVulkanWithICD(info, vk::ICD::Default);
}

bool GetSystemInfoVulkanWithICD(SystemInfo *info, vk::ICD preferredICD)
{
    const bool enableValidationLayers = false;
    vk::ScopedVkLoaderEnvironment scopedEnvironment(enableValidationLayers, preferredICD);

    static_assert(sizeof(GPUDeviceInfo::deviceUUID) == VK_UUID_SIZE);

    // This implementation builds on top of the Vulkan API, but cannot assume the existence of the
    // Vulkan library.  ANGLE can be installed on versions of Android as old as Ice Cream Sandwich.
    // Therefore, we need to use dlopen()/dlsym() in order to see if Vulkan is installed on the
    // system, and if so, to use it:
    VulkanLibrary vkLibrary;
    VkInstance instance = vkLibrary.getVulkanInstance();
    if (instance == VK_NULL_HANDLE)
    {
        // If Vulkan doesn't exist, bail-out early:
        return false;
    }

    // Enumerate the Vulkan physical devices, which are ANGLE gpus:
    auto pfnEnumeratePhysicalDevices     = vkLibrary.getEnumeratePhysicalDevicesFunc();
    auto pfnGetPhysicalDeviceProperties  = vkLibrary.getPhysicalDevicePropertiesFunc();
    auto pfnGetPhysicalDeviceProperties2 = vkLibrary.getPhysicalDeviceProperties2Func();
    uint32_t physicalDeviceCount = 0;
    if (pfnEnumeratePhysicalDevices(instance, &physicalDeviceCount, nullptr) != VK_SUCCESS)
    {
        return false;
    }
    std::vector<VkPhysicalDevice> physicalDevices(physicalDeviceCount);
    if (pfnEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices.data()) !=
        VK_SUCCESS)
    {
        return false;
    }

    // If we get to here, we will likely provide a valid answer (unless an unknown vendorID):
    info->gpus.resize(physicalDeviceCount);

    for (uint32_t i = 0; i < physicalDeviceCount; i++)
    {
        VkPhysicalDeviceDriverProperties driverProperties = {};
        driverProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;

        VkPhysicalDeviceIDProperties deviceIDProperties = {};
        deviceIDProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
        deviceIDProperties.pNext = &driverProperties;

        VkPhysicalDeviceProperties2 properties2 = {};
        properties2.sType                       = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
        properties2.pNext                       = &deviceIDProperties;

        VkPhysicalDeviceProperties &properties = properties2.properties;
        pfnGetPhysicalDeviceProperties(physicalDevices[i], &properties);

        // vkGetPhysicalDeviceProperties2() is supported since 1.1
        // Use vkGetPhysicalDeviceProperties2() to get driver information.
        if (properties.apiVersion >= VK_API_VERSION_1_1)
        {
            pfnGetPhysicalDeviceProperties2(physicalDevices[i], &properties2);
        }

        // Fill in data for a given physical device (a.k.a. gpu):
        GPUDeviceInfo &gpu = info->gpus[i];
        gpu.vendorId       = properties.vendorID;
        gpu.deviceId       = properties.deviceID;
        gpu.deviceName     = properties.deviceName;
        ANGLE_UNSAFE_TODO(memcpy(gpu.deviceUUID, deviceIDProperties.deviceUUID, VK_UUID_SIZE));
        ANGLE_UNSAFE_TODO(memcpy(gpu.driverUUID, deviceIDProperties.driverUUID, VK_UUID_SIZE));

        // TODO(http://anglebug.com/42266143): Use driverID instead of the hardware vendorID to
        // detect driveVendor, etc.
        switch (properties.vendorID)
        {
            case kVendorID_AMD:
                gpu.driverVendor                = "Advanced Micro Devices, Inc";
                gpu.detailedDriverVersion = ParseAMDVulkanDriverVersion(properties.driverVersion);
                break;
            case kVendorID_ARM:
                gpu.driverVendor                = "Arm Holdings";
                gpu.detailedDriverVersion = ParseArmVulkanDriverVersion(properties.driverVersion);
                break;
            case kVendorID_Broadcom:
                gpu.driverVendor                = "Broadcom";
                gpu.detailedDriverVersion =
                    ParseBroadcomVulkanDriverVersion(properties.driverVersion);
                break;
            case kVendorID_GOOGLE:
                gpu.driverVendor                = "Google";
                gpu.detailedDriverVersion =
                    ParseSwiftShaderVulkanDriverVersion(properties.driverVersion);
                break;
            case kVendorID_ImgTec:
                gpu.driverVendor                = "Imagination Technologies Limited";
                gpu.detailedDriverVersion =
                    ParseImaginationVulkanDriverVersion(properties.driverVersion);
                break;
            case kVendorID_Intel:
                gpu.driverVendor                = "Intel Corporation";
                if (IsWindows())
                {
                    gpu.detailedDriverVersion =
                        ParseIntelWindowsVulkanDriverVersion(properties.driverVersion);
                }
                else
                {
                    gpu.detailedDriverVersion =
                        ParseMesaVulkanDriverVersion(properties.driverVersion);
                }
                break;
            case kVendorID_Kazan:
                gpu.driverVendor                = "Kazan Software";
                gpu.detailedDriverVersion = ParseKazanVulkanDriverVersion(properties.driverVersion);
                break;
            case kVendorID_NVIDIA:
                gpu.driverVendor  = "NVIDIA Corporation";
                gpu.detailedDriverVersion =
                    ParseNvidiaVulkanDriverVersion(properties.driverVersion);
                break;
            case kVendorID_Qualcomm:
            case kVendorID_Qualcomm_DXGI:
                gpu.driverVendor = "Qualcomm Technologies, Inc";
                gpu.detailedDriverVersion =
                    ParseQualcommVulkanDriverVersion(properties.driverVersion);
                break;
            case kVendorID_Samsung:
                gpu.driverVendor                = "Samsung";
                gpu.detailedDriverVersion =
                    ParseSamsungVulkanDriverVersion(properties.driverVersion);
                break;
            case kVendorID_VeriSilicon:
                gpu.driverVendor                = "VeriSilicon";
                gpu.detailedDriverVersion =
                    ParseVeriSiliconVulkanDriverVersion(properties.driverVersion);
                break;
            case kVendorID_Vivante:
                gpu.driverVendor                = "Vivante";
                gpu.detailedDriverVersion =
                    ParseVivanteVulkanDriverVersion(properties.driverVersion);
                break;
            case kVendorID_Mesa:
                gpu.driverVendor                = "Mesa";
                gpu.detailedDriverVersion = ParseMesaVulkanDriverVersion(properties.driverVersion);
                break;
            case kVendorID_Apple:
                // Note: This is MoltenVk
                gpu.driverVendor                = "Apple";
                gpu.detailedDriverVersion =
                    ParseMoltenVulkanDriverVersion(properties.driverVersion);
                break;
            default:
                return false;
        }
        gpu.driverVersion =
            FormatString("%d.%d.%d", gpu.detailedDriverVersion.major,
                         gpu.detailedDriverVersion.minor, gpu.detailedDriverVersion.subMinor);
        gpu.driverId         = static_cast<DriverID>(driverProperties.driverID);
        gpu.driverApiVersion = properties.apiVersion;
        gpu.driverDate       = "";
    }
    return true;
}

}  // namespace angle