Statically link vulkan-loader on Mac

DEPS

@@ -90,7 +90,7 @@ deps = {
   },
 
   'third_party/VulkanMemoryAllocator': {
-    'url': '{chromium_git}/external/github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator@ec44c3121c73ae243fe59acfcc0ce1ba19e43947',
+    'url': '{chromium_git}/external/github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator@ebd397e6524227c623604c0cb2d4c5f225a5282d',
   },
 
   'third_party/VK-GL-CTS/src': {

build_overrides/vulkan_loader.gni

@@ -7,4 +7,4 @@ import("//gni/angle.gni")
 vulkan_headers_dir = "//third_party/vulkan-headers/src"
 
 vulkan_gen_subdir = "angle/vulkan"
-vulkan_loader_shared = true
+vulkan_loader_shared = angle_shared_libvulkan

gni/angle.gni

@@ -73,8 +73,8 @@ declare_args() {
         (angle_64bit_current_cpu && android64_ndk_api_level >= 26)
   }
 
-  # TODO(tobine): Remove this after roll. http://anglebug.com/4162
-  angle_shared_libvulkan = true
+  # Vulkan loader is statically linked on Mac. http://anglebug.com/4477
+  angle_shared_libvulkan = !is_mac
 
   # There's no "is_winuwp" helper in BUILDCONFIG.gn, so we define one ourselves
   angle_is_winuwp = is_win && current_os == "winuwp"

scripts/export_targets.py

@@ -198,6 +198,7 @@ IGNORED_INCLUDES = {
     b'libANGLE/renderer/vulkan/mac/DisplayVkMac.h',
     b'libANGLE/renderer/vulkan/win32/DisplayVkWin32.h',
     b'libANGLE/renderer/vulkan/xcb/DisplayVkXcb.h',
+    b'third_party/volk/volk.h',
     b'kernel/image.h',
 }
 

src/libANGLE/renderer/vulkan/BUILD.gn

@@ -161,9 +161,26 @@ config("angle_vulkan_lib_android") {
   }
 }
 
+config("angle_vulkan_headers_config") {
+  if (angle_shared_libvulkan) {
+    defines = [ "ANGLE_SHARED_LIBVULKAN=1" ]
+  }
+}
+
+angle_source_set("angle_vulkan_headers") {
+  sources = [ "vk_headers.h" ]
+  if (angle_shared_libvulkan) {
+    public_deps = [ "$angle_root/src/third_party/volk:volk" ]
+  } else {
+    public_deps =
+        [ "$angle_root/third_party/vulkan-headers/src:vulkan_headers" ]
+  }
+  public_configs = [ ":angle_vulkan_headers_config" ]
+}
+
 group("angle_vulkan_entry_points") {
   public_configs = [ ":angle_vulkan_lib_android" ]
-  public_deps = [ "$angle_root/src/third_party/volk" ]
+  public_deps = [ ":angle_vulkan_headers" ]
   if (is_fuchsia) {
     public_deps += [
       "$angle_root/src/common/fuchsia_egl",
@@ -171,7 +188,11 @@ group("angle_vulkan_entry_points") {
       "//third_party/fuchsia-sdk/sdk/pkg/vulkan",
     ]
   } else if (!is_android && !is_ggp) {
-    data_deps = [ "$angle_root/third_party/vulkan-loader/src:libvulkan" ]
+    if (angle_shared_libvulkan) {
+      data_deps = [ "$angle_root/third_party/vulkan-loader/src:libvulkan" ]
+    } else {
+      deps = [ "$angle_root/third_party/vulkan-loader/src:libvulkan" ]
+    }
   }
 }
 
@@ -183,7 +204,6 @@ config("angle_vulkan_backend_config") {
   if (angle_enable_custom_vulkan_cmd_buffers) {
     defines += [ "ANGLE_USE_CUSTOM_VULKAN_CMD_BUFFERS=1" ]
   }
-
   if (angle_enable_vulkan_gpu_trace_events) {
     defines += [ "ANGLE_ENABLE_VULKAN_GPU_TRACE_EVENTS=1" ]
   }
@@ -191,6 +211,7 @@ config("angle_vulkan_backend_config") {
 
 angle_source_set("angle_vk_mem_alloc_wrapper") {
   deps = [
+    ":angle_vulkan_headers",
     "$angle_root/third_party/VulkanMemoryAllocator:vulkan_memory_allocator",
   ]
   sources = [
@@ -212,9 +233,9 @@ angle_source_set("angle_vulkan_backend") {
   deps = [
     ":angle_vk_mem_alloc_wrapper",
     ":angle_vulkan_entry_points",
+    ":angle_vulkan_headers",
     "$angle_root:angle_gpu_info_util",
     "$angle_root:angle_image_util",
-    "$angle_root/third_party/vulkan-headers/src:vulkan_headers",
     "$angle_spirv_tools_dir:spvtools_val",
   ]
   public_deps = [
@@ -239,10 +260,12 @@ angle_source_set("angle_vulkan_backend") {
   sources += angle_vulkan_internal_shaders
 
   if (!is_android && !is_fuchsia && !is_ggp) {
-    data_deps += [
-      "$angle_root/third_party/vulkan-loader/src:libvulkan",
-      "$angle_root/third_party/vulkan-tools/src:VkICD_mock_icd",
-    ]
+    if (angle_shared_libvulkan) {
+      data_deps += [ "$angle_root/third_party/vulkan-loader/src:libvulkan" ]
+    } else {
+      deps += [ "$angle_root/third_party/vulkan-loader/src:libvulkan" ]
+    }
+    data_deps += [ "$angle_root/third_party/vulkan-tools/src:VkICD_mock_icd" ]
   }
 
   if (angle_enable_vulkan_validation_layers) {

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -10,13 +10,12 @@
 #ifndef LIBANGLE_RENDERER_VULKAN_CONTEXTVK_H_
 #define LIBANGLE_RENDERER_VULKAN_CONTEXTVK_H_
 
-#include "volk.h"
-
 #include "common/PackedEnums.h"
 #include "libANGLE/renderer/ContextImpl.h"
 #include "libANGLE/renderer/vulkan/OverlayVk.h"
 #include "libANGLE/renderer/vulkan/PersistentCommandPool.h"
 #include "libANGLE/renderer/vulkan/RendererVk.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 #include "libANGLE/renderer/vulkan/vk_helpers.h"
 
 namespace angle

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -10,7 +10,6 @@
 #include "libANGLE/renderer/vulkan/FramebufferVk.h"
 
 #include <array>
-#include "volk.h"
 
 #include "common/debug.h"
 #include "libANGLE/Context.h"
@@ -24,6 +23,7 @@
 #include "libANGLE/renderer/vulkan/ResourceVk.h"
 #include "libANGLE/renderer/vulkan/SurfaceVk.h"
 #include "libANGLE/renderer/vulkan/vk_format_utils.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 #include "libANGLE/trace.h"
 
 namespace rx

src/libANGLE/renderer/vulkan/MemoryObjectVk.cpp

@@ -11,7 +11,7 @@
 #include "libANGLE/Context.h"
 #include "libANGLE/renderer/vulkan/ContextVk.h"
 #include "libANGLE/renderer/vulkan/RendererVk.h"
-#include "volk.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 #include "vulkan/vulkan_fuchsia_ext.h"
 
 #if !defined(ANGLE_PLATFORM_WINDOWS)

src/libANGLE/renderer/vulkan/RenderTargetVk.h

@@ -10,10 +10,9 @@
 #ifndef LIBANGLE_RENDERER_VULKAN_RENDERTARGETVK_H_
 #define LIBANGLE_RENDERER_VULKAN_RENDERTARGETVK_H_
 
-#include "volk.h"
-
 #include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/renderer/renderer_utils.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 #include "libANGLE/renderer/vulkan/vk_helpers.h"
 
 namespace rx

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -702,14 +702,12 @@ void RendererVk::onDestroy()
 
     if (mDebugUtilsMessenger)
     {
-        ASSERT(mInstance && vkDestroyDebugUtilsMessengerEXT);
         vkDestroyDebugUtilsMessengerEXT(mInstance, mDebugUtilsMessenger, nullptr);
 
         ASSERT(mDebugReportCallback == VK_NULL_HANDLE);
     }
     else if (mDebugReportCallback)
     {
-        ASSERT(mInstance && vkDestroyDebugReportCallbackEXT);
         vkDestroyDebugReportCallbackEXT(mInstance, mDebugReportCallback, nullptr);
     }
 
@@ -740,8 +738,11 @@ angle::Result RendererVk::initialize(DisplayVk *displayVk,
                                      const char *wsiExtension,
                                      const char *wsiLayer)
 {
+#if defined(ANGLE_SHARED_LIBVULKAN)
     // Set all vk* function ptrs
     ANGLE_VK_TRY(displayVk, volkInitialize());
+#endif  // defined(ANGLE_SHARED_LIBVULKAN)
+
     mDisplay                         = display;
     const egl::AttributeMap &attribs = mDisplay->getAttributeMap();
     ScopedVkLoaderEnvironment scopedEnvironment(ShouldUseValidationLayers(attribs),
@@ -889,11 +890,18 @@ angle::Result RendererVk::initialize(DisplayVk *displayVk,
     instanceInfo.enabledLayerCount   = static_cast<uint32_t>(enabledInstanceLayerNames.size());
     instanceInfo.ppEnabledLayerNames = enabledInstanceLayerNames.data();
     ANGLE_VK_TRY(displayVk, vkCreateInstance(&instanceInfo, nullptr, &mInstance));
+#if defined(ANGLE_SHARED_LIBVULKAN)
+    // Load volk if we are linking dynamically
     volkLoadInstance(mInstance);
+#endif  // defined(ANGLE_SHARED_LIBVULKAN)
 
     if (mEnableDebugUtils)
     {
         // Use the newer EXT_debug_utils if it exists.
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+        InitDebugUtilsEXTFunctions(mInstance);
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
+
         // Create the messenger callback.
         VkDebugUtilsMessengerCreateInfoEXT messengerInfo = {};
 
@@ -918,6 +926,10 @@ angle::Result RendererVk::initialize(DisplayVk *displayVk,
     else if (enableDebugReport)
     {
         // Fallback to EXT_debug_report.
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+        InitDebugReportEXTFunctions(mInstance);
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
+
         VkDebugReportCallbackCreateInfoEXT debugReportInfo = {};
 
         debugReportInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
@@ -933,6 +945,9 @@ angle::Result RendererVk::initialize(DisplayVk *displayVk,
                   VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME) !=
         enabledInstanceExtensions.end())
     {
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+        InitGetPhysicalDeviceProperties2KHRFunctions(mInstance);
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
         ASSERT(vkGetPhysicalDeviceProperties2KHR);
     }
 
@@ -1248,6 +1263,9 @@ angle::Result RendererVk::initializeDevice(DisplayVk *displayVk, uint32_t queueF
         enabledDeviceExtensions.push_back(VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME);
         enabledDeviceExtensions.push_back(
             VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME);
+#    if !defined(ANGLE_SHARED_LIBVULKAN)
+        InitExternalMemoryHardwareBufferANDROIDFunctions(mInstance);
+#    endif  // !defined(ANGLE_SHARED_LIBVULKAN)
     }
 #else
     ASSERT(!getFeatures().supportsAndroidHardwareBuffer.enabled);
@@ -1274,6 +1292,9 @@ angle::Result RendererVk::initializeDevice(DisplayVk *displayVk, uint32_t queueF
         getFeatures().supportsExternalSemaphoreFuchsia.enabled)
     {
         enabledDeviceExtensions.push_back(VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+        InitExternalSemaphoreFdFunctions(mInstance);
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
     }
 
     if (getFeatures().supportsExternalSemaphoreCapabilities.enabled)
@@ -1291,9 +1312,28 @@ angle::Result RendererVk::initializeDevice(DisplayVk *displayVk, uint32_t queueF
         enabledDeviceExtensions.push_back(VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME);
     }
 
+    if (getFeatures().supportsExternalSemaphoreCapabilities.enabled)
+    {
+        enabledDeviceExtensions.push_back(VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME);
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+        InitExternalSemaphoreCapabilitiesFunctions(mInstance);
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
+    }
+
     if (getFeatures().supportsExternalFenceFd.enabled)
     {
         enabledDeviceExtensions.push_back(VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME);
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+        InitExternalFenceFdFunctions(mInstance);
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
+    }
+
+    if (getFeatures().supportsExternalFenceCapabilities.enabled)
+    {
+        enabledDeviceExtensions.push_back(VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME);
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+        InitExternalFenceCapabilitiesFunctions(mInstance);
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
     }
 
     if (getFeatures().supportsExternalSemaphoreFuchsia.enabled)
@@ -1392,6 +1432,9 @@ angle::Result RendererVk::initializeDevice(DisplayVk *displayVk, uint32_t queueF
         enabledDeviceExtensions.push_back(VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME);
         mMinImportedHostPointerAlignment =
             mPhysicalDeviceExternalMemoryHostProperties.minImportedHostPointerAlignment;
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+        InitExternalMemoryHostFunctions(mInstance);
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
     }
 
     createInfo.sType                 = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
@@ -1408,7 +1451,10 @@ angle::Result RendererVk::initializeDevice(DisplayVk *displayVk, uint32_t queueF
     createInfo.pEnabledFeatures = &enabledFeatures.features;
 
     ANGLE_VK_TRY(displayVk, vkCreateDevice(mPhysicalDevice, &createInfo, nullptr, &mDevice));
+#if defined(ANGLE_SHARED_LIBVULKAN)
+    // Load volk if we are loading dynamically
     volkLoadDevice(mDevice);
+#endif  // defined(ANGLE_SHARED_LIBVULKAN)
 
     mCurrentQueueFamilyIndex = queueFamilyIndex;
 
@@ -1437,6 +1483,13 @@ angle::Result RendererVk::initializeDevice(DisplayVk *displayVk, uint32_t queueF
         mPriorities[egl::ContextPriority::Low] = egl::ContextPriority::Low;
     }
 
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+    if (getFeatures().supportsTransformFeedbackExtension.enabled)
+    {
+        InitTransformFeedbackEXTFunctions(mDevice);
+    }
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
+
     // Initialize the vulkan pipeline cache.
     bool success = false;
     ANGLE_TRY(initPipelineCache(displayVk, &mPipelineCache, &success));
@@ -2230,6 +2283,7 @@ void RendererVk::onCompletedSerial(Serial serial)
 
 void RendererVk::reloadVolkIfNeeded() const
 {
+#if defined(ANGLE_SHARED_LIBVULKAN)
     if ((mInstance != VK_NULL_HANDLE) && (volkGetLoadedInstance() != mInstance))
     {
         volkLoadInstance(mInstance);
@@ -2239,6 +2293,7 @@ void RendererVk::reloadVolkIfNeeded() const
     {
         volkLoadDevice(mDevice);
     }
+#endif  // defined(ANGLE_SHARED_LIBVULKAN)
 }
 
 angle::Result RendererVk::getCommandBufferOneOff(vk::Context *context,

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -15,7 +15,6 @@
 #include <mutex>
 
 #include "vk_ext_provoking_vertex.h"
-#include "volk.h"
 
 #include "common/PackedEnums.h"
 #include "common/PoolAlloc.h"
@@ -26,6 +25,7 @@
 #include "libANGLE/renderer/vulkan/ResourceVk.h"
 #include "libANGLE/renderer/vulkan/UtilsVk.h"
 #include "libANGLE/renderer/vulkan/vk_format_utils.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 #include "libANGLE/renderer/vulkan/vk_helpers.h"
 #include "libANGLE/renderer/vulkan/vk_internal_shaders_autogen.h"
 #include "libANGLE/renderer/vulkan/vk_mem_alloc_wrapper.h"

src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.h

@@ -11,9 +11,8 @@
 #ifndef LIBANGLE_RENDERER_VULKAN_SECONDARYCOMMANDBUFFERVK_H_
 #define LIBANGLE_RENDERER_VULKAN_SECONDARYCOMMANDBUFFERVK_H_
 
-#include "volk.h"
-
 #include "common/PoolAlloc.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 #include "libANGLE/renderer/vulkan/vk_wrapper.h"
 
 namespace rx

src/libANGLE/renderer/vulkan/SurfaceVk.h

@@ -10,10 +10,9 @@
 #ifndef LIBANGLE_RENDERER_VULKAN_SURFACEVK_H_
 #define LIBANGLE_RENDERER_VULKAN_SURFACEVK_H_
 
-#include "volk.h"
-
 #include "libANGLE/renderer/SurfaceImpl.h"
 #include "libANGLE/renderer/vulkan/RenderTargetVk.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 #include "libANGLE/renderer/vulkan/vk_helpers.h"
 
 namespace rx

src/libANGLE/renderer/vulkan/fuchsia/WindowSurfaceVkFuchsia.cpp

@@ -36,6 +36,9 @@ bool WindowSurfaceVkFuchsia::isValidNativeWindow(EGLNativeWindowType window)
 
 angle::Result WindowSurfaceVkFuchsia::createSurfaceVk(vk::Context *context, gl::Extents *extentsOut)
 {
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+    InitImagePipeSurfaceFUCHSIAFunctions(context->getRenderer()->getInstance());
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
     fuchsia_egl_window *egl_window = reinterpret_cast<fuchsia_egl_window *>(mNativeWindowType);
 
     VkImagePipeSurfaceCreateInfoFUCHSIA createInfo = {};

src/libANGLE/renderer/vulkan/vk_caps_utils.h

@@ -10,9 +10,8 @@
 #ifndef LIBANGLE_RENDERER_VULKAN_VK_CAPS_UTILS_H_
 #define LIBANGLE_RENDERER_VULKAN_VK_CAPS_UTILS_H_
 
-#include "volk.h"
-
 #include "libANGLE/Config.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 
 namespace gl
 {

src/libANGLE/renderer/vulkan/vk_ext_provoking_vertex.h

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "volk.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 
 // THIS FILE SHOULD BE DELETED IF VK_EXT_provoking_vertex IS EVER ADDED TO THE VULKAN HEADERS
 #ifdef VK_EXT_provoking_vertex

src/libANGLE/renderer/vulkan/vk_format_utils.h

@@ -9,12 +9,11 @@
 #ifndef LIBANGLE_RENDERER_VULKAN_VK_FORMAT_UTILS_H_
 #define LIBANGLE_RENDERER_VULKAN_VK_FORMAT_UTILS_H_
 
-#include "volk.h"
-
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/Format.h"
 #include "libANGLE/renderer/copyvertex.h"
 #include "libANGLE/renderer/renderer_utils.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 #include "platform/FeaturesVk.h"
 
 #include <array>

src/libANGLE/renderer/vulkan/vk_headers.h

+//
+// Copyright 2016 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.
+//
+// vk_headers:
+//    This file should be included to ensure the vulkan headers are included
+//
+
+#ifndef LIBANGLE_RENDERER_VULKAN_VK_HEADERS_H_
+#define LIBANGLE_RENDERER_VULKAN_VK_HEADERS_H_
+
+#if ANGLE_SHARED_LIBVULKAN
+#    include "third_party/volk/volk.h"
+#else
+#    include <vulkan/vulkan.h>
+#endif
+
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+
+namespace rx
+{
+// VK_EXT_debug_utils
+extern PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT;
+extern PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT;
+extern PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT;
+extern PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT;
+extern PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT;
+
+// VK_EXT_debug_report
+extern PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT;
+extern PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT;
+
+// VK_KHR_get_physical_device_properties2
+extern PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR;
+extern PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR;
+
+// VK_KHR_external_semaphore_fd
+extern PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR;
+
+// VK_EXT_external_memory_host
+extern PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT;
+
+// VK_EXT_transform_feedback
+extern PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT;
+extern PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT;
+extern PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT;
+extern PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT;
+extern PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT;
+extern PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT;
+
+extern PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR;
+extern PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR;
+
+// VK_KHR_external_fence_capabilities
+extern PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR
+    vkGetPhysicalDeviceExternalFencePropertiesKHR;
+
+// VK_KHR_external_fence_fd
+extern PFN_vkGetFenceFdKHR vkGetFenceFdKHR;
+extern PFN_vkImportFenceFdKHR vkImportFenceFdKHR;
+
+// VK_KHR_external_semaphore_capabilities
+extern PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR
+    vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
+
+#    if defined(ANGLE_PLATFORM_FUCHSIA)
+// VK_FUCHSIA_imagepipe_surface
+extern PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA;
+#    endif
+
+#    if defined(ANGLE_PLATFORM_ANDROID)
+extern PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID;
+extern PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID;
+#    endif
+
+#    if defined(ANGLE_PLATFORM_GGP)
+extern PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP;
+#    endif  // defined(ANGLE_PLATFORM_GGP)
+
+}  // namespace rx
+
+#endif  // ANGLE_SHARED_LIBVULKAN
+
+#endif  // LIBANGLE_RENDERER_VULKAN_VK_HEADERS_H_

src/libANGLE/renderer/vulkan/vk_mem_alloc_wrapper.cpp

@@ -36,8 +36,17 @@ VkResult InitAllocator(VkPhysicalDevice physicalDevice,
     funcs.vkCreateImage                       = vkCreateImage;
     funcs.vkDestroyImage                      = vkDestroyImage;
     funcs.vkCmdCopyBuffer                     = vkCmdCopyBuffer;
-    funcs.vkGetBufferMemoryRequirements2KHR   = vkGetBufferMemoryRequirements2KHR;
-    funcs.vkGetImageMemoryRequirements2KHR    = vkGetImageMemoryRequirements2KHR;
+    {
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+        // When the vulkan-loader is statically linked, we need to use the extension
+        // functions defined in ANGLE's rx namespace. When it's dynamically linked
+        // with volk, this will default to the function definitions with no namespace
+        using rx::vkGetBufferMemoryRequirements2KHR;
+        using rx::vkGetImageMemoryRequirements2KHR;
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
+        funcs.vkGetBufferMemoryRequirements2KHR = vkGetBufferMemoryRequirements2KHR;
+        funcs.vkGetImageMemoryRequirements2KHR  = vkGetImageMemoryRequirements2KHR;
+    }
 
     VmaAllocatorCreateInfo allocatorInfo = {};
     allocatorInfo.physicalDevice         = physicalDevice;

src/libANGLE/renderer/vulkan/vk_mem_alloc_wrapper.h

@@ -10,7 +10,7 @@
 #ifndef LIBANGLE_RENDERER_VULKAN_VK_MEM_ALLOC_WRAPPER_H_
 #define LIBANGLE_RENDERER_VULKAN_VK_MEM_ALLOC_WRAPPER_H_
 
-#include <volk.h>
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 
 VK_DEFINE_HANDLE(VmaAllocator)
 VK_DEFINE_HANDLE(VmaAllocation)

src/libANGLE/renderer/vulkan/vk_utils.cpp

@@ -684,6 +684,167 @@ void MakeDebugUtilsLabel(GLenum source, const char *marker, VkDebugUtilsLabelEXT
 }
 }  // namespace vk
 
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+// VK_EXT_debug_utils
+PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT   = nullptr;
+PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = nullptr;
+PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT       = nullptr;
+PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT           = nullptr;
+PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT     = nullptr;
+
+// VK_EXT_debug_report
+PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT   = nullptr;
+PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = nullptr;
+
+// VK_KHR_get_physical_device_properties2
+PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = nullptr;
+PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR     = nullptr;
+
+// VK_KHR_external_semaphore_fd
+PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = nullptr;
+
+// VK_EXT_external_memory_host
+PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = nullptr;
+
+// VK_EXT_transform_feedback
+PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = nullptr;
+PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT             = nullptr;
+PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT                 = nullptr;
+PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT                       = nullptr;
+PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT                           = nullptr;
+PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT               = nullptr;
+
+PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = nullptr;
+PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR   = nullptr;
+
+// VK_KHR_external_fence_capabilities
+PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR =
+    nullptr;
+
+// VK_KHR_external_fence_fd
+PFN_vkGetFenceFdKHR vkGetFenceFdKHR       = nullptr;
+PFN_vkImportFenceFdKHR vkImportFenceFdKHR = nullptr;
+
+// VK_KHR_external_semaphore_capabilities
+PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR
+    vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = nullptr;
+
+#    if defined(ANGLE_PLATFORM_FUCHSIA)
+// VK_FUCHSIA_imagepipe_surface
+PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = nullptr;
+#    endif
+
+#    if defined(ANGLE_PLATFORM_ANDROID)
+PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID =
+    nullptr;
+PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = nullptr;
+#    endif
+
+#    if defined(ANGLE_PLATFORM_GGP)
+PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = nullptr;
+#    endif
+
+#    define GET_INSTANCE_FUNC(vkName)                                                          \
+        do                                                                                     \
+        {                                                                                      \
+            vkName = reinterpret_cast<PFN_##vkName>(vkGetInstanceProcAddr(instance, #vkName)); \
+            ASSERT(vkName);                                                                    \
+        } while (0)
+
+#    define GET_DEVICE_FUNC(vkName)                                                        \
+        do                                                                                 \
+        {                                                                                  \
+            vkName = reinterpret_cast<PFN_##vkName>(vkGetDeviceProcAddr(device, #vkName)); \
+            ASSERT(vkName);                                                                \
+        } while (0)
+
+void InitDebugUtilsEXTFunctions(VkInstance instance)
+{
+    GET_INSTANCE_FUNC(vkCreateDebugUtilsMessengerEXT);
+    GET_INSTANCE_FUNC(vkDestroyDebugUtilsMessengerEXT);
+    GET_INSTANCE_FUNC(vkCmdBeginDebugUtilsLabelEXT);
+    GET_INSTANCE_FUNC(vkCmdEndDebugUtilsLabelEXT);
+    GET_INSTANCE_FUNC(vkCmdInsertDebugUtilsLabelEXT);
+}
+
+void InitDebugReportEXTFunctions(VkInstance instance)
+{
+    GET_INSTANCE_FUNC(vkCreateDebugReportCallbackEXT);
+    GET_INSTANCE_FUNC(vkDestroyDebugReportCallbackEXT);
+}
+
+void InitGetPhysicalDeviceProperties2KHRFunctions(VkInstance instance)
+{
+    GET_INSTANCE_FUNC(vkGetPhysicalDeviceProperties2KHR);
+    GET_INSTANCE_FUNC(vkGetPhysicalDeviceFeatures2KHR);
+}
+
+void InitTransformFeedbackEXTFunctions(VkDevice device)
+{
+    GET_DEVICE_FUNC(vkCmdBindTransformFeedbackBuffersEXT);
+    GET_DEVICE_FUNC(vkCmdBeginTransformFeedbackEXT);
+    GET_DEVICE_FUNC(vkCmdEndTransformFeedbackEXT);
+    GET_DEVICE_FUNC(vkCmdBeginQueryIndexedEXT);
+    GET_DEVICE_FUNC(vkCmdEndQueryIndexedEXT);
+    GET_DEVICE_FUNC(vkCmdDrawIndirectByteCountEXT);
+}
+
+#    if defined(ANGLE_PLATFORM_FUCHSIA)
+void InitImagePipeSurfaceFUCHSIAFunctions(VkInstance instance)
+{
+    GET_INSTANCE_FUNC(vkCreateImagePipeSurfaceFUCHSIA);
+}
+#    endif
+
+#    if defined(ANGLE_PLATFORM_ANDROID)
+void InitExternalMemoryHardwareBufferANDROIDFunctions(VkInstance instance)
+{
+    GET_INSTANCE_FUNC(vkGetAndroidHardwareBufferPropertiesANDROID);
+    GET_INSTANCE_FUNC(vkGetMemoryAndroidHardwareBufferANDROID);
+}
+#    endif
+
+#    if defined(ANGLE_PLATFORM_GGP)
+void InitGGPStreamDescriptorSurfaceFunctions(VkInstance instance)
+{
+    GET_INSTANCE_FUNC(vkCreateStreamDescriptorSurfaceGGP);
+}
+#    endif  // defined(ANGLE_PLATFORM_GGP)
+
+void InitExternalSemaphoreFdFunctions(VkInstance instance)
+{
+    GET_INSTANCE_FUNC(vkImportSemaphoreFdKHR);
+}
+
+void InitExternalMemoryHostFunctions(VkInstance instance)
+{
+    GET_INSTANCE_FUNC(vkGetMemoryHostPointerPropertiesEXT);
+}
+
+// VK_KHR_external_fence_capabilities
+void InitExternalFenceCapabilitiesFunctions(VkInstance instance)
+{
+    GET_INSTANCE_FUNC(vkGetPhysicalDeviceExternalFencePropertiesKHR);
+}
+
+// VK_KHR_external_fence_fd
+void InitExternalFenceFdFunctions(VkInstance instance)
+{
+    GET_INSTANCE_FUNC(vkGetFenceFdKHR);
+    GET_INSTANCE_FUNC(vkImportFenceFdKHR);
+}
+
+// VK_KHR_external_semaphore_capabilities
+void InitExternalSemaphoreCapabilitiesFunctions(VkInstance instance)
+{
+    GET_INSTANCE_FUNC(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR);
+}
+
+#    undef GET_INSTANCE_FUNC
+#    undef GET_DEVICE_FUNC
+
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
+
 namespace gl_vk
 {
 

src/libANGLE/renderer/vulkan/vk_utils.h

@@ -637,6 +637,45 @@ using SpecializationConstantMap = angle::PackedEnumMap<sh::vk::SpecializationCon
 void MakeDebugUtilsLabel(GLenum source, const char *marker, VkDebugUtilsLabelEXT *label);
 }  // namespace vk
 
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+// Lazily load entry points for each extension as necessary.
+void InitDebugUtilsEXTFunctions(VkInstance instance);
+void InitDebugReportEXTFunctions(VkInstance instance);
+void InitGetPhysicalDeviceProperties2KHRFunctions(VkInstance instance);
+void InitTransformFeedbackEXTFunctions(VkDevice device);
+
+#    if defined(ANGLE_PLATFORM_FUCHSIA)
+// VK_FUCHSIA_imagepipe_surface
+void InitImagePipeSurfaceFUCHSIAFunctions(VkInstance instance);
+#    endif
+
+#    if defined(ANGLE_PLATFORM_ANDROID)
+// VK_ANDROID_external_memory_android_hardware_buffer
+void InitExternalMemoryHardwareBufferANDROIDFunctions(VkInstance instance);
+#    endif
+
+#    if defined(ANGLE_PLATFORM_GGP)
+// VK_GGP_stream_descriptor_surface
+void InitGGPStreamDescriptorSurfaceFunctions(VkInstance instance);
+#    endif  // defined(ANGLE_PLATFORM_GGP)
+
+// VK_KHR_external_semaphore_fd
+void InitExternalSemaphoreFdFunctions(VkInstance instance);
+
+// VK_EXT_external_memory_host
+void InitExternalMemoryHostFunctions(VkInstance instance);
+
+// VK_KHR_external_fence_capabilities
+void InitExternalFenceCapabilitiesFunctions(VkInstance instance);
+
+// VK_KHR_external_fence_fd
+void InitExternalFenceFdFunctions(VkInstance instance);
+
+// VK_KHR_external_semaphore_capabilities
+void InitExternalSemaphoreCapabilitiesFunctions(VkInstance instance);
+
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
+
 namespace gl_vk
 {
 VkRect2D GetRect(const gl::Rectangle &source);

src/libANGLE/renderer/vulkan/vk_wrapper.h

@@ -11,9 +11,8 @@
 #ifndef LIBANGLE_RENDERER_VULKAN_VK_WRAPPER_H_
 #define LIBANGLE_RENDERER_VULKAN_VK_WRAPPER_H_
 
-#include "volk.h"
-
 #include "libANGLE/renderer/renderer_utils.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 #include "libANGLE/renderer/vulkan/vk_mem_alloc_wrapper.h"
 
 namespace rx
@@ -1159,8 +1158,16 @@ ANGLE_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT(uint32_t firstB
 ANGLE_INLINE void CommandBuffer::beginDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT &labelInfo)
 {
     ASSERT(valid());
-    ASSERT(vkCmdBeginDebugUtilsLabelEXT);
-    vkCmdBeginDebugUtilsLabelEXT(mHandle, &labelInfo);
+    {
+#if !defined(ANGLE_SHARED_LIBVULKAN)
+        // When the vulkan-loader is statically linked, we need to use the extension
+        // functions defined in ANGLE's rx namespace. When it's dynamically linked
+        // with volk, this will default to the function definitions with no namespace
+        using rx::vkCmdBeginDebugUtilsLabelEXT;
+#endif  // !defined(ANGLE_SHARED_LIBVULKAN)
+        ASSERT(vkCmdBeginDebugUtilsLabelEXT);
+        vkCmdBeginDebugUtilsLabelEXT(mHandle, &labelInfo);
+    }
 }
 
 ANGLE_INLINE void CommandBuffer::endDebugUtilsLabelEXT()

src/libANGLE/renderer/vulkan/win32/DisplayVkWin32.cpp

@@ -12,9 +12,9 @@
 #include "libANGLE/renderer/vulkan/RendererVk.h"
 
 #include <windows.h>
-#include "volk.h"
 
 #include "libANGLE/renderer/vulkan/vk_caps_utils.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 #include "libANGLE/renderer/vulkan/win32/WindowSurfaceVkWin32.h"
 
 namespace rx

src/tests/test_utils/VulkanExternalHelper.cpp

@@ -141,8 +141,11 @@ VulkanExternalHelper::~VulkanExternalHelper()
 void VulkanExternalHelper::initialize()
 {
     ASSERT(mInstance == VK_NULL_HANDLE);
-    VkResult result = volkInitialize();
+    VkResult result = VK_SUCCESS;
+#if ANGLE_SHARED_LIBVULKAN
+    result = volkInitialize();
     ASSERT(result == VK_SUCCESS);
+#endif  // ANGLE_SHARED_LIBVULKAN
     std::vector<VkExtensionProperties> instanceExtensionProperties =
         EnumerateInstanceExtensionProperties(nullptr);
 
@@ -188,7 +191,9 @@ void VulkanExternalHelper::initialize()
     result = vkCreateInstance(&instanceCreateInfo, nullptr, &mInstance);
     ASSERT(result == VK_SUCCESS);
     ASSERT(mInstance != VK_NULL_HANDLE);
+#if ANGLE_SHARED_LIBVULKAN
     volkLoadInstance(mInstance);
+#endif  // ANGLE_SHARED_LIBVULKAN
 
     std::vector<VkPhysicalDevice> physicalDevices = EnumeratePhysicalDevices(mInstance);
     ASSERT(physicalDevices.size() > 0);
@@ -261,7 +266,9 @@ void VulkanExternalHelper::initialize()
     result = vkCreateDevice(mPhysicalDevice, &deviceCreateInfo, nullptr, &mDevice);
     ASSERT(result == VK_SUCCESS);
     ASSERT(mDevice != VK_NULL_HANDLE);
+#if ANGLE_SHARED_LIBVULKAN
     volkLoadDevice(mDevice);
+#endif  // ANGLE_SHARED_LIBVULKAN
 
     constexpr uint32_t kGraphicsQueueIndex = 0;
     static_assert(kGraphicsQueueIndex < kGraphicsQueueCount, "must be in range");

src/tests/test_utils/VulkanExternalHelper.h

@@ -8,7 +8,7 @@
 #ifndef ANGLE_TESTS_TESTUTILS_VULKANEXTERNALHELPER_H_
 #define ANGLE_TESTS_TESTUTILS_VULKANEXTERNALHELPER_H_
 
-#include "volk.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 #include "vulkan/vulkan_fuchsia_ext.h"
 
 namespace angle

src/tests/test_utils/third_party/vulkan_command_buffer_utils.cpp

@@ -223,8 +223,11 @@ void init_instance_extension_names(struct sample_info &info)
 
 VkResult init_instance(struct sample_info &info, char const *const app_short_name)
 {
-    VkResult res = volkInitialize();
+    VkResult res = VK_SUCCESS;
+#if ANGLE_SHARED_LIBVULKAN
+    res = volkInitialize();
     ASSERT(res == VK_SUCCESS);
+#endif  // ANGLE_SHARED_LIBVULKAN
     VkApplicationInfo app_info  = {};
     app_info.sType              = VK_STRUCTURE_TYPE_APPLICATION_INFO;
     app_info.pNext              = NULL;
@@ -247,7 +250,9 @@ VkResult init_instance(struct sample_info &info, char const *const app_short_nam
 
     res = vkCreateInstance(&inst_info, NULL, &info.inst);
     ASSERT(res == VK_SUCCESS);
+#if ANGLE_SHARED_LIBVULKAN
     volkLoadInstance(info.inst);
+#endif  // ANGLE_SHARED_LIBVULKAN
 
     return res;
 }
@@ -704,7 +709,9 @@ VkResult init_device(struct sample_info &info)
 
     res = vkCreateDevice(info.gpus[0], &device_info, NULL, &info.device);
     ASSERT(res == VK_SUCCESS);
+#if ANGLE_SHARED_LIBVULKAN
     volkLoadDevice(info.device);
+#endif  // ANGLE_SHARED_LIBVULKAN
 
     return res;
 }

src/tests/test_utils/third_party/vulkan_command_buffer_utils.h

@@ -60,7 +60,7 @@ ANGLE_REENABLE_EXTRA_SEMI_WARNING
 #    include "vulkan/vk_sdk_platform.h"
 #endif
 
-#include "volk.h"
+#include "libANGLE/renderer/vulkan/vk_headers.h"
 
 /* Number of descriptor sets needs to be the same at alloc,       */
 /* pipeline layout creation, and descriptor set layout creation   */