Fix license headers

Signed-off-by: lizzie <lizzie@eden-emu.dev>

CMakeLists.txt

@@ -24,20 +24,8 @@ include(CMakeDependentOption)
 include(CTest)
 include(CPMUtil)
 
-if (NOT DEFINED ARCHITECTURE)
-    message(FATAL_ERROR "Architecture didn't make it out of scope, did you delete DetectArchitecture.cmake?")
-endif()
-
-# Needed for FFmpeg w/ VAAPI and DRM
-if (OPENBSD)
-    # OpenBSD 7.8 broke libcxx when upgrading, so we must define the PSTL backend manually
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R6/include -D_LIBCPP_PSTL_BACKEND_SERIAL=1")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R6/include -D_LIBCPP_PSTL_BACKEND_SERIAL=1")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L${CMAKE_SYSROOT}/usr/X11R6/lib")
-elseif (NETBSD)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R7/include -I${CMAKE_SYSROOT}/usr/pkg/include/c++/v1")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${CMAKE_SYSROOT}/usr/X11R7/include -I${CMAKE_SYSROOT}/usr/pkg/include/c++/v1")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L${CMAKE_SYSROOT}/usr/X11R7/lib")
+if (CXX_GCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "14.0")
+    message(FATAL_ERROR "GCC versions older than 14.0 are not supported. Update your system, or use clang/clang++ instead.")
 endif()
 
 # NetBSD: Fun for the whole family!
@@ -85,7 +73,7 @@ option(ENABLE_WERROR "Enable -Werror diagnostics" ON)
 # Lossless Scaling frame generation. Only Android.
 cmake_dependent_option(ENABLE_LSFG "Enable Lossless Scaling frame generation" ON "ANDROID" OFF)
 
-option(ENABLE_RESHADE "Enable ReShade FX post-processing effects" ON)
+cmake_dependent_option(ENABLE_RESHADE "Enable ReShade FX post-processing effects" ON "WIN32 OR ANDROID OR APPLE OR LINUX OR FREEBSD" OFF)
 
 # non-linux bundled qt are static
 if (YUZU_USE_BUNDLED_QT AND (APPLE OR NOT UNIX))
@@ -276,7 +264,7 @@ cmake_dependent_option(YUZU_USE_BUNDLED_MOLTENVK "Download bundled MoltenVK lib"
 option(YUZU_DISABLE_LLVM "Disable LLVM (useful for CI)" OFF)
 
 set(DEFAULT_YUZU_USE_BUNDLED_OPENSSL OFF)
-if (EXT_DEFAULT OR SOLARIS OR OPENBSD)
+if (EXT_DEFAULT)
     set(DEFAULT_YUZU_USE_BUNDLED_OPENSSL ON)
 endif()
 
@@ -309,10 +297,12 @@ if (YUZU_ROOM)
 endif()
 
 if (UNIX AND NOT (LINUX OR WIN32))
-    if(CXX_APPLE OR CXX_CLANG)
+    if(CXX_APPLE OR (CXX_CLANG AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "20.0"))
         # libc++ has stop_token and jthread as experimental
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexperimental-library")
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fexperimental-library")
+    elseif(CXX_CLANG)
+        # New clang >=20.0, so do nothing
     else()
         # Uses glibc, mostly?
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_LIBCPP_ENABLE_EXPERIMENTAL=1")
@@ -618,7 +608,7 @@ if (ENABLE_QT)
 
     # Best practice is to ask for all components at once, so they are from the same version
     set(YUZU_QT_COMPONENTS Core Widgets Charts Concurrent Gui)
-    if (LINUX OR FREEBSD)
+    if (NOT WIN32 AND NOT APPLE)
         list(APPEND YUZU_QT_COMPONENTS DBus)
         # yes Qt, we get it
         set(QT_NO_PRIVATE_MODULE_WARNING ON)

docs/Caveats.md

@@ -65,7 +65,7 @@ export LIBGL_ALWAYS_SOFTWARE=1
 
 ## OmniOS
 
-Install `developer/gcc14` on OmniOS using pkgsrc.
+Install `developer/gcc15` on OmniOS using pkgsrc.
 
 Since so many dependencies are missing on `OmniOS`, you may wish to use `-DCPMUTIL_FORCE_BUNDLED=ON` and `-DYUZU_USE_BUNDLED_OPENSSL=OFF`.
 
@@ -74,21 +74,15 @@ For OmniOS you are required to build glslang yourself:
 sudo pkg install python-313
 git clone --depth=1 https://github.com/KhronosGroup/glslang.git
 cd glslang
-python3.13 ./update_glslang_sources.py
+python3 ./update_glslang_sources.py
 cmake -B build -DCMAKE_BUILD_TYPE=Release
-cmake --build build -- -j `nproc`
+cmake --build build -- -j`nproc`
 cmake --install build
 ```
 
-It may be tempting to specify `-t glslang`, but this will cause installation to fail. So don't.
+Use `gmake` to properly build all utilities. You require an X11 server, [this guide](https://web.archive.org/web/20260424200928/https://geekblood.wordpress.com/2017/10/26/installing-x11-and-a-desktop-environment-on-omnios/) details how to attain one, the links to pkgsrc on said guide [are better found here](https://pkgsrc.smartos.org/install-on-illumos/).
 
-Using `--parallel` on CMake incorrectly passes `dmake ... -jn` instead of `dmake ... -j n`, this is a bug with OmniOS's CMake, it's recommended to not use this option until it's fixed.
-
-You may also need to install `gmake` in order to properly build FFmpeg, this is provided by the `build-essential` package.
-
-If it wasn't obvious already, you require a X11 server to properly run the emulator within OmniOS, [this guide](https://web.archive.org/web/20260424200928/https://geekblood.wordpress.com/2017/10/26/installing-x11-and-a-desktop-environment-on-omnios/) is a great starting point for that, the links to pkgsrc are outdated so follow [this exemplar](https://pkgsrc.smartos.org/install-on-illumos/) as well.
-
-For Solaris based OSes, `${CMAKE_SYSTEM_NAME}` isn't properly set on CMake (it's set to i686 on AMD64), you may find issues when building OpenSSL from `openssl-cmake`.
+For Solaris based OSes, `${CMAKE_SYSTEM_PROCESSOR}` isn't properly set on CMake (it's set to i686 on AMD64, must be `amd64`), you may find issues when building OpenSSL from `openssl-cmake`.
 
 ## HaikuOS
 
@@ -108,6 +102,8 @@ If you have `quazip1_qt6_devel`, uninstall it. It may call `Core5Compat` on CMak
 
 ## OpenBSD
 
+OpenSSL 4.0 is available via ports, needs to be pointed to directly via `-DOPENSSL_ROOT_DIR=/usr/local/include/eopenssl40`.
+
 System boost doesn't have `context` (as of 7.8); so you may need to specify `-DYUZU_USE_CPM=ON -DBoost_FORCE_BUNDLED=ON`.
 
 After configuration, you may need to modify `externals/ffmpeg/CMakeFiles/ffmpeg-build/build.make` to use `-j$(nproc)` instead of just `-j`.
@@ -147,15 +143,13 @@ System provides a default `g++-10` which doesn't support the current C++ codebas
 
 Make may error out when generating C++ headers of SPIRV shaders, hence it's recommended to use `gmake` over the default system one.
 
-[parallel/spirv-tools](https://iso.us.netbsd.org/pub/pkgsrc/current/pkgsrc/parallel/spirv-tools/index.html) isn't available in binary form and must be built from source.
-
-glslang is not available on NetBSD, to circumvent this simply build glslang by yourself:
+If [parallel/spirv-tools](https://iso.us.netbsd.org/pub/pkgsrc/current/pkgsrc/parallel/spirv-tools/index.html) isn't available in binary, build from source:
 
 ```sh
-pkgin python313
+pkgin install python314
 git clone --depth=1 https://github.com/KhronosGroup/glslang.git
 cd glslang
-python3.13 ./update_glslang_sources.py
+python3.14 ./update_glslang_sources.py
 cmake -B build -DCMAKE_BUILD_TYPE=Release
 cmake --build build -- -j`nproc`
 cmake --install build
@@ -163,7 +157,7 @@ cmake --install build
 
 However, pkgsrc is highly recommended, see [getting pkgsrc](https://iso.us.netbsd.org/pub/pkgsrc/current/pkgsrc/doc/pkgsrc.html#getting). You must get `current` not the `2025Q2` version.
 
-`QtCore` on NetBSD is included, but due to misconfigurations(!) we MUST include one of the standard headers that include `bits/c++config.h`, since source_location (required by `QtCore`) isn't properly configured to intake `bits/c++config.h` (none of the experimental library is). This is a bug with NetBSD packaging and not our fault, but alas.
+`QtCore` on NetBSD is included, but due to misconfigurations you must include `bits/c++config.h`, since source_location (required by `QtCore`) isn't properly configured to intake `bits/c++config.h` (none of the experimental library is).
 
 ## DragonFlyBSD
 

docs/Deps.md

@@ -213,7 +213,7 @@ First, enable the community repository; [see here](https://wiki.alpinelinux.org/
 # Enable the community repository
 setup-apkrepos -c
 # Install
-apk add g++ git cmake make mesa-dev qt6-qtbase-dev qt6-qtbase-private-dev libquazip1-qt6 ffmpeg-dev qt6-charts-dev libusb-dev libtool boost-dev sdl3-dev zstd-dev vulkan-utility-libraries spirv-tools-dev openssl-dev nlohmann-json lz4-dev opus-dev jq patch
+apk add g++ git cmake make mesa-dev qt6-qtbase-dev qt6-qtbase-private-dev libquazip1-qt6 ffmpeg-dev qt6-qtcharts-dev libusb-dev boost-dev sdl3-dev zstd-dev vulkan-utility-libraries spirv-tools-dev openssl-dev nlohmann-json lz4-dev opus-dev enet-dev glslang libtool jq patch
 ```
 
 </details>
@@ -286,7 +286,7 @@ pkgin install git cmake boost fmtlib SDL3 catch2 libjwt spirv-headers spirv-tool
 
 ```sh
 pkg_add -u
-pkg_add cmake nasm git boost unzip--iconv autoconf-2.72p0 bash ffmpeg glslang gmake qt6 jq fmt nlohmann-json enet boost vulkan-utility-libraries vulkan-headers spirv-headers spirv-tools catch2 sdl3 libusb1-1.0.29 quazip-qt6
+pkg_add cmake nasm git boost unzip--iconv autoconf-2.72p0 bash ffmpeg glslang gmake qt6 jq fmt nlohmann-json enet boost vulkan-utility-libraries vulkan-headers spirv-headers spirv-tools catch2 sdl3 libusb1-1.0.29 quazip-qt6 openssl-4.0.2v0
 ```
 
 [Caveats](./Caveats.md#openbsd).
@@ -316,7 +316,7 @@ sudo pkg install git cmake qt6 boost glslang libzip library/lz4 libusb-1 nlohman
 <summary>OmniOS</summary>
 
 ```sh
-sudo pkgin install git cmake autoconf build-essential libusb-1 nasm gcc13
+sudo pkg install git cmake autoconf build-essential libusb-1 nasm gcc15 ffmpeg lz4 pkg-config unzip bash jq xsvc
 ```
 
 [Caveats](./Caveats.md#omnios).

docs/build/Android.md

@@ -15,7 +15,7 @@
 ## Cloning Eden with Git
 
 ```sh
-git clone --recursive https://git.eden-emu.dev/eden-emu/eden.git
+git clone --depth=1 https://git.eden-emu.dev/eden-emu/eden.git
 ```
 
 Eden by default will be cloned into:

src/common/CMakeLists.txt

@@ -76,6 +76,7 @@ add_library(
     logging.h
     lz4_compression.cpp
     lz4_compression.h
+    make_unique_for_overwrite.h
     math_util.h
     memory_detect.cpp
     memory_detect.h

src/common/make_unique_for_overwrite.h

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <type_traits>
+
+namespace Common {
+
+template <class T>
+    requires(!std::is_array_v<T>)
+std::unique_ptr<T> make_unique_for_overwrite() {
+    return std::unique_ptr<T>(new T);
+}
+
+template <class T>
+    requires std::is_unbounded_array_v<T>
+std::unique_ptr<T> make_unique_for_overwrite(std::size_t n) {
+    return std::unique_ptr<T>(new std::remove_extent_t<T>[n]);
+}
+
+template <class T, class... Args>
+    requires std::is_bounded_array_v<T>
+void make_unique_for_overwrite(Args&&...) = delete;
+
+} // namespace Common

src/common/scratch_buffer.h

@@ -8,7 +8,8 @@
 
 #include <iterator>
 #include <cstring>
-#include <memory>
+
+#include "common/make_unique_for_overwrite.h"
 
 namespace Common {
 
@@ -37,9 +38,8 @@ public:
     ScratchBuffer() = default;
 
     explicit ScratchBuffer(size_type initial_capacity)
-        : last_requested_size{initial_capacity}
-        , buffer_capacity{initial_capacity}
-        , buffer{std::make_unique_for_overwrite<T[]>(initial_capacity)} {}
+        : last_requested_size{initial_capacity}, buffer_capacity{initial_capacity},
+          buffer{Common::make_unique_for_overwrite<T[]>(initial_capacity)} {}
 
     ~ScratchBuffer() = default;
     ScratchBuffer(const ScratchBuffer&) = delete;
@@ -64,7 +64,7 @@ public:
     /// The previously held data will remain intact.
     void resize(size_type size) {
         if (size > buffer_capacity) {
-            auto new_buffer = std::make_unique_for_overwrite<T[]>(size);
+            auto new_buffer = Common::make_unique_for_overwrite<T[]>(size);
             std::memcpy(new_buffer.get(), buffer.get(), buffer_capacity * sizeof(T));
             buffer = std::move(new_buffer);
             buffer_capacity = size;
@@ -77,7 +77,7 @@ public:
     void resize_destructive(size_type size) {
         if (size > buffer_capacity) {
             buffer_capacity = size;
-            buffer = std::make_unique_for_overwrite<T[]>(buffer_capacity);
+            buffer = Common::make_unique_for_overwrite<T[]>(buffer_capacity);
         }
         last_requested_size = size;
     }

src/common/sparse_large_vector.cpp

@@ -8,14 +8,7 @@
 #ifdef _WIN32
 #include <windows.h>
 #include <mutex>
-#include <algorithm>
-#include <vector>
-#endif
-
-#include <cerrno>
-#include <cstring>
-
-#ifndef _WIN32
+#else
 #include <sys/mman.h>
 #endif
 
@@ -26,60 +19,54 @@
 namespace Common {
 
 #ifdef _WIN32
+static std::vector<std::pair<u64, u64>> vector_regions {};
 
-struct VectorRegion {
-    u64 start_page;
-    u64 end_page;
-};
-
-static std::mutex& GetVectorRegionsMutex() {
-    static std::mutex* m = new std::mutex();
-    return *m;
-}
-
-static std::vector<VectorRegion>& GetVectorRegions() {
-    static std::vector<VectorRegion>* v = new std::vector<VectorRegion>();
-    return *v;
-}
-
+// Workaround for handling non-commited memory accessed by Dynarmic; usually result of an error
 static LONG WINAPI FakePageFaultHandler(PEXCEPTION_POINTERS info) {
-    if (info->ExceptionRecord->ExceptionCode != EXCEPTION_ACCESS_VIOLATION) {
+    DWORD code = info->ExceptionRecord->ExceptionCode;
+    u64 exception_addr = reinterpret_cast<u64>(info->ExceptionRecord->ExceptionAddress);
+
+    if (code != EXCEPTION_ACCESS_VIOLATION) {
+        // Not our problem
         return EXCEPTION_CONTINUE_SEARCH;
     }
 
-    const u64 fault_addr = info->ExceptionRecord->ExceptionInformation[1];
-    const u64 access_type = info->ExceptionRecord->ExceptionInformation[0];
-    const bool is_write = (access_type == 1);
-    const u64 fault_page = fault_addr >> HostPageBits;
+    u64 addr = 0, addr2 = 0;
 
-    u64 addr = 0;
-    u64 addr2 = 0;
+    for (auto region: vector_regions) {
+        auto addr_shifted = exception_addr >> HostPageBits;
+        if (region.first <= addr_shifted && addr_shifted <= region.second) {
+            addr = addr_shifted;
+        }
 
-    {
-        std::lock_guard lock(GetVectorRegionsMutex());
-        for (const auto& region : GetVectorRegions()) {
-            if (fault_page >= region.start_page && fault_page < region.end_page) {
-                addr = fault_page;
-            }
-            const u64 page2 = (fault_addr + 0x3F) >> HostPageBits;
-            if (page2 != fault_page && page2 >= region.start_page && page2 < region.end_page) {
-                addr2 = page2;
-            }
-            if (addr != 0 || addr2 != 0) break;
+        // Page-boundary accesses
+        if (auto addr_ = (exception_addr + 0x40) >> HostPageBits; addr_ != addr_shifted && region.first <= addr_ && addr_ <= region.second) {
+            addr2 = addr_;
+        }
+
+        if (addr != 0 || addr2 != 0) {
+            break;
         }
     }
 
     if (addr == 0 && addr2 == 0) {
+        // Not our problem
         return EXCEPTION_CONTINUE_SEARCH;
     }
 
-    LOG_ERROR(HW_Memory, "Accessing an unallocated region of a SparseLargeVector at {:#x}; this shouldn't happen and is likely a Dynarmic error!", fault_addr);
+    LOG_ERROR(HW_Memory, "Accessing an unallocated region of a SparseLargeVector at {:#x}; this shouldn't happen and is likely a Dynarmic error!", exception_addr);
 
-    if (addr != 0 && !CommitVectorPage(addr << HostPageBits, is_write)) {
-        return EXCEPTION_CONTINUE_SEARCH;
+    // Commit this region
+    if (addr != 0) {
+        if (!CommitVectorPage(addr << HostPageBits, false)) {
+            return EXCEPTION_CONTINUE_SEARCH;
+        }
     }
-    if (addr2 != 0 && !CommitVectorPage(addr2 << HostPageBits, is_write)) {
-        return EXCEPTION_CONTINUE_SEARCH;
+    // Commit next region if needed
+    if (addr2 != 0) {
+        if (!CommitVectorPage(addr2 << HostPageBits, false)) {
+            return EXCEPTION_CONTINUE_SEARCH;
+        }
     }
 
     return EXCEPTION_CONTINUE_EXECUTION;
@@ -87,31 +74,23 @@ static LONG WINAPI FakePageFaultHandler(PEXCEPTION_POINTERS info) {
 
 bool CommitVectorPage(uintptr_t addr, bool write) noexcept {
     MEMORY_BASIC_INFORMATION info {};
-    const auto res = VirtualQuery(reinterpret_cast<void*>(addr), &info, sizeof(info));
-    const DWORD perm = write ? PAGE_READWRITE : PAGE_READONLY;
-
+    auto res = VirtualQuery(reinterpret_cast<void*>(addr), &info, sizeof(info));
     if (res == 0) {
         LOG_CRITICAL(HW_Memory, "Failed to query large buffer region at {:#x} with error {}, will try committing anyway", addr, GetLastError());
-    } else if (info.State == MEM_COMMIT) {
-        DWORD old_protect {};
-        if (!VirtualProtect(reinterpret_cast<void*>(addr), HostPageSize, perm, &old_protect)) {
-            LOG_ERROR(HW_Memory, "VirtualProtect failed at {:#x}, error {}", addr, GetLastError());
-            return false;
-        }
-        return true;
     } else if (info.State != MEM_RESERVE) {
-        LOG_ERROR(HW_Memory, "Tried to commit an unreserved large buffer region at {:#x} (state {:#x})", addr, info.State);
+        LOG_ERROR(HW_Memory, "Tried to commit an unreserved large buffer region at {:#x} that is not mapped or is already committed (state {:#x})", addr, info.State);
         return false;
     }
 
-    if (VirtualAlloc(reinterpret_cast<LPVOID>(addr), HostPageSize, MEM_COMMIT, perm) == nullptr) {
+    auto perm = write ? PAGE_READWRITE : PAGE_READONLY;
+    void* res2 = VirtualAlloc(reinterpret_cast<LPVOID>(addr), HostPageSize, MEM_COMMIT, perm);
+    if (res2 == nullptr) {
         LOG_ERROR(HW_Memory, "Failed to commit large buffer region at {:#x}, error {}", addr, GetLastError());
         return false;
     }
 
     return true;
 }
-
 #endif
 
 #ifndef MAP_NOCORE
@@ -123,103 +102,57 @@ bool CommitVectorPage(uintptr_t addr, bool write) noexcept {
 
 void DecommitVectorPage(uintptr_t base) noexcept {
 #if defined(_WIN32)
-    if (!VirtualFree(reinterpret_cast<LPVOID>(base), HostPageSize, MEM_DECOMMIT)) {
-        LOG_WARNING(HW_Memory, "VirtualFree(MEM_DECOMMIT) failed at {:#x}, error {}", base, GetLastError());
-    }
+    VirtualFree(reinterpret_cast<LPVOID>(base), HostPageSize, MEM_DECOMMIT);
 #elif defined(__linux__)
-    if (madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_DONTNEED) != 0) {
-        LOG_WARNING(HW_Memory, "madvise(MADV_DONTNEED) failed at {:#x}: {}", base, std::strerror(errno));
-    }
+    // Linux's MADV_DONTNEED zeros out pages for us
+    madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_DONTNEED);
 #else
-    if (madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_FREE) != 0) {
-        LOG_WARNING(HW_Memory, "madvise(MADV_FREE) failed at {:#x}: {}", base, std::strerror(errno));
-    }
+    madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_FREE);
     std::memset(reinterpret_cast<void*>(base), 0, HostPageSize);
 #endif
 }
 
 void* AllocateMemoryPages(std::size_t size) noexcept {
-    if (size == 0) {
-        return nullptr;
-    }
-
-    const auto page = HostPageSize;
-    if (size % page != 0) {
+    if (auto page = HostPageSize; size % page != 0) {
         LOG_WARNING(HW_Memory, "Allocating unaligned large vector with size {:#x}; aligning to {} page size", size, page);
-        if (size > SIZE_MAX - (page - 1)) {
-            LOG_CRITICAL(HW_Memory, "Size {:#x} would overflow page alignment", size);
-            return nullptr;
-        }
         size = AlignUp(size, page);
     }
 
 #ifdef _WIN32
+    // We will never use this memory entirely so instead of committing it up front let's just reserve it and commit each page individually
     void* base = VirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_READWRITE);
 
     if (base != nullptr) {
-        {
-            std::lock_guard lock(GetVectorRegionsMutex());
-            GetVectorRegions().push_back({
-                reinterpret_cast<u64>(base) >> HostPageBits,
-                (reinterpret_cast<u64>(base) + size) >> HostPageBits,
-            });
-        }
+        vector_regions.emplace_back(reinterpret_cast<u64>(base), reinterpret_cast<u64>(base) + size);
 
         static std::once_flag flag;
         std::call_once(flag, []() { AddVectoredExceptionHandler(1, FakePageFaultHandler); });
     } else {
+        // Try committing everything instead??
         LOG_WARNING(HW_Memory, "Failed to reserve large vector region with error {}, trying to commit instead..", GetLastError());
         base = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
     }
     ASSERT_MSG(base, "Failed to reserve {:#x} sized region with error {}", size, GetLastError());
 #else
-    int flags = MAP_ANON | MAP_PRIVATE;
-#ifdef MAP_NORESERVE
-    flags |= MAP_NORESERVE;
-#endif
-#if defined(MAP_NOCORE)
-    flags |= MAP_NOCORE;
-#endif
-    void* base = mmap(nullptr, size, PROT_READ, flags, -1, 0);
-    if (base == MAP_FAILED) {
+    void* base = mmap(nullptr, size, PROT_READ, MAP_ANON | MAP_PRIVATE | MAP_NOCORE, -1, 0);
+    if (base == MAP_FAILED)
         base = nullptr;
-    }
-#ifdef MADV_HUGEPAGE
-    if (base != nullptr) {
-        madvise(base, size, MADV_HUGEPAGE);
-    }
+    ASSERT_MSG(base, "Failed to allocate {:#x} sized region with error {}", size, strerror(errno));
 #endif
-    ASSERT_MSG(base, "Failed to allocate {:#x} sized region with error {}", size, std::strerror(errno));
-#endif
-
     return base;
 }
 
 void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) noexcept {
-    if (base == nullptr) {
-        return;
-    }
-
-    if (const auto page = HostPageSize; size % page != 0) {
+    if (auto page = HostPageSize; size % page != 0) {
         size = AlignUp(size, page);
     }
-
+    if (!base)
+        return;
 #ifdef _WIN32
-    {
-        std::lock_guard lock(GetVectorRegionsMutex());
-        auto& regions = GetVectorRegions();
-        const u64 base_page = reinterpret_cast<u64>(base) >> HostPageBits;
-        regions.erase(std::remove_if(regions.begin(), regions.end(),
-            [base_page](const VectorRegion& r) { return r.start_page == base_page; }), regions.end());
-    }
-    if (!VirtualFree(base, 0, MEM_RELEASE)) {
-        LOG_ERROR(HW_Memory, "VirtualFree failed, error {}", GetLastError());
-    }
+    ASSERT(VirtualFree(base, 0, MEM_RELEASE));
 #else
-    if (munmap(base, size) != 0) {
-        LOG_ERROR(HW_Memory, "munmap failed: {}", std::strerror(errno));
-    }
+    ASSERT(munmap(base, size) == 0);
 #endif
 }
 
-} // namespace Common
+} // namespace Common

src/common/sparse_large_vector.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 /* virtual_buffer.h */
@@ -7,14 +7,10 @@
 
 #pragma once
 
-#include <array>
 #include <atomic>
 #include <bit>
-#include <cerrno>
-#include <cstdlib>
-#include <cstring>
-#include <memory>
-#include <type_traits>
+#include <utility>
+#include <vector>
 
 #ifndef _WIN32
 #include <unistd.h>
@@ -32,9 +28,9 @@ constexpr u64 HostPageBits = 12;
 constexpr u64 HostPageMask = ~(HostPageSize - 1);
 bool CommitVectorPage(uintptr_t addr, bool write) noexcept;
 #else
-inline const u64 HostPageSize = static_cast<u64>(sysconf(_SC_PAGESIZE));
-inline const u64 HostPageBits = std::countr_zero(HostPageSize);
-inline const u64 HostPageMask = ~(HostPageSize - 1);
+const u64 HostPageSize = sysconf(_SC_PAGESIZE);
+const u64 HostPageBits = std::countr_zero(HostPageSize);
+const u64 HostPageMask = ~(HostPageSize - 1);
 #endif
 
 void* AllocateMemoryPages(std::size_t size) noexcept;
@@ -47,18 +43,20 @@ template <typename T>
     // requires std::is_trivially_copyable_v<T>
 class SparseLargeVector final {
 public:
-    SparseLargeVector() = default;
+    constexpr SparseLargeVector() = default;
 
-    explicit SparseLargeVector(std::size_t count) noexcept {
-        if (count > SIZE_MAX / sizeof(T)) {
-            LOG_CRITICAL(Common_Memory, "SparseLargeVector size overflow: {} elements", count);
-            return;
-        }
-        Allocate(count * sizeof(T));
+    explicit SparseLargeVector(std::size_t count) noexcept
+        : alloc_size{count * sizeof(T)}
+    {
+        base_ptr = static_cast<T*>(AllocateMemoryPages(alloc_size));
+
+        // each item in vector holds information for 64 pages
+        auto denom = HostPageSize * 64;
+        committed_pages = std::vector<std::atomic<u64>>((alloc_size + denom - 1) / denom);
     }
 
     ~SparseLargeVector() noexcept {
-        Release();
+        FreeMemoryPages(base_ptr, alloc_size);
     }
 
     SparseLargeVector(const SparseLargeVector&) = delete;
@@ -67,181 +65,145 @@ public:
     SparseLargeVector& operator=(SparseLargeVector&& other) = delete;
 
     void ResizeAndClear(std::size_t count) noexcept {
-        if (count > SIZE_MAX / sizeof(T)) {
-            LOG_CRITICAL(Common_Memory, "SparseLargeVector resize overflow: {} elements", count);
-            return;
+        if (auto const new_size = count * sizeof(T); new_size != alloc_size) {
+            FreeMemoryPages(base_ptr, alloc_size);
+            alloc_size = new_size;
+            base_ptr = static_cast<T*>(AllocateMemoryPages(alloc_size));
+
+            auto denom = HostPageSize * 64;
+            committed_pages = std::vector<std::atomic<u64>>((alloc_size + denom - 1) / denom);
         }
-        const std::size_t new_size = count * sizeof(T);
-        if (new_size == alloc_size) {
-            ZeroRegion(0, alloc_size / sizeof(T));
-            return;
-        }
-        Release();
-        Allocate(new_size);
     }
 
+    /// Returns a reference to the value of the requested index and allocates memory if needed.
     T& GetAndFault(std::size_t index) noexcept {
-        if (base_ptr == nullptr || index >= size()) [[unlikely]] {
-            LOG_CRITICAL(Common_Memory, "SparseLargeVector RW access out of bounds @ {} (size {})", index, size());
-            std::abort();
+        if (index > alloc_size / sizeof(T)) {
+            UNREACHABLE_MSG("Out of bounds RW access on SparseLargeVector @ {}", index);
         }
-        const u64 byte_offset = static_cast<u64>(index) * sizeof(T);
-        if (!CommitPage(byte_offset)) [[unlikely]] {
-            LOG_CRITICAL(Common_Memory, "SparseLargeVector commit failed @ {} (offset {:#x})", index, byte_offset);
-            std::abort();
+
+        if (!IsCommittedPage(index)) {
+            CommitPage(index);
         }
         return base_ptr[index];
     }
 
-    const T& GetOrDefault(std::size_t index) const noexcept {
-        if (base_ptr == nullptr || index >= size()) [[unlikely]] {
-            LOG_CRITICAL(Common_Memory, "SparseLargeVector RO access out of bounds @ {}", index);
-            return DefaultValue();
-        }
+    /// Returns a reference to the value of the requested index if initialized, or will otherwise return a zero-initialized object.
+    const T& GetOrDefault(std::size_t index) const {
 #ifdef _WIN32
-        if (!IsPageCommitted(static_cast<u64>(index) * sizeof(T))) {
-            return DefaultValue();
+        if (!IsCommittedPage(index)) {
+            return *reinterpret_cast<const T*>(&default_val);
         }
 #endif
+        // On non-Windows, OS page table should optimize this by pointing to a zero page if unallocated.
         return base_ptr[index];
     }
 
     void Set(std::size_t index, const T& value) noexcept {
-        if (base_ptr == nullptr || index >= size()) [[unlikely]] {
-            LOG_CRITICAL(Common_Memory, "SparseLargeVector write out of bounds @ {}", index);
-            return;
-        }
-        const u64 byte_offset = static_cast<u64>(index) * sizeof(T);
-        if (!CommitPage(byte_offset)) [[unlikely]] {
-            LOG_CRITICAL(Common_Memory, "SparseLargeVector commit failed for write @ {}", index);
+        if (index > alloc_size / sizeof(T)) {
+            LOG_CRITICAL(Common_Memory, "Out of bounds write on SparseLargeVector @ {}", index);
             return;
         }
+        if (!IsCommittedPage(index))
+            CommitPage(index);
         base_ptr[index] = value;
     }
 
     void ZeroRegion(std::size_t start, std::size_t end_) noexcept {
-        if (base_ptr == nullptr || start >= end_) return;
+        u64 base = reinterpret_cast<u64>(&base_ptr[start]);
+        const u64 end = reinterpret_cast<u64>(&base_ptr[end_]);
 
-        const u64 start_off = static_cast<u64>(start) * sizeof(T);
-        const u64 end_off = static_cast<u64>(end_) * sizeof(T);
-        const u64 first_page_end = (start_off + HostPageSize - 1) & HostPageMask;
+        const u64 end_page = AlignUp(base, HostPageSize);
+        const u64 first_size = (std::min)(end_page, end) - base;
 
-        if (start_off < first_page_end) {
-            const u64 chunk_end = (std::min)(first_page_end, end_off);
-            const u64 chunk_size = chunk_end - start_off;
-            if (chunk_size != 0 && IsPageCommitted(start_off)) {
-                std::memset(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(base_ptr) + start_off), 0, chunk_size);
-            }
-            if (end_off <= first_page_end) return;
+        if (IsCommittedPage(start)) {
+            std::memset(reinterpret_cast<void*>(base), 0, first_size);
         }
 
-        for (u64 off = first_page_end; off < end_off; off += HostPageSize) {
-            if (!IsPageCommitted(off)) continue;
-            const u64 remaining = end_off - off;
-            if (remaining >= HostPageSize) {
-                DecommitPage(off);
+        if (end <= end_page)
+            return;
+
+        base = end_page;
+
+        for (u64 page = base; page < end; page += HostPageSize) {
+            auto index = (page - reinterpret_cast<u64>(base_ptr)) / sizeof(T);
+            if (!IsCommittedPage(index)) {
+                continue;
+            }
+
+            if (end - page >= HostPageSize) {
+                DecommitPage(index);
             } else {
-                std::memset(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(base_ptr) + off), 0, remaining);
+                std::memset(reinterpret_cast<void*>(page), 0, end - page);
             }
         }
     }
 
-    void CommitRegion(std::size_t index, std::size_t end_) noexcept {
-        if (base_ptr == nullptr || index >= end_) return;
-        const u64 start_off = static_cast<u64>(index) * sizeof(T);
-        const u64 end_off = static_cast<u64>(end_) * sizeof(T);
-        const u64 start_page = start_off & HostPageMask;
-        for (u64 off = start_page; off < end_off; off += HostPageSize) {
-            if (!IsPageCommitted(off)) {
-                (void)CommitPage(off);
+    constexpr void CommitRegion(size_t index, size_t end_) {
+        const u64 base = static_cast<u64>(index) * sizeof(T);
+        const u64 end = static_cast<u64>(end_) * sizeof(T);
+
+        for (u64 page = AlignDown(base, HostPageSize); page < end; page += HostPageSize) {
+            if (!IsCommittedPage(page / sizeof(T))) {
+                CommitPage(page / sizeof(T));
             }
         }
     }
 
-    T& GetUnchecked(std::size_t index) noexcept { return base_ptr[index]; }
+    constexpr T& GetUnchecked(size_t index) {
+        return base_ptr[index];
+    }
 
-    [[nodiscard]] const T& operator[](std::size_t index) const noexcept { return GetOrDefault(index); }
-    [[nodiscard]] const T* data() const noexcept { return base_ptr; }
-    [[nodiscard]] std::size_t size() const noexcept { return alloc_size / sizeof(T); }
+    [[nodiscard]] constexpr const T& operator[](std::size_t index) const noexcept {
+        return GetOrDefault(index);
+    }
+
+    [[nodiscard]] constexpr const T* data() const noexcept {
+        return base_ptr;
+    }
+
+    [[nodiscard]] constexpr std::size_t size() const noexcept {
+        return alloc_size / sizeof(T);
+    }
 
 private:
-    void Allocate(std::size_t new_size) noexcept {
-        alloc_size = new_size;
-        if (alloc_size == 0) {
-            base_ptr = nullptr;
-            committed_pages.reset();
-            return;
-        }
-        base_ptr = static_cast<T*>(AllocateMemoryPages(alloc_size));
-        const std::size_t num_pages = NumPages();
-        const std::size_t num_words = (num_pages + 63) / 64;
-        committed_pages = std::make_unique<std::atomic<u64>[]>(num_words);
-    }
-
-    void Release() noexcept {
-        if (base_ptr != nullptr) {
-            FreeMemoryPages(base_ptr, alloc_size);
-            base_ptr = nullptr;
-        }
-        committed_pages.reset();
-        alloc_size = 0;
-    }
-
-    [[nodiscard]] u64 NumPages() const noexcept {
-        return (alloc_size + HostPageSize - 1) >> HostPageBits;
-    }
-
-    [[nodiscard]] bool IsPageCommitted(u64 byte_offset) const noexcept {
-        const u64 page_index = byte_offset >> HostPageBits;
-        if (committed_pages == nullptr || page_index >= NumPages()) return false;
-        const auto val = committed_pages[page_index >> 6].load(std::memory_order_acquire);
-        return (val >> (page_index & 63)) & 1;
-    }
-
-    void SetPageBit(u64 page_index, bool value) noexcept {
-        if (committed_pages == nullptr) return;
-        const u64 bit = 1ULL << (page_index & 63);
-        auto& atom = committed_pages[page_index >> 6];
-        if (value) {
-            atom.fetch_or(bit, std::memory_order_release);
-        } else {
-            atom.fetch_and(~bit, std::memory_order_release);
-        }
-    }
-
-    bool CommitPage(u64 byte_offset) noexcept {
-        const u64 page_index = byte_offset >> HostPageBits;
-        const uintptr_t page_addr = (reinterpret_cast<uintptr_t>(base_ptr) + byte_offset) & HostPageMask;
-
-        if (IsPageCommitted(byte_offset)) return true;
-
-#if defined(_WIN32)
-        if (!CommitVectorPage(page_addr, true)) return false;
-#else
-        if (mprotect(reinterpret_cast<void*>(page_addr), HostPageSize, PROT_READ | PROT_WRITE) != 0) {
-            LOG_ERROR(Common_Memory, "mprotect failed at {:#x}: {}", page_addr, std::strerror(errno));
+    [[nodiscard]] constexpr bool IsCommittedPage(std::size_t index) const noexcept {
+        if (index > alloc_size / sizeof(T)) {
+            LOG_CRITICAL(Common_Memory, "Out of bounds access on large vector @ {}", index);
             return false;
         }
+
+        auto page = (index * sizeof(T)) >> HostPageBits;
+        auto val = committed_pages[page >> 6].load(std::memory_order_acquire);
+        return (val >> (page & 63)) & 1;
+    }
+
+    constexpr void CommitPage(std::size_t index) noexcept {
+        auto page_index = (index * sizeof(T)) >> HostPageBits;
+        auto page = reinterpret_cast<uintptr_t>(base_ptr + index) & HostPageMask;
+#if defined(_WIN32)
+        CommitVectorPage(page, true);
+#else
+        mprotect(reinterpret_cast<void*>(page), HostPageSize, PROT_READ | PROT_WRITE);
 #endif
-        SetPageBit(page_index, true);
-        return true;
+
+        committed_pages[page_index >> 6].fetch_or(1ULL << (page_index & 63), std::memory_order_release);
     }
 
-    void DecommitPage(u64 byte_offset) noexcept {
-        const u64 page_index = byte_offset >> HostPageBits;
-        const uintptr_t page_addr = (reinterpret_cast<uintptr_t>(base_ptr) + byte_offset) & HostPageMask;
-        DecommitVectorPage(page_addr);
-        SetPageBit(page_index, false);
-    }
+    constexpr void DecommitPage(std::size_t index) noexcept {
+        auto page_index = (index * sizeof(T)) >> HostPageBits;
+        auto page = reinterpret_cast<uintptr_t>(base_ptr + index) & HostPageMask;
 
-    [[nodiscard]] const T& DefaultValue() const noexcept {
-        return *reinterpret_cast<const T*>(&default_val);
+        committed_pages[page_index >> 6].fetch_and(~(1ULL << (page_index & 63)), std::memory_order_release);
+        DecommitVectorPage(page);
     }
 
     std::size_t alloc_size{};
     T* base_ptr{};
-    std::unique_ptr<std::atomic<u64>[]> committed_pages{};
-    alignas(T) const std::array<u8, sizeof(T)> default_val{};
+
+    std::vector<std::atomic<u64>> committed_pages{};
+#ifdef _WIN32
+    const std::array<u8, sizeof(T)> default_val{};
+#endif
 };
 
-} // namespace Common
+} // namespace Common

src/core/file_sys/vfs/vfs_real.cpp

@@ -109,7 +109,8 @@ VirtualFile RealVfsFilesystem::OpenFileFromEntry(std::string_view path_, std::op
     auto reference = std::make_unique<FileReference>();
     this->InsertReferenceIntoListLocked(*reference);
 
-    auto file = std::make_shared<RealVfsFile>(*this, std::move(reference), path, perms, size, std::move(parent_path));
+    auto file = std::shared_ptr<RealVfsFile>(
+        new RealVfsFile(*this, std::move(reference), path, perms, size, std::move(parent_path)));
     cache[path] = file;
 
     return file;
@@ -176,7 +177,7 @@ bool RealVfsFilesystem::DeleteFile(std::string_view path_) {
 
 VirtualDir RealVfsFilesystem::OpenDirectory(std::string_view path_, OpenMode perms) {
     const auto path = FS::SanitizePath(path_, FS::DirectorySeparator::PlatformDefault);
-    return std::make_shared<RealVfsDirectory>(*this, path, perms);
+    return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms));
 }
 
 VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, OpenMode perms) {
@@ -184,7 +185,7 @@ VirtualDir RealVfsFilesystem::CreateDirectory(std::string_view path_, OpenMode p
     if (!FS::CreateDirs(path)) {
         return nullptr;
     }
-    return std::make_shared<RealVfsDirectory>(*this, path, perms);
+    return std::shared_ptr<RealVfsDirectory>(new RealVfsDirectory(*this, path, perms));
 }
 
 VirtualDir RealVfsFilesystem::CopyDirectory(std::string_view old_path_,

src/core/file_sys/vfs/vfs_real.h

@@ -82,9 +82,6 @@ class RealVfsFile : public VfsFile {
     friend class RealVfsFilesystem;
 
 public:
-    RealVfsFile(RealVfsFilesystem& base, std::unique_ptr<FileReference> reference,
-                const std::string& path, OpenMode perms = OpenMode::Read,
-                std::optional<u64> size = {}, std::optional<std::string> parent_path = {});
     ~RealVfsFile() override;
 
     std::string GetName() const override;
@@ -98,6 +95,9 @@ public:
     bool Rename(std::string_view name) override;
 
 private:
+    RealVfsFile(RealVfsFilesystem& base, std::unique_ptr<FileReference> reference,
+                const std::string& path, OpenMode perms = OpenMode::Read,
+                std::optional<u64> size = {}, std::optional<std::string> parent_path = {});
 
     RealVfsFilesystem& base;
     std::unique_ptr<FileReference> reference;
@@ -113,8 +113,6 @@ class RealVfsDirectory : public VfsDirectory {
     friend class RealVfsFilesystem;
 
 public:
-    RealVfsDirectory(RealVfsFilesystem& base, const std::string& path,
-                     OpenMode perms = OpenMode::Read);
     ~RealVfsDirectory() override;
 
     VirtualFile GetFileRelative(std::string_view relative_path) const override;
@@ -140,6 +138,9 @@ public:
     std::map<std::string, VfsEntryType, std::less<>> GetEntries() const override;
 
 private:
+    RealVfsDirectory(RealVfsFilesystem& base, const std::string& path,
+                     OpenMode perms = OpenMode::Read);
+
     template <typename T, typename R>
     std::vector<std::shared_ptr<R>> IterateEntries() const;
 

src/core/hle/service/am/window_system.cpp

@@ -517,7 +517,7 @@ void WindowSystem::UpdateAppletStateLocked(Applet* applet, bool is_foreground, b
     // Layer ordering. Composition sorts back-to-front. Now with enums for calrity.
     s32 z_index = Background;
     if (is_overlay) {
-        z_index = this->IsOverlayOpenLocked(*applet) ? Overlay : Background;
+        z_index = Overlay;
     } else if (inherited_foreground) {
         z_index = is_obscured ? Foreground : ForegroundVisible;
     }

src/core/hle/service/psc/ovln/receiver_service.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -24,7 +24,7 @@ IReceiverService::~IReceiverService() = default;
 
 Result IReceiverService::OpenReceiver(Out<SharedPointer<IReceiver>> out_receiver) {
     LOG_DEBUG(Service_PSC, "called");
-    *out_receiver = std::make_shared<IReceiver>(system);
+    *out_receiver = std::shared_ptr<IReceiver>(new IReceiver(system));
     R_SUCCEED();
 }
 

src/dynarmic/src/dynarmic/common/context.h

@@ -67,9 +67,7 @@
 #else
 #   define CTX_SP (_UC_MACHINE_SP(ucontext))
 #endif
-#endif
-
-#if defined(ARCHITECTURE_arm64)
+#elif defined(ARCHITECTURE_arm64)
 #    if defined(__APPLE__)
 #        define CTX_PC (mctx->__ss.__pc)
 #        define CTX_SP (mctx->__ss.__sp)

src/hid_core/resources/npad/npad.cpp

@@ -45,19 +45,6 @@ NPad::NPad(Core::HID::HIDCore& hid_core_, KernelHelpers::ServiceContext& service
         AbstractPad{hid_core_.kernel},
     }}
 {
-    for (std::size_t aruid_index = 0; aruid_index < AruidIndexMax; ++aruid_index) {
-        for (std::size_t i = 0; i < controller_data[aruid_index].size(); ++i) {
-            auto& controller = controller_data[aruid_index][i];
-            controller.device = hid_core.GetEmulatedControllerByIndex(i);
-            Core::HID::ControllerUpdateCallback engine_callback{
-                .on_change = [this, i, kernel = &hid_core.kernel](Core::HID::ControllerTriggerType type) {
-                    ControllerUpdate(*kernel, type, i);
-                },
-                .is_npad_service = true,
-            };
-            controller.callback_key = controller.device->SetCallback(engine_callback);
-        }
-    }
     for (std::size_t i = 0; i < abstracted_pads.size(); ++i) {
         abstracted_pads[i].SetNpadId(IndexToNpadIdType(i));
     }
@@ -106,6 +93,16 @@ Result NPad::Activate(u64 aruid) {
     for (std::size_t i = 0; i < controller_data[aruid_index].size(); ++i) {
         auto& controller = controller_data[aruid_index][i];
         controller.shared_memory = &data->shared_memory_format->npad.npad_entry[i].internal_state;
+        controller.device = hid_core.GetEmulatedControllerByIndex(i);
+        if (!controller.callback_key) {
+            Core::HID::ControllerUpdateCallback engine_callback{
+                .on_change = [this, i](Core::HID::ControllerTriggerType type) {
+                    ControllerUpdate(hid_core.kernel, type, i);
+                },
+                .is_npad_service = true,
+            };
+            controller.callback_key = controller.device->SetCallback(engine_callback);
+        }
     }
 
     // Prefill controller buffers

src/hid_core/resources/npad/npad_types.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <vector>
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"

src/qt_common/CMakeLists.txt

@@ -92,7 +92,7 @@ if (ENABLE_OPENGL)
     target_compile_definitions(qt_common PUBLIC HAS_OPENGL)
 endif()
 
-if (UNIX AND NOT APPLE)
+if (LINUX OR FREEBSD)
     if (DEFINED Qt6Gui_PRIVATE_INCLUDE_DIRS)
         target_include_directories(qt_common PRIVATE ${Qt6Gui_PRIVATE_INCLUDE_DIRS})
     else()

src/video_core/buffer_cache/buffer_cache.h

@@ -121,7 +121,7 @@ void BufferCache<P>::UnmapGPUMemory(size_t as_id, GPUVAddr gpu_addr, size_t size
 
 template <class P>
 void BufferCache<P>::WriteMemory(DAddr device_addr, u64 size) {
-    if (IsRegionGpuModified(device_addr, size)) {
+    if (memory_tracker.IsRegionGpuModified(device_addr, size)) {
         ClearDownload(device_addr, size);
         gpu_modified_ranges.Subtract(device_addr, size);
     }
@@ -311,8 +311,11 @@ std::pair<typename P::Buffer*, u32> BufferCache<P>::ObtainCPUBuffer(
         MarkWrittenBuffer(buffer_id, device_addr, size);
         break;
     case ObtainBufferOperation::DiscardWrite: {
-        ClearDownload(device_addr, size);
-        gpu_modified_ranges.Subtract(device_addr, size);
+        const DAddr device_addr_start = Common::AlignDown(device_addr, 64);
+        const DAddr device_addr_end = Common::AlignUp(device_addr + size, 64);
+        const size_t new_size = device_addr_end - device_addr_start;
+        ClearDownload(device_addr_start, new_size);
+        gpu_modified_ranges.Subtract(device_addr_start, new_size);
         break;
     }
     default:
@@ -1739,24 +1742,14 @@ bool BufferCache<P>::SynchronizeBuffer(Buffer& buffer, DAddr device_addr, u32 si
     u64 total_size_bytes = 0;
     u64 largest_copy = 0;
     const DAddr buffer_start = buffer.cpu_addr_cached;
-    const auto add_upload = [&](DAddr start, DAddr end) {
-        if (start == end) return;
-        const u64 range_size = end - start;
+    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
         upload_copies.push_back(BufferCopy{
             .src_offset = total_size_bytes,
-            .dst_offset = start - buffer_start,
+            .dst_offset = device_addr_out - buffer_start,
             .size = range_size,
         });
         total_size_bytes += range_size;
         largest_copy = (std::max)(largest_copy, range_size);
-    };
-    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
-        DAddr upload_start = device_addr_out;
-        gpu_modified_ranges.ForEachInRange(device_addr_out, range_size, [&](DAddr gpu_start, DAddr gpu_end) {
-            add_upload(upload_start, gpu_start);
-            upload_start = gpu_end;
-        });
-        add_upload(upload_start, device_addr_out + range_size);
     });
     if (total_size_bytes == 0) {
         return true;

src/video_core/dma_pusher.cpp

@@ -16,7 +16,7 @@
 namespace Tegra {
 
 constexpr u32 MacroRegistersStart = 0xE00;
-constexpr u32 ComputeInline = 0x6D;
+[[maybe_unused]] constexpr u32 ComputeInline = 0x6D;
 
 DmaPusher::DmaPusher(Core::System& system_, MemoryManager& memory_manager_, Control::ChannelState& channel_state_)
     : system{system_}
@@ -73,16 +73,11 @@ bool DmaPusher::Step() {
         synced = false;
     }
 
+    if (header.size > 0 && dma_state.method >= MacroRegistersStart && subchannels[dma_state.subchannel]) {
+        subchannels[dma_state.subchannel]->current_dirty = memory_manager.IsMemoryDirty(dma_state.dma_get, header.size * sizeof(u32));
+    }
+
     if (header.size > 0) {
-        if (subchannels[dma_state.subchannel] && dma_state.method_count) {
-            const auto engine = subchannel_type[dma_state.subchannel];
-            const bool kepler_payload = engine == Engines::EngineTypes::KeplerCompute && dma_state.method == ComputeInline && dma_state.non_incrementing;
-            const bool macro_payload = engine == Engines::EngineTypes::Maxwell3D && dma_state.method >= MacroRegistersStart;
-            if (kepler_payload || macro_payload) {
-                const size_t words = std::min<size_t>(dma_state.method_count, header.size);
-                subchannels[dma_state.subchannel]->current_dirty = memory_manager.IsMemoryDirty(dma_state.dma_get, words * sizeof(u32));
-            }
-        }
         const bool use_safe = Settings::IsDMALevelDefault() ? Settings::IsGPULevelHigh() : Settings::IsDMALevelSafe();
         if (use_safe) {
             Tegra::Memory::GpuGuestMemory<Tegra::CommandHeader, Tegra::Memory::GuestMemoryFlags::SafeRead>headers(memory_manager, dma_state.dma_get, header.size, &command_headers);

src/video_core/engines/kepler_compute.cpp

@@ -49,16 +49,13 @@ void KeplerCompute::CallMethod(Core::System& system, u32 method, u32 method_argu
     case KEPLER_COMPUTE_REG_INDEX(exec_upload): {
         UploadInfo info{.upload_address = upload_address,
                         .exec_address = upload_state.ExecTargetAddress(),
-                        .copy_size = upload_state.GetUploadSize(),
-                        .was_dirty = upload_dirty};
+                        .copy_size = upload_state.GetUploadSize()};
         uploads.push_back(info);
         upload_state.ProcessExec(regs.exec_upload.linear != 0);
         break;
     }
     case KEPLER_COMPUTE_REG_INDEX(data_upload): {
         upload_address = current_dma_segment;
-        upload_dirty = current_dirty;
-        current_dirty = false;
         upload_state.ProcessData(method_argument, is_last_call);
         break;
     }
@@ -67,11 +64,9 @@ void KeplerCompute::CallMethod(Core::System& system, u32 method, u32 method_argu
 
         for (auto& data : uploads) {
             const GPUVAddr offset = data.exec_address - launch_desc_loc;
-            if (offset / sizeof(u32) == LAUNCH_REG_INDEX(grid_dim_x)) {
-                const bool source_dirty = memory_manager.IsMemoryDirty(data.upload_address, data.copy_size);
-                if (data.was_dirty || source_dirty) {
-                    indirect_compute = {data.upload_address};
-                }
+            if (offset / sizeof(u32) == LAUNCH_REG_INDEX(grid_dim_x) &&
+                memory_manager.IsMemoryDirty(data.upload_address, data.copy_size)) {
+                indirect_compute = {data.upload_address};
             }
         }
         uploads.clear();
@@ -88,8 +83,6 @@ void KeplerCompute::CallMultiMethod(Core::System& system, u32 method, const u32*
     switch (method) {
     case KEPLER_COMPUTE_REG_INDEX(data_upload):
         upload_address = current_dma_segment;
-        upload_dirty = current_dirty;
-        current_dirty = false;
         upload_state.ProcessData(base_start, amount);
         return;
     default:

src/video_core/engines/kepler_compute.h

@@ -226,13 +226,11 @@ private:
     VideoCore::RasterizerInterface* rasterizer = nullptr;
     Upload::State upload_state;
     GPUVAddr upload_address;
-    bool upload_dirty{};
 
     struct UploadInfo {
         GPUVAddr upload_address;
         GPUVAddr exec_address;
         u32 copy_size;
-        bool was_dirty;
     };
     std::vector<UploadInfo> uploads;
     std::optional<GPUVAddr> indirect_compute{};

src/video_core/renderer_vulkan/present/layer.cpp

@@ -94,13 +94,13 @@ void Layer::ConfigureDraw(const Device& device, PresentPushConstants* out_push_c
     const u32 scaled_width = texture_info ? texture_info->scaled_width : texture_width;
     const u32 scaled_height = texture_info ? texture_info->scaled_height : texture_height;
     const bool use_accelerated = texture_info.has_value();
-    const bool is_applet =
-        (framebuffer.layer_stack_mask & Service::Nvnflinger::LayerStackBit(
-                                            Service::Nvnflinger::LayerStackId::Recording)) == 0;
 
     RefreshResources(device, framebuffer);
     SetAntiAliasPass(device);
 #ifdef HAS_RESHADE
+    const bool is_applet =
+        (framebuffer.layer_stack_mask & Service::Nvnflinger::LayerStackBit(
+                                            Service::Nvnflinger::LayerStackId::Recording)) == 0;
     SetPostProcessPass(device, is_applet);
 #endif
 
@@ -141,11 +141,8 @@ void Layer::ConfigureDraw(const Device& device, PresentPushConstants* out_push_c
         source_image_view = fsr->Draw(device, scheduler, image_index, source_image, source_image_view, render_extent, crop_rect);
         crop_rect = {0, 0, 1, 1};
     } else if (auto* sgsr = std::get_if<SGSR>(&sr_filter)) {
-        if (!is_applet) {
-            source_image_view = sgsr->Draw(device, scheduler, image_index, source_image,
-                                           source_image_view, render_extent, crop_rect);
-            crop_rect = {0, 0, 1, 1};
-        }
+        source_image_view = sgsr->Draw(device, scheduler, image_index, source_image, source_image_view, render_extent, crop_rect);
+        crop_rect = {0, 0, 1, 1};
     }
 
     SetMatrixData(device, *out_push_constants, layout);

src/video_core/vulkan_common/vulkan_instance.cpp

@@ -43,26 +43,32 @@ namespace {
     switch (window_type) {
     case Core::Frontend::WindowSystemType::Headless:
         break;
-#ifdef _WIN32
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
     case Core::Frontend::WindowSystemType::Windows:
         extensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
         break;
-#elif defined(__APPLE__)
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
     case Core::Frontend::WindowSystemType::Cocoa:
         extensions.push_back(VK_EXT_METAL_SURFACE_EXTENSION_NAME);
         break;
-#elif defined(__ANDROID__)
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
     case Core::Frontend::WindowSystemType::Android:
         extensions.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
         break;
-#elif defined(__HAIKU__)
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
     case Core::Frontend::WindowSystemType::Xcb:
         extensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
         break;
-#else
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
     case Core::Frontend::WindowSystemType::X11:
         extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
         break;
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
     case Core::Frontend::WindowSystemType::Wayland:
         extensions.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
         break;

src/video_core/vulkan_common/vulkan_surface.cpp

@@ -8,6 +8,7 @@
 #include "core/frontend/emu_window.h"
 #include "video_core/vulkan_common/vulkan_surface.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
+#include "video_core/vulkan_common/vulkan.h"
 
 namespace Vulkan {
 
@@ -17,7 +18,7 @@ vk::SurfaceKHR CreateSurface(
     [[maybe_unused]] const vk::InstanceDispatch& dld = instance.Dispatch();
     VkSurfaceKHR unsafe_surface = VkSurfaceKHR{};
 
-#ifdef _WIN32
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
     if (window_info.type == Core::Frontend::WindowSystemType::Windows) {
         const HWND hWnd = static_cast<HWND>(window_info.render_surface);
         const VkWin32SurfaceCreateInfoKHR win32_ci{VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
@@ -30,7 +31,8 @@ vk::SurfaceKHR CreateSurface(
             throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
         }
     }
-#elif defined(__APPLE__)
+#endif
+#if defined(VK_USE_PLATFORM_METAL_EXT)
     if (window_info.type == Core::Frontend::WindowSystemType::Cocoa) {
         const VkMetalSurfaceCreateInfoEXT metal_ci = {
             .sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT,
@@ -45,7 +47,8 @@ vk::SurfaceKHR CreateSurface(
             throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
         }
     }
-#elif defined(__ANDROID__)
+#endif
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
     if (window_info.type == Core::Frontend::WindowSystemType::Android) {
         const VkAndroidSurfaceCreateInfoKHR android_ci{
             VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, nullptr, 0,
@@ -59,7 +62,8 @@ vk::SurfaceKHR CreateSurface(
             throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
         }
     }
-#elif defined(__HAIKU__)
+#endif
+#if defined(VK_USE_PLATFORM_XCB_KHR)
     if (window_info.type == Core::Frontend::WindowSystemType::Xcb) {
         const VkXcbSurfaceCreateInfoKHR xcb_ci{
             .sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,
@@ -76,7 +80,8 @@ vk::SurfaceKHR CreateSurface(
             throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
         }
     }
-#else
+#endif
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
     if (window_info.type == Core::Frontend::WindowSystemType::X11) {
         const VkXlibSurfaceCreateInfoKHR xlib_ci{
             VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, nullptr, 0,
@@ -90,6 +95,8 @@ vk::SurfaceKHR CreateSurface(
             throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
         }
     }
+#endif
+#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
     if (window_info.type == Core::Frontend::WindowSystemType::Wayland) {
         const VkWaylandSurfaceCreateInfoKHR wayland_ci{
             VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, nullptr, 0,
@@ -105,7 +112,6 @@ vk::SurfaceKHR CreateSurface(
         }
     }
 #endif
-
     if (!unsafe_surface) {
         LOG_ERROR(Render_Vulkan, "Presentation not supported on this platform");
         throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);