[vulkan] Clarify configuration macros for external memory and semaphores.

src/Vulkan/VkConfig.h

@@ -84,13 +84,9 @@ constexpr int SUBPIXEL_PRECISION_MASK = 0xFFFFFFFF >> (32 - SUBPIXEL_PRECISION_B
 
 }
 
-#if VK_USE_PLATFORM_XLIB_KHR || VK_USE_PLATFORM_ANDROID_KHR
-#define SWIFTSHADER_EXTERNAL_MEMORY_LINUX_MEMFD        1
-#define SWIFTSHADER_EXTERNAL_SEMAPHORE_LINUX_MEMFD     1
-#endif
-
-#if VK_USE_PLATFORM_FUCHSIA
-#define SWIFTSHADER_EXTERNAL_SEMAPHORE_ZIRCON_EVENT  1
+#if defined(__linux__) || defined(__ANDROID__)
+#define SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD        1
+#define SWIFTSHADER_EXTERNAL_SEMAPHORE_OPAQUE_FD     1
 #endif
 
 #endif // VK_CONFIG_HPP_

src/Vulkan/VkDeviceMemory.cpp

@@ -36,7 +36,7 @@ public:
     // A value of 0 corresponds to non-external memory.
 	virtual VkExternalMemoryHandleTypeFlagBits getFlagBit() const = 0;
 
-#if SWIFTSHADER_EXTERNAL_MEMORY_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
 	virtual VkResult exportFd(int* pFd) const
 	{
 		return VK_ERROR_INVALID_EXTERNAL_HANDLE;
@@ -121,8 +121,12 @@ public:
 
 }  // namespace vk
 
-#if SWIFTSHADER_EXTERNAL_MEMORY_LINUX_MEMFD
-#include "VkDeviceMemoryExternalLinux.hpp"
+#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
+#  if defined(__linux__) || defined(__ANDROID__)
+#    include "VkDeviceMemoryExternalLinux.hpp"
+#  else
+#    error "Missing VK_KHR_external_memory_fd implementation for this platform!"
+#  endif
 #endif
 
 namespace vk
@@ -131,8 +135,8 @@ namespace vk
 static void findTraits(const VkMemoryAllocateInfo* pAllocateInfo,
 					   ExternalMemoryTraits*       pTraits)
 {
-#if SWIFTSHADER_EXTERNAL_MEMORY_LINUX_MEMFD
-	if (parseCreateInfo<LinuxMemfdExternalMemory>(pAllocateInfo, pTraits))
+#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
+	if (parseCreateInfo<OpaqueFdExternalMemory>(pAllocateInfo, pTraits))
 	{
 		return;
 	}
@@ -220,7 +224,7 @@ bool DeviceMemory::checkExternalMemoryHandleType(
 	return (supportedHandleTypes & handle_type_bit) != 0;
 }
 
-#if SWIFTSHADER_EXTERNAL_MEMORY_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
 VkResult DeviceMemory::exportFd(int* pFd) const
 {
 	return external->exportFd(pFd);

src/Vulkan/VkDeviceMemory.hpp

@@ -28,7 +28,7 @@ public:
 
 	static size_t ComputeRequiredAllocationSize(const VkMemoryAllocateInfo* pCreateInfo);
 
-#if SWIFTSHADER_EXTERNAL_MEMORY_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
 	VkResult exportFd(int* pFd) const;
 #endif
 

src/Vulkan/VkDeviceMemoryExternalLinux.hpp

@@ -19,7 +19,7 @@
 #include <string.h>
 #include <sys/mman.h>
 
-class LinuxMemfdExternalMemory : public vk::DeviceMemory::ExternalBase
+class OpaqueFdExternalMemory : public vk::DeviceMemory::ExternalBase
 {
 public:
 	// Helper struct to parse the VkMemoryAllocateInfo.pNext chain and
@@ -81,12 +81,12 @@ public:
 		return info.importFd || info.exportFd;
 	}
 
-	explicit LinuxMemfdExternalMemory(const VkMemoryAllocateInfo* pAllocateInfo)
+	explicit OpaqueFdExternalMemory(const VkMemoryAllocateInfo* pAllocateInfo)
 			: allocateInfo(pAllocateInfo)
 	{
 	}
 
-	~LinuxMemfdExternalMemory()
+	~OpaqueFdExternalMemory()
 	{
 		memfd.close();
 	}

src/Vulkan/VkGetProcAddress.cpp

@@ -347,7 +347,7 @@ static const std::vector<std::pair<const char*, std::unordered_map<std::string,
 	},
 #endif
 
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_SEMAPHORE_OPAQUE_FD
 	// VK_KHR_external_semaphore_fd
 	{
 		VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME,
@@ -358,7 +358,7 @@ static const std::vector<std::pair<const char*, std::unordered_map<std::string,
 	},
 #endif
 
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_ZIRCON_EVENT
+#if VK_USE_PLATFORM_FUCHSIA
 	// VK_FUCHSIA_external_semaphore
 	{
 		VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME,
@@ -369,7 +369,7 @@ static const std::vector<std::pair<const char*, std::unordered_map<std::string,
 	},
 #endif
 
-#if SWIFTSHADER_EXTERNAL_MEMORY_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
 	// VK_KHR_external_memory_fd
 	{
 		VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME,

src/Vulkan/VkPhysicalDevice.cpp

@@ -25,7 +25,7 @@ namespace vk
 
 static void setExternalMemoryProperties(VkExternalMemoryHandleTypeFlagBits handleType, VkExternalMemoryProperties* properties)
 {
-#if SWIFTSHADER_EXTERNAL_MEMORY_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
 	if (handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
 	{
 		properties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
@@ -384,7 +384,7 @@ void PhysicalDevice::getProperties(const VkPhysicalDeviceExternalFenceInfo* pExt
 
 void PhysicalDevice::getProperties(const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) const
 {
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_SEMAPHORE_OPAQUE_FD
 	if (pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT)
 	{
 		pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
@@ -393,7 +393,7 @@ void PhysicalDevice::getProperties(const VkPhysicalDeviceExternalSemaphoreInfo*
 		return;
 	}
 #endif
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_ZIRCON_EVENT
+#if VK_USE_PLATFORM_FUCHSIA
 	if (pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA)
 	{
 		pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA;

src/Vulkan/VkSemaphore.cpp

@@ -16,9 +16,13 @@
 
 #include "VkConfig.h"
 
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_LINUX_MEMFD
-#include "VkSemaphoreExternalLinux.hpp"
-#elif SWIFTSHADER_EXTERNAL_SEMAPHORE_ZIRCON_EVENT
+#if SWIFTSHADER_EXTERNAL_SEMAPHORE_OPAQUE_FD
+#  if defined(__linux__) || defined(__ANDROID__)
+#    include "VkSemaphoreExternalLinux.hpp"
+#  else
+#    error "Missing VK_KHR_external_semaphore_fd implementation for this platform!"
+#  endif
+#elif VK_USE_PLATFORM_FUCHSIA
 #include "VkSemaphoreExternalFuchsia.hpp"
 #else
 #include "VkSemaphoreExternalNone.hpp"
@@ -196,7 +200,7 @@ void Semaphore::signal()
 	impl->signal();
 }
 
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_SEMAPHORE_OPAQUE_FD
 VkResult Semaphore::importFd(int fd, bool temporaryImport)
 {
 	std::unique_lock<std::mutex> lock(impl->mutex);
@@ -226,9 +230,9 @@ VkResult Semaphore::exportFd(int* pFd) const
 	}
 	return impl->external->exportFd(pFd);
 }
-#endif  // SWIFTSHADER_EXTERNAL_SEMAPHORE_LINUX_MEMFD
+#endif  // SWIFTSHADER_EXTERNAL_SEMAPHORE_OPAQUE_FD
 
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_ZIRCON_EVENT
+#if VK_USE_PLATFORM_FUCHSIA
 VkResult Semaphore::importHandle(zx_handle_t handle, bool temporaryImport)
 {
 	std::unique_lock<std::mutex> lock(impl->mutex);
@@ -252,6 +256,6 @@ VkResult Semaphore::exportHandle(zx_handle_t *pHandle) const
 	}
 	return impl->external->exportHandle(pHandle);
 }
-#endif  // SWIFTSHADER_EXTERNAL_SEMAPHORE_ZIRCON_EVENT
+#endif  // VK_USE_PLATFORM_FUCHSIA
 
 }  // namespace vk

src/Vulkan/VkSemaphore.hpp

@@ -18,7 +18,7 @@
 #include "VkConfig.h"
 #include "VkObject.hpp"
 
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_ZIRCON_EVENT
+#if VK_USE_PLATFORM_FUCHSIA
 #include <zircon/types.h>
 #endif
 
@@ -43,12 +43,12 @@ public:
 
 	void signal();
 
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_SEMAPHORE_OPAQUE_FD
 	VkResult importFd(int fd, bool temporaryImport);
 	VkResult exportFd(int* pFd) const;
 #endif
 
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_ZIRCON_EVENT
+#if VK_USE_PLATFORM_FUCHSIA
 	VkResult importHandle(zx_handle_t handle, bool temporaryImport);
 	VkResult exportHandle(zx_handle_t *pHandle) const;
 #endif

src/Vulkan/libVulkan.cpp

@@ -248,13 +248,13 @@ static const VkExtensionProperties deviceExtensionProperties[] =
 	// (from KHR_swapchain v70) to vkBindImageMemory2.
 	{ VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME, 7 },
 #endif
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_SEMAPHORE_OPAQUE_FD
 	{ VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME, VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION },
 #endif
-#if SWIFTSHADER_EXTERNAL_MEMORY_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
 	{ VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME, VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION },
 #endif
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_ZIRCON_EVENT
+#if VK_USE_PLATFORM_FUCHSIA
 	{ VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME, VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION },
 #endif
 	{ VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME, VK_EXT_PROVOKING_VERTEX_SPEC_VERSION },
@@ -809,7 +809,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryA
 			// This extension controls on which physical devices the memory gets allocated.
 			// SwiftShader only has a single physical device, so this extension does nothing in this case.
 			break;
-#if SWIFTSHADER_EXTERNAL_MEMORY_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
 		case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
 		{
 			auto* importInfo = reinterpret_cast<const VkImportMemoryFdInfoKHR *>(allocationInfo);
@@ -830,7 +830,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryA
 			}
 			break;
 		}
-#endif
+#endif  // SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
 		default:
 			WARN("pAllocateInfo->pNext sType = %s", vk::Stringify(allocationInfo->sType).c_str());
 			break;
@@ -864,7 +864,7 @@ VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory,
 	vk::destroy(memory, pAllocator);
 }
 
-#if SWIFTSHADER_EXTERNAL_MEMORY_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* getFdInfo, int* pFd)
 {
 	TRACE("(VkDevice device = %p, const VkMemoryGetFdInfoKHR* getFdInfo = %p, int* pFd = %p",
@@ -902,7 +902,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(VkDevice device, VkExt
 
 	return VK_SUCCESS;
 }
-#endif  // SWIFTSHADER_EXTERNAL_MEMORY_LINUX_MEMFD
+#endif  // SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
 
 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData)
 {
@@ -1098,7 +1098,7 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semap
 	vk::destroy(semaphore, pAllocator);
 }
 
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_LINUX_MEMFD
+#if SWIFTSHADER_EXTERNAL_SEMAPHORE_OPAQUE_FD
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd)
 {
 	TRACE("(VkDevice device = %p, const VkSemaphoreGetFdInfoKHR* pGetFdInfo = %p, int* pFd = %p)",
@@ -1125,9 +1125,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(VkDevice device, const VkI
 
 	return vk::Cast(pImportSemaphoreInfo->semaphore)->importFd(pImportSemaphoreInfo->fd, temporaryImport);
 }
-#endif  // SWIFTSHADER_EXTERNAL_SEMAPHORE_LINUX_MEMFD
+#endif  // SWIFTSHADER_EXTERNAL_SEMAPHORE_OPAQUE_FD
 
-#if SWIFTSHADER_EXTERNAL_SEMAPHORE_ZIRCON_EVENT
+#if VK_USE_PLATFORM_FUCHSIA
 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA(
 	VkDevice                                        device,
 	const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo)
@@ -1161,7 +1161,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(
 
 	return vk::Cast(pGetZirconHandleInfo->semaphore)->exportHandle(pZirconHandle);
 }
-#endif  // SWIFTSHADER_EXTERNAL_SEMAPHORE_ZIRCON_EVENT
+#endif  // VK_USE_PLATFORM_FUCHSIA
 
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
 {