Move away from PCSX2 fastmem

third_party/host_memory/dynamic_library.cpp

@@ -0,0 +1,97 @@
+// SPDX-FileCopyrightText: 2019 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "host_memory/dynamic_library.h"
+
+#include <fmt/format.h>
+
+#include <string>
+#include <utility>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+namespace Common {
+
+	DynamicLibrary::DynamicLibrary() = default;
+	DynamicLibrary::DynamicLibrary(const char* filename) { void(Open(filename)); }
+	DynamicLibrary::DynamicLibrary(void* handle_) : handle{handle_} {}
+	DynamicLibrary::DynamicLibrary(DynamicLibrary&& rhs) noexcept : handle{std::exchange(rhs.handle, nullptr)} {}
+
+	DynamicLibrary& DynamicLibrary::operator=(DynamicLibrary&& rhs) noexcept {
+		Close();
+		handle = std::exchange(rhs.handle, nullptr);
+		return *this;
+	}
+
+	DynamicLibrary::~DynamicLibrary() { Close(); }
+
+	std::string DynamicLibrary::GetUnprefixedFilename(const char* filename) {
+#if defined(_WIN32)
+		return std::string(filename) + ".dll";
+#elif defined(__APPLE__)
+		return std::string(filename) + ".dylib";
+#else
+		return std::string(filename) + ".so";
+#endif
+	}
+
+	std::string DynamicLibrary::GetVersionedFilename(const char* libname, int major, int minor) {
+#if defined(_WIN32)
+		if (major >= 0 && minor >= 0)
+			return fmt::format("{}-{}-{}.dll", libname, major, minor);
+		else if (major >= 0)
+			return fmt::format("{}-{}.dll", libname, major);
+		else
+			return fmt::format("{}.dll", libname);
+#elif defined(__APPLE__)
+		const char* prefix = std::strncmp(libname, "lib", 3) ? "lib" : "";
+		if (major >= 0 && minor >= 0)
+			return fmt::format("{}{}.{}.{}.dylib", prefix, libname, major, minor);
+		else if (major >= 0)
+			return fmt::format("{}{}.{}.dylib", prefix, libname, major);
+		else
+			return fmt::format("{}{}.dylib", prefix, libname);
+#else
+		const char* prefix = std::strncmp(libname, "lib", 3) ? "lib" : "";
+		if (major >= 0 && minor >= 0)
+			return fmt::format("{}{}.so.{}.{}", prefix, libname, major, minor);
+		else if (major >= 0)
+			return fmt::format("{}{}.so.{}", prefix, libname, major);
+		else
+			return fmt::format("{}{}.so", prefix, libname);
+#endif
+	}
+
+	bool DynamicLibrary::Open(const char* filename) {
+#ifdef _WIN32
+		handle = reinterpret_cast<void*>(LoadLibraryA(filename));
+#else
+		handle = dlopen(filename, RTLD_NOW);
+#endif
+		return handle != nullptr;
+	}
+
+	void DynamicLibrary::Close() {
+		if (!IsOpen()) return;
+
+#ifdef _WIN32
+		FreeLibrary(reinterpret_cast<HMODULE>(handle));
+#else
+		dlclose(handle);
+#endif
+		handle = nullptr;
+	}
+
+	void* DynamicLibrary::GetSymbolAddress(const char* name) const {
+#ifdef _WIN32
+		return reinterpret_cast<void*>(GetProcAddress(reinterpret_cast<HMODULE>(handle), name));
+#else
+		return reinterpret_cast<void*>(dlsym(handle, name));
+#endif
+	}
+
+}  // namespace Common

third_party/host_memory/host_memory.cpp

@@ -0,0 +1,691 @@
+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#ifdef _WIN32
+
+#include <windows.h>
+
+#include <boost/icl/separate_interval_set.hpp>
+#include <iterator>
+#include <unordered_map>
+
+#include "host_memory/dynamic_library.h"
+
+
+#elif defined(__linux__) || defined(__FreeBSD__)  // ^^^ Windows ^^^ vvv Linux vvv
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/random.h>
+#include <unistd.h>
+
+#include <boost/icl/interval_set.hpp>
+
+#include "common/scope_exit.h"
+
+
+#ifndef MAP_NORESERVE
+#define MAP_NORESERVE 0
+#endif
+
+#endif  // ^^^ Linux ^^^
+
+#include <mutex>
+#include <random>
+#include <memory>
+
+#include "align.hpp"
+#include <host_memory/host_memory.h>
+// #include "common/free_region_manager.h"
+
+namespace Common {
+
+	constexpr size_t PageAlignment = 0x1000;
+	constexpr size_t HugePageSize = 0x200000;
+
+#ifdef _WIN32
+
+// Manually imported for MinGW compatibility
+#ifndef MEM_RESERVE_PLACEHOLDER
+#define MEM_RESERVE_PLACEHOLDER 0x00040000
+#endif
+#ifndef MEM_REPLACE_PLACEHOLDER
+#define MEM_REPLACE_PLACEHOLDER 0x00004000
+#endif
+#ifndef MEM_COALESCE_PLACEHOLDERS
+#define MEM_COALESCE_PLACEHOLDERS 0x00000001
+#endif
+#ifndef MEM_PRESERVE_PLACEHOLDER
+#define MEM_PRESERVE_PLACEHOLDER 0x00000002
+#endif
+
+	using PFN_CreateFileMapping2 = _Ret_maybenull_ HANDLE(WINAPI*)(
+		_In_ HANDLE File, _In_opt_ SECURITY_ATTRIBUTES* SecurityAttributes, _In_ ULONG DesiredAccess, _In_ ULONG PageProtection,
+		_In_ ULONG AllocationAttributes, _In_ ULONG64 MaximumSize, _In_opt_ PCWSTR Name,
+		_Inout_updates_opt_(ParameterCount) MEM_EXTENDED_PARAMETER* ExtendedParameters, _In_ ULONG ParameterCount
+	);
+
+	using PFN_VirtualAlloc2 = _Ret_maybenull_ PVOID(WINAPI*)(
+		_In_opt_ HANDLE Process, _In_opt_ PVOID BaseAddress, _In_ SIZE_T Size, _In_ ULONG AllocationType, _In_ ULONG PageProtection,
+		_Inout_updates_opt_(ParameterCount) MEM_EXTENDED_PARAMETER* ExtendedParameters, _In_ ULONG ParameterCount
+	);
+
+	using PFN_MapViewOfFile3 = _Ret_maybenull_ PVOID(WINAPI*)(
+		_In_ HANDLE FileMapping, _In_opt_ HANDLE Process, _In_opt_ PVOID BaseAddress, _In_ ULONG64 Offset, _In_ SIZE_T ViewSize,
+		_In_ ULONG AllocationType, _In_ ULONG PageProtection, _Inout_updates_opt_(ParameterCount) MEM_EXTENDED_PARAMETER* ExtendedParameters,
+		_In_ ULONG ParameterCount
+	);
+
+	using PFN_UnmapViewOfFile2 = BOOL(WINAPI*)(_In_ HANDLE Process, _In_ PVOID BaseAddress, _In_ ULONG UnmapFlags);
+
+	template <typename T>
+	static void GetFuncAddress(Common::DynamicLibrary& dll, const char* name, T& pfn) {
+		if (!dll.GetSymbol(name, &pfn)) {
+			LOG_CRITICAL(HW_Memory, "Failed to load {}", name);
+			throw std::bad_alloc{};
+		}
+	}
+
+	class HostMemory::Impl {
+	  public:
+		explicit Impl(size_t backing_size_, size_t virtual_size_)
+			: backing_size{backing_size_}, virtual_size{virtual_size_}, process{GetCurrentProcess()}, kernelbase_dll("Kernelbase") {
+			if (!kernelbase_dll.IsOpen()) {
+				LOG_CRITICAL(HW_Memory, "Failed to load Kernelbase.dll");
+				throw std::bad_alloc{};
+			}
+			GetFuncAddress(kernelbase_dll, "CreateFileMapping2", pfn_CreateFileMapping2);
+			GetFuncAddress(kernelbase_dll, "VirtualAlloc2", pfn_VirtualAlloc2);
+			GetFuncAddress(kernelbase_dll, "MapViewOfFile3", pfn_MapViewOfFile3);
+			GetFuncAddress(kernelbase_dll, "UnmapViewOfFile2", pfn_UnmapViewOfFile2);
+
+			// Allocate backing file map
+			backing_handle = pfn_CreateFileMapping2(
+				INVALID_HANDLE_VALUE, nullptr, FILE_MAP_WRITE | FILE_MAP_READ, PAGE_READWRITE, SEC_COMMIT, backing_size, nullptr, nullptr, 0
+			);
+			if (!backing_handle) {
+				LOG_CRITICAL(HW_Memory, "Failed to allocate {} MiB of backing memory", backing_size >> 20);
+				throw std::bad_alloc{};
+			}
+			// Allocate a virtual memory for the backing file map as placeholder
+			backing_base =
+				static_cast<u8*>(pfn_VirtualAlloc2(process, nullptr, backing_size, MEM_RESERVE | MEM_RESERVE_PLACEHOLDER, PAGE_NOACCESS, nullptr, 0));
+			if (!backing_base) {
+				Release();
+				LOG_CRITICAL(HW_Memory, "Failed to reserve {} MiB of virtual memory", backing_size >> 20);
+				throw std::bad_alloc{};
+			}
+			// Map backing placeholder
+			void* const ret =
+				pfn_MapViewOfFile3(backing_handle, process, backing_base, 0, backing_size, MEM_REPLACE_PLACEHOLDER, PAGE_READWRITE, nullptr, 0);
+			if (ret != backing_base) {
+				Release();
+				LOG_CRITICAL(HW_Memory, "Failed to map {} MiB of virtual memory", backing_size >> 20);
+				throw std::bad_alloc{};
+			}
+			// Allocate virtual address placeholder
+			virtual_base =
+				static_cast<u8*>(pfn_VirtualAlloc2(process, nullptr, virtual_size, MEM_RESERVE | MEM_RESERVE_PLACEHOLDER, PAGE_NOACCESS, nullptr, 0));
+			if (!virtual_base) {
+				Release();
+				LOG_CRITICAL(HW_Memory, "Failed to reserve {} GiB of virtual memory", virtual_size >> 30);
+				throw std::bad_alloc{};
+			}
+		}
+
+		~Impl() { Release(); }
+
+		void Map(size_t virtual_offset, size_t host_offset, size_t length, MemoryPermission perms) {
+			std::unique_lock lock{placeholder_mutex};
+			if (!IsNiechePlaceholder(virtual_offset, length)) {
+				Split(virtual_offset, length);
+			}
+			ASSERT(placeholders.find({virtual_offset, virtual_offset + length}) == placeholders.end());
+			TrackPlaceholder(virtual_offset, host_offset, length);
+
+			MapView(virtual_offset, host_offset, length);
+		}
+
+		void Unmap(size_t virtual_offset, size_t length) {
+			std::scoped_lock lock{placeholder_mutex};
+
+			// Unmap until there are no more placeholders
+			while (UnmapOnePlaceholder(virtual_offset, length)) {
+			}
+		}
+
+		void Protect(size_t virtual_offset, size_t length, bool read, bool write, bool execute) {
+			DWORD new_flags{};
+			if (read && write) {
+				new_flags = PAGE_READWRITE;
+			} else if (read && !write) {
+				new_flags = PAGE_READONLY;
+			} else if (!read && !write) {
+				new_flags = PAGE_NOACCESS;
+			} else {
+				UNIMPLEMENTED_MSG("Protection flag combination read={} write={}", read, write);
+			}
+			const size_t virtual_end = virtual_offset + length;
+
+			std::scoped_lock lock{placeholder_mutex};
+			auto [it, end] = placeholders.equal_range({virtual_offset, virtual_end});
+			while (it != end) {
+				const size_t offset = std::max(it->lower(), virtual_offset);
+				const size_t protect_length = std::min(it->upper(), virtual_end) - offset;
+				DWORD old_flags{};
+				if (!VirtualProtect(virtual_base + offset, protect_length, new_flags, &old_flags)) {
+					LOG_CRITICAL(HW_Memory, "Failed to change virtual memory protect rules");
+				}
+				++it;
+			}
+		}
+
+		bool ClearBackingRegion(size_t physical_offset, size_t length) {
+			// TODO: This does not seem to be possible on Windows.
+			return false;
+		}
+
+		void EnableDirectMappedAddress() {
+			// TODO
+			UNREACHABLE();
+		}
+
+		const size_t backing_size;  ///< Size of the backing memory in bytes
+		const size_t virtual_size;  ///< Size of the virtual address placeholder in bytes
+
+		u8* backing_base{};
+		u8* virtual_base{};
+
+	  private:
+		/// Release all resources in the object
+		void Release() {
+			if (!placeholders.empty()) {
+				for (const auto& placeholder : placeholders) {
+					if (!pfn_UnmapViewOfFile2(process, virtual_base + placeholder.lower(), MEM_PRESERVE_PLACEHOLDER)) {
+						LOG_CRITICAL(HW_Memory, "Failed to unmap virtual memory placeholder");
+					}
+				}
+				Coalesce(0, virtual_size);
+			}
+			if (virtual_base) {
+				if (!VirtualFree(virtual_base, 0, MEM_RELEASE)) {
+					LOG_CRITICAL(HW_Memory, "Failed to free virtual memory");
+				}
+			}
+			if (backing_base) {
+				if (!pfn_UnmapViewOfFile2(process, backing_base, MEM_PRESERVE_PLACEHOLDER)) {
+					LOG_CRITICAL(HW_Memory, "Failed to unmap backing memory placeholder");
+				}
+				if (!VirtualFreeEx(process, backing_base, 0, MEM_RELEASE)) {
+					LOG_CRITICAL(HW_Memory, "Failed to free backing memory");
+				}
+			}
+			if (!CloseHandle(backing_handle)) {
+				LOG_CRITICAL(HW_Memory, "Failed to free backing memory file handle");
+			}
+		}
+
+		/// Unmap one placeholder in the given range (partial unmaps are supported)
+		/// Return true when there are no more placeholders to unmap
+		bool UnmapOnePlaceholder(size_t virtual_offset, size_t length) {
+			const auto it = placeholders.find({virtual_offset, virtual_offset + length});
+			const auto begin = placeholders.begin();
+			const auto end = placeholders.end();
+			if (it == end) {
+				return false;
+			}
+			const size_t placeholder_begin = it->lower();
+			const size_t placeholder_end = it->upper();
+			const size_t unmap_begin = std::max(virtual_offset, placeholder_begin);
+			const size_t unmap_end = std::min(virtual_offset + length, placeholder_end);
+			ASSERT(unmap_begin >= placeholder_begin && unmap_begin < placeholder_end);
+			ASSERT(unmap_end <= placeholder_end && unmap_end > placeholder_begin);
+
+			const auto host_pointer_it = placeholder_host_pointers.find(placeholder_begin);
+			ASSERT(host_pointer_it != placeholder_host_pointers.end());
+			const size_t host_offset = host_pointer_it->second;
+
+			const bool split_left = unmap_begin > placeholder_begin;
+			const bool split_right = unmap_end < placeholder_end;
+
+			if (!pfn_UnmapViewOfFile2(process, virtual_base + placeholder_begin, MEM_PRESERVE_PLACEHOLDER)) {
+				LOG_CRITICAL(HW_Memory, "Failed to unmap placeholder");
+			}
+			// If we have to remap memory regions due to partial unmaps, we are in a data race as
+			// Windows doesn't support remapping memory without unmapping first. Avoid adding any extra
+			// logic within the panic region described below.
+
+			// Panic region, we are in a data race right now
+			if (split_left || split_right) {
+				Split(unmap_begin, unmap_end - unmap_begin);
+			}
+			if (split_left) {
+				MapView(placeholder_begin, host_offset, unmap_begin - placeholder_begin);
+			}
+			if (split_right) {
+				MapView(unmap_end, host_offset + unmap_end - placeholder_begin, placeholder_end - unmap_end);
+			}
+			// End panic region
+
+			size_t coalesce_begin = unmap_begin;
+			if (!split_left) {
+				// Try to coalesce pages to the left
+				coalesce_begin = it == begin ? 0 : std::prev(it)->upper();
+				if (coalesce_begin != placeholder_begin) {
+					Coalesce(coalesce_begin, unmap_end - coalesce_begin);
+				}
+			}
+			if (!split_right) {
+				// Try to coalesce pages to the right
+				const auto next = std::next(it);
+				const size_t next_begin = next == end ? virtual_size : next->lower();
+				if (placeholder_end != next_begin) {
+					// We can coalesce to the right
+					Coalesce(coalesce_begin, next_begin - coalesce_begin);
+				}
+			}
+			// Remove and reinsert placeholder trackers
+			UntrackPlaceholder(it);
+			if (split_left) {
+				TrackPlaceholder(placeholder_begin, host_offset, unmap_begin - placeholder_begin);
+			}
+			if (split_right) {
+				TrackPlaceholder(unmap_end, host_offset + unmap_end - placeholder_begin, placeholder_end - unmap_end);
+			}
+			return true;
+		}
+
+		void MapView(size_t virtual_offset, size_t host_offset, size_t length) {
+			if (!pfn_MapViewOfFile3(
+					backing_handle, process, virtual_base + virtual_offset, host_offset, length, MEM_REPLACE_PLACEHOLDER, PAGE_READWRITE, nullptr, 0
+				)) {
+				LOG_CRITICAL(HW_Memory, "Failed to map placeholder");
+			}
+		}
+
+		void Split(size_t virtual_offset, size_t length) {
+			if (!VirtualFreeEx(process, reinterpret_cast<LPVOID>(virtual_base + virtual_offset), length, MEM_RELEASE | MEM_PRESERVE_PLACEHOLDER)) {
+				LOG_CRITICAL(HW_Memory, "Failed to split placeholder");
+			}
+		}
+
+		void Coalesce(size_t virtual_offset, size_t length) {
+			if (!VirtualFreeEx(process, reinterpret_cast<LPVOID>(virtual_base + virtual_offset), length, MEM_RELEASE | MEM_COALESCE_PLACEHOLDERS)) {
+				LOG_CRITICAL(HW_Memory, "Failed to coalesce placeholders");
+			}
+		}
+
+		void TrackPlaceholder(size_t virtual_offset, size_t host_offset, size_t length) {
+			placeholders.insert({virtual_offset, virtual_offset + length});
+			placeholder_host_pointers.emplace(virtual_offset, host_offset);
+		}
+
+		void UntrackPlaceholder(boost::icl::separate_interval_set<size_t>::iterator it) {
+			placeholder_host_pointers.erase(it->lower());
+			placeholders.erase(it);
+		}
+
+		/// Return true when a given memory region is a "nieche" and the placeholders don't have to be
+		/// split.
+		bool IsNiechePlaceholder(size_t virtual_offset, size_t length) const {
+			const auto it = placeholders.upper_bound({virtual_offset, virtual_offset + length});
+			if (it != placeholders.end() && it->lower() == virtual_offset + length) {
+				return it == placeholders.begin() ? virtual_offset == 0 : std::prev(it)->upper() == virtual_offset;
+			}
+			return false;
+		}
+
+		HANDLE process{};         ///< Current process handle
+		HANDLE backing_handle{};  ///< File based backing memory
+
+		DynamicLibrary kernelbase_dll;
+		PFN_CreateFileMapping2 pfn_CreateFileMapping2{};
+		PFN_VirtualAlloc2 pfn_VirtualAlloc2{};
+		PFN_MapViewOfFile3 pfn_MapViewOfFile3{};
+		PFN_UnmapViewOfFile2 pfn_UnmapViewOfFile2{};
+
+		std::mutex placeholder_mutex;                                  ///< Mutex for placeholders
+		boost::icl::separate_interval_set<size_t> placeholders;        ///< Mapped placeholders
+		std::unordered_map<size_t, size_t> placeholder_host_pointers;  ///< Placeholder backing offset
+	};
+
+#elif defined(__linux__) || defined(__FreeBSD__)  // ^^^ Windows ^^^ vvv Linux vvv
+
+#ifdef ARCHITECTURE_arm64
+
+	static void* ChooseVirtualBase(size_t virtual_size) {
+		constexpr uintptr_t Map39BitSize = (1ULL << 39);
+		constexpr uintptr_t Map36BitSize = (1ULL << 36);
+
+		// This is not a cryptographic application, we just want something random.
+		std::mt19937_64 rng;
+
+		// We want to ensure we are allocating at an address aligned to the L2 block size.
+		// For Qualcomm devices, we must also allocate memory above 36 bits.
+		const size_t lower = Map36BitSize / HugePageSize;
+		const size_t upper = (Map39BitSize - virtual_size) / HugePageSize;
+		const size_t range = upper - lower;
+
+		// Try up to 64 times to allocate memory at random addresses in the range.
+		for (int i = 0; i < 64; i++) {
+			// Calculate a possible location.
+			uintptr_t hint_address = ((rng() % range) + lower) * HugePageSize;
+
+			// Try to map.
+			// Note: we may be able to take advantage of MAP_FIXED_NOREPLACE here.
+			void* map_pointer =
+				mmap(reinterpret_cast<void*>(hint_address), virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
+
+			// If we successfully mapped, we're done.
+			if (reinterpret_cast<uintptr_t>(map_pointer) == hint_address) {
+				return map_pointer;
+			}
+
+			// Unmap if necessary, and try again.
+			if (map_pointer != MAP_FAILED) {
+				munmap(map_pointer, virtual_size);
+			}
+		}
+
+		return MAP_FAILED;
+	}
+
+#else
+
+	static void* ChooseVirtualBase(size_t virtual_size) {
+#if defined(__FreeBSD__)
+		void* virtual_base =
+			mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER, -1, 0);
+
+		if (virtual_base != MAP_FAILED) {
+			return virtual_base;
+		}
+#endif
+
+		return mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
+	}
+
+#endif
+
+	class HostMemory::Impl {
+	  public:
+		explicit Impl(size_t backing_size_, size_t virtual_size_) : backing_size{backing_size_}, virtual_size{virtual_size_} {
+			bool good = false;
+			SCOPE_EXIT {
+				if (!good) {
+					Release();
+				}
+			};
+
+			long page_size = sysconf(_SC_PAGESIZE);
+			if (page_size != 0x1000) {
+				LOG_CRITICAL(HW_Memory, "page size {:#x} is incompatible with 4K paging", page_size);
+				throw std::bad_alloc{};
+			}
+
+			// Backing memory initialization
+#if defined(__FreeBSD__) && __FreeBSD__ < 13
+			// XXX Drop after FreeBSD 12.* reaches EOL on 2024-06-30
+			fd = shm_open(SHM_ANON, O_RDWR, 0600);
+#else
+			fd = memfd_create("HostMemory", 0);
+#endif
+			if (fd < 0) {
+				LOG_CRITICAL(HW_Memory, "memfd_create failed: {}", strerror(errno));
+				throw std::bad_alloc{};
+			}
+
+			// Defined to extend the file with zeros
+			int ret = ftruncate(fd, backing_size);
+			if (ret != 0) {
+				LOG_CRITICAL(HW_Memory, "ftruncate failed with {}, are you out-of-memory?", strerror(errno));
+				throw std::bad_alloc{};
+			}
+
+			backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
+			if (backing_base == MAP_FAILED) {
+				LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
+				throw std::bad_alloc{};
+			}
+
+			// Virtual memory initialization
+			virtual_base = virtual_map_base = static_cast<u8*>(ChooseVirtualBase(virtual_size));
+			if (virtual_base == MAP_FAILED) {
+				LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
+				throw std::bad_alloc{};
+			}
+#if defined(__linux__)
+			madvise(virtual_base, virtual_size, MADV_HUGEPAGE);
+#endif
+
+			free_manager.SetAddressSpace(virtual_base, virtual_size);
+			good = true;
+		}
+
+		~Impl() { Release(); }
+
+		void Map(size_t virtual_offset, size_t host_offset, size_t length, MemoryPermission perms) {
+			// Intersect the range with our address space.
+			AdjustMap(&virtual_offset, &length);
+
+			// We are removing a placeholder.
+			free_manager.AllocateBlock(virtual_base + virtual_offset, length);
+
+			// Deduce mapping protection flags.
+			int flags = PROT_NONE;
+			if (True(perms & MemoryPermission::Read)) {
+				flags |= PROT_READ;
+			}
+			if (True(perms & MemoryPermission::Write)) {
+				flags |= PROT_WRITE;
+			}
+#ifdef ARCHITECTURE_arm64
+			if (True(perms & MemoryPermission::Execute)) {
+				flags |= PROT_EXEC;
+			}
+#endif
+
+			void* ret = mmap(virtual_base + virtual_offset, length, flags, MAP_SHARED | MAP_FIXED, fd, host_offset);
+			ASSERT_MSG(ret != MAP_FAILED, "mmap failed: {}", strerror(errno));
+		}
+
+		void Unmap(size_t virtual_offset, size_t length) {
+			// The method name is wrong. We're still talking about the virtual range.
+			// We don't want to unmap, we want to reserve this memory.
+
+			// Intersect the range with our address space.
+			AdjustMap(&virtual_offset, &length);
+
+			// Merge with any adjacent placeholder mappings.
+			auto [merged_pointer, merged_size] = free_manager.FreeBlock(virtual_base + virtual_offset, length);
+
+			void* ret = mmap(merged_pointer, merged_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+			ASSERT_MSG(ret != MAP_FAILED, "mmap failed: {}", strerror(errno));
+		}
+
+		void Protect(size_t virtual_offset, size_t length, bool read, bool write, bool execute) {
+			// Intersect the range with our address space.
+			AdjustMap(&virtual_offset, &length);
+
+			int flags = PROT_NONE;
+			if (read) {
+				flags |= PROT_READ;
+			}
+			if (write) {
+				flags |= PROT_WRITE;
+			}
+#ifdef HAS_NCE
+			if (execute) {
+				flags |= PROT_EXEC;
+			}
+#endif
+			int ret = mprotect(virtual_base + virtual_offset, length, flags);
+			ASSERT_MSG(ret == 0, "mprotect failed: {}", strerror(errno));
+		}
+
+		bool ClearBackingRegion(size_t physical_offset, size_t length) {
+#ifdef __linux__
+			// Set MADV_REMOVE on backing map to destroy it instantly.
+			// This also deletes the area from the backing file.
+			int ret = madvise(backing_base + physical_offset, length, MADV_REMOVE);
+			ASSERT_MSG(ret == 0, "madvise failed: {}", strerror(errno));
+
+			return true;
+#else
+			return false;
+#endif
+		}
+
+		void EnableDirectMappedAddress() { virtual_base = nullptr; }
+
+		const size_t backing_size;  ///< Size of the backing memory in bytes
+		const size_t virtual_size;  ///< Size of the virtual address placeholder in bytes
+
+		u8* backing_base{reinterpret_cast<u8*>(MAP_FAILED)};
+		u8* virtual_base{reinterpret_cast<u8*>(MAP_FAILED)};
+		u8* virtual_map_base{reinterpret_cast<u8*>(MAP_FAILED)};
+
+	  private:
+		/// Release all resources in the object
+		void Release() {
+			if (virtual_map_base != MAP_FAILED) {
+				int ret = munmap(virtual_map_base, virtual_size);
+				ASSERT_MSG(ret == 0, "munmap failed: {}", strerror(errno));
+			}
+
+			if (backing_base != MAP_FAILED) {
+				int ret = munmap(backing_base, backing_size);
+				ASSERT_MSG(ret == 0, "munmap failed: {}", strerror(errno));
+			}
+
+			if (fd != -1) {
+				int ret = close(fd);
+				ASSERT_MSG(ret == 0, "close failed: {}", strerror(errno));
+			}
+		}
+
+		void AdjustMap(size_t* virtual_offset, size_t* length) {
+			if (virtual_base != nullptr) {
+				return;
+			}
+
+			// If we are direct mapped, we want to make sure we are operating on a region
+			// that is in range of our virtual mapping.
+			size_t intended_start = *virtual_offset;
+			size_t intended_end = intended_start + *length;
+			size_t address_space_start = reinterpret_cast<size_t>(virtual_map_base);
+			size_t address_space_end = address_space_start + virtual_size;
+
+			if (address_space_start > intended_end || intended_start > address_space_end) {
+				*virtual_offset = 0;
+				*length = 0;
+			} else {
+				*virtual_offset = std::max(intended_start, address_space_start);
+				*length = std::min(intended_end, address_space_end) - *virtual_offset;
+			}
+		}
+
+		int fd{-1};  // memfd file descriptor, -1 is the error value of memfd_create
+		FreeRegionManager free_manager{};
+	};
+
+#else  // ^^^ Linux ^^^ vvv Generic vvv
+
+	class HostMemory::Impl {
+	  public:
+		explicit Impl(size_t /*backing_size */, size_t /* virtual_size */) {
+			// This is just a place holder.
+			// Please implement fastmem in a proper way on your platform.
+			throw std::bad_alloc{};
+		}
+
+		void Map(size_t virtual_offset, size_t host_offset, size_t length, MemoryPermission perm) {}
+		void Unmap(size_t virtual_offset, size_t length) {}
+		void Protect(size_t virtual_offset, size_t length, bool read, bool write, bool execute) {}
+		bool ClearBackingRegion(size_t physical_offset, size_t length) { return false; }
+		void EnableDirectMappedAddress() {}
+
+		u8* backing_base{nullptr};
+		u8* virtual_base{nullptr};
+	};
+
+#endif  // ^^^ Generic ^^^
+
+	HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_) : backing_size(backing_size_), virtual_size(virtual_size_) {
+		try {
+			// Try to allocate a fastmem arena.
+			// The implementation will fail with std::bad_alloc on errors.
+			impl = std::make_unique<HostMemory::Impl>(Common::alignUp(backing_size, PageAlignment), Common::alignUp(virtual_size, PageAlignment) + HugePageSize);
+			backing_base = impl->backing_base;
+			virtual_base = impl->virtual_base;
+
+			if (virtual_base) {
+				// Ensure the virtual base is aligned to the L2 block size.
+				virtual_base = reinterpret_cast<u8*>(Common::alignUp(reinterpret_cast<uintptr_t>(virtual_base), HugePageSize));
+				virtual_base_offset = virtual_base - impl->virtual_base;
+			}
+
+		} catch (const std::bad_alloc&) {
+			Helpers::warn("Fastmem unavailable, falling back to VirtualBuffer for memory allocation");
+			fallback_buffer = std::make_unique<Common::VirtualBuffer<u8>>(backing_size);
+			backing_base = fallback_buffer->data();
+			virtual_base = nullptr;
+		}
+	}
+
+	HostMemory::~HostMemory() = default;
+	HostMemory::HostMemory(HostMemory&&) noexcept = default;
+	HostMemory& HostMemory::operator=(HostMemory&&) noexcept = default;
+
+	void HostMemory::Map(size_t virtual_offset, size_t host_offset, size_t length, MemoryPermission perms, bool separate_heap) {
+		ASSERT(virtual_offset % PageAlignment == 0);
+		ASSERT(host_offset % PageAlignment == 0);
+		ASSERT(length % PageAlignment == 0);
+		ASSERT(virtual_offset + length <= virtual_size);
+		ASSERT(host_offset + length <= backing_size);
+		if (length == 0 || !virtual_base || !impl) {
+			return;
+		}
+		impl->Map(virtual_offset + virtual_base_offset, host_offset, length, perms);
+	}
+
+	void HostMemory::Unmap(size_t virtual_offset, size_t length, bool separate_heap) {
+		ASSERT(virtual_offset % PageAlignment == 0);
+		ASSERT(length % PageAlignment == 0);
+		ASSERT(virtual_offset + length <= virtual_size);
+		if (length == 0 || !virtual_base || !impl) {
+			return;
+		}
+		impl->Unmap(virtual_offset + virtual_base_offset, length);
+	}
+
+	void HostMemory::Protect(size_t virtual_offset, size_t length, MemoryPermission perm) {
+		ASSERT(virtual_offset % PageAlignment == 0);
+		ASSERT(length % PageAlignment == 0);
+		ASSERT(virtual_offset + length <= virtual_size);
+		if (length == 0 || !virtual_base || !impl) {
+			return;
+		}
+		const bool read = True(perm & MemoryPermission::Read);
+		const bool write = True(perm & MemoryPermission::Write);
+		const bool execute = True(perm & MemoryPermission::Execute);
+		impl->Protect(virtual_offset + virtual_base_offset, length, read, write, execute);
+	}
+
+	void HostMemory::ClearBackingRegion(size_t physical_offset, size_t length, u32 fill_value) {
+		if (!impl || fill_value != 0 || !impl->ClearBackingRegion(physical_offset, length)) {
+			std::memset(backing_base + physical_offset, fill_value, length);
+		}
+	}
+
+	void HostMemory::EnableDirectMappedAddress() {
+		if (impl) {
+			impl->EnableDirectMappedAddress();
+			virtual_size += reinterpret_cast<uintptr_t>(virtual_base);
+		}
+	}
+
+}  // namespace Common

third_party/host_memory/include/host_memory/dynamic_library.h

@@ -0,0 +1,75 @@
+// SPDX-FileCopyrightText: 2019 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+
+namespace Common {
+
+	/**
+	 * Provides a platform-independent interface for loading a dynamic library and retrieving symbols.
+	 * The interface maintains an internal reference count to allow one handle to be shared between
+	 * multiple users.
+	 */
+	class DynamicLibrary final {
+	  public:
+		/// Default constructor, does not load a library.
+		explicit DynamicLibrary();
+
+		/// Automatically loads the specified library. Call IsOpen() to check validity before use.
+		explicit DynamicLibrary(const char* filename);
+
+		/// Initializes the dynamic library with an already opened handle.
+		explicit DynamicLibrary(void* handle_);
+
+		/// Moves the library.
+		DynamicLibrary(DynamicLibrary&&) noexcept;
+		DynamicLibrary& operator=(DynamicLibrary&&) noexcept;
+
+		/// Delete copies, we can't copy a dynamic library.
+		DynamicLibrary(const DynamicLibrary&) = delete;
+		DynamicLibrary& operator=(const DynamicLibrary&) = delete;
+
+		/// Closes the library.
+		~DynamicLibrary();
+
+		/// Returns the specified library name with the platform-specific suffix added.
+		[[nodiscard]] static std::string GetUnprefixedFilename(const char* filename);
+
+		/// Returns the specified library name in platform-specific format.
+		/// Major/minor versions will not be included if set to -1.
+		/// If libname already contains the "lib" prefix, it will not be added again.
+		/// Windows: LIBNAME-MAJOR-MINOR.dll
+		/// Linux: libLIBNAME.so.MAJOR.MINOR
+		/// Mac: libLIBNAME.MAJOR.MINOR.dylib
+		[[nodiscard]] static std::string GetVersionedFilename(const char* libname, int major = -1, int minor = -1);
+
+		/// Returns true if a module is loaded, otherwise false.
+		[[nodiscard]] bool IsOpen() const { return handle != nullptr; }
+
+		/// Loads (or replaces) the handle with the specified library file name.
+		/// Returns true if the library was loaded and can be used.
+		[[nodiscard]] bool Open(const char* filename);
+
+		/// Unloads the library, any function pointers from this library are no longer valid.
+		void Close();
+
+		/// Returns the address of the specified symbol (function or variable) as an untyped pointer.
+		/// If the specified symbol does not exist in this library, nullptr is returned.
+		[[nodiscard]] void* GetSymbolAddress(const char* name) const;
+
+		/// Obtains the address of the specified symbol, automatically casting to the correct type.
+		/// Returns true if the symbol was found and assigned, otherwise false.
+		template <typename T>
+		[[nodiscard]] bool GetSymbol(const char* name, T* ptr) const {
+			*ptr = reinterpret_cast<T>(GetSymbolAddress(name));
+			return *ptr != nullptr;
+		}
+
+	  private:
+		/// Platform-dependent data type representing a dynamic library handle.
+		void* handle = nullptr;
+	};
+
+}  // namespace Common

third_party/host_memory/include/host_memory/host_memory.h

@@ -0,0 +1,75 @@
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+
+#include "common/common_funcs.h"
+#include "host_memory/virtual_buffer.h"
+#include "helpers.hpp"
+
+namespace Common {
+
+	enum class MemoryPermission : u32 {
+		Read = 1 << 0,
+		Write = 1 << 1,
+		ReadWrite = Read | Write,
+		Execute = 1 << 2,
+	};
+	DECLARE_ENUM_FLAG_OPERATORS(MemoryPermission)
+
+	/**
+	 * A low level linear memory buffer, which supports multiple mappings
+	 * Its purpose is to rebuild a given sparse memory layout, including mirrors.
+	 */
+	class HostMemory {
+	  public:
+		explicit HostMemory(size_t backing_size_, size_t virtual_size_);
+		~HostMemory();
+
+		/**
+		 * Copy constructors. They shall return a copy of the buffer without the mappings.
+		 * TODO: Implement them with COW if needed.
+		 */
+		HostMemory(const HostMemory& other) = delete;
+		HostMemory& operator=(const HostMemory& other) = delete;
+
+		/**
+		 * Move constructors. They will move the buffer and the mappings to the new object.
+		 */
+		HostMemory(HostMemory&& other) noexcept;
+		HostMemory& operator=(HostMemory&& other) noexcept;
+
+		void Map(size_t virtual_offset, size_t host_offset, size_t length, MemoryPermission perms, bool separate_heap);
+		void Unmap(size_t virtual_offset, size_t length, bool separate_heap);
+		void Protect(size_t virtual_offset, size_t length, MemoryPermission perms);
+
+		void EnableDirectMappedAddress();
+
+		void ClearBackingRegion(size_t physical_offset, size_t length, u32 fill_value);
+
+		[[nodiscard]] u8* BackingBasePointer() noexcept { return backing_base; }
+		[[nodiscard]] const u8* BackingBasePointer() const noexcept { return backing_base; }
+
+		[[nodiscard]] u8* VirtualBasePointer() noexcept { return virtual_base; }
+		[[nodiscard]] const u8* VirtualBasePointer() const noexcept { return virtual_base; }
+
+		bool IsInVirtualRange(void* address) const noexcept { return address >= virtual_base && address < virtual_base + virtual_size; }
+
+	  private:
+		size_t backing_size{};
+		size_t virtual_size{};
+
+		// Low level handler for the platform dependent memory routines
+		class Impl;
+		std::unique_ptr<Impl> impl;
+		u8* backing_base{};
+		u8* virtual_base{};
+		size_t virtual_base_offset{};
+
+		// Fallback if fastmem is not supported on this platform
+		std::unique_ptr<Common::VirtualBuffer<u8>> fallback_buffer;
+	};
+
+}  // namespace Common

third_party/host_memory/include/host_memory/virtual_buffer.h

@@ -0,0 +1,68 @@
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "helpers.hpp"
+#include <utility>
+
+namespace Common {
+
+	void* AllocateMemoryPages(std::size_t size) noexcept;
+	void FreeMemoryPages(void* base, std::size_t size) noexcept;
+
+	template <typename T>
+	class VirtualBuffer final {
+	  public:
+		// TODO: Uncomment this and change Common::PageTable::PageInfo to be trivially constructible
+		// using std::atomic_ref once libc++ has support for it
+		// static_assert(
+		//     std::is_trivially_constructible_v<T>,
+		//     "T must be trivially constructible, as non-trivial constructors will not be executed "
+		//     "with the current allocator");
+
+		constexpr VirtualBuffer() = default;
+		explicit VirtualBuffer(std::size_t count) : alloc_size{count * sizeof(T)} {
+			base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
+		}
+
+		~VirtualBuffer() noexcept { FreeMemoryPages(base_ptr, alloc_size); }
+
+		VirtualBuffer(const VirtualBuffer&) = delete;
+		VirtualBuffer& operator=(const VirtualBuffer&) = delete;
+
+		VirtualBuffer(VirtualBuffer&& other) noexcept
+			: alloc_size{std::exchange(other.alloc_size, 0)}, base_ptr{std::exchange(other.base_ptr), nullptr} {}
+
+		VirtualBuffer& operator=(VirtualBuffer&& other) noexcept {
+			alloc_size = std::exchange(other.alloc_size, 0);
+			base_ptr = std::exchange(other.base_ptr, nullptr);
+			return *this;
+		}
+
+		void resize(std::size_t count) {
+			const auto new_size = count * sizeof(T);
+			if (new_size == alloc_size) {
+				return;
+			}
+
+			FreeMemoryPages(base_ptr, alloc_size);
+
+			alloc_size = new_size;
+			base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
+		}
+
+		[[nodiscard]] constexpr const T& operator[](std::size_t index) const { return base_ptr[index]; }
+		[[nodiscard]] constexpr T& operator[](std::size_t index) { return base_ptr[index]; }
+
+		[[nodiscard]] constexpr T* data() { return base_ptr; }
+		[[nodiscard]] constexpr const T* data() const { return base_ptr; }
+
+		[[nodiscard]] constexpr std::size_t size() const { return alloc_size / sizeof(T); }
+
+	  private:
+		std::size_t alloc_size{};
+		T* base_ptr{};
+	};
+
+}  // namespace Common

third_party/host_memory/virtual_buffer.cpp

@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/mman.h>
+#endif
+
+#include "host_memory/virtual_buffer.h"
+
+namespace Common {
+
+void* AllocateMemoryPages(std::size_t size) noexcept {
+#ifdef _WIN32
+    void* base{VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE)};
+#else
+    void* base{mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0)};
+
+    if (base == MAP_FAILED) {
+        base = nullptr;
+    }
+#endif
+
+    if (!base) {
+		Helpers::panic("Failed to allocate memory pages");
+    }
+
+    return base;
+}
+
+void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) noexcept {
+    if (!base) {
+        return;
+    }
+#ifdef _WIN32
+	if (!VirtualFree(base, 0, MEM_RELEASE)) {
+		Helpers::panic("Failed to free memory pages");
+	}
+#else
+	if (munmap(base, size) != 0) {
+		Helpers::panic("Failed to free memory pages");
+    }
+#endif
+}
+
+} // namespace Common