17 files changed, 894 insertions, 211 deletions

diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index 635fb85c8..c0555f840 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -14,34 +14,11 @@ if (DEFINED ENV{DISPLAYVERSION})
   set(DISPLAY_VERSION $ENV{DISPLAYVERSION})
 endif ()
 
-# Pass the path to git to the GenerateSCMRev.cmake as well
-find_package(Git QUIET)
-
-add_custom_command(OUTPUT scm_rev.cpp
-    COMMAND ${CMAKE_COMMAND}
-      -DSRC_DIR=${CMAKE_SOURCE_DIR}
-      -DBUILD_REPOSITORY=${BUILD_REPOSITORY}
-      -DTITLE_BAR_FORMAT_IDLE=${TITLE_BAR_FORMAT_IDLE}
-      -DTITLE_BAR_FORMAT_RUNNING=${TITLE_BAR_FORMAT_RUNNING}
-      -DBUILD_TAG=${BUILD_TAG}
-      -DBUILD_ID=${DISPLAY_VERSION}
-      -DGIT_REF_SPEC=${GIT_REF_SPEC}
-      -DGIT_REV=${GIT_REV}
-      -DGIT_DESC=${GIT_DESC}
-      -DGIT_BRANCH=${GIT_BRANCH}
-      -DBUILD_FULLNAME=${BUILD_FULLNAME}
-      -DGIT_EXECUTABLE=${GIT_EXECUTABLE}
-      -P ${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake
-    DEPENDS
-      # Check that the scm_rev files haven't changed
-      "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in"
-      "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.h"
-      # technically we should regenerate if the git version changed, but its not worth the effort imo
-      "${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake"
-    VERBATIM
-)
+include(GenerateSCMRev)
 
 add_library(common STATIC
+    address_space.cpp
+    address_space.h
     algorithm.h
     alignment.h
     announce_multiplayer_room.h
@@ -106,6 +83,8 @@ add_library(common STATIC
     microprofile.cpp
     microprofile.h
     microprofileui.h
+    multi_level_page_table.cpp
+    multi_level_page_table.h
     nvidia_flags.cpp
     nvidia_flags.h
     page_table.cpp
@@ -117,7 +96,7 @@ add_library(common STATIC
     quaternion.h
     reader_writer_queue.h
     ring_buffer.h
-    scm_rev.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/scm_rev.cpp
     scm_rev.h
     scope_exit.h
     settings.cpp
@@ -166,6 +145,7 @@ if(ARCHITECTURE_x86_64)
             x64/xbyak_abi.h
             x64/xbyak_util.h
     )
+    target_link_libraries(common PRIVATE xbyak)
 endif()
 
 if (MSVC)
@@ -176,12 +156,13 @@ if (MSVC)
   )
   target_compile_options(common PRIVATE
     /W4
-    /WX
+
+    /we4242 # 'identifier': conversion from 'type1' to 'type2', possible loss of data
+    /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
+    /we4800 # Implicit conversion from 'type' to bool. Possible information loss
   )
 else()
   target_compile_options(common PRIVATE
-    -Werror
-
     $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
   )
 endif()
@@ -189,7 +170,11 @@ endif()
 create_target_directory_groups(common)
 
 target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile Threads::Threads)
-target_link_libraries(common PRIVATE lz4::lz4 xbyak)
+if (TARGET lz4::lz4)
+  target_link_libraries(common PRIVATE lz4::lz4)
+else()
+  target_link_libraries(common PRIVATE LZ4::lz4_shared)
+endif()
 if (TARGET zstd::zstd)
   target_link_libraries(common PRIVATE zstd::zstd)
 else()
diff --git a/src/common/address_space.cpp b/src/common/address_space.cpp
new file mode 100644
index 000000000..866e78dbe
--- /dev/null
+++ b/src/common/address_space.cpp
@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "common/address_space.inc"
+
+namespace Common {
+
+template class Common::FlatAllocator<u32, 0, 32>;
+
+}
diff --git a/src/common/address_space.h b/src/common/address_space.h
new file mode 100644
index 000000000..9222b2fdc
--- /dev/null
+++ b/src/common/address_space.h
@@ -0,0 +1,150 @@
+// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <concepts>
+#include <functional>
+#include <mutex>
+#include <vector>
+
+#include "common/common_types.h"
+
+namespace Common {
+template <typename VaType, size_t AddressSpaceBits>
+concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >= AddressSpaceBits;
+
+struct EmptyStruct {};
+
+/**
+ * @brief FlatAddressSpaceMap provides a generic VA->PA mapping implementation using a sorted vector
+ */
+template <typename VaType, VaType UnmappedVa, typename PaType, PaType UnmappedPa,
+          bool PaContigSplit, size_t AddressSpaceBits, typename ExtraBlockInfo = EmptyStruct>
+requires AddressSpaceValid<VaType, AddressSpaceBits>
+class FlatAddressSpaceMap {
+public:
+    /// The maximum VA that this AS can technically reach
+    static constexpr VaType VaMaximum{(1ULL << (AddressSpaceBits - 1)) +
+                                      ((1ULL << (AddressSpaceBits - 1)) - 1)};
+
+    explicit FlatAddressSpaceMap(VaType va_limit,
+                                 std::function<void(VaType, VaType)> unmap_callback = {});
+
+    FlatAddressSpaceMap() = default;
+
+    void Map(VaType virt, PaType phys, VaType size, ExtraBlockInfo extra_info = {}) {
+        std::scoped_lock lock(block_mutex);
+        MapLocked(virt, phys, size, extra_info);
+    }
+
+    void Unmap(VaType virt, VaType size) {
+        std::scoped_lock lock(block_mutex);
+        UnmapLocked(virt, size);
+    }
+
+    VaType GetVALimit() const {
+        return va_limit;
+    }
+
+protected:
+    /**
+     * @brief Represents a block of memory in the AS, the physical mapping is contiguous until
+     * another block with a different phys address is hit
+     */
+    struct Block {
+        /// VA of the block
+        VaType virt{UnmappedVa};
+        /// PA of the block, will increase 1-1 with VA until a new block is encountered
+        PaType phys{UnmappedPa};
+        [[no_unique_address]] ExtraBlockInfo extra_info;
+
+        Block() = default;
+
+        Block(VaType virt_, PaType phys_, ExtraBlockInfo extra_info_)
+            : virt(virt_), phys(phys_), extra_info(extra_info_) {}
+
+        bool Valid() const {
+            return virt != UnmappedVa;
+        }
+
+        bool Mapped() const {
+            return phys != UnmappedPa;
+        }
+
+        bool Unmapped() const {
+            return phys == UnmappedPa;
+        }
+
+        bool operator<(const VaType& p_virt) const {
+            return virt < p_virt;
+        }
+    };
+
+    /**
+     * @brief Maps a PA range into the given AS region
+     * @note block_mutex MUST be locked when calling this
+     */
+    void MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInfo extra_info);
+
+    /**
+     * @brief Unmaps the given range and merges it with other unmapped regions
+     * @note block_mutex MUST be locked when calling this
+     */
+    void UnmapLocked(VaType virt, VaType size);
+
+    std::mutex block_mutex;
+    std::vector<Block> blocks{Block{}};
+
+    /// a soft limit on the maximum VA of the AS
+    VaType va_limit{VaMaximum};
+
+private:
+    /// Callback called when the mappings in an region have changed
+    std::function<void(VaType, VaType)> unmap_callback{};
+};
+
+/**
+ * @brief FlatMemoryManager specialises FlatAddressSpaceMap to work as an allocator, with an
+ * initial, fast linear pass and a subsequent slower pass that iterates until it finds a free block
+ */
+template <typename VaType, VaType UnmappedVa, size_t AddressSpaceBits>
+requires AddressSpaceValid<VaType, AddressSpaceBits>
+class FlatAllocator
+    : public FlatAddressSpaceMap<VaType, UnmappedVa, bool, false, false, AddressSpaceBits> {
+private:
+    using Base = FlatAddressSpaceMap<VaType, UnmappedVa, bool, false, false, AddressSpaceBits>;
+
+public:
+    explicit FlatAllocator(VaType virt_start, VaType va_limit = Base::VaMaximum);
+
+    /**
+     * @brief Allocates a region in the AS of the given size and returns its address
+     */
+    VaType Allocate(VaType size);
+
+    /**
+     * @brief Marks the given region in the AS as allocated
+     */
+    void AllocateFixed(VaType virt, VaType size);
+
+    /**
+     * @brief Frees an AS region so it can be used again
+     */
+    void Free(VaType virt, VaType size);
+
+    VaType GetVAStart() const {
+        return virt_start;
+    }
+
+private:
+    /// The base VA of the allocator, no allocations will be below this
+    VaType virt_start;
+
+    /**
+     * The end address for the initial linear allocation pass
+     * Once this reaches the AS limit the slower allocation path will be used
+     */
+    VaType current_linear_alloc_end;
+};
+} // namespace Common
diff --git a/src/common/address_space.inc b/src/common/address_space.inc
new file mode 100644
index 000000000..2195dabd5
--- /dev/null
+++ b/src/common/address_space.inc
@@ -0,0 +1,366 @@
+// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "common/address_space.h"
+#include "common/assert.h"
+
+#define MAP_MEMBER(returnType)                                                                     \
+    template <typename VaType, VaType UnmappedVa, typename PaType, PaType UnmappedPa,              \
+              bool PaContigSplit, size_t AddressSpaceBits, typename ExtraBlockInfo>                \
+    requires AddressSpaceValid<VaType, AddressSpaceBits> returnType FlatAddressSpaceMap<           \
+        VaType, UnmappedVa, PaType, UnmappedPa, PaContigSplit, AddressSpaceBits, ExtraBlockInfo>
+#define MAP_MEMBER_CONST()                                                                         \
+    template <typename VaType, VaType UnmappedVa, typename PaType, PaType UnmappedPa,              \
+              bool PaContigSplit, size_t AddressSpaceBits, typename ExtraBlockInfo>                \
+    requires AddressSpaceValid<VaType, AddressSpaceBits> FlatAddressSpaceMap<                      \
+        VaType, UnmappedVa, PaType, UnmappedPa, PaContigSplit, AddressSpaceBits, ExtraBlockInfo>
+
+#define MM_MEMBER(returnType)                                                                      \
+    template <typename VaType, VaType UnmappedVa, size_t AddressSpaceBits>                         \
+    requires AddressSpaceValid<VaType, AddressSpaceBits> returnType                                \
+        FlatMemoryManager<VaType, UnmappedVa, AddressSpaceBits>
+
+#define ALLOC_MEMBER(returnType)                                                                   \
+    template <typename VaType, VaType UnmappedVa, size_t AddressSpaceBits>                         \
+    requires AddressSpaceValid<VaType, AddressSpaceBits> returnType                                \
+        FlatAllocator<VaType, UnmappedVa, AddressSpaceBits>
+#define ALLOC_MEMBER_CONST()                                                                       \
+    template <typename VaType, VaType UnmappedVa, size_t AddressSpaceBits>                         \
+    requires AddressSpaceValid<VaType, AddressSpaceBits>                                           \
+        FlatAllocator<VaType, UnmappedVa, AddressSpaceBits>
+
+namespace Common {
+MAP_MEMBER_CONST()::FlatAddressSpaceMap(VaType va_limit_,
+                                        std::function<void(VaType, VaType)> unmap_callback_)
+    : va_limit{va_limit_}, unmap_callback{std::move(unmap_callback_)} {
+    if (va_limit > VaMaximum) {
+        ASSERT_MSG(false, "Invalid VA limit!");
+    }
+}
+
+MAP_MEMBER(void)::MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInfo extra_info) {
+    VaType virt_end{virt + size};
+
+    if (virt_end > va_limit) {
+        ASSERT_MSG(false,
+                   "Trying to map a block past the VA limit: virt_end: 0x{:X}, va_limit: 0x{:X}",
+                   virt_end, va_limit);
+    }
+
+    auto block_end_successor{std::lower_bound(blocks.begin(), blocks.end(), virt_end)};
+    if (block_end_successor == blocks.begin()) {
+        ASSERT_MSG(false, "Trying to map a block before the VA start: virt_end: 0x{:X}", virt_end);
+    }
+
+    auto block_end_predecessor{std::prev(block_end_successor)};
+
+    if (block_end_successor != blocks.end()) {
+        // We have blocks in front of us, if one is directly in front then we don't have to add a
+        // tail
+        if (block_end_successor->virt != virt_end) {
+            PaType tailPhys{[&]() -> PaType {
+                if constexpr (!PaContigSplit) {
+                    // Always propagate unmapped regions rather than calculating offset
+                    return block_end_predecessor->phys;
+                } else {
+                    if (block_end_predecessor->Unmapped()) {
+                        // Always propagate unmapped regions rather than calculating offset
+                        return block_end_predecessor->phys;
+                    } else {
+                        return block_end_predecessor->phys + virt_end - block_end_predecessor->virt;
+                    }
+                }
+            }()};
+
+            if (block_end_predecessor->virt >= virt) {
+                // If this block's start would be overlapped by the map then reuse it as a tail
+                // block
+                block_end_predecessor->virt = virt_end;
+                block_end_predecessor->phys = tailPhys;
+                block_end_predecessor->extra_info = block_end_predecessor->extra_info;
+
+                // No longer predecessor anymore
+                block_end_successor = block_end_predecessor--;
+            } else {
+                // Else insert a new one and we're done
+                blocks.insert(block_end_successor,
+                              {Block(virt, phys, extra_info),
+                               Block(virt_end, tailPhys, block_end_predecessor->extra_info)});
+                if (unmap_callback) {
+                    unmap_callback(virt, size);
+                }
+
+                return;
+            }
+        }
+    } else {
+        // block_end_predecessor will always be unmapped as blocks has to be terminated by an
+        // unmapped chunk
+        if (block_end_predecessor != blocks.begin() && block_end_predecessor->virt >= virt) {
+            // Move the unmapped block start backwards
+            block_end_predecessor->virt = virt_end;
+
+            // No longer predecessor anymore
+            block_end_successor = block_end_predecessor--;
+        } else {
+            // Else insert a new one and we're done
+            blocks.insert(block_end_successor,
+                          {Block(virt, phys, extra_info), Block(virt_end, UnmappedPa, {})});
+            if (unmap_callback) {
+                unmap_callback(virt, size);
+            }
+
+            return;
+        }
+    }
+
+    auto block_start_successor{block_end_successor};
+
+    // Walk the block vector to find the start successor as this is more efficient than another
+    // binary search in most scenarios
+    while (std::prev(block_start_successor)->virt >= virt) {
+        block_start_successor--;
+    }
+
+    // Check that the start successor is either the end block or something in between
+    if (block_start_successor->virt > virt_end) {
+        ASSERT_MSG(false, "Unsorted block in AS map: virt: 0x{:X}", block_start_successor->virt);
+    } else if (block_start_successor->virt == virt_end) {
+        // We need to create a new block as there are none spare that we would overwrite
+        blocks.insert(block_start_successor, Block(virt, phys, extra_info));
+    } else {
+        // Erase overwritten blocks
+        if (auto eraseStart{std::next(block_start_successor)}; eraseStart != block_end_successor) {
+            blocks.erase(eraseStart, block_end_successor);
+        }
+
+        // Reuse a block that would otherwise be overwritten as a start block
+        block_start_successor->virt = virt;
+        block_start_successor->phys = phys;
+        block_start_successor->extra_info = extra_info;
+    }
+
+    if (unmap_callback) {
+        unmap_callback(virt, size);
+    }
+}
+
+MAP_MEMBER(void)::UnmapLocked(VaType virt, VaType size) {
+    VaType virt_end{virt + size};
+
+    if (virt_end > va_limit) {
+        ASSERT_MSG(false,
+                   "Trying to map a block past the VA limit: virt_end: 0x{:X}, va_limit: 0x{:X}",
+                   virt_end, va_limit);
+    }
+
+    auto block_end_successor{std::lower_bound(blocks.begin(), blocks.end(), virt_end)};
+    if (block_end_successor == blocks.begin()) {
+        ASSERT_MSG(false, "Trying to unmap a block before the VA start: virt_end: 0x{:X}",
+                   virt_end);
+    }
+
+    auto block_end_predecessor{std::prev(block_end_successor)};
+
+    auto walk_back_to_predecessor{[&](auto iter) {
+        while (iter->virt >= virt) {
+            iter--;
+        }
+
+        return iter;
+    }};
+
+    auto erase_blocks_with_end_unmapped{[&](auto unmappedEnd) {
+        auto block_start_predecessor{walk_back_to_predecessor(unmappedEnd)};
+        auto block_start_successor{std::next(block_start_predecessor)};
+
+        auto eraseEnd{[&]() {
+            if (block_start_predecessor->Unmapped()) {
+                // If the start predecessor is unmapped then we can erase everything in our region
+                // and be done
+                return std::next(unmappedEnd);
+            } else {
+                // Else reuse the end predecessor as the start of our unmapped region then erase all
+                // up to it
+                unmappedEnd->virt = virt;
+                return unmappedEnd;
+            }
+        }()};
+
+        // We can't have two unmapped regions after each other
+        if (eraseEnd != blocks.end() &&
+            (eraseEnd == block_start_successor ||
+             (block_start_predecessor->Unmapped() && eraseEnd->Unmapped()))) {
+            ASSERT_MSG(false, "Multiple contiguous unmapped regions are unsupported!");
+        }
+
+        blocks.erase(block_start_successor, eraseEnd);
+    }};
+
+    // We can avoid any splitting logic if these are the case
+    if (block_end_predecessor->Unmapped()) {
+        if (block_end_predecessor->virt > virt) {
+            erase_blocks_with_end_unmapped(block_end_predecessor);
+        }
+
+        if (unmap_callback) {
+            unmap_callback(virt, size);
+        }
+
+        return; // The region is unmapped, bail out early
+    } else if (block_end_successor->virt == virt_end && block_end_successor->Unmapped()) {
+        erase_blocks_with_end_unmapped(block_end_successor);
+
+        if (unmap_callback) {
+            unmap_callback(virt, size);
+        }
+
+        return; // The region is unmapped here and doesn't need splitting, bail out early
+    } else if (block_end_successor == blocks.end()) {
+        // This should never happen as the end should always follow an unmapped block
+        ASSERT_MSG(false, "Unexpected Memory Manager state!");
+    } else if (block_end_successor->virt != virt_end) {
+        // If one block is directly in front then we don't have to add a tail
+
+        // The previous block is mapped so we will need to add a tail with an offset
+        PaType tailPhys{[&]() {
+            if constexpr (PaContigSplit) {
+                return block_end_predecessor->phys + virt_end - block_end_predecessor->virt;
+            } else {
+                return block_end_predecessor->phys;
+            }
+        }()};
+
+        if (block_end_predecessor->virt >= virt) {
+            // If this block's start would be overlapped by the unmap then reuse it as a tail block
+            block_end_predecessor->virt = virt_end;
+            block_end_predecessor->phys = tailPhys;
+
+            // No longer predecessor anymore
+            block_end_successor = block_end_predecessor--;
+        } else {
+            blocks.insert(block_end_successor,
+                          {Block(virt, UnmappedPa, {}),
+                           Block(virt_end, tailPhys, block_end_predecessor->extra_info)});
+            if (unmap_callback) {
+                unmap_callback(virt, size);
+            }
+
+            // The previous block is mapped and ends before
+            return;
+        }
+    }
+
+    // Walk the block vector to find the start predecessor as this is more efficient than another
+    // binary search in most scenarios
+    auto block_start_predecessor{walk_back_to_predecessor(block_end_successor)};
+    auto block_start_successor{std::next(block_start_predecessor)};
+
+    if (block_start_successor->virt > virt_end) {
+        ASSERT_MSG(false, "Unsorted block in AS map: virt: 0x{:X}", block_start_successor->virt);
+    } else if (block_start_successor->virt == virt_end) {
+        // There are no blocks between the start and the end that would let us skip inserting a new
+        // one for head
+
+        // The previous block is may be unmapped, if so we don't need to insert any unmaps after it
+        if (block_start_predecessor->Mapped()) {
+            blocks.insert(block_start_successor, Block(virt, UnmappedPa, {}));
+        }
+    } else if (block_start_predecessor->Unmapped()) {
+        // If the previous block is unmapped
+        blocks.erase(block_start_successor, block_end_predecessor);
+    } else {
+        // Erase overwritten blocks, skipping the first one as we have written the unmapped start
+        // block there
+        if (auto eraseStart{std::next(block_start_successor)}; eraseStart != block_end_successor) {
+            blocks.erase(eraseStart, block_end_successor);
+        }
+
+        // Add in the unmapped block header
+        block_start_successor->virt = virt;
+        block_start_successor->phys = UnmappedPa;
+    }
+
+    if (unmap_callback)
+        unmap_callback(virt, size);
+}
+
+ALLOC_MEMBER_CONST()::FlatAllocator(VaType virt_start_, VaType va_limit_)
+    : Base{va_limit_}, virt_start{virt_start_}, current_linear_alloc_end{virt_start_} {}
+
+ALLOC_MEMBER(VaType)::Allocate(VaType size) {
+    std::scoped_lock lock(this->block_mutex);
+
+    VaType alloc_start{UnmappedVa};
+    VaType alloc_end{current_linear_alloc_end + size};
+
+    // Avoid searching backwards in the address space if possible
+    if (alloc_end >= current_linear_alloc_end && alloc_end <= this->va_limit) {
+        auto alloc_end_successor{
+            std::lower_bound(this->blocks.begin(), this->blocks.end(), alloc_end)};
+        if (alloc_end_successor == this->blocks.begin()) {
+            ASSERT_MSG(false, "First block in AS map is invalid!");
+        }
+
+        auto alloc_end_predecessor{std::prev(alloc_end_successor)};
+        if (alloc_end_predecessor->virt <= current_linear_alloc_end) {
+            alloc_start = current_linear_alloc_end;
+        } else {
+            // Skip over fixed any mappings in front of us
+            while (alloc_end_successor != this->blocks.end()) {
+                if (alloc_end_successor->virt - alloc_end_predecessor->virt < size ||
+                    alloc_end_predecessor->Mapped()) {
+                    alloc_start = alloc_end_predecessor->virt;
+                    break;
+                }
+
+                alloc_end_predecessor = alloc_end_successor++;
+
+                // Use the VA limit to calculate if we can fit in the final block since it has no
+                // successor
+                if (alloc_end_successor == this->blocks.end()) {
+                    alloc_end = alloc_end_predecessor->virt + size;
+
+                    if (alloc_end >= alloc_end_predecessor->virt && alloc_end <= this->va_limit) {
+                        alloc_start = alloc_end_predecessor->virt;
+                    }
+                }
+            }
+        }
+    }
+
+    if (alloc_start != UnmappedVa) {
+        current_linear_alloc_end = alloc_start + size;
+    } else { // If linear allocation overflows the AS then find a gap
+        if (this->blocks.size() <= 2) {
+            ASSERT_MSG(false, "Unexpected allocator state!");
+        }
+
+        auto search_predecessor{this->blocks.begin()};
+        auto search_successor{std::next(search_predecessor)};
+
+        while (search_successor != this->blocks.end() &&
+               (search_successor->virt - search_predecessor->virt < size ||
+                search_predecessor->Mapped())) {
+            search_predecessor = search_successor++;
+        }
+
+        if (search_successor != this->blocks.end()) {
+            alloc_start = search_predecessor->virt;
+        } else {
+            return {}; // AS is full
+        }
+    }
+
+    this->MapLocked(alloc_start, true, size, {});
+    return alloc_start;
+}
+
+ALLOC_MEMBER(void)::AllocateFixed(VaType virt, VaType size) {
+    this->Map(virt, true, size);
+}
+
+ALLOC_MEMBER(void)::Free(VaType virt, VaType size) {
+    this->Unmap(virt, size);
+}
+} // namespace Common
diff --git a/src/common/algorithm.h b/src/common/algorithm.h
index 9ddfd637b..c27c9241d 100644
--- a/src/common/algorithm.h
+++ b/src/common/algorithm.h
@@ -24,4 +24,12 @@ template <class ForwardIt, class T, class Compare = std::less<>>
     return first != last && !comp(value, *first) ? first : last;
 }
 
+template <typename T, typename Func, typename... Args>
+T FoldRight(T initial_value, Func&& func, Args&&... args) {
+    T value{initial_value};
+    const auto high_func = [&value, &func]<typename U>(U x) { value = func(value, x); };
+    (std::invoke(high_func, std::forward<Args>(args)), ...);
+    return value;
+}
+
 } // namespace Common
diff --git a/src/common/bit_field.h b/src/common/bit_field.h
index 7e1df62b1..e4e58ea45 100644
--- a/src/common/bit_field.h
+++ b/src/common/bit_field.h
@@ -141,10 +141,6 @@ public:
     constexpr BitField(BitField&&) noexcept = default;
     constexpr BitField& operator=(BitField&&) noexcept = default;
 
-    [[nodiscard]] constexpr operator T() const {
-        return Value();
-    }
-
     constexpr void Assign(const T& value) {
 #ifdef _MSC_VER
         storage = static_cast<StorageType>((storage & ~mask) | FormatValue(value));
@@ -162,6 +158,17 @@ public:
         return ExtractValue(storage);
     }
 
+    template <typename ConvertedToType>
+    [[nodiscard]] constexpr ConvertedToType As() const {
+        static_assert(!std::is_same_v<T, ConvertedToType>,
+                      "Unnecessary cast. Use Value() instead.");
+        return static_cast<ConvertedToType>(Value());
+    }
+
+    [[nodiscard]] constexpr operator T() const {
+        return Value();
+    }
+
     [[nodiscard]] constexpr explicit operator bool() const {
         return Value() != 0;
     }
diff --git a/src/common/bounded_threadsafe_queue.h b/src/common/bounded_threadsafe_queue.h
index 7e465549b..21217801e 100644
--- a/src/common/bounded_threadsafe_queue.h
+++ b/src/common/bounded_threadsafe_queue.h
@@ -21,11 +21,6 @@ constexpr size_t hardware_interference_size = std::hardware_destructive_interfer
 constexpr size_t hardware_interference_size = 64;
 #endif
 
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4324)
-#endif
-
 template <typename T, size_t capacity = 0x400>
 class MPSCQueue {
 public:
@@ -160,8 +155,4 @@ private:
     static_assert(std::is_nothrow_destructible_v<T>, "T must be nothrow destructible");
 };
 
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
 } // namespace Common
diff --git a/src/common/concepts.h b/src/common/concepts.h
index a97555f6a..e8ce30dfe 100644
--- a/src/common/concepts.h
+++ b/src/common/concepts.h
@@ -34,4 +34,12 @@ concept DerivedFrom = requires {
 template <typename From, typename To>
 concept ConvertibleTo = std::is_convertible_v<From, To>;
 
+// No equivalents in the stdlib
+
+template <typename T>
+concept IsArithmetic = std::is_arithmetic_v<T>;
+
+template <typename T>
+concept IsIntegral = std::is_integral_v<T>;
+
 } // namespace Common
diff --git a/src/common/fixed_point.h b/src/common/fixed_point.h
index 4a0f72cc9..f899b0d54 100644
--- a/src/common/fixed_point.h
+++ b/src/common/fixed_point.h
@@ -4,14 +4,7 @@
 // From: https://github.com/eteran/cpp-utilities/blob/master/fixed/include/cpp-utilities/fixed.h
 // See also: http://stackoverflow.com/questions/79677/whats-the-best-way-to-do-fixed-point-math
 
-#ifndef FIXED_H_
-#define FIXED_H_
-
-#if __cplusplus >= 201402L
-#define CONSTEXPR14 constexpr
-#else
-#define CONSTEXPR14
-#endif
+#pragma once
 
 #include <cstddef> // for size_t
 #include <cstdint>
@@ -19,6 +12,8 @@
 #include <ostream>
 #include <type_traits>
 
+#include <common/concepts.h>
+
 namespace Common {
 
 template <size_t I, size_t F>
@@ -57,8 +52,8 @@ struct type_from_size<64> {
     static constexpr size_t size = 64;
 
     using value_type = int64_t;
-    using unsigned_type = std::make_unsigned<value_type>::type;
-    using signed_type = std::make_signed<value_type>::type;
+    using unsigned_type = std::make_unsigned_t<value_type>;
+    using signed_type = std::make_signed_t<value_type>;
     using next_size = type_from_size<128>;
 };
 
@@ -68,8 +63,8 @@ struct type_from_size<32> {
     static constexpr size_t size = 32;
 
     using value_type = int32_t;
-    using unsigned_type = std::make_unsigned<value_type>::type;
-    using signed_type = std::make_signed<value_type>::type;
+    using unsigned_type = std::make_unsigned_t<value_type>;
+    using signed_type = std::make_signed_t<value_type>;
     using next_size = type_from_size<64>;
 };
 
@@ -79,8 +74,8 @@ struct type_from_size<16> {
     static constexpr size_t size = 16;
 
     using value_type = int16_t;
-    using unsigned_type = std::make_unsigned<value_type>::type;
-    using signed_type = std::make_signed<value_type>::type;
+    using unsigned_type = std::make_unsigned_t<value_type>;
+    using signed_type = std::make_signed_t<value_type>;
     using next_size = type_from_size<32>;
 };
 
@@ -90,8 +85,8 @@ struct type_from_size<8> {
     static constexpr size_t size = 8;
 
     using value_type = int8_t;
-    using unsigned_type = std::make_unsigned<value_type>::type;
-    using signed_type = std::make_signed<value_type>::type;
+    using unsigned_type = std::make_unsigned_t<value_type>;
+    using signed_type = std::make_signed_t<value_type>;
     using next_size = type_from_size<16>;
 };
 
@@ -106,9 +101,9 @@ constexpr B next_to_base(N rhs) {
 struct divide_by_zero : std::exception {};
 
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> divide(
+constexpr FixedPoint<I, F> divide(
     FixedPoint<I, F> numerator, FixedPoint<I, F> denominator, FixedPoint<I, F>& remainder,
-    typename std::enable_if<type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
+    std::enable_if_t<type_from_size<I + F>::next_size::is_specialized>* = nullptr) {
 
     using next_type = typename FixedPoint<I, F>::next_type;
     using base_type = typename FixedPoint<I, F>::base_type;
@@ -126,9 +121,9 @@ CONSTEXPR14 FixedPoint<I, F> divide(
 }
 
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> divide(
+constexpr FixedPoint<I, F> divide(
     FixedPoint<I, F> numerator, FixedPoint<I, F> denominator, FixedPoint<I, F>& remainder,
-    typename std::enable_if<!type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
+    std::enable_if_t<!type_from_size<I + F>::next_size::is_specialized>* = nullptr) {
 
     using unsigned_type = typename FixedPoint<I, F>::unsigned_type;
 
@@ -196,9 +191,9 @@ CONSTEXPR14 FixedPoint<I, F> divide(
 
 // this is the usual implementation of multiplication
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> multiply(
+constexpr FixedPoint<I, F> multiply(
     FixedPoint<I, F> lhs, FixedPoint<I, F> rhs,
-    typename std::enable_if<type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
+    std::enable_if_t<type_from_size<I + F>::next_size::is_specialized>* = nullptr) {
 
     using next_type = typename FixedPoint<I, F>::next_type;
     using base_type = typename FixedPoint<I, F>::base_type;
@@ -215,9 +210,9 @@ CONSTEXPR14 FixedPoint<I, F> multiply(
 // it is slightly slower, but is more robust since it doesn't
 // require and upgraded type
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> multiply(
+constexpr FixedPoint<I, F> multiply(
     FixedPoint<I, F> lhs, FixedPoint<I, F> rhs,
-    typename std::enable_if<!type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
+    std::enable_if_t<!type_from_size<I + F>::next_size::is_specialized>* = nullptr) {
 
     using base_type = typename FixedPoint<I, F>::base_type;
 
@@ -272,19 +267,20 @@ public:
     static constexpr base_type one = base_type(1) << fractional_bits;
 
 public: // constructors
-    FixedPoint() = default;
-    FixedPoint(const FixedPoint&) = default;
-    FixedPoint(FixedPoint&&) = default;
-    FixedPoint& operator=(const FixedPoint&) = default;
+    constexpr FixedPoint() = default;
+
+    constexpr FixedPoint(const FixedPoint&) = default;
+    constexpr FixedPoint& operator=(const FixedPoint&) = default;
+
+    constexpr FixedPoint(FixedPoint&&) noexcept = default;
+    constexpr FixedPoint& operator=(FixedPoint&&) noexcept = default;
 
-    template <class Number>
-    constexpr FixedPoint(
-        Number n, typename std::enable_if<std::is_arithmetic<Number>::value>::type* = nullptr)
-        : data_(static_cast<base_type>(n * one)) {}
+    template <IsArithmetic Number>
+    constexpr FixedPoint(Number n) : data_(static_cast<base_type>(n * one)) {}
 
 public: // conversion
     template <size_t I2, size_t F2>
-    CONSTEXPR14 explicit FixedPoint(FixedPoint<I2, F2> other) {
+    constexpr explicit FixedPoint(FixedPoint<I2, F2> other) {
         static_assert(I2 <= I && F2 <= F, "Scaling conversion can only upgrade types");
         using T = FixedPoint<I2, F2>;
 
@@ -308,36 +304,14 @@ public:
     }
 
 public: // comparison operators
-    constexpr bool operator==(FixedPoint rhs) const {
-        return data_ == rhs.data_;
-    }
-
-    constexpr bool operator!=(FixedPoint rhs) const {
-        return data_ != rhs.data_;
-    }
-
-    constexpr bool operator<(FixedPoint rhs) const {
-        return data_ < rhs.data_;
-    }
-
-    constexpr bool operator>(FixedPoint rhs) const {
-        return data_ > rhs.data_;
-    }
-
-    constexpr bool operator<=(FixedPoint rhs) const {
-        return data_ <= rhs.data_;
-    }
-
-    constexpr bool operator>=(FixedPoint rhs) const {
-        return data_ >= rhs.data_;
-    }
+    friend constexpr auto operator<=>(FixedPoint lhs, FixedPoint rhs) = default;
 
 public: // unary operators
-    constexpr bool operator!() const {
+    [[nodiscard]] constexpr bool operator!() const {
         return !data_;
     }
 
-    constexpr FixedPoint operator~() const {
+    [[nodiscard]] constexpr FixedPoint operator~() const {
         // NOTE(eteran): this will often appear to "just negate" the value
         // that is not an error, it is because -x == (~x+1)
         // and that "+1" is adding an infinitesimally small fraction to the
@@ -345,89 +319,87 @@ public: // unary operators
         return FixedPoint::from_base(~data_);
     }
 
-    constexpr FixedPoint operator-() const {
+    [[nodiscard]] constexpr FixedPoint operator-() const {
         return FixedPoint::from_base(-data_);
     }
 
-    constexpr FixedPoint operator+() const {
+    [[nodiscard]] constexpr FixedPoint operator+() const {
         return FixedPoint::from_base(+data_);
     }
 
-    CONSTEXPR14 FixedPoint& operator++() {
+    constexpr FixedPoint& operator++() {
         data_ += one;
         return *this;
     }
 
-    CONSTEXPR14 FixedPoint& operator--() {
+    constexpr FixedPoint& operator--() {
         data_ -= one;
         return *this;
     }
 
-    CONSTEXPR14 FixedPoint operator++(int) {
+    constexpr FixedPoint operator++(int) {
         FixedPoint tmp(*this);
         data_ += one;
         return tmp;
     }
 
-    CONSTEXPR14 FixedPoint operator--(int) {
+    constexpr FixedPoint operator--(int) {
         FixedPoint tmp(*this);
         data_ -= one;
         return tmp;
     }
 
 public: // basic math operators
-    CONSTEXPR14 FixedPoint& operator+=(FixedPoint n) {
+    constexpr FixedPoint& operator+=(FixedPoint n) {
         data_ += n.data_;
         return *this;
     }
 
-    CONSTEXPR14 FixedPoint& operator-=(FixedPoint n) {
+    constexpr FixedPoint& operator-=(FixedPoint n) {
         data_ -= n.data_;
         return *this;
     }
 
-    CONSTEXPR14 FixedPoint& operator*=(FixedPoint n) {
+    constexpr FixedPoint& operator*=(FixedPoint n) {
         return assign(detail::multiply(*this, n));
     }
 
-    CONSTEXPR14 FixedPoint& operator/=(FixedPoint n) {
+    constexpr FixedPoint& operator/=(FixedPoint n) {
         FixedPoint temp;
         return assign(detail::divide(*this, n, temp));
     }
 
 private:
-    CONSTEXPR14 FixedPoint& assign(FixedPoint rhs) {
+    constexpr FixedPoint& assign(FixedPoint rhs) {
         data_ = rhs.data_;
         return *this;
     }
 
 public: // binary math operators, effects underlying bit pattern since these
         // don't really typically make sense for non-integer values
-    CONSTEXPR14 FixedPoint& operator&=(FixedPoint n) {
+    constexpr FixedPoint& operator&=(FixedPoint n) {
         data_ &= n.data_;
         return *this;
     }
 
-    CONSTEXPR14 FixedPoint& operator|=(FixedPoint n) {
+    constexpr FixedPoint& operator|=(FixedPoint n) {
         data_ |= n.data_;
         return *this;
     }
 
-    CONSTEXPR14 FixedPoint& operator^=(FixedPoint n) {
+    constexpr FixedPoint& operator^=(FixedPoint n) {
         data_ ^= n.data_;
         return *this;
     }
 
-    template <class Integer,
-              class = typename std::enable_if<std::is_integral<Integer>::value>::type>
-    CONSTEXPR14 FixedPoint& operator>>=(Integer n) {
+    template <IsIntegral Integer>
+    constexpr FixedPoint& operator>>=(Integer n) {
         data_ >>= n;
         return *this;
     }
 
-    template <class Integer,
-              class = typename std::enable_if<std::is_integral<Integer>::value>::type>
-    CONSTEXPR14 FixedPoint& operator<<=(Integer n) {
+    template <IsIntegral Integer>
+    constexpr FixedPoint& operator<<=(Integer n) {
         data_ <<= n;
         return *this;
     }
@@ -437,42 +409,42 @@ public: // conversion to basic types
         data_ += (data_ & fractional_mask) >> 1;
     }
 
-    constexpr int to_int() {
+    [[nodiscard]] constexpr int to_int() {
         round_up();
         return static_cast<int>((data_ & integer_mask) >> fractional_bits);
     }
 
-    constexpr unsigned int to_uint() const {
+    [[nodiscard]] constexpr unsigned int to_uint() {
         round_up();
         return static_cast<unsigned int>((data_ & integer_mask) >> fractional_bits);
     }
 
-    constexpr int64_t to_long() {
+    [[nodiscard]] constexpr int64_t to_long() {
         round_up();
         return static_cast<int64_t>((data_ & integer_mask) >> fractional_bits);
     }
 
-    constexpr int to_int_floor() const {
+    [[nodiscard]] constexpr int to_int_floor() const {
         return static_cast<int>((data_ & integer_mask) >> fractional_bits);
     }
 
-    constexpr int64_t to_long_floor() {
+    [[nodiscard]] constexpr int64_t to_long_floor() const {
         return static_cast<int64_t>((data_ & integer_mask) >> fractional_bits);
     }
 
-    constexpr unsigned int to_uint_floor() const {
+    [[nodiscard]] constexpr unsigned int to_uint_floor() const {
         return static_cast<unsigned int>((data_ & integer_mask) >> fractional_bits);
     }
 
-    constexpr float to_float() const {
+    [[nodiscard]] constexpr float to_float() const {
         return static_cast<float>(data_) / FixedPoint::one;
     }
 
-    constexpr double to_double() const {
+    [[nodiscard]] constexpr double to_double() const {
         return static_cast<double>(data_) / FixedPoint::one;
     }
 
-    constexpr base_type to_raw() const {
+    [[nodiscard]] constexpr base_type to_raw() const {
         return data_;
     }
 
@@ -480,27 +452,27 @@ public: // conversion to basic types
         data_ &= fractional_mask;
     }
 
-    constexpr base_type get_frac() const {
+    [[nodiscard]] constexpr base_type get_frac() const {
         return data_ & fractional_mask;
     }
 
 public:
-    CONSTEXPR14 void swap(FixedPoint& rhs) {
+    constexpr void swap(FixedPoint& rhs) noexcept {
         using std::swap;
         swap(data_, rhs.data_);
     }
 
 public:
-    base_type data_;
+    base_type data_{};
 };
 
 // if we have the same fractional portion, but differing integer portions, we trivially upgrade the
 // smaller type
 template <size_t I1, size_t I2, size_t F>
-CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
-operator+(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator+(
+    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 
-    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
+    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;
 
     const T l = T::from_base(lhs.to_raw());
     const T r = T::from_base(rhs.to_raw());
@@ -508,10 +480,10 @@ operator+(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 }
 
 template <size_t I1, size_t I2, size_t F>
-CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
-operator-(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator-(
+    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 
-    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
+    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;
 
     const T l = T::from_base(lhs.to_raw());
     const T r = T::from_base(rhs.to_raw());
@@ -519,10 +491,10 @@ operator-(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 }
 
 template <size_t I1, size_t I2, size_t F>
-CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
-operator*(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator*(
+    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 
-    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
+    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;
 
     const T l = T::from_base(lhs.to_raw());
     const T r = T::from_base(rhs.to_raw());
@@ -530,10 +502,10 @@ operator*(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 }
 
 template <size_t I1, size_t I2, size_t F>
-CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
-operator/(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator/(
+    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 
-    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
+    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;
 
     const T l = T::from_base(lhs.to_raw());
     const T r = T::from_base(rhs.to_raw());
@@ -548,159 +520,133 @@ std::ostream& operator<<(std::ostream& os, FixedPoint<I, F> f) {
 
 // basic math operators
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+constexpr FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
     lhs += rhs;
     return lhs;
 }
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+constexpr FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
     lhs -= rhs;
     return lhs;
 }
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+constexpr FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
     lhs *= rhs;
     return lhs;
 }
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+constexpr FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
     lhs /= rhs;
     return lhs;
 }
 
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, Number rhs) {
     lhs += FixedPoint<I, F>(rhs);
     return lhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, Number rhs) {
     lhs -= FixedPoint<I, F>(rhs);
     return lhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, Number rhs) {
     lhs *= FixedPoint<I, F>(rhs);
     return lhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, Number rhs) {
     lhs /= FixedPoint<I, F>(rhs);
     return lhs;
 }
 
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator+(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator+(Number lhs, FixedPoint<I, F> rhs) {
     FixedPoint<I, F> tmp(lhs);
     tmp += rhs;
     return tmp;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator-(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator-(Number lhs, FixedPoint<I, F> rhs) {
     FixedPoint<I, F> tmp(lhs);
     tmp -= rhs;
     return tmp;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator*(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator*(Number lhs, FixedPoint<I, F> rhs) {
     FixedPoint<I, F> tmp(lhs);
     tmp *= rhs;
     return tmp;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator/(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator/(Number lhs, FixedPoint<I, F> rhs) {
     FixedPoint<I, F> tmp(lhs);
     tmp /= rhs;
     return tmp;
 }
 
 // shift operators
-template <size_t I, size_t F, class Integer,
-          class = typename std::enable_if<std::is_integral<Integer>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator<<(FixedPoint<I, F> lhs, Integer rhs) {
+template <size_t I, size_t F, IsIntegral Integer>
+constexpr FixedPoint<I, F> operator<<(FixedPoint<I, F> lhs, Integer rhs) {
     lhs <<= rhs;
     return lhs;
 }
-template <size_t I, size_t F, class Integer,
-          class = typename std::enable_if<std::is_integral<Integer>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator>>(FixedPoint<I, F> lhs, Integer rhs) {
+template <size_t I, size_t F, IsIntegral Integer>
+constexpr FixedPoint<I, F> operator>>(FixedPoint<I, F> lhs, Integer rhs) {
     lhs >>= rhs;
     return lhs;
 }
 
 // comparison operators
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator>(FixedPoint<I, F> lhs, Number rhs) {
     return lhs > FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator<(FixedPoint<I, F> lhs, Number rhs) {
     return lhs < FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator>=(FixedPoint<I, F> lhs, Number rhs) {
     return lhs >= FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator<=(FixedPoint<I, F> lhs, Number rhs) {
     return lhs <= FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator==(FixedPoint<I, F> lhs, Number rhs) {
     return lhs == FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator!=(FixedPoint<I, F> lhs, Number rhs) {
     return lhs != FixedPoint<I, F>(rhs);
 }
 
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator>(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) > rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator<(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) < rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator>=(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) >= rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator<=(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) <= rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator==(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) == rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator!=(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) != rhs;
 }
 
 } // namespace Common
-
-#undef CONSTEXPR14
-
-#endif
diff --git a/src/common/hash.h b/src/common/hash.h
index b6f3e6d6f..e8fe78b07 100644
--- a/src/common/hash.h
+++ b/src/common/hash.h
@@ -18,4 +18,11 @@ struct PairHash {
     }
 };
 
+template <typename T>
+struct IdentityHash {
+    [[nodiscard]] size_t operator()(T value) const noexcept {
+        return static_cast<size_t>(value);
+    }
+};
+
 } // namespace Common
diff --git a/src/common/input.h b/src/common/input.h
index 825b0d650..b533f3844 100644
--- a/src/common/input.h
+++ b/src/common/input.h
@@ -76,6 +76,19 @@ enum class PollingError {
     Unknown,
 };
 
+// Nfc reply from the controller
+enum class NfcState {
+    Success,
+    NewAmiibo,
+    WaitingForAmiibo,
+    AmiiboRemoved,
+    NotAnAmiibo,
+    NotSupported,
+    WrongDeviceState,
+    WriteFailed,
+    Unknown,
+};
+
 // Ir camera reply from the controller
 enum class CameraError {
     None,
@@ -202,6 +215,11 @@ struct CameraStatus {
     std::vector<u8> data{};
 };
 
+struct NfcStatus {
+    NfcState state{};
+    std::vector<u8> data{};
+};
+
 // List of buttons to be passed to Qt that can be translated
 enum class ButtonNames {
     Undefined,
@@ -259,7 +277,9 @@ struct CallbackStatus {
     BodyColorStatus color_status{};
     BatteryStatus battery_status{};
     VibrationStatus vibration_status{};
-    CameraStatus camera_status{};
+    CameraFormat camera_status{CameraFormat::None};
+    NfcState nfc_status{NfcState::Unknown};
+    std::vector<u8> raw_data{};
 };
 
 // Triggered once every input change
@@ -312,6 +332,14 @@ public:
     virtual CameraError SetCameraFormat([[maybe_unused]] CameraFormat camera_format) {
         return CameraError::NotSupported;
     }
+
+    virtual NfcState SupportsNfc() const {
+        return NfcState::NotSupported;
+    }
+
+    virtual NfcState WriteNfcData([[maybe_unused]] const std::vector<u8>& data) {
+        return NfcState::NotSupported;
+    }
 };
 
 /// An abstract class template for a factory that can create input devices.
diff --git a/src/common/logging/backend.cpp b/src/common/logging/backend.cpp
index 8ce1c2fd1..15d92505e 100644
--- a/src/common/logging/backend.cpp
+++ b/src/common/logging/backend.cpp
@@ -219,7 +219,7 @@ private:
 
     void StartBackendThread() {
         backend_thread = std::jthread([this](std::stop_token stop_token) {
-            Common::SetCurrentThreadName("yuzu:Log");
+            Common::SetCurrentThreadName("Logger");
             Entry entry;
             const auto write_logs = [this, &entry]() {
                 ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
diff --git a/src/common/multi_level_page_table.cpp b/src/common/multi_level_page_table.cpp
new file mode 100644
index 000000000..46e362f3b
--- /dev/null
+++ b/src/common/multi_level_page_table.cpp
@@ -0,0 +1,9 @@
+// SPDX-FileCopyrightText: 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/multi_level_page_table.inc"
+
+namespace Common {
+template class Common::MultiLevelPageTable<u64>;
+template class Common::MultiLevelPageTable<u32>;
+} // namespace Common
diff --git a/src/common/multi_level_page_table.h b/src/common/multi_level_page_table.h
new file mode 100644
index 000000000..31f6676a0
--- /dev/null
+++ b/src/common/multi_level_page_table.h
@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "common/common_types.h"
+
+namespace Common {
+
+template <typename BaseAddr>
+class MultiLevelPageTable final {
+public:
+    constexpr MultiLevelPageTable() = default;
+    explicit MultiLevelPageTable(std::size_t address_space_bits, std::size_t first_level_bits,
+                                 std::size_t page_bits);
+
+    ~MultiLevelPageTable() noexcept;
+
+    MultiLevelPageTable(const MultiLevelPageTable&) = delete;
+    MultiLevelPageTable& operator=(const MultiLevelPageTable&) = delete;
+
+    MultiLevelPageTable(MultiLevelPageTable&& other) noexcept
+        : address_space_bits{std::exchange(other.address_space_bits, 0)},
+          first_level_bits{std::exchange(other.first_level_bits, 0)}, page_bits{std::exchange(
+                                                                          other.page_bits, 0)},
+          first_level_shift{std::exchange(other.first_level_shift, 0)},
+          first_level_chunk_size{std::exchange(other.first_level_chunk_size, 0)},
+          first_level_map{std::move(other.first_level_map)}, base_ptr{std::exchange(other.base_ptr,
+                                                                                    nullptr)} {}
+
+    MultiLevelPageTable& operator=(MultiLevelPageTable&& other) noexcept {
+        address_space_bits = std::exchange(other.address_space_bits, 0);
+        first_level_bits = std::exchange(other.first_level_bits, 0);
+        page_bits = std::exchange(other.page_bits, 0);
+        first_level_shift = std::exchange(other.first_level_shift, 0);
+        first_level_chunk_size = std::exchange(other.first_level_chunk_size, 0);
+        alloc_size = std::exchange(other.alloc_size, 0);
+        first_level_map = std::move(other.first_level_map);
+        base_ptr = std::exchange(other.base_ptr, nullptr);
+        return *this;
+    }
+
+    void ReserveRange(u64 start, std::size_t size);
+
+    [[nodiscard]] const BaseAddr& operator[](std::size_t index) const {
+        return base_ptr[index];
+    }
+
+    [[nodiscard]] BaseAddr& operator[](std::size_t index) {
+        return base_ptr[index];
+    }
+
+    [[nodiscard]] BaseAddr* data() {
+        return base_ptr;
+    }
+
+    [[nodiscard]] const BaseAddr* data() const {
+        return base_ptr;
+    }
+
+private:
+    void AllocateLevel(u64 level);
+
+    std::size_t address_space_bits{};
+    std::size_t first_level_bits{};
+    std::size_t page_bits{};
+    std::size_t first_level_shift{};
+    std::size_t first_level_chunk_size{};
+    std::size_t alloc_size{};
+    std::vector<void*> first_level_map{};
+    BaseAddr* base_ptr{};
+};
+
+} // namespace Common
diff --git a/src/common/multi_level_page_table.inc b/src/common/multi_level_page_table.inc
new file mode 100644
index 000000000..8ac506fa0
--- /dev/null
+++ b/src/common/multi_level_page_table.inc
@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/mman.h>
+#endif
+
+#include "common/assert.h"
+#include "common/multi_level_page_table.h"
+
+namespace Common {
+
+template <typename BaseAddr>
+MultiLevelPageTable<BaseAddr>::MultiLevelPageTable(std::size_t address_space_bits_,
+                                                   std::size_t first_level_bits_,
+                                                   std::size_t page_bits_)
+    : address_space_bits{address_space_bits_},
+      first_level_bits{first_level_bits_}, page_bits{page_bits_} {
+    if (page_bits == 0) {
+      return;
+    }
+    first_level_shift = address_space_bits - first_level_bits;
+    first_level_chunk_size = (1ULL << (first_level_shift - page_bits)) * sizeof(BaseAddr);
+    alloc_size = (1ULL << (address_space_bits - page_bits)) * sizeof(BaseAddr);
+    std::size_t first_level_size = 1ULL << first_level_bits;
+    first_level_map.resize(first_level_size, nullptr);
+#ifdef _WIN32
+    void* base{VirtualAlloc(nullptr, alloc_size, MEM_RESERVE, PAGE_READWRITE)};
+#else
+    void* base{mmap(nullptr, alloc_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)};
+
+    if (base == MAP_FAILED) {
+        base = nullptr;
+    }
+#endif
+
+    ASSERT(base);
+    base_ptr = reinterpret_cast<BaseAddr*>(base);
+}
+
+template <typename BaseAddr>
+MultiLevelPageTable<BaseAddr>::~MultiLevelPageTable() noexcept {
+    if (!base_ptr) {
+        return;
+    }
+#ifdef _WIN32
+    ASSERT(VirtualFree(base_ptr, 0, MEM_RELEASE));
+#else
+    ASSERT(munmap(base_ptr, alloc_size) == 0);
+#endif
+}
+
+template <typename BaseAddr>
+void MultiLevelPageTable<BaseAddr>::ReserveRange(u64 start, std::size_t size) {
+    const u64 new_start = start >> first_level_shift;
+    const u64 new_end = (start + size) >> first_level_shift;
+    for (u64 i = new_start; i <= new_end; i++) {
+        if (!first_level_map[i]) {
+            AllocateLevel(i);
+        }
+    }
+}
+
+template <typename BaseAddr>
+void MultiLevelPageTable<BaseAddr>::AllocateLevel(u64 level) {
+    void* ptr = reinterpret_cast<char *>(base_ptr) + level * first_level_chunk_size;
+#ifdef _WIN32
+    void* base{VirtualAlloc(ptr, first_level_chunk_size, MEM_COMMIT, PAGE_READWRITE)};
+#else
+    void* base{mmap(ptr, first_level_chunk_size, PROT_READ | PROT_WRITE,
+                    MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)};
+
+    if (base == MAP_FAILED) {
+        base = nullptr;
+    }
+#endif
+    ASSERT(base);
+
+    first_level_map[level] = base;
+}
+
+} // namespace Common
diff --git a/src/common/settings.h b/src/common/settings.h
index 13651de57..0eb98939c 100644
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -431,7 +431,7 @@ struct Values {
         FullscreenMode::Exclusive,
 #endif
         FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
-    SwitchableSetting<int, true> aspect_ratio{0, 0, 3, "aspect_ratio"};
+    SwitchableSetting<int, true> aspect_ratio{0, 0, 4, "aspect_ratio"};
     SwitchableSetting<int, true> max_anisotropy{0, 0, 5, "max_anisotropy"};
     SwitchableSetting<bool> use_speed_limit{true, "use_speed_limit"};
     SwitchableSetting<u16, true> speed_limit{100, 0, 9999, "speed_limit"};
@@ -530,6 +530,8 @@ struct Values {
     Setting<bool> use_debug_asserts{false, "use_debug_asserts"};
     Setting<bool> use_auto_stub{false, "use_auto_stub"};
     Setting<bool> enable_all_controllers{false, "enable_all_controllers"};
+    Setting<bool> create_crash_dumps{false, "create_crash_dumps"};
+    Setting<bool> perform_vulkan_check{true, "perform_vulkan_check"};
 
     // Miscellaneous
     Setting<std::string> log_filter{"*:Info", "log_filter"};
diff --git a/src/common/thread.h b/src/common/thread.h
index 1552f58e0..e17a7850f 100644
--- a/src/common/thread.h
+++ b/src/common/thread.h
@@ -54,6 +54,10 @@ public:
         is_set = false;
     }
 
+    [[nodiscard]] bool IsSet() {
+        return is_set;
+    }
+
 private:
     std::condition_variable condvar;
     std::mutex mutex;