2026-09-11 18:51:14

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

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/dynarmic/src/dynarmic/backend/x64/a32_jitstate.cpp

@@ -69,8 +69,8 @@ u32 A32JitState::Cpsr() const {
     cpsr |= mcl::bit::get_bit<1>(upper_location_descriptor) ? 1 << 9 : 0;
     cpsr |= mcl::bit::get_bit<0>(upper_location_descriptor) ? 1 << 5 : 0;
     // IT state
-    cpsr |= static_cast<u32>(upper_location_descriptor & 0b11111100'00000000);
-    cpsr |= static_cast<u32>(upper_location_descriptor & 0b00000011'00000000) << 17;
+    cpsr |= u32(upper_location_descriptor & 0b11111100'00000000);
+    cpsr |= u32(upper_location_descriptor & 0b00000011'00000000) << 17;
     // Other flags
     cpsr |= cpsr_jaifm;
 
@@ -169,39 +169,36 @@ constexpr u32 FPSCR_NZCV_MASK = 0xF0000000;
 u32 A32JitState::Fpscr() const {
     DEBUG_ASSERT((fpsr_nzcv & ~FPSCR_NZCV_MASK) == 0);
 
-    const u32 fpcr_mode = static_cast<u32>(upper_location_descriptor) & FPSCR_MODE_MASK;
+    const u32 fpcr_mode = u32(upper_location_descriptor) & FPSCR_MODE_MASK;
     const u32 mxcsr = guest_MXCSR | asimd_MXCSR;
-
-    u32 FPSCR = fpcr_mode | fpsr_nzcv;
-    FPSCR |= (mxcsr & 0b0000000000001);       // IOC = IE
-    FPSCR |= (mxcsr & 0b0000000111100) >> 1;  // IXC, UFC, OFC, DZC = PE, UE, OE, ZE
-    FPSCR |= fpsr_exc;
-    FPSCR |= fpsr_qc != 0 ? 1 << 27 : 0;
-
-    return FPSCR;
+    u32 fpscr = fpcr_mode | fpsr_nzcv;
+    fpscr |= (mxcsr & 0b0000000000001);       // IOC = IE
+    fpscr |= (mxcsr & 0b0000000111100) >> 1;  // IXC, UFC, OFC, DZC = PE, UE, OE, ZE
+    fpscr |= fpsr_exc;
+    fpscr |= fpsr_qc != 0 ? 1 << 27 : 0;
+    return fpscr;
 }
 
-void A32JitState::SetFpscr(u32 FPSCR) {
+void A32JitState::SetFpscr(u32 value) {
     // Ensure that only upper half of upper_location_descriptor is used for FPSCR bits.
     static_assert((FPSCR_MODE_MASK & 0xFFFF0000) == FPSCR_MODE_MASK);
 
     upper_location_descriptor &= 0x0000FFFF;
-    upper_location_descriptor |= FPSCR & FPSCR_MODE_MASK;
+    upper_location_descriptor |= value & FPSCR_MODE_MASK;
 
-    fpsr_nzcv = FPSCR & FPSCR_NZCV_MASK;
-    fpsr_qc = (FPSCR >> 27) & 1;
+    fpsr_nzcv = value & FPSCR_NZCV_MASK;
+    fpsr_qc = (value >> 27) & 1;
 
     guest_MXCSR = 0x00001f80;
     asimd_MXCSR = 0x00009fc0;
 
     // RMode
-    const std::array<u32, 4> MXCSR_RMode{0x0, 0x4000, 0x2000, 0x6000};
-    guest_MXCSR |= MXCSR_RMode[(FPSCR >> 22) & 0x3];
+    guest_MXCSR |= ((0x6000200040000000 >> (((value >> 18) & (0x3 << 4)))) & 0xf000);
 
     // Cumulative flags IDC, IOC, IXC, UFC, OFC, DZC
-    fpsr_exc = FPSCR & 0x9F;
+    fpsr_exc = value & 0x9F;
 
-    if (mcl::bit::get_bit<24>(FPSCR)) {
+    if (mcl::bit::get_bit<24>(value)) {
         // VFP Flush to Zero
         guest_MXCSR |= (1 << 15);  // SSE Flush to Zero
         guest_MXCSR |= (1 << 6);   // SSE Denormals are Zero

src/dynarmic/src/dynarmic/backend/x64/a64_jitstate.cpp

@@ -59,16 +59,16 @@ u32 A64JitState::GetFpcr() const {
 
 void A64JitState::SetFpcr(u32 value) {
     fpcr = value & FPCR_MASK;
-
     asimd_MXCSR &= 0x0000003D;
     guest_MXCSR &= 0x0000003D;
     asimd_MXCSR |= 0x00001f80;
     guest_MXCSR |= 0x00001f80;  // Mask all exceptions
-
     // RMode
-    const std::array<u32, 4> MXCSR_RMode{0x0, 0x4000, 0x2000, 0x6000};
-    guest_MXCSR |= MXCSR_RMode[(value >> 22) & 0x3];
-
+    // 0 -> 0x0000
+    // 1 -> 0x4000
+    // 2 -> 0x2000
+    // 3 -> 0x6000
+    guest_MXCSR |= ((0x6000200040000000 >> (((value >> 18) & (0x3 << 4)))) & 0xf000);
     if (mcl::bit::get_bit<24>(value)) {
         guest_MXCSR |= (1 << 15);  // SSE Flush to Zero
         guest_MXCSR |= (1 << 6);   // SSE Denormals are Zero