Remove C++ standard flag

2020-02-27 16:48:12 +01:00
386 changed files with 12563 additions and 19817 deletions
--- a/.ci/templates/build-msvc.yml
+++ b/.ci/templates/build-msvc.yml
@@ -4,7 +4,7 @@ parameters:
  version: ''

 steps:
- script: mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
+- script: mkdir build && cd build && cmake -G "Visual Studio 15 2017 Win64" --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
  displayName: 'Configure CMake'
 - task: MSBuild@1
  displayName: 'Build'
--- a/.ci/yuzu-mainline-step2.yml
+++ b/.ci/yuzu-mainline-step2.yml
@@ -45,7 +45,7 @@ stages:
  - job: build
    displayName: 'msvc'
    pool:
-      vmImage: windows-2019
+      vmImage: vs2017-win2016
    steps:
    - template: ./templates/sync-source.yml
      parameters:
--- a/.ci/yuzu-patreon-step2.yml
+++ b/.ci/yuzu-patreon-step2.yml
@@ -22,7 +22,7 @@ stages:
  - job: build
    displayName: 'windows-msvc'
    pool:
-      vmImage: windows-2019
+      vmImage: vs2017-win2016
    steps:
    - template: ./templates/sync-source.yml
      parameters:
--- a/CMakeModules/CopyYuzuQt5Deps.cmake
+++ b/CMakeModules/CopyYuzuQt5Deps.cmake
@@ -6,9 +6,9 @@ function(copy_yuzu_Qt5_deps target_dir)
    set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
    set(Qt5_IMAGEFORMATS_DIR "${Qt5_DIR}/../../../plugins/imageformats/")
    set(Qt5_RESOURCES_DIR "${Qt5_DIR}/../../../resources/")
-    set(PLATFORMS ${DLL_DEST}plugins/platforms/)
-    set(STYLES ${DLL_DEST}plugins/styles/)
-    set(IMAGEFORMATS ${DLL_DEST}plugins/imageformats/)
+    set(PLATFORMS ${DLL_DEST}platforms/)
+    set(STYLES ${DLL_DEST}styles/)
+    set(IMAGEFORMATS ${DLL_DEST}imageformats/)
    windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
        icudt*.dll
        icuin*.dll
@@ -42,15 +42,11 @@ function(copy_yuzu_Qt5_deps target_dir)
            icudtl.dat
        )
    endif ()
+
    windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
    windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
    windows_copy_files(yuzu ${Qt5_IMAGEFORMATS_DIR} ${IMAGEFORMATS}
        qjpeg$<$<CONFIG:Debug>:d>.*
        qgif$<$<CONFIG:Debug>:d>.*
        )
-    # Create an empty qt.conf file. Qt will detect that this file exists, and use the folder that its in as the root folder.
-    # This way it'll look for plugins in the root/plugins/ folder
-    add_custom_command(TARGET yuzu POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E touch ${DLL_DEST}qt.conf
-    )
 endfunction(copy_yuzu_Qt5_deps)
--- a/CMakeModules/GenerateSCMRev.cmake
+++ b/CMakeModules/GenerateSCMRev.cmake
@@ -57,6 +57,8 @@ set(HASH_FILES
    "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.h"
    "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.cpp"
    "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.h"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.h"
    "${VIDEO_CORE}/shader/decode/arithmetic.cpp"
    "${VIDEO_CORE}/shader/decode/arithmetic_half.cpp"
    "${VIDEO_CORE}/shader/decode/arithmetic_half_immediate.cpp"
@@ -89,6 +91,8 @@ set(HASH_FILES
    "${VIDEO_CORE}/shader/ast.h"
    "${VIDEO_CORE}/shader/compiler_settings.cpp"
    "${VIDEO_CORE}/shader/compiler_settings.h"
+    "${VIDEO_CORE}/shader/const_buffer_locker.cpp"
+    "${VIDEO_CORE}/shader/const_buffer_locker.h"
    "${VIDEO_CORE}/shader/control_flow.cpp"
    "${VIDEO_CORE}/shader/control_flow.h"
    "${VIDEO_CORE}/shader/decode.cpp"
@@ -97,13 +101,9 @@ set(HASH_FILES
    "${VIDEO_CORE}/shader/node.h"
    "${VIDEO_CORE}/shader/node_helper.cpp"
    "${VIDEO_CORE}/shader/node_helper.h"
-    "${VIDEO_CORE}/shader/registry.cpp"
-    "${VIDEO_CORE}/shader/registry.h"
    "${VIDEO_CORE}/shader/shader_ir.cpp"
    "${VIDEO_CORE}/shader/shader_ir.h"
    "${VIDEO_CORE}/shader/track.cpp"
-    "${VIDEO_CORE}/shader/transform_feedback.cpp"
-    "${VIDEO_CORE}/shader/transform_feedback.h"
 )
 set(COMBINED "")
 foreach (F IN LISTS HASH_FILES)
--- a/README.md
+++ b/README.md
@@ -1,8 +1,7 @@
 yuzu emulator
 =============
-[![Travis CI Build Status](https://travis-ci.com/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.com/yuzu-emu/yuzu)
+[![Travis CI Build Status](https://travis-ci.org/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.org/yuzu-emu/yuzu)
 [![Azure Mainline CI Build Status](https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master)](https://dev.azure.com/yuzu-emu/yuzu/)
-[![Discord](https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white)](https://discord.gg/XQV6dn9)

 yuzu is an experimental open-source emulator for the Nintendo Switch from the creators of [Citra](https://citra-emu.org/).

@@ -22,7 +21,7 @@ For development discussion, please join us on [Discord](https://discord.gg/XQV6d

 Most of the development happens on GitHub. It's also where [our central repository](https://github.com/yuzu-emu/yuzu) is hosted.

-If you want to contribute please take a look at the [Contributor's Guide](https://github.com/yuzu-emu/yuzu/wiki/Contributing) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information). You should also contact any of the developers on Discord in order to know about the current state of the emulator.
+If you want to contribute please take a look at the [Contributor's Guide](CONTRIBUTING.md) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information). You should as well contact any of the developers on Discord in order to know about the current state of the emulator.

 ### Building

--- a/dist/license.md
+++ b/dist/license.md
@@ -2,8 +2,8 @@ The icons in this folder and its subfolders have the following licenses:

 Icon Name | License | Origin/Author
 --- | --- | ---
-qt_themes/default/icons/16x16/checked.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/default/icons/16x16/failed.png | CC BY-ND 3.0 | https://icons8.com
+qt_themes/default/icons/16x16/checked.png | Free for non-commercial use
+qt_themes/default/icons/16x16/failed.png | Free for non-commercial use
 qt_themes/default/icons/16x16/lock.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/default/icons/256x256/plus_folder.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/default/icons/48x48/bad_folder.png | CC BY-ND 3.0 | https://icons8.com
@@ -11,6 +11,8 @@ qt_themes/default/icons/48x48/chip.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/default/icons/48x48/folder.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/default/icons/48x48/plus.png | CC0 1.0 | Designed by BreadFish64 from the Citra team
 qt_themes/default/icons/48x48/sd_card.png | CC BY-ND 3.0 | https://icons8.com
+qt_themes/qdarkstyle/icons/16x16/checked.png | Free for non-commercial use
+qt_themes/qdarkstyle/icons/16x16/failed.png | Free for non-commercial use
 qt_themes/qdarkstyle/icons/16x16/lock.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/qdarkstyle/icons/256x256/plus_folder.png | CC BY-ND 3.0 | https://icons8.com
 qt_themes/qdarkstyle/icons/48x48/bad_folder.png | CC BY-ND 3.0 | https://icons8.com
--- a/dist/qt_themes/default/icons/16x16/checked.png
+++ b/dist/qt_themes/default/icons/16x16/checked.png
--- a/dist/qt_themes/default/icons/16x16/failed.png
+++ b/dist/qt_themes/default/icons/16x16/failed.png
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@@ -3,27 +3,13 @@
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/CMakeModules)
 include(DownloadExternals)

-# pkgconfig -- it is used to find shared libraries without cmake modules on linux systems
-find_package(PkgConfig)
-if (NOT PkgConfig_FOUND)
-    function(pkg_check_modules)
-        # STUB
-    endfunction()
-endif()
-
 # Catch
 add_library(catch-single-include INTERFACE)
 target_include_directories(catch-single-include INTERFACE catch/single_include)

 # libfmt
-pkg_check_modules(FMT IMPORTED_TARGET GLOBAL fmt>=6.1.0)
-if (FMT_FOUND)
-    add_library(fmt::fmt ALIAS PkgConfig::FMT)
-else()
-    message(STATUS "fmt 6.1.0 or newer not found, falling back to externals")
-    add_subdirectory(fmt)
-    add_library(fmt::fmt ALIAS fmt)
-endif()
+add_subdirectory(fmt)
+add_library(fmt::fmt ALIAS fmt)

 # Dynarmic
 if (ARCHITECTURE_x86_64)
@@ -44,15 +30,9 @@ add_subdirectory(glad)
 add_subdirectory(inih)

 # lz4
-pkg_check_modules(LIBLZ4 IMPORTED_TARGET GLOBAL liblz4>=1.8.0)
-if (LIBLZ4_FOUND)
-    add_library(lz4_static ALIAS PkgConfig::LIBLZ4)
-else()
-    message(STATUS "liblz4 1.8.0 or newer not found, falling back to externals")
-    set(LZ4_BUNDLED_MODE ON)
-    add_subdirectory(lz4/contrib/cmake_unofficial EXCLUDE_FROM_ALL)
-    target_include_directories(lz4_static INTERFACE ./lz4/lib)
-endif()
+set(LZ4_BUNDLED_MODE ON)
+add_subdirectory(lz4/contrib/cmake_unofficial EXCLUDE_FROM_ALL)
+target_include_directories(lz4_static INTERFACE ./lz4/lib)

 # mbedtls
 add_subdirectory(mbedtls EXCLUDE_FROM_ALL)
@@ -67,27 +47,15 @@ add_library(unicorn-headers INTERFACE)
 target_include_directories(unicorn-headers INTERFACE ./unicorn/include)

 # Zstandard
-pkg_check_modules(LIBZSTD IMPORTED_TARGET GLOBAL libzstd>=1.3.8)
-if (LIBZSTD_FOUND)
-    add_library(libzstd_static ALIAS PkgConfig::LIBZSTD)
-else()
-    message(STATUS "libzstd 1.3.8 or newer not found, falling back to externals")
-    add_subdirectory(zstd/build/cmake EXCLUDE_FROM_ALL)
-    target_include_directories(libzstd_static INTERFACE ./zstd/lib)
-endif()
+add_subdirectory(zstd/build/cmake EXCLUDE_FROM_ALL)
+target_include_directories(libzstd_static INTERFACE ./zstd/lib)

 # SoundTouch
 add_subdirectory(soundtouch)

 # Opus
-pkg_check_modules(OPUS IMPORTED_TARGET GLOBAL opus>=1.3.1)
-if (OPUS_FOUND)
-    add_library(opus ALIAS PkgConfig::OPUS)
-else()
-    message(STATUS "opus 1.3.1 or newer not found, falling back to externals")
-    add_subdirectory(opus)
-    target_include_directories(opus INTERFACE ./opus/include)
-endif()
+add_subdirectory(opus)
+target_include_directories(opus INTERFACE ./opus/include)

 # Cubeb
 if(ENABLE_CUBEB)
@@ -107,35 +75,18 @@ if (ENABLE_VULKAN)
 endif()

 # zlib
-find_package(ZLIB 1.2.11)
-if (NOT ZLIB_FOUND)
-    message(STATUS "zlib 1.2.11 or newer not found, falling back to externals")
-    add_subdirectory(zlib EXCLUDE_FROM_ALL)
-    set(ZLIB_LIBRARIES z)
-endif()
+add_subdirectory(zlib EXCLUDE_FROM_ALL)
+set(ZLIB_LIBRARIES z)

 # libzip
-pkg_check_modules(LIBZIP IMPORTED_TARGET GLOBAL libzip>=1.5.3)
-if (LIBZIP_FOUND)
-    add_library(zip ALIAS PkgConfig::LIBZIP)
-else()
-    message(STATUS "libzip 1.5.3 or newer not found, falling back to externals")
-    add_subdirectory(libzip EXCLUDE_FROM_ALL)
-endif()
+add_subdirectory(libzip EXCLUDE_FROM_ALL)

 if (ENABLE_WEB_SERVICE)
    # LibreSSL
-    find_package(OpenSSL COMPONENTS Crypto SSL)
-    if (NOT OpenSSL_FOUND)
-        message(STATUS "OpenSSL not found, falling back to externals")
-        set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
-        add_subdirectory(libressl EXCLUDE_FROM_ALL)
-        target_include_directories(ssl INTERFACE ./libressl/include)
-        target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
-        get_directory_property(OPENSSL_LIBRARIES
-            DIRECTORY libressl
-            DEFINITION OPENSSL_LIBS)
-    endif()
+    set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
+    add_subdirectory(libressl EXCLUDE_FROM_ALL)
+    target_include_directories(ssl INTERFACE ./libressl/include)
+	target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)

    # lurlparser
    add_subdirectory(lurlparser EXCLUDE_FROM_ALL)
@@ -143,8 +94,6 @@ if (ENABLE_WEB_SERVICE)
    # httplib
    add_library(httplib INTERFACE)
    target_include_directories(httplib INTERFACE ./httplib)
-    target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
-    target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})

    # JSON
    add_library(json-headers INTERFACE)
--- a/externals/Vulkan-Headers
+++ b/externals/Vulkan-Headers
--- a/externals/dynarmic
+++ b/externals/dynarmic
--- a/externals/microprofile/microprofile.h
+++ b/externals/microprofile/microprofile.h
@@ -243,7 +243,6 @@ typedef uint32_t ThreadIdType;
 #define MICROPROFILE_DEFINE_GPU(var, name, color) MicroProfileToken g_mp_##var = MicroProfileGetToken("GPU", name, color, MicroProfileTokenTypeGpu)
 #define MICROPROFILE_TOKEN_PASTE0(a, b) a ## b
 #define MICROPROFILE_TOKEN_PASTE(a, b)  MICROPROFILE_TOKEN_PASTE0(a,b)
-#define MICROPROFILE_TOKEN(var) g_mp_##var
 #define MICROPROFILE_SCOPE(var) MicroProfileScopeHandler MICROPROFILE_TOKEN_PASTE(foo, __LINE__)(g_mp_##var)
 #define MICROPROFILE_SCOPE_TOKEN(token) MicroProfileScopeHandler MICROPROFILE_TOKEN_PASTE(foo, __LINE__)(token)
 #define MICROPROFILE_SCOPEI(group, name, color) static MicroProfileToken MICROPROFILE_TOKEN_PASTE(g_mp,__LINE__) = MicroProfileGetToken(group, name, color, MicroProfileTokenTypeCpu); MicroProfileScopeHandler MICROPROFILE_TOKEN_PASTE(foo,__LINE__)( MICROPROFILE_TOKEN_PASTE(g_mp,__LINE__))
@@ -828,7 +827,7 @@ inline MicroProfileLogEntry MicroProfileMakeLogIndex(uint64_t nBegin, MicroProfi
    MicroProfileLogEntry Entry =  (nBegin<<62) | ((0x3fff&nToken)<<48) | (MP_LOG_TICK_MASK&nTick);
    int t = MicroProfileLogType(Entry);
    uint64_t nTimerIndex = MicroProfileLogTimerIndex(Entry);
-    MP_ASSERT((uint64_t)t == nBegin);
+    MP_ASSERT(t == nBegin);
    MP_ASSERT(nTimerIndex == (nToken&0x3fff));
    return Entry;

@@ -1556,10 +1555,10 @@ void MicroProfileFlip()

        pFramePut->nFrameStartCpu = MP_TICK();
        pFramePut->nFrameStartGpu = (uint32_t)MicroProfileGpuInsertTimeStamp();
-        if(pFrameNext->nFrameStartGpu != -1)
+        if(pFrameNext->nFrameStartGpu != (uint64_t)-1)
            pFrameNext->nFrameStartGpu = MicroProfileGpuGetTimeStamp((uint32_t)pFrameNext->nFrameStartGpu);

-        if(pFrameCurrent->nFrameStartGpu == -1)
+        if(pFrameCurrent->nFrameStartGpu == (uint64_t)-1)
            pFrameCurrent->nFrameStartGpu = pFrameNext->nFrameStartGpu + 1;

        uint64_t nFrameStartCpu = pFrameCurrent->nFrameStartCpu;
--- a/license.txt
+++ b/license.txt
@@ -343,8 +343,8 @@ The icons used in this project have the following licenses:

 Icon Name                                   | License       | Origin/Author
 ---                                         | ---           | ---
-checked.png                                 | CC BY-ND 3.0  | https://icons8.com
-failed.png                                  | CC BY-ND 3.0  | https://icons8.com
+checked.png                                 | Free for non-commercial use
+failed.png                                  | Free for non-commercial use
 lock.png                                    | CC BY-ND 3.0  | https://icons8.com
 plus_folder.png (Default, Dark)             | CC BY-ND 3.0  | https://icons8.com
 bad_folder.png (Default, Dark)              | CC BY-ND 3.0  | https://icons8.com
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -38,7 +38,6 @@ if (MSVC)
        /Zo
        /permissive-
        /EHsc
-        /std:c++latest
        /volatile:iso
        /Zc:externConstexpr
        /Zc:inline
@@ -53,11 +52,7 @@ if (MSVC)
 else()
    add_compile_options(
        -Wall
-        -Werror=implicit-fallthrough
-        -Werror=reorder
-        -Wextra
        -Wno-attributes
-        -Wno-unused-parameter
    )

    if (APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL Clang)
--- a/src/audio_core/algorithm/interpolate.cpp
+++ b/src/audio_core/algorithm/interpolate.cpp
@@ -8,14 +8,13 @@
 #include <climits>
 #include <cmath>
 #include <vector>
-
 #include "audio_core/algorithm/interpolate.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"

 namespace AudioCore {

-constexpr std::array<s16, 512> curve_lut0{
+constexpr std::array<s16, 512> curve_lut0 = {
    6600,  19426, 6722,  3,     6479,  19424, 6845,  9,     6359,  19419, 6968,  15,    6239,
    19412, 7093,  22,    6121,  19403, 7219,  28,    6004,  19391, 7345,  34,    5888,  19377,
    7472,  41,    5773,  19361, 7600,  48,    5659,  19342, 7728,  55,    5546,  19321, 7857,
@@ -57,7 +56,7 @@ constexpr std::array<s16, 512> curve_lut0{
    19403, 6121,  22,    7093,  19412, 6239,  15,    6968,  19419, 6359,  9,     6845,  19424,
    6479,  3,     6722,  19426, 6600};

-constexpr std::array<s16, 512> curve_lut1{
+constexpr std::array<s16, 512> curve_lut1 = {
    -68,   32639, 69,    -5,    -200,  32630, 212,   -15,   -328,  32613, 359,   -26,   -450,
    32586, 512,   -36,   -568,  32551, 669,   -47,   -680,  32507, 832,   -58,   -788,  32454,
    1000,  -69,   -891,  32393, 1174,  -80,   -990,  32323, 1352,  -92,   -1084, 32244, 1536,
@@ -99,7 +98,7 @@ constexpr std::array<s16, 512> curve_lut1{
    32551, -568,  -36,   512,   32586, -450,  -26,   359,   32613, -328,  -15,   212,   32630,
    -200,  -5,    69,    32639, -68};

-constexpr std::array<s16, 512> curve_lut2{
+constexpr std::array<s16, 512> curve_lut2 = {
    3195,  26287, 3329,  -32,   3064,  26281, 3467,  -34,   2936,  26270, 3608,  -38,   2811,
    26253, 3751,  -42,   2688,  26230, 3897,  -46,   2568,  26202, 4046,  -50,   2451,  26169,
    4199,  -54,   2338,  26130, 4354,  -58,   2227,  26085, 4512,  -63,   2120,  26035, 4673,
@@ -147,10 +146,10 @@ std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,

    if (ratio <= 0) {
        LOG_CRITICAL(Audio, "Nonsensical interpolation ratio {}", ratio);
-        return input;
+        ratio = 1.0;
    }

-    const s32 step{static_cast<s32>(ratio * 0x8000)};
+    const int step = static_cast<int>(ratio * 0x8000);
    const std::array<s16, 512>& lut = [step] {
        if (step > 0xaaaa) {
            return curve_lut0;
@@ -161,37 +160,28 @@ std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,
        return curve_lut2;
    }();

-    const std::size_t num_frames{input.size() / 2};
+    std::vector<s16> output(static_cast<std::size_t>(input.size() / ratio));
+    int in_offset = 0;
+    for (std::size_t out_offset = 0; out_offset < output.size(); out_offset += 2) {
+        const int lut_index = (state.fraction >> 8) * 4;

-    std::vector<s16> output;
-    output.reserve(static_cast<std::size_t>(input.size() / ratio + InterpolationState::taps));
+        const int l = input[(in_offset + 0) * 2 + 0] * lut[lut_index + 0] +
+                      input[(in_offset + 1) * 2 + 0] * lut[lut_index + 1] +
+                      input[(in_offset + 2) * 2 + 0] * lut[lut_index + 2] +
+                      input[(in_offset + 3) * 2 + 0] * lut[lut_index + 3];

-    for (std::size_t frame{}; frame < num_frames; ++frame) {
-        const std::size_t lut_index{(state.fraction >> 8) * InterpolationState::taps};
+        const int r = input[(in_offset + 0) * 2 + 1] * lut[lut_index + 0] +
+                      input[(in_offset + 1) * 2 + 1] * lut[lut_index + 1] +
+                      input[(in_offset + 2) * 2 + 1] * lut[lut_index + 2] +
+                      input[(in_offset + 3) * 2 + 1] * lut[lut_index + 3];

-        std::rotate(state.history.begin(), state.history.end() - 1, state.history.end());
-        state.history[0][0] = input[frame * 2 + 0];
-        state.history[0][1] = input[frame * 2 + 1];
+        const int new_offset = state.fraction + step;

-        while (state.position <= 1.0) {
-            const s32 left{state.history[0][0] * lut[lut_index + 0] +
-                           state.history[1][0] * lut[lut_index + 1] +
-                           state.history[2][0] * lut[lut_index + 2] +
-                           state.history[3][0] * lut[lut_index + 3]};
-            const s32 right{state.history[0][1] * lut[lut_index + 0] +
-                            state.history[1][1] * lut[lut_index + 1] +
-                            state.history[2][1] * lut[lut_index + 2] +
-                            state.history[3][1] * lut[lut_index + 3]};
-            const s32 new_offset{state.fraction + step};
+        in_offset += new_offset >> 15;
+        state.fraction = new_offset & 0x7fff;

-            state.fraction = new_offset & 0x7fff;
-
-            output.emplace_back(static_cast<s16>(std::clamp(left >> 15, SHRT_MIN, SHRT_MAX)));
-            output.emplace_back(static_cast<s16>(std::clamp(right >> 15, SHRT_MIN, SHRT_MAX)));
-
-            state.position += ratio;
-        }
-        state.position -= 1.0;
+        output[out_offset + 0] = static_cast<s16>(std::clamp(l >> 15, SHRT_MIN, SHRT_MAX));
+        output[out_offset + 1] = static_cast<s16>(std::clamp(r >> 15, SHRT_MIN, SHRT_MAX));
    }

    return output;
--- a/src/audio_core/algorithm/interpolate.h
+++ b/src/audio_core/algorithm/interpolate.h
@@ -6,17 +6,12 @@

 #include <array>
 #include <vector>
-
 #include "common/common_types.h"

 namespace AudioCore {

 struct InterpolationState {
-    static constexpr std::size_t taps{4};
-    static constexpr std::size_t history_size{taps * 2 - 1};
-    std::array<std::array<s16, 2>, history_size> history{};
-    double position{};
-    s32 fraction{};
+    int fraction = 0;
 };

 /// Interpolates input signal to produce output signal.
--- a/src/audio_core/audio_renderer.cpp
+++ b/src/audio_core/audio_renderer.cpp
@@ -36,9 +36,9 @@ public:
    }

    void SetWaveIndex(std::size_t index);
-    std::vector<s16> DequeueSamples(std::size_t sample_count, Core::Memory::Memory& memory);
+    std::vector<s16> DequeueSamples(std::size_t sample_count, Memory::Memory& memory);
    void UpdateState();
-    void RefreshBuffer(Core::Memory::Memory& memory);
+    void RefreshBuffer(Memory::Memory& memory);

 private:
    bool is_in_use{};
@@ -66,14 +66,13 @@ public:
        return info;
    }

-    void UpdateState(Core::Memory::Memory& memory);
+    void UpdateState(Memory::Memory& memory);

 private:
    EffectOutStatus out_status{};
    EffectInStatus info{};
 };
-
-AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory::Memory& memory_,
+AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Memory::Memory& memory_,
                             AudioRendererParameter params,
                             std::shared_ptr<Kernel::WritableEvent> buffer_event,
                             std::size_t instance_number)
@@ -209,7 +208,7 @@ void AudioRenderer::VoiceState::SetWaveIndex(std::size_t index) {
 }

 std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(std::size_t sample_count,
-                                                           Core::Memory::Memory& memory) {
+                                                           Memory::Memory& memory) {
    if (!IsPlaying()) {
        return {};
    }
@@ -259,7 +258,7 @@ void AudioRenderer::VoiceState::UpdateState() {
    is_in_use = info.is_in_use;
 }

-void AudioRenderer::VoiceState::RefreshBuffer(Core::Memory::Memory& memory) {
+void AudioRenderer::VoiceState::RefreshBuffer(Memory::Memory& memory) {
    const auto wave_buffer_address = info.wave_buffer[wave_index].buffer_addr;
    const auto wave_buffer_size = info.wave_buffer[wave_index].buffer_sz;
    std::vector<s16> new_samples(wave_buffer_size / sizeof(s16));
@@ -311,7 +310,7 @@ void AudioRenderer::VoiceState::RefreshBuffer(Core::Memory::Memory& memory) {
    is_refresh_pending = false;
 }

-void AudioRenderer::EffectState::UpdateState(Core::Memory::Memory& memory) {
+void AudioRenderer::EffectState::UpdateState(Memory::Memory& memory) {
    if (info.is_new) {
        out_status.state = EffectStatus::New;
    } else {
--- a/src/audio_core/audio_renderer.h
+++ b/src/audio_core/audio_renderer.h
@@ -22,7 +22,7 @@ namespace Kernel {
 class WritableEvent;
 }

-namespace Core::Memory {
+namespace Memory {
 class Memory;
 }

@@ -189,7 +189,7 @@ struct UpdateDataHeader {
    UpdateDataHeader() {}

    explicit UpdateDataHeader(const AudioRendererParameter& config) {
-        revision = Common::MakeMagic('R', 'E', 'V', '8'); // 9.2.0 Revision
+        revision = Common::MakeMagic('R', 'E', 'V', '4'); // 5.1.0 Revision
        behavior_size = 0xb0;
        memory_pools_size = (config.effect_count + (config.voice_count * 4)) * 0x10;
        voices_size = config.voice_count * 0x10;
@@ -221,7 +221,7 @@ static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size

 class AudioRenderer {
 public:
-    AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory::Memory& memory_,
+    AudioRenderer(Core::Timing::CoreTiming& core_timing, Memory::Memory& memory_,
                  AudioRendererParameter params,
                  std::shared_ptr<Kernel::WritableEvent> buffer_event, std::size_t instance_number);
    ~AudioRenderer();
@@ -244,7 +244,7 @@ private:
    std::vector<EffectState> effects;
    std::unique_ptr<AudioOut> audio_out;
    StreamPtr stream;
-    Core::Memory::Memory& memory;
+    Memory::Memory& memory;
 };

 } // namespace AudioCore
--- a/src/audio_core/cubeb_sink.cpp
+++ b/src/audio_core/cubeb_sink.cpp
@@ -8,7 +8,6 @@
 #include "audio_core/cubeb_sink.h"
 #include "audio_core/stream.h"
 #include "audio_core/time_stretch.h"
-#include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/ring_buffer.h"
 #include "core/settings.h"
@@ -66,25 +65,12 @@ public:
    void EnqueueSamples(u32 source_num_channels, const std::vector<s16>& samples) override {
        if (source_num_channels > num_channels) {
            // Downsample 6 channels to 2
-            ASSERT_MSG(source_num_channels == 6, "Channel count must be 6");
-
            std::vector<s16> buf;
            buf.reserve(samples.size() * num_channels / source_num_channels);
            for (std::size_t i = 0; i < samples.size(); i += source_num_channels) {
-                // Downmixing implementation taken from the ATSC standard
-                const s16 left{samples[i + 0]};
-                const s16 right{samples[i + 1]};
-                const s16 center{samples[i + 2]};
-                const s16 surround_left{samples[i + 4]};
-                const s16 surround_right{samples[i + 5]};
-                // Not used in the ATSC reference implementation
-                [[maybe_unused]] const s16 low_frequency_effects { samples[i + 3] };
-
-                constexpr s32 clev{707}; // center mixing level coefficient
-                constexpr s32 slev{707}; // surround mixing level coefficient
-
-                buf.push_back(left + (clev * center / 1000) + (slev * surround_left / 1000));
-                buf.push_back(right + (clev * center / 1000) + (slev * surround_right / 1000));
+                for (std::size_t ch = 0; ch < num_channels; ch++) {
+                    buf.push_back(samples[i + ch]);
+                }
            }
            queue.Push(buf);
            return;
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -38,6 +38,8 @@ add_custom_command(OUTPUT scm_rev.cpp
      "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.h"
      "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.cpp"
      "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.h"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.h"
      "${VIDEO_CORE}/shader/decode/arithmetic.cpp"
      "${VIDEO_CORE}/shader/decode/arithmetic_half.cpp"
      "${VIDEO_CORE}/shader/decode/arithmetic_half_immediate.cpp"
@@ -70,6 +72,8 @@ add_custom_command(OUTPUT scm_rev.cpp
      "${VIDEO_CORE}/shader/ast.h"
      "${VIDEO_CORE}/shader/compiler_settings.cpp"
      "${VIDEO_CORE}/shader/compiler_settings.h"
+      "${VIDEO_CORE}/shader/const_buffer_locker.cpp"
+      "${VIDEO_CORE}/shader/const_buffer_locker.h"
      "${VIDEO_CORE}/shader/control_flow.cpp"
      "${VIDEO_CORE}/shader/control_flow.h"
      "${VIDEO_CORE}/shader/decode.cpp"
@@ -78,13 +82,9 @@ add_custom_command(OUTPUT scm_rev.cpp
      "${VIDEO_CORE}/shader/node.h"
      "${VIDEO_CORE}/shader/node_helper.cpp"
      "${VIDEO_CORE}/shader/node_helper.h"
-      "${VIDEO_CORE}/shader/registry.cpp"
-      "${VIDEO_CORE}/shader/registry.h"
      "${VIDEO_CORE}/shader/shader_ir.cpp"
      "${VIDEO_CORE}/shader/shader_ir.h"
      "${VIDEO_CORE}/shader/track.cpp"
-      "${VIDEO_CORE}/shader/transform_feedback.cpp"
-      "${VIDEO_CORE}/shader/transform_feedback.h"
      # and also check that the scm_rev files haven't changed
      "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in"
      "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.h"
@@ -106,8 +106,6 @@ add_library(common STATIC
    common_funcs.h
    common_paths.h
    common_types.h
-    dynamic_library.cpp
-    dynamic_library.h
    file_util.cpp
    file_util.h
    hash.h
@@ -155,8 +153,6 @@ add_library(common STATIC
    uuid.cpp
    uuid.h
    vector_math.h
-    virtual_buffer.cpp
-    virtual_buffer.h
    web_result.h
    zstd_compression.cpp
    zstd_compression.h
--- a/src/common/alignment.h
+++ b/src/common/alignment.h
@@ -38,13 +38,6 @@ constexpr bool IsWordAligned(T value) {
    return (value & 0b11) == 0;
 }

-template <typename T>
-constexpr bool IsAligned(T value, std::size_t alignment) {
-    using U = typename std::make_unsigned<T>::type;
-    const U mask = static_cast<U>(alignment - 1);
-    return (value & mask) == 0;
-}
-
 template <typename T, std::size_t Align = 16>
 class AlignmentAllocator {
 public:
--- a/src/common/common_funcs.h
+++ b/src/common/common_funcs.h
@@ -55,38 +55,6 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
 // Defined in Misc.cpp.
 std::string GetLastErrorMsg();

-#define DECLARE_ENUM_FLAG_OPERATORS(type)                                                          \
-    constexpr type operator|(type a, type b) noexcept {                                            \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<type>(static_cast<T>(a) | static_cast<T>(b));                           \
-    }                                                                                              \
-    constexpr type operator&(type a, type b) noexcept {                                            \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<type>(static_cast<T>(a) & static_cast<T>(b));                           \
-    }                                                                                              \
-    constexpr type& operator|=(type& a, type b) noexcept {                                         \
-        using T = std::underlying_type_t<type>;                                                    \
-        a = static_cast<type>(static_cast<T>(a) | static_cast<T>(b));                              \
-        return a;                                                                                  \
-    }                                                                                              \
-    constexpr type& operator&=(type& a, type b) noexcept {                                         \
-        using T = std::underlying_type_t<type>;                                                    \
-        a = static_cast<type>(static_cast<T>(a) & static_cast<T>(b));                              \
-        return a;                                                                                  \
-    }                                                                                              \
-    constexpr type operator~(type key) noexcept {                                                  \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<type>(~static_cast<T>(key));                                            \
-    }                                                                                              \
-    constexpr bool True(type key) noexcept {                                                       \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<T>(key) != 0;                                                           \
-    }                                                                                              \
-    constexpr bool False(type key) noexcept {                                                      \
-        using T = std::underlying_type_t<type>;                                                    \
-        return static_cast<T>(key) == 0;                                                           \
-    }
-
 namespace Common {

 constexpr u32 MakeMagic(char a, char b, char c, char d) {
--- a/src/common/dynamic_library.cpp
+++ b/src/common/dynamic_library.cpp
@@ -1,106 +0,0 @@
-// Copyright 2019 Dolphin Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include <string>
-#include <utility>
-
-#include <fmt/format.h>
-
-#include "common/dynamic_library.h"
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <dlfcn.h>
-#endif
-
-namespace Common {
-
-DynamicLibrary::DynamicLibrary() = default;
-
-DynamicLibrary::DynamicLibrary(const char* filename) {
-    Open(filename);
-}
-
-DynamicLibrary::DynamicLibrary(DynamicLibrary&& rhs) noexcept
-    : handle{std::exchange(rhs.handle, nullptr)} {}
-
-DynamicLibrary& DynamicLibrary::operator=(DynamicLibrary&& rhs) noexcept {
-    Close();
-    handle = std::exchange(rhs.handle, nullptr);
-    return *this;
-}
-
-DynamicLibrary::~DynamicLibrary() {
-    Close();
-}
-
-std::string DynamicLibrary::GetUnprefixedFilename(const char* filename) {
-#if defined(_WIN32)
-    return std::string(filename) + ".dll";
-#elif defined(__APPLE__)
-    return std::string(filename) + ".dylib";
-#else
-    return std::string(filename) + ".so";
-#endif
-}
-
-std::string DynamicLibrary::GetVersionedFilename(const char* libname, int major, int minor) {
-#if defined(_WIN32)
-    if (major >= 0 && minor >= 0)
-        return fmt::format("{}-{}-{}.dll", libname, major, minor);
-    else if (major >= 0)
-        return fmt::format("{}-{}.dll", libname, major);
-    else
-        return fmt::format("{}.dll", libname);
-#elif defined(__APPLE__)
-    const char* prefix = std::strncmp(libname, "lib", 3) ? "lib" : "";
-    if (major >= 0 && minor >= 0)
-        return fmt::format("{}{}.{}.{}.dylib", prefix, libname, major, minor);
-    else if (major >= 0)
-        return fmt::format("{}{}.{}.dylib", prefix, libname, major);
-    else
-        return fmt::format("{}{}.dylib", prefix, libname);
-#else
-    const char* prefix = std::strncmp(libname, "lib", 3) ? "lib" : "";
-    if (major >= 0 && minor >= 0)
-        return fmt::format("{}{}.so.{}.{}", prefix, libname, major, minor);
-    else if (major >= 0)
-        return fmt::format("{}{}.so.{}", prefix, libname, major);
-    else
-        return fmt::format("{}{}.so", prefix, libname);
-#endif
-}
-
-bool DynamicLibrary::Open(const char* filename) {
-#ifdef _WIN32
-    handle = reinterpret_cast<void*>(LoadLibraryA(filename));
-#else
-    handle = dlopen(filename, RTLD_NOW);
-#endif
-    return handle != nullptr;
-}
-
-void DynamicLibrary::Close() {
-    if (!IsOpen())
-        return;
-
-#ifdef _WIN32
-    FreeLibrary(reinterpret_cast<HMODULE>(handle));
-#else
-    dlclose(handle);
-#endif
-    handle = nullptr;
-}
-
-void* DynamicLibrary::GetSymbolAddress(const char* name) const {
-#ifdef _WIN32
-    return reinterpret_cast<void*>(GetProcAddress(reinterpret_cast<HMODULE>(handle), name));
-#else
-    return reinterpret_cast<void*>(dlsym(handle, name));
-#endif
-}
-
-} // namespace Common
--- a/src/common/dynamic_library.h
+++ b/src/common/dynamic_library.h
@@ -1,75 +0,0 @@
-// Copyright 2019 Dolphin Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-
-namespace Common {
-
-/**
- * Provides a platform-independent interface for loading a dynamic library and retrieving symbols.
- * The interface maintains an internal reference count to allow one handle to be shared between
- * multiple users.
- */
-class DynamicLibrary final {
-public:
-    /// Default constructor, does not load a library.
-    explicit DynamicLibrary();
-
-    /// Automatically loads the specified library. Call IsOpen() to check validity before use.
-    explicit DynamicLibrary(const char* filename);
-
-    /// Moves the library.
-    DynamicLibrary(DynamicLibrary&&) noexcept;
-    DynamicLibrary& operator=(DynamicLibrary&&) noexcept;
-
-    /// Delete copies, we can't copy a dynamic library.
-    DynamicLibrary(const DynamicLibrary&) = delete;
-    DynamicLibrary& operator=(const DynamicLibrary&) = delete;
-
-    /// Closes the library.
-    ~DynamicLibrary();
-
-    /// Returns the specified library name with the platform-specific suffix added.
-    static std::string GetUnprefixedFilename(const char* filename);
-
-    /// Returns the specified library name in platform-specific format.
-    /// Major/minor versions will not be included if set to -1.
-    /// If libname already contains the "lib" prefix, it will not be added again.
-    /// Windows: LIBNAME-MAJOR-MINOR.dll
-    /// Linux: libLIBNAME.so.MAJOR.MINOR
-    /// Mac: libLIBNAME.MAJOR.MINOR.dylib
-    static std::string GetVersionedFilename(const char* libname, int major = -1, int minor = -1);
-
-    /// Returns true if a module is loaded, otherwise false.
-    bool IsOpen() const {
-        return handle != nullptr;
-    }
-
-    /// Loads (or replaces) the handle with the specified library file name.
-    /// Returns true if the library was loaded and can be used.
-    bool Open(const char* filename);
-
-    /// Unloads the library, any function pointers from this library are no longer valid.
-    void Close();
-
-    /// Returns the address of the specified symbol (function or variable) as an untyped pointer.
-    /// If the specified symbol does not exist in this library, nullptr is returned.
-    void* GetSymbolAddress(const char* name) const;
-
-    /// Obtains the address of the specified symbol, automatically casting to the correct type.
-    /// Returns true if the symbol was found and assigned, otherwise false.
-    template <typename T>
-    bool GetSymbol(const char* name, T* ptr) const {
-        *ptr = reinterpret_cast<T>(GetSymbolAddress(name));
-        return *ptr != nullptr;
-    }
-
-private:
-    /// Platform-dependent data type representing a dynamic library handle.
-    void* handle = nullptr;
-};
-
-} // namespace Common
--- a/src/common/file_util.cpp
+++ b/src/common/file_util.cpp
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.

 #include <array>
-#include <limits>
 #include <memory>
 #include <sstream>
 #include <unordered_map>
@@ -531,11 +530,11 @@ void CopyDir(const std::string& source_path, const std::string& dest_path) {
 std::optional<std::string> GetCurrentDir() {
 // Get the current working directory (getcwd uses malloc)
 #ifdef _WIN32
-    wchar_t* dir = _wgetcwd(nullptr, 0);
-    if (!dir) {
+    wchar_t* dir;
+    if (!(dir = _wgetcwd(nullptr, 0))) {
 #else
-    char* dir = getcwd(nullptr, 0);
-    if (!dir) {
+    char* dir;
+    if (!(dir = getcwd(nullptr, 0))) {
 #endif
        LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
        return {};
@@ -919,22 +918,19 @@ void IOFile::Swap(IOFile& other) noexcept {

 bool IOFile::Open(const std::string& filename, const char openmode[], int flags) {
    Close();
-    bool m_good;
 #ifdef _WIN32
    if (flags != 0) {
        m_file = _wfsopen(Common::UTF8ToUTF16W(filename).c_str(),
                          Common::UTF8ToUTF16W(openmode).c_str(), flags);
-        m_good = m_file != nullptr;
    } else {
-        m_good = _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
-                           Common::UTF8ToUTF16W(openmode).c_str()) == 0;
+        _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
+                  Common::UTF8ToUTF16W(openmode).c_str());
    }
 #else
-    m_file = std::fopen(filename.c_str(), openmode);
-    m_good = m_file != nullptr;
+    m_file = fopen(filename.c_str(), openmode);
 #endif

-    return m_good;
+    return IsOpen();
 }

 bool IOFile::Close() {
@@ -960,7 +956,7 @@ u64 IOFile::Tell() const {
    if (IsOpen())
        return ftello(m_file);

-    return std::numeric_limits<u64>::max();
+    return -1;
 }

 bool IOFile::Flush() {
--- a/src/common/math_util.h
+++ b/src/common/math_util.h
@@ -24,29 +24,17 @@ struct Rectangle {
        : left(left), top(top), right(right), bottom(bottom) {}

    T GetWidth() const {
-        if constexpr (std::is_floating_point_v<T>) {
-            return std::abs(right - left);
-        } else {
-            return std::abs(static_cast<std::make_signed_t<T>>(right - left));
-        }
+        return std::abs(static_cast<std::make_signed_t<T>>(right - left));
    }
-
    T GetHeight() const {
-        if constexpr (std::is_floating_point_v<T>) {
-            return std::abs(bottom - top);
-        } else {
-            return std::abs(static_cast<std::make_signed_t<T>>(bottom - top));
-        }
+        return std::abs(static_cast<std::make_signed_t<T>>(bottom - top));
    }
-
    Rectangle<T> TranslateX(const T x) const {
        return Rectangle{left + x, top, right + x, bottom};
    }
-
    Rectangle<T> TranslateY(const T y) const {
        return Rectangle{left, top + y, right, bottom + y};
    }
-
    Rectangle<T> Scale(const float s) const {
        return Rectangle{left, top, static_cast<T>(left + GetWidth() * s),
                         static_cast<T>(top + GetHeight() * s)};
--- a/src/common/page_table.cpp
+++ b/src/common/page_table.cpp
@@ -6,20 +6,26 @@

 namespace Common {

-PageTable::PageTable() = default;
+PageTable::PageTable(std::size_t page_size_in_bits) : page_size_in_bits{page_size_in_bits} {}

 PageTable::~PageTable() = default;

-void PageTable::Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits,
-                       bool has_attribute) {
-    const std::size_t num_page_table_entries{1ULL
-                                             << (address_space_width_in_bits - page_size_in_bits)};
+void PageTable::Resize(std::size_t address_space_width_in_bits) {
+    const std::size_t num_page_table_entries = 1ULL
+                                               << (address_space_width_in_bits - page_size_in_bits);
+
    pointers.resize(num_page_table_entries);
+    attributes.resize(num_page_table_entries);
    backing_addr.resize(num_page_table_entries);

-    if (has_attribute) {
-        attributes.resize(num_page_table_entries);
-    }
+    // The default is a 39-bit address space, which causes an initial 1GB allocation size. If the
+    // vector size is subsequently decreased (via resize), the vector might not automatically
+    // actually reallocate/resize its underlying allocation, which wastes up to ~800 MB for
+    // 36-bit titles. Call shrink_to_fit to reduce capacity to what's actually in use.
+
+    pointers.shrink_to_fit();
+    attributes.shrink_to_fit();
+    backing_addr.shrink_to_fit();
 }

 } // namespace Common
--- a/src/common/page_table.h
+++ b/src/common/page_table.h
@@ -5,12 +5,9 @@
 #pragma once

 #include <vector>
-
 #include <boost/icl/interval_map.hpp>
-
 #include "common/common_types.h"
 #include "common/memory_hook.h"
-#include "common/virtual_buffer.h"

 namespace Common {

@@ -50,7 +47,7 @@ struct SpecialRegion {
 * mimics the way a real CPU page table works.
 */
 struct PageTable {
-    PageTable();
+    explicit PageTable(std::size_t page_size_in_bits);
    ~PageTable();

    /**
@@ -59,18 +56,29 @@ struct PageTable {
     *
     * @param address_space_width_in_bits The address size width in bits.
     */
-    void Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits,
-                bool has_attribute);
+    void Resize(std::size_t address_space_width_in_bits);

    /**
     * Vector of memory pointers backing each page. An entry can only be non-null if the
     * corresponding entry in the `attributes` vector is of type `Memory`.
     */
-    VirtualBuffer<u8*> pointers;
+    std::vector<u8*> pointers;

-    VirtualBuffer<u64> backing_addr;
+    /**
+     * Contains MMIO handlers that back memory regions whose entries in the `attribute` vector is
+     * of type `Special`.
+     */
+    boost::icl::interval_map<u64, std::set<SpecialRegion>> special_regions;

-    VirtualBuffer<PageType> attributes;
+    /**
+     * Vector of fine grained page attributes. If it is set to any value other than `Memory`, then
+     * the corresponding entry in `pointers` MUST be set to null.
+     */
+    std::vector<PageType> attributes;
+
+    std::vector<u64> backing_addr;
+
+    const std::size_t page_size_in_bits{};
 };

 } // namespace Common
--- a/src/common/scope_exit.h
+++ b/src/common/scope_exit.h
@@ -12,17 +12,10 @@ template <typename Func>
 struct ScopeExitHelper {
    explicit ScopeExitHelper(Func&& func) : func(std::move(func)) {}
    ~ScopeExitHelper() {
-        if (active) {
-            func();
-        }
-    }
-
-    void Cancel() {
-        active = false;
+        func();
    }

    Func func;
-    bool active{true};
 };

 template <typename Func>
--- a/src/common/thread.cpp
+++ b/src/common/thread.cpp
@@ -28,8 +28,11 @@ namespace Common {
 #ifdef _MSC_VER

 // Sets the debugger-visible name of the current thread.
-// Uses trick documented in:
-// https://docs.microsoft.com/en-us/visualstudio/debugger/how-to-set-a-thread-name-in-native-code
+// Uses undocumented (actually, it is now documented) trick.
+// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vsdebug/html/vxtsksettingthreadname.asp
+
+// This is implemented much nicer in upcoming msvc++, see:
+// http://msdn.microsoft.com/en-us/library/xcb2z8hs(VS.100).aspx
 void SetCurrentThreadName(const char* name) {
    static const DWORD MS_VC_EXCEPTION = 0x406D1388;

@@ -44,7 +47,7 @@ void SetCurrentThreadName(const char* name) {

    info.dwType = 0x1000;
    info.szName = name;
-    info.dwThreadID = std::numeric_limits<DWORD>::max();
+    info.dwThreadID = -1; // dwThreadID;
    info.dwFlags = 0;

    __try {
--- a/src/common/virtual_buffer.cpp
+++ b/src/common/virtual_buffer.cpp
@@ -1,52 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <stdio.h>
-#include <sys/mman.h>
-#include <sys/types.h>
-#if defined __APPLE__ || defined __FreeBSD__ || defined __OpenBSD__
-#include <sys/sysctl.h>
-#elif defined __HAIKU__
-#include <OS.h>
-#else
-#include <sys/sysinfo.h>
-#endif
-#endif
-
-#include "common/assert.h"
-#include "common/virtual_buffer.h"
-
-namespace Common {
-
-void* AllocateMemoryPages(std::size_t size) {
-#ifdef _WIN32
-    void* base{VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE)};
-#else
-    void* base{mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0)};
-
-    if (base == MAP_FAILED) {
-        base = nullptr;
-    }
-#endif
-
-    ASSERT(base);
-
-    return base;
-}
-
-void FreeMemoryPages(void* base, std::size_t size) {
-    if (!base) {
-        return;
-    }
-#ifdef _WIN32
-    ASSERT(VirtualFree(base, 0, MEM_RELEASE));
-#else
-    ASSERT(munmap(base, size) == 0);
-#endif
-}
-
-} // namespace Common
--- a/src/common/virtual_buffer.h
+++ b/src/common/virtual_buffer.h
@@ -1,58 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_funcs.h"
-
-namespace Common {
-
-void* AllocateMemoryPages(std::size_t size);
-void FreeMemoryPages(void* base, std::size_t size);
-
-template <typename T>
-class VirtualBuffer final : NonCopyable {
-public:
-    constexpr VirtualBuffer() = default;
-    explicit VirtualBuffer(std::size_t count) : alloc_size{count * sizeof(T)} {
-        base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
-    }
-
-    ~VirtualBuffer() {
-        FreeMemoryPages(base_ptr, alloc_size);
-    }
-
-    void resize(std::size_t count) {
-        FreeMemoryPages(base_ptr, alloc_size);
-
-        alloc_size = count * sizeof(T);
-        base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
-    }
-
-    constexpr const T& operator[](std::size_t index) const {
-        return base_ptr[index];
-    }
-
-    constexpr T& operator[](std::size_t index) {
-        return base_ptr[index];
-    }
-
-    constexpr T* data() {
-        return base_ptr;
-    }
-
-    constexpr const T* data() const {
-        return base_ptr;
-    }
-
-    constexpr std::size_t size() const {
-        return alloc_size / sizeof(T);
-    }
-
-private:
-    std::size_t alloc_size{};
-    T* base_ptr{};
-};
-
-} // namespace Common
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -35,8 +35,6 @@ add_library(core STATIC
    crypto/ctr_encryption_layer.h
    crypto/xts_encryption_layer.cpp
    crypto/xts_encryption_layer.h
-    device_memory.cpp
-    device_memory.h
    file_sys/bis_factory.cpp
    file_sys/bis_factory.h
    file_sys/card_image.cpp
@@ -133,6 +131,8 @@ add_library(core STATIC
    frontend/framebuffer_layout.cpp
    frontend/framebuffer_layout.h
    frontend/input.h
+    frontend/scope_acquire_window_context.cpp
+    frontend/scope_acquire_window_context.h
    gdbstub/gdbstub.cpp
    gdbstub/gdbstub.h
    hardware_interrupt_manager.cpp
@@ -154,23 +154,6 @@ add_library(core STATIC
    hle/kernel/hle_ipc.h
    hle/kernel/kernel.cpp
    hle/kernel/kernel.h
-    hle/kernel/memory/address_space_info.cpp
-    hle/kernel/memory/address_space_info.h
-    hle/kernel/memory/memory_block.h
-    hle/kernel/memory/memory_block_manager.cpp
-    hle/kernel/memory/memory_block_manager.h
-    hle/kernel/memory/memory_layout.h
-    hle/kernel/memory/memory_manager.cpp
-    hle/kernel/memory/memory_manager.h
-    hle/kernel/memory/memory_types.h
-    hle/kernel/memory/page_linked_list.h
-    hle/kernel/memory/page_heap.cpp
-    hle/kernel/memory/page_heap.h
-    hle/kernel/memory/page_table.cpp
-    hle/kernel/memory/page_table.h
-    hle/kernel/memory/slab_heap.h
-    hle/kernel/memory/system_control.cpp
-    hle/kernel/memory/system_control.h
    hle/kernel/mutex.cpp
    hle/kernel/mutex.h
    hle/kernel/object.cpp
@@ -197,7 +180,6 @@ add_library(core STATIC
    hle/kernel/shared_memory.h
    hle/kernel/svc.cpp
    hle/kernel/svc.h
-    hle/kernel/svc_types.h
    hle/kernel/svc_wrap.h
    hle/kernel/synchronization_object.cpp
    hle/kernel/synchronization_object.h
@@ -209,6 +191,8 @@ add_library(core STATIC
    hle/kernel/time_manager.h
    hle/kernel/transfer_memory.cpp
    hle/kernel/transfer_memory.h
+    hle/kernel/vm_manager.cpp
+    hle/kernel/vm_manager.h
    hle/kernel/writable_event.cpp
    hle/kernel/writable_event.h
    hle/lock.cpp
@@ -303,18 +287,6 @@ add_library(core STATIC
    hle/service/btm/btm.h
    hle/service/caps/caps.cpp
    hle/service/caps/caps.h
-    hle/service/caps/caps_a.cpp
-    hle/service/caps/caps_a.h
-    hle/service/caps/caps_c.cpp
-    hle/service/caps/caps_c.h
-    hle/service/caps/caps_u.cpp
-    hle/service/caps/caps_u.h
-    hle/service/caps/caps_sc.cpp
-    hle/service/caps/caps_sc.h
-    hle/service/caps/caps_ss.cpp
-    hle/service/caps/caps_ss.h
-    hle/service/caps/caps_su.cpp
-    hle/service/caps/caps_su.h
    hle/service/erpt/erpt.cpp
    hle/service/erpt/erpt.h
    hle/service/es/es.cpp
@@ -609,8 +581,11 @@ target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
 target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt json-headers mbedtls opus unicorn)

 if (YUZU_ENABLE_BOXCAT)
-    target_compile_definitions(core PRIVATE -DYUZU_ENABLE_BOXCAT)
-    target_link_libraries(core PRIVATE httplib json-headers zip)
+    get_directory_property(OPENSSL_LIBS
+        DIRECTORY ${PROJECT_SOURCE_DIR}/externals/libressl
+        DEFINITION OPENSSL_LIBS)
+    target_compile_definitions(core PRIVATE -DCPPHTTPLIB_OPENSSL_SUPPORT -DYUZU_ENABLE_BOXCAT)
+    target_link_libraries(core PRIVATE httplib json-headers ${OPENSSL_LIBS} zip)
 endif()

 if (ENABLE_WEB_SERVICE)
@@ -620,12 +595,8 @@ endif()

 if (ARCHITECTURE_x86_64)
    target_sources(core PRIVATE
-        arm/dynarmic/arm_dynarmic_32.cpp
-        arm/dynarmic/arm_dynarmic_32.h
-        arm/dynarmic/arm_dynarmic_64.cpp
-        arm/dynarmic/arm_dynarmic_64.h
-        arm/dynarmic/arm_dynarmic_cp15.cpp
-        arm/dynarmic/arm_dynarmic_cp15.h
+        arm/dynarmic/arm_dynarmic.cpp
+        arm/dynarmic/arm_dynarmic.h
    )
    target_link_libraries(core PRIVATE dynarmic)
 endif()
--- a/src/core/arm/arm_interface.cpp
+++ b/src/core/arm/arm_interface.cpp
@@ -60,7 +60,7 @@ static_assert(sizeof(ELFSymbol) == 0x18, "ELFSymbol has incorrect size.");

 using Symbols = std::vector<std::pair<ELFSymbol, std::string>>;

-Symbols GetSymbols(VAddr text_offset, Core::Memory::Memory& memory) {
+Symbols GetSymbols(VAddr text_offset, Memory::Memory& memory) {
    const auto mod_offset = text_offset + memory.Read32(text_offset + 4);

    if (mod_offset < text_offset || (mod_offset & 0b11) != 0 ||
@@ -123,7 +123,7 @@ Symbols GetSymbols(VAddr text_offset, Core::Memory::Memory& memory) {
 std::optional<std::string> GetSymbolName(const Symbols& symbols, VAddr func_address) {
    const auto iter =
        std::find_if(symbols.begin(), symbols.end(), [func_address](const auto& pair) {
-            const auto& symbol = pair.first;
+            const auto& [symbol, name] = pair;
            const auto end_address = symbol.value + symbol.size;
            return func_address >= symbol.value && func_address < end_address;
        });
@@ -146,7 +146,7 @@ std::vector<ARM_Interface::BacktraceEntry> ARM_Interface::GetBacktrace() const {
    auto fp = GetReg(29);
    auto lr = GetReg(30);
    while (true) {
-        out.push_back({"", 0, lr, 0, ""});
+        out.push_back({"", 0, lr, 0});
        if (!fp) {
            break;
        }
--- a/src/core/arm/arm_interface.h
+++ b/src/core/arm/arm_interface.h
@@ -25,33 +25,20 @@ public:
    explicit ARM_Interface(System& system_) : system{system_} {}
    virtual ~ARM_Interface() = default;

-    struct ThreadContext32 {
-        std::array<u32, 16> cpu_registers{};
-        u32 cpsr{};
-        std::array<u8, 4> padding{};
-        std::array<u64, 32> fprs{};
-        u32 fpscr{};
-        u32 fpexc{};
-        u32 tpidr{};
-    };
-    // Internally within the kernel, it expects the AArch32 version of the
-    // thread context to be 344 bytes in size.
-    static_assert(sizeof(ThreadContext32) == 0x158);
-
-    struct ThreadContext64 {
-        std::array<u64, 31> cpu_registers{};
-        u64 sp{};
-        u64 pc{};
-        u32 pstate{};
-        std::array<u8, 4> padding{};
-        std::array<u128, 32> vector_registers{};
-        u32 fpcr{};
-        u32 fpsr{};
-        u64 tpidr{};
+    struct ThreadContext {
+        std::array<u64, 31> cpu_registers;
+        u64 sp;
+        u64 pc;
+        u32 pstate;
+        std::array<u8, 4> padding;
+        std::array<u128, 32> vector_registers;
+        u32 fpcr;
+        u32 fpsr;
+        u64 tpidr;
    };
    // Internally within the kernel, it expects the AArch64 version of the
    // thread context to be 800 bytes in size.
-    static_assert(sizeof(ThreadContext64) == 0x320);
+    static_assert(sizeof(ThreadContext) == 0x320);

    /// Runs the CPU until an event happens
    virtual void Run() = 0;
@@ -143,10 +130,17 @@ public:
     */
    virtual void SetTPIDR_EL0(u64 value) = 0;

-    virtual void SaveContext(ThreadContext32& ctx) = 0;
-    virtual void SaveContext(ThreadContext64& ctx) = 0;
-    virtual void LoadContext(const ThreadContext32& ctx) = 0;
-    virtual void LoadContext(const ThreadContext64& ctx) = 0;
+    /**
+     * Saves the current CPU context
+     * @param ctx Thread context to save
+     */
+    virtual void SaveContext(ThreadContext& ctx) = 0;
+
+    /**
+     * Loads a CPU context
+     * @param ctx Thread context to load
+     */
+    virtual void LoadContext(const ThreadContext& ctx) = 0;

    /// Clears the exclusive monitor's state.
    virtual void ClearExclusiveState() = 0;
--- a/src/core/arm/dynarmic/arm_dynarmic_64.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.cpp
@@ -8,8 +8,7 @@
 #include <dynarmic/A64/config.h>
 #include "common/logging/log.h"
 #include "common/microprofile.h"
-#include "common/page_table.h"
-#include "core/arm/dynarmic/arm_dynarmic_64.h"
+#include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/core.h"
 #include "core/core_manager.h"
 #include "core/core_timing.h"
@@ -19,15 +18,16 @@
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"

 namespace Core {

 using Vector = Dynarmic::A64::Vector;

-class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
+class ARM_Dynarmic_Callbacks : public Dynarmic::A64::UserCallbacks {
 public:
-    explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent) : parent(parent) {}
+    explicit ARM_Dynarmic_Callbacks(ARM_Dynarmic& parent) : parent(parent) {}

    u8 MemoryRead8(u64 vaddr) override {
        return parent.system.Memory().Read8(vaddr);
@@ -68,7 +68,7 @@ public:
        LOG_INFO(Core_ARM, "Unicorn fallback @ 0x{:X} for {} instructions (instr = {:08X})", pc,
                 num_instructions, MemoryReadCode(pc));

-        ARM_Interface::ThreadContext64 ctx;
+        ARM_Interface::ThreadContext ctx;
        parent.SaveContext(ctx);
        parent.inner_unicorn.LoadContext(ctx);
        parent.inner_unicorn.ExecuteInstructions(num_instructions);
@@ -90,7 +90,7 @@ public:
                parent.jit->HaltExecution();
                parent.SetPC(pc);
                Kernel::Thread* const thread = parent.system.CurrentScheduler().GetCurrentThread();
-                parent.SaveContext(thread->GetContext64());
+                parent.SaveContext(thread->GetContext());
                GDBStub::Break();
                GDBStub::SendTrap(thread, 5);
                return;
@@ -103,7 +103,7 @@ public:
    }

    void CallSVC(u32 swi) override {
-        Kernel::Svc::Call(parent.system, swi);
+        Kernel::CallSVC(parent.system, swi);
    }

    void AddTicks(u64 ticks) override {
@@ -126,14 +126,14 @@ public:
        return Timing::CpuCyclesToClockCycles(parent.system.CoreTiming().GetTicks());
    }

-    ARM_Dynarmic_64& parent;
+    ARM_Dynarmic& parent;
    std::size_t num_interpreted_instructions = 0;
    u64 tpidrro_el0 = 0;
    u64 tpidr_el0 = 0;
 };

-std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable& page_table,
-                                                             std::size_t address_space_bits) const {
+std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit(Common::PageTable& page_table,
+                                                          std::size_t address_space_bits) const {
    Dynarmic::A64::UserConfig config;

    // Callbacks
@@ -159,82 +159,79 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable&
    // Unpredictable instructions
    config.define_unpredictable_behaviour = true;

-    config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
-    config.only_detect_misalignment_via_page_table_on_page_boundary = true;
-
-    return std::make_shared<Dynarmic::A64::Jit>(config);
+    return std::make_unique<Dynarmic::A64::Jit>(config);
 }

-MICROPROFILE_DEFINE(ARM_Jit_Dynarmic_64, "ARM JIT", "Dynarmic", MP_RGB(255, 64, 64));
+MICROPROFILE_DEFINE(ARM_Jit_Dynarmic, "ARM JIT", "Dynarmic", MP_RGB(255, 64, 64));

-void ARM_Dynarmic_64::Run() {
-    MICROPROFILE_SCOPE(ARM_Jit_Dynarmic_64);
+void ARM_Dynarmic::Run() {
+    MICROPROFILE_SCOPE(ARM_Jit_Dynarmic);

    jit->Run();
 }

-void ARM_Dynarmic_64::Step() {
+void ARM_Dynarmic::Step() {
    cb->InterpreterFallback(jit->GetPC(), 1);
 }

-ARM_Dynarmic_64::ARM_Dynarmic_64(System& system, ExclusiveMonitor& exclusive_monitor,
-                                 std::size_t core_index)
+ARM_Dynarmic::ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor,
+                           std::size_t core_index)
    : ARM_Interface{system},
-      cb(std::make_unique<DynarmicCallbacks64>(*this)), inner_unicorn{system},
+      cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), inner_unicorn{system},
      core_index{core_index}, exclusive_monitor{
                                  dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}

-ARM_Dynarmic_64::~ARM_Dynarmic_64() = default;
+ARM_Dynarmic::~ARM_Dynarmic() = default;

-void ARM_Dynarmic_64::SetPC(u64 pc) {
+void ARM_Dynarmic::SetPC(u64 pc) {
    jit->SetPC(pc);
 }

-u64 ARM_Dynarmic_64::GetPC() const {
+u64 ARM_Dynarmic::GetPC() const {
    return jit->GetPC();
 }

-u64 ARM_Dynarmic_64::GetReg(int index) const {
+u64 ARM_Dynarmic::GetReg(int index) const {
    return jit->GetRegister(index);
 }

-void ARM_Dynarmic_64::SetReg(int index, u64 value) {
+void ARM_Dynarmic::SetReg(int index, u64 value) {
    jit->SetRegister(index, value);
 }

-u128 ARM_Dynarmic_64::GetVectorReg(int index) const {
+u128 ARM_Dynarmic::GetVectorReg(int index) const {
    return jit->GetVector(index);
 }

-void ARM_Dynarmic_64::SetVectorReg(int index, u128 value) {
+void ARM_Dynarmic::SetVectorReg(int index, u128 value) {
    jit->SetVector(index, value);
 }

-u32 ARM_Dynarmic_64::GetPSTATE() const {
+u32 ARM_Dynarmic::GetPSTATE() const {
    return jit->GetPstate();
 }

-void ARM_Dynarmic_64::SetPSTATE(u32 pstate) {
+void ARM_Dynarmic::SetPSTATE(u32 pstate) {
    jit->SetPstate(pstate);
 }

-u64 ARM_Dynarmic_64::GetTlsAddress() const {
+u64 ARM_Dynarmic::GetTlsAddress() const {
    return cb->tpidrro_el0;
 }

-void ARM_Dynarmic_64::SetTlsAddress(VAddr address) {
+void ARM_Dynarmic::SetTlsAddress(VAddr address) {
    cb->tpidrro_el0 = address;
 }

-u64 ARM_Dynarmic_64::GetTPIDR_EL0() const {
+u64 ARM_Dynarmic::GetTPIDR_EL0() const {
    return cb->tpidr_el0;
 }

-void ARM_Dynarmic_64::SetTPIDR_EL0(u64 value) {
+void ARM_Dynarmic::SetTPIDR_EL0(u64 value) {
    cb->tpidr_el0 = value;
 }

-void ARM_Dynarmic_64::SaveContext(ThreadContext64& ctx) {
+void ARM_Dynarmic::SaveContext(ThreadContext& ctx) {
    ctx.cpu_registers = jit->GetRegisters();
    ctx.sp = jit->GetSP();
    ctx.pc = jit->GetPC();
@@ -245,7 +242,7 @@ void ARM_Dynarmic_64::SaveContext(ThreadContext64& ctx) {
    ctx.tpidr = cb->tpidr_el0;
 }

-void ARM_Dynarmic_64::LoadContext(const ThreadContext64& ctx) {
+void ARM_Dynarmic::LoadContext(const ThreadContext& ctx) {
    jit->SetRegisters(ctx.cpu_registers);
    jit->SetSP(ctx.sp);
    jit->SetPC(ctx.pc);
@@ -256,32 +253,25 @@ void ARM_Dynarmic_64::LoadContext(const ThreadContext64& ctx) {
    SetTPIDR_EL0(ctx.tpidr);
 }

-void ARM_Dynarmic_64::PrepareReschedule() {
+void ARM_Dynarmic::PrepareReschedule() {
    jit->HaltExecution();
 }

-void ARM_Dynarmic_64::ClearInstructionCache() {
+void ARM_Dynarmic::ClearInstructionCache() {
    jit->ClearCache();
 }

-void ARM_Dynarmic_64::ClearExclusiveState() {
+void ARM_Dynarmic::ClearExclusiveState() {
    jit->ClearExclusiveState();
 }

-void ARM_Dynarmic_64::PageTableChanged(Common::PageTable& page_table,
-                                       std::size_t new_address_space_size_in_bits) {
-    auto key = std::make_pair(&page_table, new_address_space_size_in_bits);
-    auto iter = jit_cache.find(key);
-    if (iter != jit_cache.end()) {
-        jit = iter->second;
-        return;
-    }
+void ARM_Dynarmic::PageTableChanged(Common::PageTable& page_table,
+                                    std::size_t new_address_space_size_in_bits) {
    jit = MakeJit(page_table, new_address_space_size_in_bits);
-    jit_cache.emplace(key, jit);
 }

-DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(Memory::Memory& memory, std::size_t core_count)
-    : monitor(core_count), memory{memory} {}
+DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(Memory::Memory& memory_, std::size_t core_count)
+    : monitor(core_count), memory{memory_} {}

 DynarmicExclusiveMonitor::~DynarmicExclusiveMonitor() = default;

--- a/src/core/arm/dynarmic/arm_dynarmic_64.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.h
@@ -5,30 +5,27 @@
 #pragma once

 #include <memory>
-#include <unordered_map>
-
 #include <dynarmic/A64/a64.h>
 #include <dynarmic/A64/exclusive_monitor.h>
 #include "common/common_types.h"
-#include "common/hash.h"
 #include "core/arm/arm_interface.h"
 #include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"

-namespace Core::Memory {
+namespace Memory {
 class Memory;
 }

 namespace Core {

-class DynarmicCallbacks64;
+class ARM_Dynarmic_Callbacks;
 class DynarmicExclusiveMonitor;
 class System;

-class ARM_Dynarmic_64 final : public ARM_Interface {
+class ARM_Dynarmic final : public ARM_Interface {
 public:
-    ARM_Dynarmic_64(System& system, ExclusiveMonitor& exclusive_monitor, std::size_t core_index);
-    ~ARM_Dynarmic_64() override;
+    ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor, std::size_t core_index);
+    ~ARM_Dynarmic() override;

    void SetPC(u64 pc) override;
    u64 GetPC() const override;
@@ -45,10 +42,8 @@ public:
    void SetTPIDR_EL0(u64 value) override;
    u64 GetTPIDR_EL0() const override;

-    void SaveContext(ThreadContext32& ctx) override {}
-    void SaveContext(ThreadContext64& ctx) override;
-    void LoadContext(const ThreadContext32& ctx) override {}
-    void LoadContext(const ThreadContext64& ctx) override;
+    void SaveContext(ThreadContext& ctx) override;
+    void LoadContext(const ThreadContext& ctx) override;

    void PrepareReschedule() override;
    void ClearExclusiveState() override;
@@ -58,17 +53,12 @@ public:
                          std::size_t new_address_space_size_in_bits) override;

 private:
-    std::shared_ptr<Dynarmic::A64::Jit> MakeJit(Common::PageTable& page_table,
+    std::unique_ptr<Dynarmic::A64::Jit> MakeJit(Common::PageTable& page_table,
                                                std::size_t address_space_bits) const;

-    using JitCacheKey = std::pair<Common::PageTable*, std::size_t>;
-    using JitCacheType =
-        std::unordered_map<JitCacheKey, std::shared_ptr<Dynarmic::A64::Jit>, Common::PairHash>;
-
-    friend class DynarmicCallbacks64;
-    std::unique_ptr<DynarmicCallbacks64> cb;
-    JitCacheType jit_cache;
-    std::shared_ptr<Dynarmic::A64::Jit> jit;
+    friend class ARM_Dynarmic_Callbacks;
+    std::unique_ptr<ARM_Dynarmic_Callbacks> cb;
+    std::unique_ptr<Dynarmic::A64::Jit> jit;
    ARM_Unicorn inner_unicorn;

    std::size_t core_index;
@@ -77,7 +67,7 @@ private:

 class DynarmicExclusiveMonitor final : public ExclusiveMonitor {
 public:
-    explicit DynarmicExclusiveMonitor(Memory::Memory& memory, std::size_t core_count);
+    explicit DynarmicExclusiveMonitor(Memory::Memory& memory_, std::size_t core_count);
    ~DynarmicExclusiveMonitor() override;

    void SetExclusive(std::size_t core_index, VAddr addr) override;
@@ -90,9 +80,9 @@ public:
    bool ExclusiveWrite128(std::size_t core_index, VAddr vaddr, u128 value) override;

 private:
-    friend class ARM_Dynarmic_64;
+    friend class ARM_Dynarmic;
    Dynarmic::A64::ExclusiveMonitor monitor;
-    Core::Memory::Memory& memory;
+    Memory::Memory& memory;
 };

 } // namespace Core
--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
@@ -1,208 +0,0 @@
-// Copyright 2020 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cinttypes>
-#include <memory>
-#include <dynarmic/A32/a32.h>
-#include <dynarmic/A32/config.h>
-#include <dynarmic/A32/context.h>
-#include "common/microprofile.h"
-#include "core/arm/dynarmic/arm_dynarmic_32.h"
-#include "core/arm/dynarmic/arm_dynarmic_64.h"
-#include "core/arm/dynarmic/arm_dynarmic_cp15.h"
-#include "core/core.h"
-#include "core/core_manager.h"
-#include "core/core_timing.h"
-#include "core/hle/kernel/svc.h"
-#include "core/memory.h"
-
-namespace Core {
-
-class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
-public:
-    explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent) : parent(parent) {}
-
-    u8 MemoryRead8(u32 vaddr) override {
-        return parent.system.Memory().Read8(vaddr);
-    }
-    u16 MemoryRead16(u32 vaddr) override {
-        return parent.system.Memory().Read16(vaddr);
-    }
-    u32 MemoryRead32(u32 vaddr) override {
-        return parent.system.Memory().Read32(vaddr);
-    }
-    u64 MemoryRead64(u32 vaddr) override {
-        return parent.system.Memory().Read64(vaddr);
-    }
-
-    void MemoryWrite8(u32 vaddr, u8 value) override {
-        parent.system.Memory().Write8(vaddr, value);
-    }
-    void MemoryWrite16(u32 vaddr, u16 value) override {
-        parent.system.Memory().Write16(vaddr, value);
-    }
-    void MemoryWrite32(u32 vaddr, u32 value) override {
-        parent.system.Memory().Write32(vaddr, value);
-    }
-    void MemoryWrite64(u32 vaddr, u64 value) override {
-        parent.system.Memory().Write64(vaddr, value);
-    }
-
-    void InterpreterFallback(u32 pc, std::size_t num_instructions) override {
-        UNIMPLEMENTED();
-    }
-
-    void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override {
-        switch (exception) {
-        case Dynarmic::A32::Exception::UndefinedInstruction:
-        case Dynarmic::A32::Exception::UnpredictableInstruction:
-            break;
-        case Dynarmic::A32::Exception::Breakpoint:
-            break;
-        }
-        LOG_CRITICAL(HW_GPU, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
-                     static_cast<std::size_t>(exception), pc, MemoryReadCode(pc));
-        UNIMPLEMENTED();
-    }
-
-    void CallSVC(u32 swi) override {
-        Kernel::Svc::Call(parent.system, swi);
-    }
-
-    void AddTicks(u64 ticks) override {
-        // Divide the number of ticks by the amount of CPU cores. TODO(Subv): This yields only a
-        // rough approximation of the amount of executed ticks in the system, it may be thrown off
-        // if not all cores are doing a similar amount of work. Instead of doing this, we should
-        // device a way so that timing is consistent across all cores without increasing the ticks 4
-        // times.
-        u64 amortized_ticks = (ticks - num_interpreted_instructions) / Core::NUM_CPU_CORES;
-        // Always execute at least one tick.
-        amortized_ticks = std::max<u64>(amortized_ticks, 1);
-
-        parent.system.CoreTiming().AddTicks(amortized_ticks);
-        num_interpreted_instructions = 0;
-    }
-    u64 GetTicksRemaining() override {
-        return std::max(parent.system.CoreTiming().GetDowncount(), {});
-    }
-
-    ARM_Dynarmic_32& parent;
-    std::size_t num_interpreted_instructions{};
-    u64 tpidrro_el0{};
-    u64 tpidr_el0{};
-};
-
-std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable& page_table,
-                                                             std::size_t address_space_bits) const {
-    Dynarmic::A32::UserConfig config;
-    config.callbacks = cb.get();
-    // TODO(bunnei): Implement page table for 32-bit
-    // config.page_table = &page_table.pointers;
-    config.coprocessors[15] = std::make_shared<DynarmicCP15>((u32*)&CP15_regs[0]);
-    config.define_unpredictable_behaviour = true;
-    return std::make_unique<Dynarmic::A32::Jit>(config);
-}
-
-MICROPROFILE_DEFINE(ARM_Jit_Dynarmic_32, "ARM JIT", "Dynarmic", MP_RGB(255, 64, 64));
-
-void ARM_Dynarmic_32::Run() {
-    MICROPROFILE_SCOPE(ARM_Jit_Dynarmic_32);
-    jit->Run();
-}
-
-void ARM_Dynarmic_32::Step() {
-    cb->InterpreterFallback(jit->Regs()[15], 1);
-}
-
-ARM_Dynarmic_32::ARM_Dynarmic_32(System& system, ExclusiveMonitor& exclusive_monitor,
-                                 std::size_t core_index)
-    : ARM_Interface{system},
-      cb(std::make_unique<DynarmicCallbacks32>(*this)), core_index{core_index},
-      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}
-
-ARM_Dynarmic_32::~ARM_Dynarmic_32() = default;
-
-void ARM_Dynarmic_32::SetPC(u64 pc) {
-    jit->Regs()[15] = static_cast<u32>(pc);
-}
-
-u64 ARM_Dynarmic_32::GetPC() const {
-    return jit->Regs()[15];
-}
-
-u64 ARM_Dynarmic_32::GetReg(int index) const {
-    return jit->Regs()[index];
-}
-
-void ARM_Dynarmic_32::SetReg(int index, u64 value) {
-    jit->Regs()[index] = static_cast<u32>(value);
-}
-
-u128 ARM_Dynarmic_32::GetVectorReg(int index) const {
-    return {};
-}
-
-void ARM_Dynarmic_32::SetVectorReg(int index, u128 value) {}
-
-u32 ARM_Dynarmic_32::GetPSTATE() const {
-    return jit->Cpsr();
-}
-
-void ARM_Dynarmic_32::SetPSTATE(u32 cpsr) {
-    jit->SetCpsr(cpsr);
-}
-
-u64 ARM_Dynarmic_32::GetTlsAddress() const {
-    return CP15_regs[static_cast<std::size_t>(CP15Register::CP15_THREAD_URO)];
-}
-
-void ARM_Dynarmic_32::SetTlsAddress(VAddr address) {
-    CP15_regs[static_cast<std::size_t>(CP15Register::CP15_THREAD_URO)] = static_cast<u32>(address);
-}
-
-u64 ARM_Dynarmic_32::GetTPIDR_EL0() const {
-    return cb->tpidr_el0;
-}
-
-void ARM_Dynarmic_32::SetTPIDR_EL0(u64 value) {
-    cb->tpidr_el0 = value;
-}
-
-void ARM_Dynarmic_32::SaveContext(ThreadContext32& ctx) {
-    Dynarmic::A32::Context context;
-    jit->SaveContext(context);
-    ctx.cpu_registers = context.Regs();
-    ctx.cpsr = context.Cpsr();
-}
-
-void ARM_Dynarmic_32::LoadContext(const ThreadContext32& ctx) {
-    Dynarmic::A32::Context context;
-    context.Regs() = ctx.cpu_registers;
-    context.SetCpsr(ctx.cpsr);
-    jit->LoadContext(context);
-}
-
-void ARM_Dynarmic_32::PrepareReschedule() {
-    jit->HaltExecution();
-}
-
-void ARM_Dynarmic_32::ClearInstructionCache() {
-    jit->ClearCache();
-}
-
-void ARM_Dynarmic_32::ClearExclusiveState() {}
-
-void ARM_Dynarmic_32::PageTableChanged(Common::PageTable& page_table,
-                                       std::size_t new_address_space_size_in_bits) {
-    auto key = std::make_pair(&page_table, new_address_space_size_in_bits);
-    auto iter = jit_cache.find(key);
-    if (iter != jit_cache.end()) {
-        jit = iter->second;
-        return;
-    }
-    jit = MakeJit(page_table, new_address_space_size_in_bits);
-    jit_cache.emplace(key, jit);
-}
-
-} // namespace Core
--- a/src/core/arm/dynarmic/arm_dynarmic_32.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.h
@@ -1,77 +0,0 @@
-// Copyright 2020 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <unordered_map>
-
-#include <dynarmic/A32/a32.h>
-#include <dynarmic/A64/a64.h>
-#include <dynarmic/A64/exclusive_monitor.h>
-#include "common/common_types.h"
-#include "common/hash.h"
-#include "core/arm/arm_interface.h"
-#include "core/arm/exclusive_monitor.h"
-
-namespace Core::Memory {
-class Memory;
-}
-
-namespace Core {
-
-class DynarmicCallbacks32;
-class DynarmicExclusiveMonitor;
-class System;
-
-class ARM_Dynarmic_32 final : public ARM_Interface {
-public:
-    ARM_Dynarmic_32(System& system, ExclusiveMonitor& exclusive_monitor, std::size_t core_index);
-    ~ARM_Dynarmic_32() override;
-
-    void SetPC(u64 pc) override;
-    u64 GetPC() const override;
-    u64 GetReg(int index) const override;
-    void SetReg(int index, u64 value) override;
-    u128 GetVectorReg(int index) const override;
-    void SetVectorReg(int index, u128 value) override;
-    u32 GetPSTATE() const override;
-    void SetPSTATE(u32 pstate) override;
-    void Run() override;
-    void Step() override;
-    VAddr GetTlsAddress() const override;
-    void SetTlsAddress(VAddr address) override;
-    void SetTPIDR_EL0(u64 value) override;
-    u64 GetTPIDR_EL0() const override;
-
-    void SaveContext(ThreadContext32& ctx) override;
-    void SaveContext(ThreadContext64& ctx) override {}
-    void LoadContext(const ThreadContext32& ctx) override;
-    void LoadContext(const ThreadContext64& ctx) override {}
-
-    void PrepareReschedule() override;
-    void ClearExclusiveState() override;
-
-    void ClearInstructionCache() override;
-    void PageTableChanged(Common::PageTable& new_page_table,
-                          std::size_t new_address_space_size_in_bits) override;
-
-private:
-    std::shared_ptr<Dynarmic::A32::Jit> MakeJit(Common::PageTable& page_table,
-                                                std::size_t address_space_bits) const;
-
-    using JitCacheKey = std::pair<Common::PageTable*, std::size_t>;
-    using JitCacheType =
-        std::unordered_map<JitCacheKey, std::shared_ptr<Dynarmic::A32::Jit>, Common::PairHash>;
-
-    friend class DynarmicCallbacks32;
-    std::unique_ptr<DynarmicCallbacks32> cb;
-    JitCacheType jit_cache;
-    std::shared_ptr<Dynarmic::A32::Jit> jit;
-    std::size_t core_index;
-    DynarmicExclusiveMonitor& exclusive_monitor;
-    std::array<u32, 84> CP15_regs{};
-};
-
-} // namespace Core
--- a/src/core/arm/dynarmic/arm_dynarmic_cp15.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_cp15.cpp
@@ -1,80 +0,0 @@
-// Copyright 2017 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/arm/dynarmic/arm_dynarmic_cp15.h"
-
-using Callback = Dynarmic::A32::Coprocessor::Callback;
-using CallbackOrAccessOneWord = Dynarmic::A32::Coprocessor::CallbackOrAccessOneWord;
-using CallbackOrAccessTwoWords = Dynarmic::A32::Coprocessor::CallbackOrAccessTwoWords;
-
-std::optional<Callback> DynarmicCP15::CompileInternalOperation(bool two, unsigned opc1,
-                                                               CoprocReg CRd, CoprocReg CRn,
-                                                               CoprocReg CRm, unsigned opc2) {
-    return {};
-}
-
-CallbackOrAccessOneWord DynarmicCP15::CompileSendOneWord(bool two, unsigned opc1, CoprocReg CRn,
-                                                         CoprocReg CRm, unsigned opc2) {
-    // TODO(merry): Privileged CP15 registers
-
-    if (!two && CRn == CoprocReg::C7 && opc1 == 0 && CRm == CoprocReg::C5 && opc2 == 4) {
-        // This is a dummy write, we ignore the value written here.
-        return &CP15[static_cast<std::size_t>(CP15Register::CP15_FLUSH_PREFETCH_BUFFER)];
-    }
-
-    if (!two && CRn == CoprocReg::C7 && opc1 == 0 && CRm == CoprocReg::C10) {
-        switch (opc2) {
-        case 4:
-            // This is a dummy write, we ignore the value written here.
-            return &CP15[static_cast<std::size_t>(CP15Register::CP15_DATA_SYNC_BARRIER)];
-        case 5:
-            // This is a dummy write, we ignore the value written here.
-            return &CP15[static_cast<std::size_t>(CP15Register::CP15_DATA_MEMORY_BARRIER)];
-        default:
-            return {};
-        }
-    }
-
-    if (!two && CRn == CoprocReg::C13 && opc1 == 0 && CRm == CoprocReg::C0 && opc2 == 2) {
-        return &CP15[static_cast<std::size_t>(CP15Register::CP15_THREAD_UPRW)];
-    }
-
-    return {};
-}
-
-CallbackOrAccessTwoWords DynarmicCP15::CompileSendTwoWords(bool two, unsigned opc, CoprocReg CRm) {
-    return {};
-}
-
-CallbackOrAccessOneWord DynarmicCP15::CompileGetOneWord(bool two, unsigned opc1, CoprocReg CRn,
-                                                        CoprocReg CRm, unsigned opc2) {
-    // TODO(merry): Privileged CP15 registers
-
-    if (!two && CRn == CoprocReg::C13 && opc1 == 0 && CRm == CoprocReg::C0) {
-        switch (opc2) {
-        case 2:
-            return &CP15[static_cast<std::size_t>(CP15Register::CP15_THREAD_UPRW)];
-        case 3:
-            return &CP15[static_cast<std::size_t>(CP15Register::CP15_THREAD_URO)];
-        default:
-            return {};
-        }
-    }
-
-    return {};
-}
-
-CallbackOrAccessTwoWords DynarmicCP15::CompileGetTwoWords(bool two, unsigned opc, CoprocReg CRm) {
-    return {};
-}
-
-std::optional<Callback> DynarmicCP15::CompileLoadWords(bool two, bool long_transfer, CoprocReg CRd,
-                                                       std::optional<u8> option) {
-    return {};
-}
-
-std::optional<Callback> DynarmicCP15::CompileStoreWords(bool two, bool long_transfer, CoprocReg CRd,
-                                                        std::optional<u8> option) {
-    return {};
-}
--- a/src/core/arm/dynarmic/arm_dynarmic_cp15.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_cp15.h
@@ -1,152 +0,0 @@
-// Copyright 2017 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <optional>
-
-#include <dynarmic/A32/coprocessor.h>
-#include "common/common_types.h"
-
-enum class CP15Register {
-    // c0 - Information registers
-    CP15_MAIN_ID,
-    CP15_CACHE_TYPE,
-    CP15_TCM_STATUS,
-    CP15_TLB_TYPE,
-    CP15_CPU_ID,
-    CP15_PROCESSOR_FEATURE_0,
-    CP15_PROCESSOR_FEATURE_1,
-    CP15_DEBUG_FEATURE_0,
-    CP15_AUXILIARY_FEATURE_0,
-    CP15_MEMORY_MODEL_FEATURE_0,
-    CP15_MEMORY_MODEL_FEATURE_1,
-    CP15_MEMORY_MODEL_FEATURE_2,
-    CP15_MEMORY_MODEL_FEATURE_3,
-    CP15_ISA_FEATURE_0,
-    CP15_ISA_FEATURE_1,
-    CP15_ISA_FEATURE_2,
-    CP15_ISA_FEATURE_3,
-    CP15_ISA_FEATURE_4,
-
-    // c1 - Control registers
-    CP15_CONTROL,
-    CP15_AUXILIARY_CONTROL,
-    CP15_COPROCESSOR_ACCESS_CONTROL,
-
-    // c2 - Translation table registers
-    CP15_TRANSLATION_BASE_TABLE_0,
-    CP15_TRANSLATION_BASE_TABLE_1,
-    CP15_TRANSLATION_BASE_CONTROL,
-    CP15_DOMAIN_ACCESS_CONTROL,
-    CP15_RESERVED,
-
-    // c5 - Fault status registers
-    CP15_FAULT_STATUS,
-    CP15_INSTR_FAULT_STATUS,
-    CP15_COMBINED_DATA_FSR = CP15_FAULT_STATUS,
-    CP15_INST_FSR,
-
-    // c6 - Fault Address registers
-    CP15_FAULT_ADDRESS,
-    CP15_COMBINED_DATA_FAR = CP15_FAULT_ADDRESS,
-    CP15_WFAR,
-    CP15_IFAR,
-
-    // c7 - Cache operation registers
-    CP15_WAIT_FOR_INTERRUPT,
-    CP15_PHYS_ADDRESS,
-    CP15_INVALIDATE_INSTR_CACHE,
-    CP15_INVALIDATE_INSTR_CACHE_USING_MVA,
-    CP15_INVALIDATE_INSTR_CACHE_USING_INDEX,
-    CP15_FLUSH_PREFETCH_BUFFER,
-    CP15_FLUSH_BRANCH_TARGET_CACHE,
-    CP15_FLUSH_BRANCH_TARGET_CACHE_ENTRY,
-    CP15_INVALIDATE_DATA_CACHE,
-    CP15_INVALIDATE_DATA_CACHE_LINE_USING_MVA,
-    CP15_INVALIDATE_DATA_CACHE_LINE_USING_INDEX,
-    CP15_INVALIDATE_DATA_AND_INSTR_CACHE,
-    CP15_CLEAN_DATA_CACHE,
-    CP15_CLEAN_DATA_CACHE_LINE_USING_MVA,
-    CP15_CLEAN_DATA_CACHE_LINE_USING_INDEX,
-    CP15_DATA_SYNC_BARRIER,
-    CP15_DATA_MEMORY_BARRIER,
-    CP15_CLEAN_AND_INVALIDATE_DATA_CACHE,
-    CP15_CLEAN_AND_INVALIDATE_DATA_CACHE_LINE_USING_MVA,
-    CP15_CLEAN_AND_INVALIDATE_DATA_CACHE_LINE_USING_INDEX,
-
-    // c8 - TLB operations
-    CP15_INVALIDATE_ITLB,
-    CP15_INVALIDATE_ITLB_SINGLE_ENTRY,
-    CP15_INVALIDATE_ITLB_ENTRY_ON_ASID_MATCH,
-    CP15_INVALIDATE_ITLB_ENTRY_ON_MVA,
-    CP15_INVALIDATE_DTLB,
-    CP15_INVALIDATE_DTLB_SINGLE_ENTRY,
-    CP15_INVALIDATE_DTLB_ENTRY_ON_ASID_MATCH,
-    CP15_INVALIDATE_DTLB_ENTRY_ON_MVA,
-    CP15_INVALIDATE_UTLB,
-    CP15_INVALIDATE_UTLB_SINGLE_ENTRY,
-    CP15_INVALIDATE_UTLB_ENTRY_ON_ASID_MATCH,
-    CP15_INVALIDATE_UTLB_ENTRY_ON_MVA,
-
-    // c9 - Data cache lockdown register
-    CP15_DATA_CACHE_LOCKDOWN,
-
-    // c10 - TLB/Memory map registers
-    CP15_TLB_LOCKDOWN,
-    CP15_PRIMARY_REGION_REMAP,
-    CP15_NORMAL_REGION_REMAP,
-
-    // c13 - Thread related registers
-    CP15_PID,
-    CP15_CONTEXT_ID,
-    CP15_THREAD_UPRW, // Thread ID register - User/Privileged Read/Write
-    CP15_THREAD_URO,  // Thread ID register - User Read Only (Privileged R/W)
-    CP15_THREAD_PRW,  // Thread ID register - Privileged R/W only.
-
-    // c15 - Performance and TLB lockdown registers
-    CP15_PERFORMANCE_MONITOR_CONTROL,
-    CP15_CYCLE_COUNTER,
-    CP15_COUNT_0,
-    CP15_COUNT_1,
-    CP15_READ_MAIN_TLB_LOCKDOWN_ENTRY,
-    CP15_WRITE_MAIN_TLB_LOCKDOWN_ENTRY,
-    CP15_MAIN_TLB_LOCKDOWN_VIRT_ADDRESS,
-    CP15_MAIN_TLB_LOCKDOWN_PHYS_ADDRESS,
-    CP15_MAIN_TLB_LOCKDOWN_ATTRIBUTE,
-    CP15_TLB_DEBUG_CONTROL,
-
-    // Skyeye defined
-    CP15_TLB_FAULT_ADDR,
-    CP15_TLB_FAULT_STATUS,
-
-    // Not an actual register.
-    // All registers should be defined above this.
-    CP15_REGISTER_COUNT,
-};
-
-class DynarmicCP15 final : public Dynarmic::A32::Coprocessor {
-public:
-    using CoprocReg = Dynarmic::A32::CoprocReg;
-
-    explicit DynarmicCP15(u32* cp15) : CP15(cp15){};
-
-    std::optional<Callback> CompileInternalOperation(bool two, unsigned opc1, CoprocReg CRd,
-                                                     CoprocReg CRn, CoprocReg CRm,
-                                                     unsigned opc2) override;
-    CallbackOrAccessOneWord CompileSendOneWord(bool two, unsigned opc1, CoprocReg CRn,
-                                               CoprocReg CRm, unsigned opc2) override;
-    CallbackOrAccessTwoWords CompileSendTwoWords(bool two, unsigned opc, CoprocReg CRm) override;
-    CallbackOrAccessOneWord CompileGetOneWord(bool two, unsigned opc1, CoprocReg CRn, CoprocReg CRm,
-                                              unsigned opc2) override;
-    CallbackOrAccessTwoWords CompileGetTwoWords(bool two, unsigned opc, CoprocReg CRm) override;
-    std::optional<Callback> CompileLoadWords(bool two, bool long_transfer, CoprocReg CRd,
-                                             std::optional<u8> option) override;
-    std::optional<Callback> CompileStoreWords(bool two, bool long_transfer, CoprocReg CRd,
-                                              std::optional<u8> option) override;
-
-private:
-    u32* CP15{};
-};
--- a/src/core/arm/exclusive_monitor.cpp
+++ b/src/core/arm/exclusive_monitor.cpp
@@ -3,7 +3,7 @@
 // Refer to the license.txt file included.

 #ifdef ARCHITECTURE_x86_64
-#include "core/arm/dynarmic/arm_dynarmic_64.h"
+#include "core/arm/dynarmic/arm_dynarmic.h"
 #endif
 #include "core/arm/exclusive_monitor.h"
 #include "core/memory.h"
--- a/src/core/arm/exclusive_monitor.h
+++ b/src/core/arm/exclusive_monitor.h
@@ -8,7 +8,7 @@

 #include "common/common_types.h"

-namespace Core::Memory {
+namespace Memory {
 class Memory;
 }

--- a/src/core/arm/unicorn/arm_unicorn.cpp
+++ b/src/core/arm/unicorn/arm_unicorn.cpp
@@ -53,7 +53,7 @@ static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int si
                               void* user_data) {
    auto* const system = static_cast<System*>(user_data);

-    ARM_Interface::ThreadContext64 ctx{};
+    ARM_Interface::ThreadContext ctx{};
    system->CurrentArmInterface().SaveContext(ctx);
    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x{:X}, pc=0x{:X}, lr=0x{:X}", addr,
               ctx.pc, ctx.cpu_registers[30]);
@@ -179,7 +179,7 @@ void ARM_Unicorn::ExecuteInstructions(std::size_t num_instructions) {
        }

        Kernel::Thread* const thread = system.CurrentScheduler().GetCurrentThread();
-        SaveContext(thread->GetContext64());
+        SaveContext(thread->GetContext());
        if (last_bkpt_hit || GDBStub::IsMemoryBreak() || GDBStub::GetCpuStepFlag()) {
            last_bkpt_hit = false;
            GDBStub::Break();
@@ -188,7 +188,7 @@ void ARM_Unicorn::ExecuteInstructions(std::size_t num_instructions) {
    }
 }

-void ARM_Unicorn::SaveContext(ThreadContext64& ctx) {
+void ARM_Unicorn::SaveContext(ThreadContext& ctx) {
    int uregs[32];
    void* tregs[32];

@@ -215,7 +215,7 @@ void ARM_Unicorn::SaveContext(ThreadContext64& ctx) {
    CHECKED(uc_reg_read_batch(uc, uregs, tregs, 32));
 }

-void ARM_Unicorn::LoadContext(const ThreadContext64& ctx) {
+void ARM_Unicorn::LoadContext(const ThreadContext& ctx) {
    int uregs[32];
    void* tregs[32];

@@ -266,7 +266,7 @@ void ARM_Unicorn::InterruptHook(uc_engine* uc, u32 int_no, void* user_data) {

    switch (ec) {
    case 0x15: // SVC
-        Kernel::Svc::Call(arm_instance->system, iss);
+        Kernel::CallSVC(arm_instance->system, iss);
        break;
    }
 }
--- a/src/core/arm/unicorn/arm_unicorn.h
+++ b/src/core/arm/unicorn/arm_unicorn.h
@@ -30,6 +30,8 @@ public:
    void SetTlsAddress(VAddr address) override;
    void SetTPIDR_EL0(u64 value) override;
    u64 GetTPIDR_EL0() const override;
+    void SaveContext(ThreadContext& ctx) override;
+    void LoadContext(const ThreadContext& ctx) override;
    void PrepareReschedule() override;
    void ClearExclusiveState() override;
    void ExecuteInstructions(std::size_t num_instructions);
@@ -39,11 +41,6 @@ public:
    void PageTableChanged(Common::PageTable&, std::size_t) override {}
    void RecordBreak(GDBStub::BreakpointAddress bkpt);

-    void SaveContext(ThreadContext32& ctx) override {}
-    void SaveContext(ThreadContext64& ctx) override;
-    void LoadContext(const ThreadContext32& ctx) override {}
-    void LoadContext(const ThreadContext64& ctx) override;
-
 private:
    static void InterruptHook(uc_engine* uc, u32 int_no, void* user_data);

--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -14,7 +14,6 @@
 #include "core/core_manager.h"
 #include "core/core_timing.h"
 #include "core/cpu_manager.h"
-#include "core/device_memory.h"
 #include "core/file_sys/bis_factory.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/mode.h"
@@ -141,8 +140,6 @@ struct System::Impl {
    ResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
        LOG_DEBUG(HW_Memory, "initialized OK");

-        device_memory = std::make_unique<Core::DeviceMemory>(system);
-
        core_timing.Initialize();
        kernel.Initialize();
        cpu_manager.Initialize();
@@ -168,14 +165,14 @@ struct System::Impl {
        service_manager = std::make_shared<Service::SM::ServiceManager>();

        Service::Init(service_manager, system);
-        GDBStub::DeferStart();
+        GDBStub::Init();

-        interrupt_manager = std::make_unique<Core::Hardware::InterruptManager>(system);
-        gpu_core = VideoCore::CreateGPU(emu_window, system);
-        if (!gpu_core) {
+        renderer = VideoCore::CreateRenderer(emu_window, system);
+        if (!renderer->Init()) {
            return ResultStatus::ErrorVideoCore;
        }
-        gpu_core->Renderer().Rasterizer().SetupDirtyFlags();
+        interrupt_manager = std::make_unique<Core::Hardware::InterruptManager>(system);
+        gpu_core = VideoCore::CreateGPU(system);

        is_powered_on = true;
        exit_lock = false;
@@ -215,6 +212,10 @@ struct System::Impl {
        AddGlueRegistrationForProcess(*app_loader, *main_process);
        kernel.MakeCurrentProcess(main_process.get());

+        // Main process has been loaded and been made current.
+        // Begin GPU and CPU execution.
+        gpu_core->Start();
+
        // Initialize cheat engine
        if (cheat_engine) {
            cheat_engine->Initialize();
@@ -272,6 +273,7 @@ struct System::Impl {
        }

        // Shutdown emulation session
+        renderer.reset();
        GDBStub::Shutdown();
        Service::Shutdown();
        service_manager.reset();
@@ -279,7 +281,6 @@ struct System::Impl {
        telemetry_session.reset();
        perf_stats.reset();
        gpu_core.reset();
-        device_memory.reset();

        // Close all CPU/threading state
        cpu_manager.Shutdown();
@@ -348,10 +349,10 @@ struct System::Impl {
    Service::FileSystem::FileSystemController fs_controller;
    /// AppLoader used to load the current executing application
    std::unique_ptr<Loader::AppLoader> app_loader;
+    std::unique_ptr<VideoCore::RendererBase> renderer;
    std::unique_ptr<Tegra::GPU> gpu_core;
    std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
-    std::unique_ptr<Core::DeviceMemory> device_memory;
-    Core::Memory::Memory memory;
+    Memory::Memory memory;
    CpuManager cpu_manager;
    bool is_powered_on = false;
    bool exit_lock = false;
@@ -477,14 +478,6 @@ Kernel::Process* System::CurrentProcess() {
    return impl->kernel.CurrentProcess();
 }

-Core::DeviceMemory& System::DeviceMemory() {
-    return *impl->device_memory;
-}
-
-const Core::DeviceMemory& System::DeviceMemory() const {
-    return *impl->device_memory;
-}
-
 const Kernel::Process* System::CurrentProcess() const {
    return impl->kernel.CurrentProcess();
 }
@@ -518,7 +511,7 @@ Memory::Memory& System::Memory() {
    return impl->memory;
 }

-const Core::Memory::Memory& System::Memory() const {
+const Memory::Memory& System::Memory() const {
    return impl->memory;
 }

@@ -539,11 +532,11 @@ const Core::Hardware::InterruptManager& System::InterruptManager() const {
 }

 VideoCore::RendererBase& System::Renderer() {
-    return impl->gpu_core->Renderer();
+    return *impl->renderer;
 }

 const VideoCore::RendererBase& System::Renderer() const {
-    return impl->gpu_core->Renderer();
+    return *impl->renderer;
 }

 Kernel::KernelCore& System::Kernel() {
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -36,10 +36,9 @@ class AppLoader;
 enum class ResultStatus : u16;
 } // namespace Loader

-namespace Core::Memory {
+namespace Memory {
 struct CheatEntry;
-class Memory;
-} // namespace Core::Memory
+} // namespace Memory

 namespace Service {

@@ -87,11 +86,14 @@ namespace Core::Hardware {
 class InterruptManager;
 }

+namespace Memory {
+class Memory;
+}
+
 namespace Core {

 class ARM_Interface;
 class CoreManager;
-class DeviceMemory;
 class ExclusiveMonitor;
 class FrameLimiter;
 class PerfStats;
@@ -228,10 +230,10 @@ public:
    const ExclusiveMonitor& Monitor() const;

    /// Gets a mutable reference to the system memory instance.
-    Core::Memory::Memory& Memory();
+    Memory::Memory& Memory();

    /// Gets a constant reference to the system memory instance.
-    const Core::Memory::Memory& Memory() const;
+    const Memory::Memory& Memory() const;

    /// Gets a mutable reference to the GPU interface
    Tegra::GPU& GPU();
@@ -257,12 +259,6 @@ public:
    /// Gets the global scheduler
    const Kernel::GlobalScheduler& GlobalScheduler() const;

-    /// Gets the manager for the guest device memory
-    Core::DeviceMemory& DeviceMemory();
-
-    /// Gets the manager for the guest device memory
-    const Core::DeviceMemory& DeviceMemory() const;
-
    /// Provides a pointer to the current process
    Kernel::Process* CurrentProcess();

--- a/src/core/core_manager.cpp
+++ b/src/core/core_manager.cpp
@@ -6,6 +6,9 @@
 #include <mutex>

 #include "common/logging/log.h"
+#ifdef ARCHITECTURE_x86_64
+#include "core/arm/dynarmic/arm_dynarmic.h"
+#endif
 #include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
 #include "core/core.h"
--- a/src/core/core_manager.h
+++ b/src/core/core_manager.h
@@ -22,7 +22,7 @@ namespace Core::Timing {
 class CoreTiming;
 }

-namespace Core::Memory {
+namespace Memory {
 class Memory;
 }

--- a/src/core/device_memory.cpp
+++ b/src/core/device_memory.cpp
@@ -1,15 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/core.h"
-#include "core/device_memory.h"
-#include "core/memory.h"
-
-namespace Core {
-
-DeviceMemory::DeviceMemory(System& system) : buffer{DramMemoryMap::Size}, system{system} {}
-
-DeviceMemory::~DeviceMemory() = default;
-
-} // namespace Core
--- a/src/core/device_memory.h
+++ b/src/core/device_memory.h
@@ -1,51 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/assert.h"
-#include "common/common_funcs.h"
-#include "common/virtual_buffer.h"
-
-namespace Core {
-
-class System;
-
-namespace DramMemoryMap {
-enum : u64 {
-    Base = 0x80000000ULL,
-    Size = 0x100000000ULL,
-    End = Base + Size,
-    KernelReserveBase = Base + 0x60000,
-    SlabHeapBase = KernelReserveBase + 0x85000,
-    SlapHeapSize = 0xa21000,
-    SlabHeapEnd = SlabHeapBase + SlapHeapSize,
-};
-}; // namespace DramMemoryMap
-
-class DeviceMemory : NonCopyable {
-public:
-    explicit DeviceMemory(Core::System& system);
-    ~DeviceMemory();
-
-    template <typename T>
-    PAddr GetPhysicalAddr(const T* ptr) const {
-        return (reinterpret_cast<uintptr_t>(ptr) - reinterpret_cast<uintptr_t>(buffer.data())) +
-               DramMemoryMap::Base;
-    }
-
-    u8* GetPointer(PAddr addr) {
-        return buffer.data() + (addr - DramMemoryMap::Base);
-    }
-
-    const u8* GetPointer(PAddr addr) const {
-        return buffer.data() + (addr - DramMemoryMap::Base);
-    }
-
-private:
-    Common::VirtualBuffer<u8> buffer;
-    Core::System& system;
-};
-
-} // namespace Core
--- a/src/core/file_sys/patch_manager.cpp
+++ b/src/core/file_sys/patch_manager.cpp
@@ -249,7 +249,7 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
 }

 namespace {
-std::optional<std::vector<Core::Memory::CheatEntry>> ReadCheatFileFromFolder(
+std::optional<std::vector<Memory::CheatEntry>> ReadCheatFileFromFolder(
    const Core::System& system, u64 title_id, const std::array<u8, 0x20>& build_id_,
    const VirtualDir& base_path, bool upper) {
    const auto build_id_raw = Common::HexToString(build_id_, upper);
@@ -269,14 +269,14 @@ std::optional<std::vector<Core::Memory::CheatEntry>> ReadCheatFileFromFolder(
        return std::nullopt;
    }

-    Core::Memory::TextCheatParser parser;
+    Memory::TextCheatParser parser;
    return parser.Parse(
        system, std::string_view(reinterpret_cast<const char* const>(data.data()), data.size()));
 }

 } // Anonymous namespace

-std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
+std::vector<Memory::CheatEntry> PatchManager::CreateCheatList(
    const Core::System& system, const std::array<u8, 32>& build_id_) const {
    const auto load_dir = system.GetFileSystemController().GetModificationLoadRoot(title_id);
    if (load_dir == nullptr) {
@@ -289,7 +289,7 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
    std::sort(patch_dirs.begin(), patch_dirs.end(),
              [](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });

-    std::vector<Core::Memory::CheatEntry> out;
+    std::vector<Memory::CheatEntry> out;
    for (const auto& subdir : patch_dirs) {
        if (std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend()) {
            continue;
@@ -348,12 +348,6 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
        if (ext_dir != nullptr)
            layers_ext.push_back(std::move(ext_dir));
    }
-
-    // When there are no layers to apply, return early as there is no need to rebuild the RomFS
-    if (layers.empty() && layers_ext.empty()) {
-        return;
-    }
-
    layers.push_back(std::move(extracted));

    auto layered = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers));
@@ -440,8 +434,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
    // Game Updates
    const auto update_tid = GetUpdateTitleID(title_id);
    PatchManager update{update_tid};
-    const auto metadata = update.GetControlMetadata();
-    const auto& nacp = metadata.first;
+    auto [nacp, discard_icon_file] = update.GetControlMetadata();

    const auto update_disabled =
        std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
--- a/src/core/file_sys/patch_manager.h
+++ b/src/core/file_sys/patch_manager.h
@@ -51,8 +51,8 @@ public:
    bool HasNSOPatch(const std::array<u8, 0x20>& build_id) const;

    // Creates a CheatList object with all
-    std::vector<Core::Memory::CheatEntry> CreateCheatList(
-        const Core::System& system, const std::array<u8, 0x20>& build_id) const;
+    std::vector<Memory::CheatEntry> CreateCheatList(const Core::System& system,
+                                                    const std::array<u8, 0x20>& build_id) const;

    // Currently tracked RomFS patches:
    // - Game Updates
--- a/src/core/file_sys/registered_cache.cpp
+++ b/src/core/file_sys/registered_cache.cpp
@@ -591,18 +591,14 @@ InstallResult RegisteredCache::InstallEntry(const NSP& nsp, bool overwrite_if_ex
 InstallResult RegisteredCache::InstallEntry(const NCA& nca, TitleType type,
                                            bool overwrite_if_exists, const VfsCopyFunction& copy) {
    CNMTHeader header{
-        nca.GetTitleId(), // Title ID
-        0,                // Ignore/Default title version
-        type,             // Type
-        {},               // Padding
-        0x10,             // Default table offset
-        1,                // 1 Content Entry
-        0,                // No Meta Entries
-        {},               // Padding
-        {},               // Reserved 1
-        0,                // Is committed
-        0,                // Required download system version
-        {},               // Reserved 2
+        nca.GetTitleId(), ///< Title ID
+        0,                ///< Ignore/Default title version
+        type,             ///< Type
+        {},               ///< Padding
+        0x10,             ///< Default table offset
+        1,                ///< 1 Content Entry
+        0,                ///< No Meta Entries
+        {},               ///< Padding
    };
    OptionalHeader opt_header{0, 0};
    ContentRecord c_rec{{}, {}, {}, GetCRTypeFromNCAType(nca.GetType()), {}};
@@ -852,8 +848,7 @@ VirtualFile ManualContentProvider::GetEntryUnparsed(u64 title_id, ContentRecordT
 VirtualFile ManualContentProvider::GetEntryRaw(u64 title_id, ContentRecordType type) const {
    const auto iter =
        std::find_if(entries.begin(), entries.end(), [title_id, type](const auto& entry) {
-            const auto content_type = std::get<1>(entry.first);
-            const auto e_title_id = std::get<2>(entry.first);
+            const auto [title_type, content_type, e_title_id] = entry.first;
            return content_type == type && e_title_id == title_id;
        });
    if (iter == entries.end())
--- a/src/core/file_sys/romfs.cpp
+++ b/src/core/file_sys/romfs.cpp
@@ -5,7 +5,6 @@
 #include <memory>

 #include "common/common_types.h"
-#include "common/string_util.h"
 #include "common/swap.h"
 #include "core/file_sys/fsmitm_romfsbuild.h"
 #include "core/file_sys/romfs.h"
@@ -127,7 +126,7 @@ VirtualDir ExtractRomFS(VirtualFile file, RomFSExtractionType type) {
        return out->GetSubdirectories().front();

    while (out->GetSubdirectories().size() == 1 && out->GetFiles().empty()) {
-        if (Common::ToLower(out->GetSubdirectories().front()->GetName()) == "data" &&
+        if (out->GetSubdirectories().front()->GetName() == "data" &&
            type == RomFSExtractionType::Truncated)
            break;
        out = out->GetSubdirectories().front();
--- a/src/core/file_sys/vfs_libzip.cpp
+++ b/src/core/file_sys/vfs_libzip.cpp
@@ -42,11 +42,11 @@ VirtualDir ExtractZIP(VirtualFile file) {
            continue;

        if (name.back() != '/') {
-            std::unique_ptr<zip_file_t, decltype(&zip_fclose)> file2{
+            std::unique_ptr<zip_file_t, decltype(&zip_fclose)> file{
                zip_fopen_index(zip.get(), i, 0), zip_fclose};

            std::vector<u8> buf(stat.size);
-            if (zip_fread(file2.get(), buf.data(), buf.size()) != s64(buf.size()))
+            if (zip_fread(file.get(), buf.data(), buf.size()) != buf.size())
                return nullptr;

            const auto parts = FileUtil::SplitPathComponents(stat.name);
--- a/src/core/frontend/emu_window.h
+++ b/src/core/frontend/emu_window.h
@@ -12,49 +12,23 @@

 namespace Core::Frontend {

-/// Information for the Graphics Backends signifying what type of screen pointer is in
-/// WindowInformation
-enum class WindowSystemType {
-    Headless,
-    Windows,
-    X11,
-    Wayland,
-};
-
 /**
- * Represents a drawing context that supports graphics operations.
+ * Represents a graphics context that can be used for background computation or drawing. If the
+ * graphics backend doesn't require the context, then the implementation of these methods can be
+ * stubs
 */
 class GraphicsContext {
 public:
    virtual ~GraphicsContext();

-    /// Inform the driver to swap the front/back buffers and present the current image
-    virtual void SwapBuffers() {}
-
    /// Makes the graphics context current for the caller thread
-    virtual void MakeCurrent() {}
+    virtual void MakeCurrent() = 0;

    /// Releases (dunno if this is the "right" word) the context from the caller thread
-    virtual void DoneCurrent() {}
+    virtual void DoneCurrent() = 0;

-    class Scoped {
-    public:
-        explicit Scoped(GraphicsContext& context_) : context(context_) {
-            context.MakeCurrent();
-        }
-        ~Scoped() {
-            context.DoneCurrent();
-        }
-
-    private:
-        GraphicsContext& context;
-    };
-
-    /// Calls MakeCurrent on the context and calls DoneCurrent when the scope for the returned value
-    /// ends
-    Scoped Acquire() {
-        return Scoped{*this};
-    }
+    /// Swap buffers to display the next frame
+    virtual void SwapBuffers() = 0;
 };

 /**
@@ -75,7 +49,7 @@ public:
 * - DO NOT TREAT THIS CLASS AS A GUI TOOLKIT ABSTRACTION LAYER. That's not what it is. Please
 *   re-read the upper points again and think about it if you don't see this.
 */
-class EmuWindow {
+class EmuWindow : public GraphicsContext {
 public:
    /// Data structure to store emuwindow configuration
    struct WindowConfig {
@@ -85,34 +59,29 @@ public:
        std::pair<unsigned, unsigned> min_client_area_size;
    };

-    /// Data describing host window system information
-    struct WindowSystemInfo {
-        // Window system type. Determines which GL context or Vulkan WSI is used.
-        WindowSystemType type = WindowSystemType::Headless;
-
-        // Connection to a display server. This is used on X11 and Wayland platforms.
-        void* display_connection = nullptr;
-
-        // Render surface. This is a pointer to the native window handle, which depends
-        // on the platform. e.g. HWND for Windows, Window for X11. If the surface is
-        // set to nullptr, the video backend will run in headless mode.
-        void* render_surface = nullptr;
-
-        // Scale of the render surface. For hidpi systems, this will be >1.
-        float render_surface_scale = 1.0f;
-    };
-
    /// Polls window events
    virtual void PollEvents() = 0;

    /**
-     * Returns a GraphicsContext that the frontend provides to be used for rendering.
+     * Returns a GraphicsContext that the frontend provides that is shared with the emu window. This
+     * context can be used from other threads for background graphics computation. If the frontend
+     * is using a graphics backend that doesn't need anything specific to run on a different thread,
+     * then it can use a stubbed implemenation for GraphicsContext.
+     *
+     * If the return value is null, then the core should assume that the frontend cannot provide a
+     * Shared Context
     */
-    virtual std::unique_ptr<GraphicsContext> CreateSharedContext() const = 0;
+    virtual std::unique_ptr<GraphicsContext> CreateSharedContext() const {
+        return nullptr;
+    }

    /// Returns if window is shown (not minimized)
    virtual bool IsShown() const = 0;

+    /// Retrieves Vulkan specific handlers from the window
+    virtual void RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
+                                        void* surface) const = 0;
+
    /**
     * Signal that a touch pressed event has occurred (e.g. mouse click pressed)
     * @param framebuffer_x Framebuffer x-coordinate that was pressed
@@ -149,13 +118,6 @@ public:
        config = val;
    }

-    /**
-     * Returns system information about the drawing area.
-     */
-    const WindowSystemInfo& GetWindowInfo() const {
-        return window_info;
-    }
-
    /**
     * Gets the framebuffer layout (width, height, and screen regions)
     * @note This method is thread-safe
@@ -171,7 +133,7 @@ public:
    void UpdateCurrentFramebufferLayout(unsigned width, unsigned height);

 protected:
-    explicit EmuWindow();
+    EmuWindow();
    virtual ~EmuWindow();

    /**
@@ -208,8 +170,6 @@ protected:
        client_area_height = size.second;
    }

-    WindowSystemInfo window_info;
-
 private:
    /**
     * Handler called when the minimal client area was requested to be changed via SetConfig.
--- a/src/core/frontend/framebuffer_layout.cpp
+++ b/src/core/frontend/framebuffer_layout.cpp
@@ -25,7 +25,7 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
    ASSERT(height > 0);
    // The drawing code needs at least somewhat valid values for both screens
    // so just calculate them both even if the other isn't showing.
-    FramebufferLayout res{width, height, false, {}};
+    FramebufferLayout res{width, height};

    const float window_aspect_ratio = static_cast<float>(height) / width;
    const float emulation_aspect_ratio = EmulationAspectRatio(
@@ -48,8 +48,8 @@ FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale) {
    u32 width, height;

    if (Settings::values.use_docked_mode) {
-        width = ScreenDocked::Width * res_scale;
-        height = ScreenDocked::Height * res_scale;
+        width = ScreenDocked::WidthDocked * res_scale;
+        height = ScreenDocked::HeightDocked * res_scale;
    } else {
        width = ScreenUndocked::Width * res_scale;
        height = ScreenUndocked::Height * res_scale;
--- a/src/core/frontend/framebuffer_layout.h
+++ b/src/core/frontend/framebuffer_layout.h
@@ -8,15 +8,15 @@

 namespace Layout {

-namespace ScreenUndocked {
-constexpr u32 Width = 1280;
-constexpr u32 Height = 720;
-} // namespace ScreenUndocked
+enum ScreenUndocked : u32 {
+    Width = 1280,
+    Height = 720,
+};

-namespace ScreenDocked {
-constexpr u32 Width = 1920;
-constexpr u32 Height = 1080;
-} // namespace ScreenDocked
+enum ScreenDocked : u32 {
+    WidthDocked = 1920,
+    HeightDocked = 1080,
+};

 enum class AspectRatio {
    Default,
@@ -29,7 +29,6 @@ enum class AspectRatio {
 struct FramebufferLayout {
    u32 width{ScreenUndocked::Width};
    u32 height{ScreenUndocked::Height};
-    bool is_srgb{};

    Common::Rectangle<u32> screen;

--- a/src/core/frontend/scope_acquire_window_context.cpp
+++ b/src/core/frontend/scope_acquire_window_context.cpp
@@ -0,0 +1,18 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/frontend/emu_window.h"
+#include "core/frontend/scope_acquire_window_context.h"
+
+namespace Core::Frontend {
+
+ScopeAcquireWindowContext::ScopeAcquireWindowContext(Core::Frontend::EmuWindow& emu_window_)
+    : emu_window{emu_window_} {
+    emu_window.MakeCurrent();
+}
+ScopeAcquireWindowContext::~ScopeAcquireWindowContext() {
+    emu_window.DoneCurrent();
+}
+
+} // namespace Core::Frontend
--- a/src/core/frontend/scope_acquire_window_context.h
+++ b/src/core/frontend/scope_acquire_window_context.h
@@ -0,0 +1,23 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace Core::Frontend {
+
+class EmuWindow;
+
+/// Helper class to acquire/release window context within a given scope
+class ScopeAcquireWindowContext : NonCopyable {
+public:
+    explicit ScopeAcquireWindowContext(Core::Frontend::EmuWindow& window);
+    ~ScopeAcquireWindowContext();
+
+private:
+    Core::Frontend::EmuWindow& emu_window;
+};
+
+} // namespace Core::Frontend
--- a/src/core/gdbstub/gdbstub.cpp
+++ b/src/core/gdbstub/gdbstub.cpp
@@ -37,9 +37,9 @@
 #include "core/core.h"
 #include "core/core_manager.h"
 #include "core/gdbstub/gdbstub.h"
-#include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
+#include "core/hle/kernel/vm_manager.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"

@@ -141,7 +141,6 @@ constexpr char target_xml[] =
 )";

 int gdbserver_socket = -1;
-bool defer_start = false;

 u8 command_buffer[GDB_BUFFER_SIZE];
 u32 command_length;
@@ -218,7 +217,7 @@ static u64 RegRead(std::size_t id, Kernel::Thread* thread = nullptr) {
        return 0;
    }

-    const auto& thread_context = thread->GetContext64();
+    const auto& thread_context = thread->GetContext();

    if (id < SP_REGISTER) {
        return thread_context.cpu_registers[id];
@@ -240,7 +239,7 @@ static void RegWrite(std::size_t id, u64 val, Kernel::Thread* thread = nullptr)
        return;
    }

-    auto& thread_context = thread->GetContext64();
+    auto& thread_context = thread->GetContext();

    if (id < SP_REGISTER) {
        thread_context.cpu_registers[id] = val;
@@ -260,7 +259,7 @@ static u128 FpuRead(std::size_t id, Kernel::Thread* thread = nullptr) {
        return u128{0};
    }

-    auto& thread_context = thread->GetContext64();
+    auto& thread_context = thread->GetContext();

    if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
        return thread_context.vector_registers[id - UC_ARM64_REG_Q0];
@@ -276,7 +275,7 @@ static void FpuWrite(std::size_t id, u128 val, Kernel::Thread* thread = nullptr)
        return;
    }

-    auto& thread_context = thread->GetContext64();
+    auto& thread_context = thread->GetContext();

    if (id >= UC_ARM64_REG_Q0 && id < FPCR_REGISTER) {
        thread_context.vector_registers[id - UC_ARM64_REG_Q0] = val;
@@ -643,7 +642,7 @@ static void HandleQuery() {
        SendReply(target_xml);
    } else if (strncmp(query, "Offsets", strlen("Offsets")) == 0) {
        const VAddr base_address =
-            Core::System::GetInstance().CurrentProcess()->PageTable().GetCodeRegionStart();
+            Core::System::GetInstance().CurrentProcess()->VMManager().GetCodeRegionBaseAddress();
        std::string buffer = fmt::format("TextSeg={:0x}", base_address);
        SendReply(buffer.c_str());
    } else if (strncmp(query, "fThreadInfo", strlen("fThreadInfo")) == 0) {
@@ -917,7 +916,7 @@ static void WriteRegister() {
    // Update ARM context, skipping scheduler - no running threads at this point
    Core::System::GetInstance()
        .ArmInterface(current_core)
-        .LoadContext(current_thread->GetContext64());
+        .LoadContext(current_thread->GetContext());

    SendReply("OK");
 }
@@ -948,7 +947,7 @@ static void WriteRegisters() {
    // Update ARM context, skipping scheduler - no running threads at this point
    Core::System::GetInstance()
        .ArmInterface(current_core)
-        .LoadContext(current_thread->GetContext64());
+        .LoadContext(current_thread->GetContext());

    SendReply("OK");
 }
@@ -1020,7 +1019,7 @@ static void Step() {
        // Update ARM context, skipping scheduler - no running threads at this point
        Core::System::GetInstance()
            .ArmInterface(current_core)
-            .LoadContext(current_thread->GetContext64());
+            .LoadContext(current_thread->GetContext());
    }
    step_loop = true;
    halt_loop = true;
@@ -1167,9 +1166,6 @@ static void RemoveBreakpoint() {

 void HandlePacket() {
    if (!IsConnected()) {
-        if (defer_start) {
-            ToggleServer(true);
-        }
        return;
    }

@@ -1260,10 +1256,6 @@ void ToggleServer(bool status) {
    }
 }

-void DeferStart() {
-    defer_start = true;
-}
-
 static void Init(u16 port) {
    if (!server_enabled) {
        // Set the halt loop to false in case the user enabled the gdbstub mid-execution.
@@ -1349,7 +1341,6 @@ void Shutdown() {
    if (!server_enabled) {
        return;
    }
-    defer_start = false;

    LOG_INFO(Debug_GDBStub, "Stopping GDB ...");
    if (gdbserver_socket != -1) {
--- a/src/core/gdbstub/gdbstub.h
+++ b/src/core/gdbstub/gdbstub.h
@@ -43,13 +43,6 @@ void ToggleServer(bool status);
 /// Start the gdbstub server.
 void Init();

-/**
- * Defer initialization of the gdbstub to the first packet processing functions.
- * This avoids a case where the gdbstub thread is frozen after initialization
- * and fails to respond in time to packets.
- */
-void DeferStart();
-
 /// Stop gdbstub server.
 void Shutdown();

--- a/src/core/hle/kernel/client_session.cpp
+++ b/src/core/hle/kernel/client_session.cpp
@@ -47,8 +47,7 @@ ResultVal<std::shared_ptr<ClientSession>> ClientSession::Create(KernelCore& kern
    return MakeResult(std::move(client_session));
 }

-ResultCode ClientSession::SendSyncRequest(std::shared_ptr<Thread> thread,
-                                          Core::Memory::Memory& memory) {
+ResultCode ClientSession::SendSyncRequest(std::shared_ptr<Thread> thread, Memory::Memory& memory) {
    // Keep ServerSession alive until we're done working with it.
    if (!parent->Server()) {
        return ERR_SESSION_CLOSED_BY_REMOTE;
--- a/src/core/hle/kernel/client_session.h
+++ b/src/core/hle/kernel/client_session.h
@@ -12,7 +12,7 @@

 union ResultCode;

-namespace Core::Memory {
+namespace Memory {
 class Memory;
 }

@@ -42,7 +42,7 @@ public:
        return HANDLE_TYPE;
    }

-    ResultCode SendSyncRequest(std::shared_ptr<Thread> thread, Core::Memory::Memory& memory);
+    ResultCode SendSyncRequest(std::shared_ptr<Thread> thread, Memory::Memory& memory);

    bool ShouldWait(const Thread* thread) const override;

--- a/src/core/hle/kernel/errors.h
+++ b/src/core/hle/kernel/errors.h
@@ -14,7 +14,6 @@ constexpr ResultCode ERR_MAX_CONNECTIONS_REACHED{ErrorModule::Kernel, 7};
 constexpr ResultCode ERR_INVALID_CAPABILITY_DESCRIPTOR{ErrorModule::Kernel, 14};
 constexpr ResultCode ERR_INVALID_SIZE{ErrorModule::Kernel, 101};
 constexpr ResultCode ERR_INVALID_ADDRESS{ErrorModule::Kernel, 102};
-constexpr ResultCode ERR_OUT_OF_RESOURCES{ErrorModule::Kernel, 103};
 constexpr ResultCode ERR_OUT_OF_MEMORY{ErrorModule::Kernel, 104};
 constexpr ResultCode ERR_HANDLE_TABLE_FULL{ErrorModule::Kernel, 105};
 constexpr ResultCode ERR_INVALID_ADDRESS_STATE{ErrorModule::Kernel, 106};
--- a/src/core/hle/kernel/hle_ipc.cpp
+++ b/src/core/hle/kernel/hle_ipc.cpp
@@ -284,17 +284,17 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {

 std::vector<u8> HLERequestContext::ReadBuffer(int buffer_index) const {
    std::vector<u8> buffer;
-    const bool is_buffer_a{BufferDescriptorA().size() > std::size_t(buffer_index) &&
+    const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
                           BufferDescriptorA()[buffer_index].Size()};
    auto& memory = Core::System::GetInstance().Memory();

    if (is_buffer_a) {
-        ASSERT_MSG(BufferDescriptorA().size() > std::size_t(buffer_index),
+        ASSERT_MSG(BufferDescriptorA().size() > buffer_index,
                   "BufferDescriptorA invalid buffer_index {}", buffer_index);
        buffer.resize(BufferDescriptorA()[buffer_index].Size());
        memory.ReadBlock(BufferDescriptorA()[buffer_index].Address(), buffer.data(), buffer.size());
    } else {
-        ASSERT_MSG(BufferDescriptorX().size() > std::size_t(buffer_index),
+        ASSERT_MSG(BufferDescriptorX().size() > buffer_index,
                   "BufferDescriptorX invalid buffer_index {}", buffer_index);
        buffer.resize(BufferDescriptorX()[buffer_index].Size());
        memory.ReadBlock(BufferDescriptorX()[buffer_index].Address(), buffer.data(), buffer.size());
@@ -310,7 +310,7 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
        return 0;
    }

-    const bool is_buffer_b{BufferDescriptorB().size() > std::size_t(buffer_index) &&
+    const bool is_buffer_b{BufferDescriptorB().size() > buffer_index &&
                           BufferDescriptorB()[buffer_index].Size()};
    const std::size_t buffer_size{GetWriteBufferSize(buffer_index)};
    if (size > buffer_size) {
@@ -321,13 +321,13 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,

    auto& memory = Core::System::GetInstance().Memory();
    if (is_buffer_b) {
-        ASSERT_MSG(BufferDescriptorB().size() > std::size_t(buffer_index),
+        ASSERT_MSG(BufferDescriptorB().size() > buffer_index,
                   "BufferDescriptorB invalid buffer_index {}", buffer_index);
        ASSERT_MSG(BufferDescriptorB()[buffer_index].Size() >= size,
                   "BufferDescriptorB buffer_index {} is not large enough", buffer_index);
        memory.WriteBlock(BufferDescriptorB()[buffer_index].Address(), buffer, size);
    } else {
-        ASSERT_MSG(BufferDescriptorC().size() > std::size_t(buffer_index),
+        ASSERT_MSG(BufferDescriptorC().size() > buffer_index,
                   "BufferDescriptorC invalid buffer_index {}", buffer_index);
        ASSERT_MSG(BufferDescriptorC()[buffer_index].Size() >= size,
                   "BufferDescriptorC buffer_index {} is not large enough", buffer_index);
@@ -338,16 +338,16 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
 }

 std::size_t HLERequestContext::GetReadBufferSize(int buffer_index) const {
-    const bool is_buffer_a{BufferDescriptorA().size() > std::size_t(buffer_index) &&
+    const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
                           BufferDescriptorA()[buffer_index].Size()};
    if (is_buffer_a) {
-        ASSERT_MSG(BufferDescriptorA().size() > std::size_t(buffer_index),
+        ASSERT_MSG(BufferDescriptorA().size() > buffer_index,
                   "BufferDescriptorA invalid buffer_index {}", buffer_index);
        ASSERT_MSG(BufferDescriptorA()[buffer_index].Size() > 0,
                   "BufferDescriptorA buffer_index {} is empty", buffer_index);
        return BufferDescriptorA()[buffer_index].Size();
    } else {
-        ASSERT_MSG(BufferDescriptorX().size() > std::size_t(buffer_index),
+        ASSERT_MSG(BufferDescriptorX().size() > buffer_index,
                   "BufferDescriptorX invalid buffer_index {}", buffer_index);
        ASSERT_MSG(BufferDescriptorX()[buffer_index].Size() > 0,
                   "BufferDescriptorX buffer_index {} is empty", buffer_index);
@@ -356,14 +356,14 @@ std::size_t HLERequestContext::GetReadBufferSize(int buffer_index) const {
 }

 std::size_t HLERequestContext::GetWriteBufferSize(int buffer_index) const {
-    const bool is_buffer_b{BufferDescriptorB().size() > std::size_t(buffer_index) &&
+    const bool is_buffer_b{BufferDescriptorB().size() > buffer_index &&
                           BufferDescriptorB()[buffer_index].Size()};
    if (is_buffer_b) {
-        ASSERT_MSG(BufferDescriptorB().size() > std::size_t(buffer_index),
+        ASSERT_MSG(BufferDescriptorB().size() > buffer_index,
                   "BufferDescriptorB invalid buffer_index {}", buffer_index);
        return BufferDescriptorB()[buffer_index].Size();
    } else {
-        ASSERT_MSG(BufferDescriptorC().size() > std::size_t(buffer_index),
+        ASSERT_MSG(BufferDescriptorC().size() > buffer_index,
                   "BufferDescriptorC invalid buffer_index {}", buffer_index);
        return BufferDescriptorC()[buffer_index].Size();
    }
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -18,20 +18,15 @@
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
-#include "core/device_memory.h"
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/memory/memory_layout.h"
-#include "core/hle/kernel/memory/memory_manager.h"
-#include "core/hle/kernel/memory/slab_heap.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/scheduler.h"
-#include "core/hle/kernel/shared_memory.h"
 #include "core/hle/kernel/synchronization.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/time_manager.h"
@@ -108,14 +103,13 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_

 struct KernelCore::Impl {
    explicit Impl(Core::System& system, KernelCore& kernel)
-        : global_scheduler{kernel}, synchronization{system}, time_manager{system}, system{system} {}
+        : system{system}, global_scheduler{kernel}, synchronization{system}, time_manager{system} {}

    void Initialize(KernelCore& kernel) {
        Shutdown();

        InitializePhysicalCores();
        InitializeSystemResourceLimit(kernel);
-        InitializeMemoryLayout();
        InitializeThreads();
        InitializePreemption();
    }
@@ -160,17 +154,12 @@ struct KernelCore::Impl {
        system_resource_limit = ResourceLimit::Create(kernel);

        // If setting the default system values fails, then something seriously wrong has occurred.
-        ASSERT(system_resource_limit->SetLimitValue(ResourceType::PhysicalMemory, 0x100000000)
+        ASSERT(system_resource_limit->SetLimitValue(ResourceType::PhysicalMemory, 0x200000000)
                   .IsSuccess());
        ASSERT(system_resource_limit->SetLimitValue(ResourceType::Threads, 800).IsSuccess());
        ASSERT(system_resource_limit->SetLimitValue(ResourceType::Events, 700).IsSuccess());
        ASSERT(system_resource_limit->SetLimitValue(ResourceType::TransferMemory, 200).IsSuccess());
        ASSERT(system_resource_limit->SetLimitValue(ResourceType::Sessions, 900).IsSuccess());
-
-        if (!system_resource_limit->Reserve(ResourceType::PhysicalMemory, 0) ||
-            !system_resource_limit->Reserve(ResourceType::PhysicalMemory, 0x60000)) {
-            UNREACHABLE();
-        }
    }

    void InitializeThreads() {
@@ -197,10 +186,6 @@ struct KernelCore::Impl {
            return;
        }

-        for (auto& core : cores) {
-            core.SetIs64Bit(process->Is64BitProcess());
-        }
-
        system.Memory().SetCurrentPageTable(*process);
    }

@@ -248,57 +233,6 @@ struct KernelCore::Impl {
        return result;
    }

-    void InitializeMemoryLayout() {
-        // Initialize memory layout
-        constexpr Memory::MemoryLayout layout{Memory::MemoryLayout::GetDefaultLayout()};
-        constexpr std::size_t hid_size{0x40000};
-        constexpr std::size_t font_size{0x1100000};
-        constexpr std::size_t irs_size{0x8000};
-        constexpr std::size_t time_size{0x1000};
-        constexpr PAddr hid_addr{layout.System().StartAddress()};
-        constexpr PAddr font_pa{layout.System().StartAddress() + hid_size};
-        constexpr PAddr irs_addr{layout.System().StartAddress() + hid_size + font_size};
-        constexpr PAddr time_addr{layout.System().StartAddress() + hid_size + font_size + irs_size};
-
-        // Initialize memory manager
-        memory_manager = std::make_unique<Memory::MemoryManager>();
-        memory_manager->InitializeManager(Memory::MemoryManager::Pool::Application,
-                                          layout.Application().StartAddress(),
-                                          layout.Application().EndAddress());
-        memory_manager->InitializeManager(Memory::MemoryManager::Pool::Applet,
-                                          layout.Applet().StartAddress(),
-                                          layout.Applet().EndAddress());
-        memory_manager->InitializeManager(Memory::MemoryManager::Pool::System,
-                                          layout.System().StartAddress(),
-                                          layout.System().EndAddress());
-
-        hid_shared_mem = Kernel::SharedMemory::Create(
-            system.Kernel(), system.DeviceMemory(), nullptr,
-            {hid_addr, hid_size / Memory::PageSize}, Memory::MemoryPermission::None,
-            Memory::MemoryPermission::Read, hid_addr, hid_size, "HID:SharedMemory");
-        font_shared_mem = Kernel::SharedMemory::Create(
-            system.Kernel(), system.DeviceMemory(), nullptr,
-            {font_pa, font_size / Memory::PageSize}, Memory::MemoryPermission::None,
-            Memory::MemoryPermission::Read, font_pa, font_size, "Font:SharedMemory");
-        irs_shared_mem = Kernel::SharedMemory::Create(
-            system.Kernel(), system.DeviceMemory(), nullptr,
-            {irs_addr, irs_size / Memory::PageSize}, Memory::MemoryPermission::None,
-            Memory::MemoryPermission::Read, irs_addr, irs_size, "IRS:SharedMemory");
-        time_shared_mem = Kernel::SharedMemory::Create(
-            system.Kernel(), system.DeviceMemory(), nullptr,
-            {time_addr, time_size / Memory::PageSize}, Memory::MemoryPermission::None,
-            Memory::MemoryPermission::Read, time_addr, time_size, "Time:SharedMemory");
-
-        // Allocate slab heaps
-        user_slab_heap_pages = std::make_unique<Memory::SlabHeap<Memory::Page>>();
-
-        // Initialize slab heaps
-        constexpr u64 user_slab_heap_size{0x3de000};
-        user_slab_heap_pages->Initialize(
-            system.DeviceMemory().GetPointer(Core::DramMemoryMap::SlabHeapBase),
-            user_slab_heap_size);
-    }
-
    std::atomic<u32> next_object_id{0};
    std::atomic<u64> next_kernel_process_id{Process::InitialKIPIDMin};
    std::atomic<u64> next_user_process_id{Process::ProcessIDMin};
@@ -333,16 +267,6 @@ struct KernelCore::Impl {
    std::bitset<Core::Hardware::NUM_CPU_CORES> registered_core_threads;
    std::mutex register_thread_mutex;

-    // Kernel memory management
-    std::unique_ptr<Memory::MemoryManager> memory_manager;
-    std::unique_ptr<Memory::SlabHeap<Memory::Page>> user_slab_heap_pages;
-
-    // Shared memory for services
-    std::shared_ptr<Kernel::SharedMemory> hid_shared_mem;
-    std::shared_ptr<Kernel::SharedMemory> font_shared_mem;
-    std::shared_ptr<Kernel::SharedMemory> irs_shared_mem;
-    std::shared_ptr<Kernel::SharedMemory> time_shared_mem;
-
    // System context
    Core::System& system;
 };
@@ -509,52 +433,4 @@ Core::EmuThreadHandle KernelCore::GetCurrentEmuThreadID() const {
    return impl->GetCurrentEmuThreadID();
 }

-Memory::MemoryManager& KernelCore::MemoryManager() {
-    return *impl->memory_manager;
-}
-
-const Memory::MemoryManager& KernelCore::MemoryManager() const {
-    return *impl->memory_manager;
-}
-
-Memory::SlabHeap<Memory::Page>& KernelCore::GetUserSlabHeapPages() {
-    return *impl->user_slab_heap_pages;
-}
-
-const Memory::SlabHeap<Memory::Page>& KernelCore::GetUserSlabHeapPages() const {
-    return *impl->user_slab_heap_pages;
-}
-
-Kernel::SharedMemory& KernelCore::GetHidSharedMem() {
-    return *impl->hid_shared_mem;
-}
-
-const Kernel::SharedMemory& KernelCore::GetHidSharedMem() const {
-    return *impl->hid_shared_mem;
-}
-
-Kernel::SharedMemory& KernelCore::GetFontSharedMem() {
-    return *impl->font_shared_mem;
-}
-
-const Kernel::SharedMemory& KernelCore::GetFontSharedMem() const {
-    return *impl->font_shared_mem;
-}
-
-Kernel::SharedMemory& KernelCore::GetIrsSharedMem() {
-    return *impl->irs_shared_mem;
-}
-
-const Kernel::SharedMemory& KernelCore::GetIrsSharedMem() const {
-    return *impl->irs_shared_mem;
-}
-
-Kernel::SharedMemory& KernelCore::GetTimeSharedMem() {
-    return *impl->time_shared_mem;
-}
-
-const Kernel::SharedMemory& KernelCore::GetTimeSharedMem() const {
-    return *impl->time_shared_mem;
-}
-
 } // namespace Kernel
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -8,7 +8,6 @@
 #include <string>
 #include <unordered_map>
 #include <vector>
-#include "core/hle/kernel/memory/memory_types.h"
 #include "core/hle/kernel/object.h"

 namespace Core {
@@ -24,12 +23,6 @@ struct EventType;

 namespace Kernel {

-namespace Memory {
-class MemoryManager;
-template <typename T>
-class SlabHeap;
-} // namespace Memory
-
 class AddressArbiter;
 class ClientPort;
 class GlobalScheduler;
@@ -38,7 +31,6 @@ class PhysicalCore;
 class Process;
 class ResourceLimit;
 class Scheduler;
-class SharedMemory;
 class Synchronization;
 class Thread;
 class TimeManager;
@@ -155,42 +147,6 @@ public:
    /// Register the current thread as a non CPU core thread.
    void RegisterHostThread();

-    /// Gets the virtual memory manager for the kernel.
-    Memory::MemoryManager& MemoryManager();
-
-    /// Gets the virtual memory manager for the kernel.
-    const Memory::MemoryManager& MemoryManager() const;
-
-    /// Gets the slab heap allocated for user space pages.
-    Memory::SlabHeap<Memory::Page>& GetUserSlabHeapPages();
-
-    /// Gets the slab heap allocated for user space pages.
-    const Memory::SlabHeap<Memory::Page>& GetUserSlabHeapPages() const;
-
-    /// Gets the shared memory object for HID services.
-    Kernel::SharedMemory& GetHidSharedMem();
-
-    /// Gets the shared memory object for HID services.
-    const Kernel::SharedMemory& GetHidSharedMem() const;
-
-    /// Gets the shared memory object for font services.
-    Kernel::SharedMemory& GetFontSharedMem();
-
-    /// Gets the shared memory object for font services.
-    const Kernel::SharedMemory& GetFontSharedMem() const;
-
-    /// Gets the shared memory object for IRS services.
-    Kernel::SharedMemory& GetIrsSharedMem();
-
-    /// Gets the shared memory object for IRS services.
-    const Kernel::SharedMemory& GetIrsSharedMem() const;
-
-    /// Gets the shared memory object for Time services.
-    Kernel::SharedMemory& GetTimeSharedMem();
-
-    /// Gets the shared memory object for Time services.
-    const Kernel::SharedMemory& GetTimeSharedMem() const;
-
 private:
    friend class Object;
    friend class Process;
--- a/src/core/hle/kernel/memory/address_space_info.cpp
+++ b/src/core/hle/kernel/memory/address_space_info.cpp
@@ -1,118 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-// This file references various implementation details from Atmosph<70>re, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosph<70>re-NX.
-
-#include <array>
-
-#include "common/assert.h"
-#include "core/hle/kernel/memory/address_space_info.h"
-
-namespace Kernel::Memory {
-
-namespace {
-
-enum : u64 {
-    Size_1_MB = 0x100000,
-    Size_2_MB = 2 * Size_1_MB,
-    Size_128_MB = 128 * Size_1_MB,
-    Size_1_GB = 0x40000000,
-    Size_2_GB = 2 * Size_1_GB,
-    Size_4_GB = 4 * Size_1_GB,
-    Size_6_GB = 6 * Size_1_GB,
-    Size_64_GB = 64 * Size_1_GB,
-    Size_512_GB = 512 * Size_1_GB,
-    Invalid = std::numeric_limits<u64>::max(),
-};
-
-// clang-format off
-constexpr std::array<AddressSpaceInfo, 13> AddressSpaceInfos{{
-   { 32 /*bit_width*/, Size_2_MB   /*addr*/, Size_1_GB   - Size_2_MB   /*size*/, AddressSpaceInfo::Type::Is32Bit,    },
-   { 32 /*bit_width*/, Size_1_GB   /*addr*/, Size_4_GB   - Size_1_GB   /*size*/, AddressSpaceInfo::Type::Small64Bit, },
-   { 32 /*bit_width*/, Invalid     /*addr*/, Size_1_GB                 /*size*/, AddressSpaceInfo::Type::Heap,       },
-   { 32 /*bit_width*/, Invalid     /*addr*/, Size_1_GB                 /*size*/, AddressSpaceInfo::Type::Alias,      },
-   { 36 /*bit_width*/, Size_128_MB /*addr*/, Size_2_GB   - Size_128_MB /*size*/, AddressSpaceInfo::Type::Is32Bit,    },
-   { 36 /*bit_width*/, Size_2_GB   /*addr*/, Size_64_GB  - Size_2_GB   /*size*/, AddressSpaceInfo::Type::Small64Bit, },
-   { 36 /*bit_width*/, Invalid     /*addr*/, Size_6_GB                 /*size*/, AddressSpaceInfo::Type::Heap,       },
-   { 36 /*bit_width*/, Invalid     /*addr*/, Size_6_GB                 /*size*/, AddressSpaceInfo::Type::Alias,      },
-   { 39 /*bit_width*/, Size_128_MB /*addr*/, Size_512_GB - Size_128_MB /*size*/, AddressSpaceInfo::Type::Large64Bit, },
-   { 39 /*bit_width*/, Invalid     /*addr*/, Size_64_GB                /*size*/, AddressSpaceInfo::Type::Is32Bit     },
-   { 39 /*bit_width*/, Invalid     /*addr*/, Size_6_GB                 /*size*/, AddressSpaceInfo::Type::Heap,       },
-   { 39 /*bit_width*/, Invalid     /*addr*/, Size_64_GB                /*size*/, AddressSpaceInfo::Type::Alias,      },
-   { 39 /*bit_width*/, Invalid     /*addr*/, Size_2_GB                 /*size*/, AddressSpaceInfo::Type::Stack,      },
-}};
-// clang-format on
-
-constexpr bool IsAllowedIndexForAddress(std::size_t index) {
-    return index < std::size(AddressSpaceInfos) && AddressSpaceInfos[index].GetAddress() != Invalid;
-}
-
-constexpr std::size_t
-    AddressSpaceIndices32Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
-        0, 1, 0, 2, 0, 3,
-    };
-
-constexpr std::size_t
-    AddressSpaceIndices36Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
-        4, 5, 4, 6, 4, 7,
-    };
-
-constexpr std::size_t
-    AddressSpaceIndices39Bit[static_cast<std::size_t>(AddressSpaceInfo::Type::Count)]{
-        9, 8, 8, 10, 12, 11,
-    };
-
-constexpr bool IsAllowed32BitType(AddressSpaceInfo::Type type) {
-    return type < AddressSpaceInfo::Type::Count && type != AddressSpaceInfo::Type::Large64Bit &&
-           type != AddressSpaceInfo::Type::Stack;
-}
-
-constexpr bool IsAllowed36BitType(AddressSpaceInfo::Type type) {
-    return type < AddressSpaceInfo::Type::Count && type != AddressSpaceInfo::Type::Large64Bit &&
-           type != AddressSpaceInfo::Type::Stack;
-}
-
-constexpr bool IsAllowed39BitType(AddressSpaceInfo::Type type) {
-    return type < AddressSpaceInfo::Type::Count && type != AddressSpaceInfo::Type::Small64Bit;
-}
-
-} // namespace
-
-u64 AddressSpaceInfo::GetAddressSpaceStart(std::size_t width, AddressSpaceInfo::Type type) {
-    const std::size_t index{static_cast<std::size_t>(type)};
-    switch (width) {
-    case 32:
-        ASSERT(IsAllowed32BitType(type));
-        ASSERT(IsAllowedIndexForAddress(AddressSpaceIndices32Bit[index]));
-        return AddressSpaceInfos[AddressSpaceIndices32Bit[index]].GetAddress();
-    case 36:
-        ASSERT(IsAllowed36BitType(type));
-        ASSERT(IsAllowedIndexForAddress(AddressSpaceIndices36Bit[index]));
-        return AddressSpaceInfos[AddressSpaceIndices36Bit[index]].GetAddress();
-    case 39:
-        ASSERT(IsAllowed39BitType(type));
-        ASSERT(IsAllowedIndexForAddress(AddressSpaceIndices39Bit[index]));
-        return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].GetAddress();
-    }
-    UNREACHABLE();
-}
-
-std::size_t AddressSpaceInfo::GetAddressSpaceSize(std::size_t width, AddressSpaceInfo::Type type) {
-    const std::size_t index{static_cast<std::size_t>(type)};
-    switch (width) {
-    case 32:
-        ASSERT(IsAllowed32BitType(type));
-        return AddressSpaceInfos[AddressSpaceIndices32Bit[index]].GetSize();
-    case 36:
-        ASSERT(IsAllowed36BitType(type));
-        return AddressSpaceInfos[AddressSpaceIndices36Bit[index]].GetSize();
-    case 39:
-        ASSERT(IsAllowed39BitType(type));
-        return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].GetSize();
-    }
-    UNREACHABLE();
-}
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/address_space_info.h
+++ b/src/core/hle/kernel/memory/address_space_info.h
@@ -1,54 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-// This file references various implementation details from Atmosph<70>re, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosph<70>re-NX.
-
-#pragma once
-
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-
-namespace Kernel::Memory {
-
-class AddressSpaceInfo final : NonCopyable {
-public:
-    enum class Type : u32 {
-        Is32Bit = 0,
-        Small64Bit = 1,
-        Large64Bit = 2,
-        Heap = 3,
-        Stack = 4,
-        Alias = 5,
-        Count,
-    };
-
-private:
-    std::size_t bit_width{};
-    std::size_t addr{};
-    std::size_t size{};
-    Type type{};
-
-public:
-    static u64 GetAddressSpaceStart(std::size_t width, Type type);
-    static std::size_t GetAddressSpaceSize(std::size_t width, Type type);
-
-    constexpr AddressSpaceInfo(std::size_t bit_width, std::size_t addr, std::size_t size, Type type)
-        : bit_width{bit_width}, addr{addr}, size{size}, type{type} {}
-
-    constexpr std::size_t GetWidth() const {
-        return bit_width;
-    }
-    constexpr std::size_t GetAddress() const {
-        return addr;
-    }
-    constexpr std::size_t GetSize() const {
-        return size;
-    }
-    constexpr Type GetType() const {
-        return type;
-    }
-};
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/memory_block.h
+++ b/src/core/hle/kernel/memory/memory_block.h
@@ -1,318 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-// This file references various implementation details from Atmosph<70>re, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosph<70>re-NX.
-
-#pragma once
-
-#include "common/alignment.h"
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "core/hle/kernel/memory/memory_types.h"
-#include "core/hle/kernel/svc_types.h"
-
-namespace Kernel::Memory {
-
-enum class MemoryState : u32 {
-    None = 0,
-    Mask = 0xFFFFFFFF, // TODO(bunnei): This should probable be 0xFF
-    All = ~None,
-
-    FlagCanReprotect = (1 << 8),
-    FlagCanDebug = (1 << 9),
-    FlagCanUseIpc = (1 << 10),
-    FlagCanUseNonDeviceIpc = (1 << 11),
-    FlagCanUseNonSecureIpc = (1 << 12),
-    FlagMapped = (1 << 13),
-    FlagCode = (1 << 14),
-    FlagCanAlias = (1 << 15),
-    FlagCanCodeAlias = (1 << 16),
-    FlagCanTransfer = (1 << 17),
-    FlagCanQueryPhysical = (1 << 18),
-    FlagCanDeviceMap = (1 << 19),
-    FlagCanAlignedDeviceMap = (1 << 20),
-    FlagCanIpcUserBuffer = (1 << 21),
-    FlagReferenceCounted = (1 << 22),
-    FlagCanMapProcess = (1 << 23),
-    FlagCanChangeAttribute = (1 << 24),
-    FlagCanCodeMemory = (1 << 25),
-
-    FlagsData = FlagCanReprotect | FlagCanUseIpc | FlagCanUseNonDeviceIpc | FlagCanUseNonSecureIpc |
-                FlagMapped | FlagCanAlias | FlagCanTransfer | FlagCanQueryPhysical |
-                FlagCanDeviceMap | FlagCanAlignedDeviceMap | FlagCanIpcUserBuffer |
-                FlagReferenceCounted | FlagCanChangeAttribute,
-
-    FlagsCode = FlagCanDebug | FlagCanUseIpc | FlagCanUseNonDeviceIpc | FlagCanUseNonSecureIpc |
-                FlagMapped | FlagCode | FlagCanQueryPhysical | FlagCanDeviceMap |
-                FlagCanAlignedDeviceMap | FlagReferenceCounted,
-
-    FlagsMisc = FlagMapped | FlagReferenceCounted | FlagCanQueryPhysical | FlagCanDeviceMap,
-
-    Free = static_cast<u32>(Svc::MemoryState::Free),
-    Io = static_cast<u32>(Svc::MemoryState::Io) | FlagMapped,
-    Static = static_cast<u32>(Svc::MemoryState::Static) | FlagMapped | FlagCanQueryPhysical,
-    Code = static_cast<u32>(Svc::MemoryState::Code) | FlagsCode | FlagCanMapProcess,
-    CodeData = static_cast<u32>(Svc::MemoryState::CodeData) | FlagsData | FlagCanMapProcess |
-               FlagCanCodeMemory,
-    Shared = static_cast<u32>(Svc::MemoryState::Shared) | FlagMapped | FlagReferenceCounted,
-    Normal = static_cast<u32>(Svc::MemoryState::Normal) | FlagsData | FlagCanCodeMemory,
-
-    AliasCode = static_cast<u32>(Svc::MemoryState::AliasCode) | FlagsCode | FlagCanMapProcess |
-                FlagCanCodeAlias,
-    AliasCodeData = static_cast<u32>(Svc::MemoryState::AliasCodeData) | FlagsData |
-                    FlagCanMapProcess | FlagCanCodeAlias | FlagCanCodeMemory,
-
-    Ipc = static_cast<u32>(Svc::MemoryState::Ipc) | FlagsMisc | FlagCanAlignedDeviceMap |
-          FlagCanUseIpc | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
-
-    Stack = static_cast<u32>(Svc::MemoryState::Stack) | FlagsMisc | FlagCanAlignedDeviceMap |
-            FlagCanUseIpc | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
-
-    ThreadLocal =
-        static_cast<u32>(Svc::MemoryState::ThreadLocal) | FlagMapped | FlagReferenceCounted,
-
-    Transfered = static_cast<u32>(Svc::MemoryState::Transfered) | FlagsMisc |
-                 FlagCanAlignedDeviceMap | FlagCanChangeAttribute | FlagCanUseIpc |
-                 FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
-
-    SharedTransfered = static_cast<u32>(Svc::MemoryState::SharedTransfered) | FlagsMisc |
-                       FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
-
-    SharedCode = static_cast<u32>(Svc::MemoryState::SharedCode) | FlagMapped |
-                 FlagReferenceCounted | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
-
-    Inaccessible = static_cast<u32>(Svc::MemoryState::Inaccessible),
-
-    NonSecureIpc = static_cast<u32>(Svc::MemoryState::NonSecureIpc) | FlagsMisc |
-                   FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
-
-    NonDeviceIpc =
-        static_cast<u32>(Svc::MemoryState::NonDeviceIpc) | FlagsMisc | FlagCanUseNonDeviceIpc,
-
-    Kernel = static_cast<u32>(Svc::MemoryState::Kernel) | FlagMapped,
-
-    GeneratedCode = static_cast<u32>(Svc::MemoryState::GeneratedCode) | FlagMapped |
-                    FlagReferenceCounted | FlagCanDebug,
-    CodeOut = static_cast<u32>(Svc::MemoryState::CodeOut) | FlagMapped | FlagReferenceCounted,
-};
-DECLARE_ENUM_FLAG_OPERATORS(MemoryState);
-
-static_assert(static_cast<u32>(MemoryState::Free) == 0x00000000);
-static_assert(static_cast<u32>(MemoryState::Io) == 0x00002001);
-static_assert(static_cast<u32>(MemoryState::Static) == 0x00042002);
-static_assert(static_cast<u32>(MemoryState::Code) == 0x00DC7E03);
-static_assert(static_cast<u32>(MemoryState::CodeData) == 0x03FEBD04);
-static_assert(static_cast<u32>(MemoryState::Normal) == 0x037EBD05);
-static_assert(static_cast<u32>(MemoryState::Shared) == 0x00402006);
-static_assert(static_cast<u32>(MemoryState::AliasCode) == 0x00DD7E08);
-static_assert(static_cast<u32>(MemoryState::AliasCodeData) == 0x03FFBD09);
-static_assert(static_cast<u32>(MemoryState::Ipc) == 0x005C3C0A);
-static_assert(static_cast<u32>(MemoryState::Stack) == 0x005C3C0B);
-static_assert(static_cast<u32>(MemoryState::ThreadLocal) == 0x0040200C);
-static_assert(static_cast<u32>(MemoryState::Transfered) == 0x015C3C0D);
-static_assert(static_cast<u32>(MemoryState::SharedTransfered) == 0x005C380E);
-static_assert(static_cast<u32>(MemoryState::SharedCode) == 0x0040380F);
-static_assert(static_cast<u32>(MemoryState::Inaccessible) == 0x00000010);
-static_assert(static_cast<u32>(MemoryState::NonSecureIpc) == 0x005C3811);
-static_assert(static_cast<u32>(MemoryState::NonDeviceIpc) == 0x004C2812);
-static_assert(static_cast<u32>(MemoryState::Kernel) == 0x00002013);
-static_assert(static_cast<u32>(MemoryState::GeneratedCode) == 0x00402214);
-static_assert(static_cast<u32>(MemoryState::CodeOut) == 0x00402015);
-
-enum class MemoryPermission : u8 {
-    None = 0,
-    Mask = static_cast<u8>(~None),
-
-    Read = 1 << 0,
-    Write = 1 << 1,
-    Execute = 1 << 2,
-
-    ReadAndWrite = Read | Write,
-    ReadAndExecute = Read | Execute,
-
-    UserMask = static_cast<u8>(Svc::MemoryPermission::Read | Svc::MemoryPermission::Write |
-                               Svc::MemoryPermission::Execute),
-};
-DECLARE_ENUM_FLAG_OPERATORS(MemoryPermission);
-
-enum class MemoryAttribute : u8 {
-    None = 0x00,
-    Mask = 0x7F,
-    All = Mask,
-    DontCareMask = 0x80,
-
-    Locked = static_cast<u8>(Svc::MemoryAttribute::Locked),
-    IpcLocked = static_cast<u8>(Svc::MemoryAttribute::IpcLocked),
-    DeviceShared = static_cast<u8>(Svc::MemoryAttribute::DeviceShared),
-    Uncached = static_cast<u8>(Svc::MemoryAttribute::Uncached),
-
-    IpcAndDeviceMapped = IpcLocked | DeviceShared,
-    LockedAndIpcLocked = Locked | IpcLocked,
-    DeviceSharedAndUncached = DeviceShared | Uncached
-};
-DECLARE_ENUM_FLAG_OPERATORS(MemoryAttribute);
-
-static_assert((static_cast<u8>(MemoryAttribute::Mask) &
-               static_cast<u8>(MemoryAttribute::DontCareMask)) == 0);
-
-struct MemoryInfo {
-    VAddr addr{};
-    std::size_t size{};
-    MemoryState state{};
-    MemoryPermission perm{};
-    MemoryAttribute attribute{};
-    MemoryPermission original_perm{};
-    u16 ipc_lock_count{};
-    u16 device_use_count{};
-
-    constexpr Svc::MemoryInfo GetSvcMemoryInfo() const {
-        return {
-            addr,
-            size,
-            static_cast<Svc::MemoryState>(state & MemoryState::Mask),
-            static_cast<Svc::MemoryAttribute>(attribute & MemoryAttribute::Mask),
-            static_cast<Svc::MemoryPermission>(perm & MemoryPermission::UserMask),
-            ipc_lock_count,
-            device_use_count,
-        };
-    }
-
-    constexpr VAddr GetAddress() const {
-        return addr;
-    }
-    constexpr std::size_t GetSize() const {
-        return size;
-    }
-    constexpr std::size_t GetNumPages() const {
-        return GetSize() / PageSize;
-    }
-    constexpr VAddr GetEndAddress() const {
-        return GetAddress() + GetSize();
-    }
-    constexpr VAddr GetLastAddress() const {
-        return GetEndAddress() - 1;
-    }
-};
-
-class MemoryBlock final {
-    friend class MemoryBlockManager;
-
-private:
-    VAddr addr{};
-    std::size_t num_pages{};
-    MemoryState state{MemoryState::None};
-    u16 ipc_lock_count{};
-    u16 device_use_count{};
-    MemoryPermission perm{MemoryPermission::None};
-    MemoryPermission original_perm{MemoryPermission::None};
-    MemoryAttribute attribute{MemoryAttribute::None};
-
-public:
-    static constexpr int Compare(const MemoryBlock& lhs, const MemoryBlock& rhs) {
-        if (lhs.GetAddress() < rhs.GetAddress()) {
-            return -1;
-        } else if (lhs.GetAddress() <= rhs.GetLastAddress()) {
-            return 0;
-        } else {
-            return 1;
-        }
-    }
-
-public:
-    constexpr MemoryBlock() = default;
-    constexpr MemoryBlock(VAddr addr, std::size_t num_pages, MemoryState state,
-                          MemoryPermission perm, MemoryAttribute attribute)
-        : addr{addr}, num_pages(num_pages), state{state}, perm{perm}, attribute{attribute} {}
-
-    constexpr VAddr GetAddress() const {
-        return addr;
-    }
-
-    constexpr std::size_t GetNumPages() const {
-        return num_pages;
-    }
-
-    constexpr std::size_t GetSize() const {
-        return GetNumPages() * PageSize;
-    }
-
-    constexpr VAddr GetEndAddress() const {
-        return GetAddress() + GetSize();
-    }
-
-    constexpr VAddr GetLastAddress() const {
-        return GetEndAddress() - 1;
-    }
-
-    constexpr MemoryInfo GetMemoryInfo() const {
-        return {
-            GetAddress(), GetSize(),     state,          perm,
-            attribute,    original_perm, ipc_lock_count, device_use_count,
-        };
-    }
-
-private:
-    constexpr bool HasProperties(MemoryState s, MemoryPermission p, MemoryAttribute a) const {
-        constexpr MemoryAttribute AttributeIgnoreMask{MemoryAttribute::DontCareMask |
-                                                      MemoryAttribute::IpcLocked |
-                                                      MemoryAttribute::DeviceShared};
-        return state == s && perm == p &&
-               (attribute | AttributeIgnoreMask) == (a | AttributeIgnoreMask);
-    }
-
-    constexpr bool HasSameProperties(const MemoryBlock& rhs) const {
-        return state == rhs.state && perm == rhs.perm && original_perm == rhs.original_perm &&
-               attribute == rhs.attribute && ipc_lock_count == rhs.ipc_lock_count &&
-               device_use_count == rhs.device_use_count;
-    }
-
-    constexpr bool Contains(VAddr start) const {
-        return GetAddress() <= start && start <= GetEndAddress();
-    }
-
-    constexpr void Add(std::size_t count) {
-        ASSERT(count > 0);
-        ASSERT(GetAddress() + count * PageSize - 1 < GetEndAddress() + count * PageSize - 1);
-
-        num_pages += count;
-    }
-
-    constexpr void Update(MemoryState new_state, MemoryPermission new_perm,
-                          MemoryAttribute new_attribute) {
-        ASSERT(original_perm == MemoryPermission::None);
-        ASSERT((attribute & MemoryAttribute::IpcLocked) == MemoryAttribute::None);
-
-        state = new_state;
-        perm = new_perm;
-
-        // TODO(bunnei): Is this right?
-        attribute = static_cast<MemoryAttribute>(
-            new_attribute /*| (attribute & (MemoryAttribute::IpcLocked | MemoryAttribute::DeviceShared))*/);
-    }
-
-    constexpr MemoryBlock Split(VAddr split_addr) {
-        ASSERT(GetAddress() < split_addr);
-        ASSERT(Contains(split_addr));
-        ASSERT(Common::IsAligned(split_addr, PageSize));
-
-        MemoryBlock block;
-        block.addr = addr;
-        block.num_pages = (split_addr - GetAddress()) / PageSize;
-        block.state = state;
-        block.ipc_lock_count = ipc_lock_count;
-        block.device_use_count = device_use_count;
-        block.perm = perm;
-        block.original_perm = original_perm;
-        block.attribute = attribute;
-
-        addr = split_addr;
-        num_pages -= block.num_pages;
-
-        return block;
-    }
-};
-static_assert(std::is_trivially_destructible<MemoryBlock>::value);
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/memory_block_manager.cpp
+++ b/src/core/hle/kernel/memory/memory_block_manager.cpp
@@ -1,190 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/kernel/memory/memory_block_manager.h"
-#include "core/hle/kernel/memory/memory_types.h"
-
-namespace Kernel::Memory {
-
-MemoryBlockManager::MemoryBlockManager(VAddr start_addr, VAddr end_addr)
-    : start_addr{start_addr}, end_addr{end_addr} {
-    const u64 num_pages{(end_addr - start_addr) / PageSize};
-    memory_block_tree.emplace_back(start_addr, num_pages, MemoryState::Free, MemoryPermission::None,
-                                   MemoryAttribute::None);
-}
-
-MemoryBlockManager::iterator MemoryBlockManager::FindIterator(VAddr addr) {
-    auto node{memory_block_tree.begin()};
-    while (node != end()) {
-        const VAddr end_addr{node->GetNumPages() * PageSize + node->GetAddress()};
-        if (node->GetAddress() <= addr && end_addr - 1 >= addr) {
-            return node;
-        }
-        node = std::next(node);
-    }
-    return end();
-}
-
-VAddr MemoryBlockManager::FindFreeArea(VAddr region_start, std::size_t region_num_pages,
-                                       std::size_t num_pages, std::size_t align, std::size_t offset,
-                                       std::size_t guard_pages) {
-    if (num_pages == 0) {
-        return {};
-    }
-
-    const VAddr region_end{region_start + region_num_pages * PageSize};
-    const VAddr region_last{region_end - 1};
-    for (auto it{FindIterator(region_start)}; it != memory_block_tree.cend(); it++) {
-        const auto info{it->GetMemoryInfo()};
-        if (region_last < info.GetAddress()) {
-            break;
-        }
-
-        if (info.state != MemoryState::Free) {
-            continue;
-        }
-
-        VAddr area{(info.GetAddress() <= region_start) ? region_start : info.GetAddress()};
-        area += guard_pages * PageSize;
-
-        const VAddr offset_area{Common::AlignDown(area, align) + offset};
-        area = (area <= offset_area) ? offset_area : offset_area + align;
-
-        const VAddr area_end{area + num_pages * PageSize + guard_pages * PageSize};
-        const VAddr area_last{area_end - 1};
-
-        if (info.GetAddress() <= area && area < area_last && area_last <= region_last &&
-            area_last <= info.GetLastAddress()) {
-            return area;
-        }
-    }
-
-    return {};
-}
-
-void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState prev_state,
-                                MemoryPermission prev_perm, MemoryAttribute prev_attribute,
-                                MemoryState state, MemoryPermission perm,
-                                MemoryAttribute attribute) {
-    const std::size_t prev_count{memory_block_tree.size()};
-    const VAddr end_addr{addr + num_pages * PageSize};
-    iterator node{memory_block_tree.begin()};
-
-    prev_attribute |= MemoryAttribute::IpcAndDeviceMapped;
-
-    while (node != memory_block_tree.end()) {
-        MemoryBlock* block{&(*node)};
-        iterator next_node{std::next(node)};
-        const VAddr cur_addr{block->GetAddress()};
-        const VAddr cur_end_addr{block->GetNumPages() * PageSize + cur_addr};
-
-        if (addr < cur_end_addr && cur_addr < end_addr) {
-            if (!block->HasProperties(prev_state, prev_perm, prev_attribute)) {
-                node = next_node;
-                continue;
-            }
-
-            iterator new_node{node};
-            if (addr > cur_addr) {
-                memory_block_tree.insert(node, block->Split(addr));
-            }
-
-            if (end_addr < cur_end_addr) {
-                new_node = memory_block_tree.insert(node, block->Split(end_addr));
-            }
-
-            new_node->Update(state, perm, attribute);
-
-            MergeAdjacent(new_node, next_node);
-        }
-
-        if (cur_end_addr - 1 >= end_addr - 1) {
-            break;
-        }
-
-        node = next_node;
-    }
-}
-
-void MemoryBlockManager::Update(VAddr addr, std::size_t num_pages, MemoryState state,
-                                MemoryPermission perm, MemoryAttribute attribute) {
-    const std::size_t prev_count{memory_block_tree.size()};
-    const VAddr end_addr{addr + num_pages * PageSize};
-    iterator node{memory_block_tree.begin()};
-
-    while (node != memory_block_tree.end()) {
-        MemoryBlock* block{&(*node)};
-        iterator next_node{std::next(node)};
-        const VAddr cur_addr{block->GetAddress()};
-        const VAddr cur_end_addr{block->GetNumPages() * PageSize + cur_addr};
-
-        if (addr < cur_end_addr && cur_addr < end_addr) {
-            iterator new_node{node};
-
-            if (addr > cur_addr) {
-                memory_block_tree.insert(node, block->Split(addr));
-            }
-
-            if (end_addr < cur_end_addr) {
-                new_node = memory_block_tree.insert(node, block->Split(end_addr));
-            }
-
-            new_node->Update(state, perm, attribute);
-
-            MergeAdjacent(new_node, next_node);
-        }
-
-        if (cur_end_addr - 1 >= end_addr - 1) {
-            break;
-        }
-
-        node = next_node;
-    }
-}
-
-void MemoryBlockManager::IterateForRange(VAddr start, VAddr end, IterateFunc&& func) {
-    const_iterator it{FindIterator(start)};
-    MemoryInfo info{};
-    do {
-        info = it->GetMemoryInfo();
-        func(info);
-        it = std::next(it);
-    } while (info.addr + info.size - 1 < end - 1 && it != cend());
-}
-
-void MemoryBlockManager::MergeAdjacent(iterator it, iterator& next_it) {
-    MemoryBlock* block{&(*it)};
-
-    auto EraseIt = [&](const iterator it_to_erase) {
-        if (next_it == it_to_erase) {
-            next_it = std::next(next_it);
-        }
-        memory_block_tree.erase(it_to_erase);
-    };
-
-    if (it != memory_block_tree.begin()) {
-        MemoryBlock* prev{&(*std::prev(it))};
-
-        if (block->HasSameProperties(*prev)) {
-            const iterator prev_it{std::prev(it)};
-
-            prev->Add(block->GetNumPages());
-            EraseIt(it);
-
-            it = prev_it;
-            block = prev;
-        }
-    }
-
-    if (it != cend()) {
-        const MemoryBlock* const next{&(*std::next(it))};
-
-        if (block->HasSameProperties(*next)) {
-            block->Add(next->GetNumPages());
-            EraseIt(std::next(it));
-        }
-    }
-}
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/memory_block_manager.h
+++ b/src/core/hle/kernel/memory/memory_block_manager.h
@@ -1,64 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <functional>
-#include <list>
-#include <memory>
-
-#include "common/common_types.h"
-#include "core/hle/kernel/memory/memory_block.h"
-
-namespace Kernel::Memory {
-
-class MemoryBlockManager final {
-public:
-    using MemoryBlockTree = std::list<MemoryBlock>;
-    using iterator = MemoryBlockTree::iterator;
-    using const_iterator = MemoryBlockTree::const_iterator;
-
-public:
-    MemoryBlockManager(VAddr start_addr, VAddr end_addr);
-
-    iterator end() {
-        return memory_block_tree.end();
-    }
-    const_iterator end() const {
-        return memory_block_tree.end();
-    }
-    const_iterator cend() const {
-        return memory_block_tree.cend();
-    }
-
-    iterator FindIterator(VAddr addr);
-
-    VAddr FindFreeArea(VAddr region_start, std::size_t region_num_pages, std::size_t num_pages,
-                       std::size_t align, std::size_t offset, std::size_t guard_pages);
-
-    void Update(VAddr addr, std::size_t num_pages, MemoryState prev_state,
-                MemoryPermission prev_perm, MemoryAttribute prev_attribute, MemoryState state,
-                MemoryPermission perm, MemoryAttribute attribute);
-
-    void Update(VAddr addr, std::size_t num_pages, MemoryState state,
-                MemoryPermission perm = MemoryPermission::None,
-                MemoryAttribute attribute = MemoryAttribute::None);
-
-    using IterateFunc = std::function<void(const MemoryInfo&)>;
-    void IterateForRange(VAddr start, VAddr end, IterateFunc&& func);
-
-    MemoryBlock& FindBlock(VAddr addr) {
-        return *FindIterator(addr);
-    }
-
-private:
-    void MergeAdjacent(iterator it, iterator& next_it);
-
-    const VAddr start_addr;
-    const VAddr end_addr;
-
-    MemoryBlockTree memory_block_tree;
-};
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/memory_layout.h
+++ b/src/core/hle/kernel/memory/memory_layout.h
@@ -1,73 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-
-namespace Kernel::Memory {
-
-class MemoryRegion final {
-    friend class MemoryLayout;
-
-public:
-    constexpr PAddr StartAddress() const {
-        return start_address;
-    }
-
-    constexpr PAddr EndAddress() const {
-        return end_address;
-    }
-
-private:
-    constexpr MemoryRegion() = default;
-    constexpr MemoryRegion(PAddr start_address, PAddr end_address)
-        : start_address{start_address}, end_address{end_address} {}
-
-    const PAddr start_address{};
-    const PAddr end_address{};
-};
-
-class MemoryLayout final {
-public:
-    constexpr const MemoryRegion& Application() const {
-        return application;
-    }
-
-    constexpr const MemoryRegion& Applet() const {
-        return applet;
-    }
-
-    constexpr const MemoryRegion& System() const {
-        return system;
-    }
-
-    static constexpr MemoryLayout GetDefaultLayout() {
-        constexpr std::size_t application_size{0xcd500000};
-        constexpr std::size_t applet_size{0x1fb00000};
-        constexpr PAddr application_start_address{Core::DramMemoryMap::End - application_size};
-        constexpr PAddr application_end_address{Core::DramMemoryMap::End};
-        constexpr PAddr applet_start_address{application_start_address - applet_size};
-        constexpr PAddr applet_end_address{applet_start_address + applet_size};
-        constexpr PAddr system_start_address{Core::DramMemoryMap::SlabHeapEnd};
-        constexpr PAddr system_end_address{applet_start_address};
-        return {application_start_address, application_end_address, applet_start_address,
-                applet_end_address,        system_start_address,    system_end_address};
-    }
-
-private:
-    constexpr MemoryLayout(PAddr application_start_address, std::size_t application_size,
-                           PAddr applet_start_address, std::size_t applet_size,
-                           PAddr system_start_address, std::size_t system_size)
-        : application{application_start_address, application_size},
-          applet{applet_start_address, applet_size}, system{system_start_address, system_size} {}
-
-    const MemoryRegion application;
-    const MemoryRegion applet;
-    const MemoryRegion system;
-
-    const PAddr start_address{};
-};
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/memory_manager.cpp
+++ b/src/core/hle/kernel/memory/memory_manager.cpp
@@ -1,176 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-
-#include "common/alignment.h"
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "common/scope_exit.h"
-#include "core/hle/kernel/errors.h"
-#include "core/hle/kernel/memory/memory_manager.h"
-#include "core/hle/kernel/memory/page_linked_list.h"
-
-namespace Kernel::Memory {
-
-std::size_t MemoryManager::Impl::Initialize(Pool new_pool, u64 start_address, u64 end_address) {
-    const auto size{end_address - start_address};
-
-    // Calculate metadata sizes
-    const auto ref_count_size{(size / PageSize) * sizeof(u16)};
-    const auto optimize_map_size{(Common::AlignUp((size / PageSize), 64) / 64) * sizeof(u64)};
-    const auto manager_size{Common::AlignUp(optimize_map_size + ref_count_size, PageSize)};
-    const auto page_heap_size{PageHeap::CalculateMetadataOverheadSize(size)};
-    const auto total_metadata_size{manager_size + page_heap_size};
-    ASSERT(manager_size <= total_metadata_size);
-    ASSERT(Common::IsAligned(total_metadata_size, PageSize));
-
-    // Setup region
-    pool = new_pool;
-
-    // Initialize the manager's KPageHeap
-    heap.Initialize(start_address, size, page_heap_size);
-
-    // Free the memory to the heap
-    heap.Free(start_address, size / PageSize);
-
-    // Update the heap's used size
-    heap.UpdateUsedSize();
-
-    return total_metadata_size;
-}
-
-void MemoryManager::InitializeManager(Pool pool, u64 start_address, u64 end_address) {
-    ASSERT(pool < Pool::Count);
-    managers[static_cast<std::size_t>(pool)].Initialize(pool, start_address, end_address);
-}
-
-VAddr MemoryManager::AllocateContinuous(std::size_t num_pages, std::size_t align_pages, Pool pool,
-                                        Direction dir) {
-    // Early return if we're allocating no pages
-    if (num_pages == 0) {
-        return {};
-    }
-
-    // Lock the pool that we're allocating from
-    const auto pool_index{static_cast<std::size_t>(pool)};
-    std::lock_guard lock{pool_locks[pool_index]};
-
-    // Choose a heap based on our page size request
-    const s32 heap_index{PageHeap::GetAlignedBlockIndex(num_pages, align_pages)};
-
-    // Loop, trying to iterate from each block
-    // TODO (bunnei): Support multiple managers
-    Impl& chosen_manager{managers[pool_index]};
-    VAddr allocated_block{chosen_manager.AllocateBlock(heap_index)};
-
-    // If we failed to allocate, quit now
-    if (!allocated_block) {
-        return {};
-    }
-
-    // If we allocated more than we need, free some
-    const auto allocated_pages{PageHeap::GetBlockNumPages(heap_index)};
-    if (allocated_pages > num_pages) {
-        chosen_manager.Free(allocated_block + num_pages * PageSize, allocated_pages - num_pages);
-    }
-
-    return allocated_block;
-}
-
-ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pages, Pool pool,
-                                   Direction dir) {
-    ASSERT(page_list.GetNumPages() == 0);
-
-    // Early return if we're allocating no pages
-    if (num_pages == 0) {
-        return RESULT_SUCCESS;
-    }
-
-    // Lock the pool that we're allocating from
-    const auto pool_index{static_cast<std::size_t>(pool)};
-    std::lock_guard lock{pool_locks[pool_index]};
-
-    // Choose a heap based on our page size request
-    const s32 heap_index{PageHeap::GetBlockIndex(num_pages)};
-    if (heap_index < 0) {
-        return ERR_OUT_OF_MEMORY;
-    }
-
-    // TODO (bunnei): Support multiple managers
-    Impl& chosen_manager{managers[pool_index]};
-
-    // Ensure that we don't leave anything un-freed
-    auto group_guard = detail::ScopeExit([&] {
-        for (const auto& it : page_list.Nodes()) {
-            const auto num_pages{std::min(
-                it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
-            chosen_manager.Free(it.GetAddress(), num_pages);
-        }
-    });
-
-    // Keep allocating until we've allocated all our pages
-    for (s32 index{heap_index}; index >= 0 && num_pages > 0; index--) {
-        const auto pages_per_alloc{PageHeap::GetBlockNumPages(index)};
-
-        while (num_pages >= pages_per_alloc) {
-            // Allocate a block
-            VAddr allocated_block{chosen_manager.AllocateBlock(index)};
-            if (!allocated_block) {
-                break;
-            }
-
-            // Safely add it to our group
-            {
-                auto block_guard = detail::ScopeExit(
-                    [&] { chosen_manager.Free(allocated_block, pages_per_alloc); });
-
-                if (const ResultCode result{page_list.AddBlock(allocated_block, pages_per_alloc)};
-                    result.IsError()) {
-                    return result;
-                }
-
-                block_guard.Cancel();
-            }
-
-            num_pages -= pages_per_alloc;
-        }
-    }
-
-    // Only succeed if we allocated as many pages as we wanted
-    ASSERT(num_pages >= 0);
-    if (num_pages) {
-        return ERR_OUT_OF_MEMORY;
-    }
-
-    // We succeeded!
-    group_guard.Cancel();
-    return RESULT_SUCCESS;
-}
-
-ResultCode MemoryManager::Free(PageLinkedList& page_list, std::size_t num_pages, Pool pool,
-                               Direction dir) {
-    // Early return if we're freeing no pages
-    if (!num_pages) {
-        return RESULT_SUCCESS;
-    }
-
-    // Lock the pool that we're freeing from
-    const auto pool_index{static_cast<std::size_t>(pool)};
-    std::lock_guard lock{pool_locks[pool_index]};
-
-    // TODO (bunnei): Support multiple managers
-    Impl& chosen_manager{managers[pool_index]};
-
-    // Free all of the pages
-    for (const auto& it : page_list.Nodes()) {
-        const auto num_pages{std::min(
-            it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
-        chosen_manager.Free(it.GetAddress(), num_pages);
-    }
-
-    return RESULT_SUCCESS;
-}
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/memory_manager.h
+++ b/src/core/hle/kernel/memory/memory_manager.h
@@ -1,97 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <mutex>
-
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "core/hle/kernel/memory/page_heap.h"
-#include "core/hle/result.h"
-
-namespace Kernel::Memory {
-
-class PageLinkedList;
-
-class MemoryManager final : NonCopyable {
-public:
-    enum class Pool : u32 {
-        Application = 0,
-        Applet = 1,
-        System = 2,
-        SystemNonSecure = 3,
-
-        Count,
-
-        Shift = 4,
-        Mask = (0xF << Shift),
-    };
-
-    enum class Direction : u32 {
-        FromFront = 0,
-        FromBack = 1,
-
-        Shift = 0,
-        Mask = (0xF << Shift),
-    };
-
-    MemoryManager() = default;
-
-    constexpr std::size_t GetSize(Pool pool) const {
-        return managers[static_cast<std::size_t>(pool)].GetSize();
-    }
-
-    void InitializeManager(Pool pool, u64 start_address, u64 end_address);
-    VAddr AllocateContinuous(std::size_t num_pages, std::size_t align_pages, Pool pool,
-                             Direction dir = Direction::FromFront);
-    ResultCode Allocate(PageLinkedList& page_list, std::size_t num_pages, Pool pool,
-                        Direction dir = Direction::FromFront);
-    ResultCode Free(PageLinkedList& page_list, std::size_t num_pages, Pool pool,
-                    Direction dir = Direction::FromFront);
-
-    static constexpr std::size_t MaxManagerCount = 10;
-
-private:
-    class Impl final : NonCopyable {
-    private:
-        using RefCount = u16;
-
-    private:
-        PageHeap heap;
-        Pool pool{};
-
-    public:
-        Impl() = default;
-
-        std::size_t Initialize(Pool new_pool, u64 start_address, u64 end_address);
-
-        VAddr AllocateBlock(s32 index) {
-            return heap.AllocateBlock(index);
-        }
-
-        void Free(VAddr addr, std::size_t num_pages) {
-            heap.Free(addr, num_pages);
-        }
-
-        constexpr std::size_t GetSize() const {
-            return heap.GetSize();
-        }
-
-        constexpr VAddr GetAddress() const {
-            return heap.GetAddress();
-        }
-
-        constexpr VAddr GetEndAddress() const {
-            return heap.GetEndAddress();
-        }
-    };
-
-private:
-    std::array<std::mutex, static_cast<std::size_t>(Pool::Count)> pool_locks;
-    std::array<Impl, MaxManagerCount> managers;
-};
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/memory_types.h
+++ b/src/core/hle/kernel/memory/memory_types.h
@@ -1,18 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-
-#include "common/common_types.h"
-
-namespace Kernel::Memory {
-
-constexpr std::size_t PageBits{12};
-constexpr std::size_t PageSize{1 << PageBits};
-
-using Page = std::array<u8, PageSize>;
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/page_heap.cpp
+++ b/src/core/hle/kernel/memory/page_heap.cpp
@@ -1,119 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-// This file references various implementation details from Atmosph<70>re, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosph<70>re-NX.
-
-#include "core/core.h"
-#include "core/hle/kernel/memory/page_heap.h"
-#include "core/memory.h"
-
-namespace Kernel::Memory {
-
-void PageHeap::Initialize(VAddr address, std::size_t size, std::size_t metadata_size) {
-    // Check our assumptions
-    ASSERT(Common::IsAligned((address), PageSize));
-    ASSERT(Common::IsAligned(size, PageSize));
-
-    // Set our members
-    heap_address = address;
-    heap_size = size;
-
-    // Setup bitmaps
-    metadata.resize(metadata_size / sizeof(u64));
-    u64* cur_bitmap_storage{metadata.data()};
-    for (std::size_t i = 0; i < MemoryBlockPageShifts.size(); i++) {
-        const std::size_t cur_block_shift{MemoryBlockPageShifts[i]};
-        const std::size_t next_block_shift{
-            (i != MemoryBlockPageShifts.size() - 1) ? MemoryBlockPageShifts[i + 1] : 0};
-        cur_bitmap_storage = blocks[i].Initialize(heap_address, heap_size, cur_block_shift,
-                                                  next_block_shift, cur_bitmap_storage);
-    }
-}
-
-VAddr PageHeap::AllocateBlock(s32 index) {
-    const std::size_t needed_size{blocks[index].GetSize()};
-
-    for (s32 i{index}; i < static_cast<s32>(MemoryBlockPageShifts.size()); i++) {
-        if (const VAddr addr{blocks[i].PopBlock()}; addr) {
-            if (const std::size_t allocated_size{blocks[i].GetSize()};
-                allocated_size > needed_size) {
-                Free(addr + needed_size, (allocated_size - needed_size) / PageSize);
-            }
-            return addr;
-        }
-    }
-
-    return 0;
-}
-
-void PageHeap::FreeBlock(VAddr block, s32 index) {
-    do {
-        block = blocks[index++].PushBlock(block);
-    } while (block != 0);
-}
-
-void PageHeap::Free(VAddr addr, std::size_t num_pages) {
-    // Freeing no pages is a no-op
-    if (num_pages == 0) {
-        return;
-    }
-
-    // Find the largest block size that we can free, and free as many as possible
-    s32 big_index{static_cast<s32>(MemoryBlockPageShifts.size()) - 1};
-    const VAddr start{addr};
-    const VAddr end{(num_pages * PageSize) + addr};
-    VAddr before_start{start};
-    VAddr before_end{start};
-    VAddr after_start{end};
-    VAddr after_end{end};
-    while (big_index >= 0) {
-        const std::size_t block_size{blocks[big_index].GetSize()};
-        const VAddr big_start{Common::AlignUp((start), block_size)};
-        const VAddr big_end{Common::AlignDown((end), block_size)};
-        if (big_start < big_end) {
-            // Free as many big blocks as we can
-            for (auto block{big_start}; block < big_end; block += block_size) {
-                FreeBlock(block, big_index);
-            }
-            before_end = big_start;
-            after_start = big_end;
-            break;
-        }
-        big_index--;
-    }
-    ASSERT(big_index >= 0);
-
-    // Free space before the big blocks
-    for (s32 i{big_index - 1}; i >= 0; i--) {
-        const std::size_t block_size{blocks[i].GetSize()};
-        while (before_start + block_size <= before_end) {
-            before_end -= block_size;
-            FreeBlock(before_end, i);
-        }
-    }
-
-    // Free space after the big blocks
-    for (s32 i{big_index - 1}; i >= 0; i--) {
-        const std::size_t block_size{blocks[i].GetSize()};
-        while (after_start + block_size <= after_end) {
-            FreeBlock(after_start, i);
-            after_start += block_size;
-        }
-    }
-}
-
-std::size_t PageHeap::CalculateMetadataOverheadSize(std::size_t region_size) {
-    std::size_t overhead_size = 0;
-    for (std::size_t i = 0; i < MemoryBlockPageShifts.size(); i++) {
-        const std::size_t cur_block_shift{MemoryBlockPageShifts[i]};
-        const std::size_t next_block_shift{
-            (i != MemoryBlockPageShifts.size() - 1) ? MemoryBlockPageShifts[i + 1] : 0};
-        overhead_size += PageHeap::Block::CalculateMetadataOverheadSize(
-            region_size, cur_block_shift, next_block_shift);
-    }
-    return Common::AlignUp(overhead_size, PageSize);
-}
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/page_heap.h
+++ b/src/core/hle/kernel/memory/page_heap.h
@@ -1,370 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-// This file references various implementation details from Atmosph<70>re, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosph<70>re-NX.
-
-#pragma once
-
-#include <array>
-#include <vector>
-
-#include "common/alignment.h"
-#include "common/assert.h"
-#include "common/bit_util.h"
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "core/hle/kernel/memory/memory_types.h"
-
-namespace Kernel::Memory {
-
-class PageHeap final : NonCopyable {
-public:
-    static constexpr s32 GetAlignedBlockIndex(std::size_t num_pages, std::size_t align_pages) {
-        const auto target_pages{std::max(num_pages, align_pages)};
-        for (std::size_t i = 0; i < NumMemoryBlockPageShifts; i++) {
-            if (target_pages <=
-                (static_cast<std::size_t>(1) << MemoryBlockPageShifts[i]) / PageSize) {
-                return static_cast<s32>(i);
-            }
-        }
-        return -1;
-    }
-
-    static constexpr s32 GetBlockIndex(std::size_t num_pages) {
-        for (s32 i{static_cast<s32>(NumMemoryBlockPageShifts) - 1}; i >= 0; i--) {
-            if (num_pages >= (static_cast<std::size_t>(1) << MemoryBlockPageShifts[i]) / PageSize) {
-                return i;
-            }
-        }
-        return -1;
-    }
-
-    static constexpr std::size_t GetBlockSize(std::size_t index) {
-        return static_cast<std::size_t>(1) << MemoryBlockPageShifts[index];
-    }
-
-    static constexpr std::size_t GetBlockNumPages(std::size_t index) {
-        return GetBlockSize(index) / PageSize;
-    }
-
-private:
-    static constexpr std::size_t NumMemoryBlockPageShifts{7};
-    static constexpr std::array<std::size_t, NumMemoryBlockPageShifts> MemoryBlockPageShifts{
-        0xC, 0x10, 0x15, 0x16, 0x19, 0x1D, 0x1E,
-    };
-
-    class Block final : NonCopyable {
-    private:
-        class Bitmap final : NonCopyable {
-        public:
-            static constexpr std::size_t MaxDepth{4};
-
-        private:
-            std::array<u64*, MaxDepth> bit_storages{};
-            std::size_t num_bits{};
-            std::size_t used_depths{};
-
-        public:
-            constexpr Bitmap() = default;
-
-            constexpr std::size_t GetNumBits() const {
-                return num_bits;
-            }
-            constexpr s32 GetHighestDepthIndex() const {
-                return static_cast<s32>(used_depths) - 1;
-            }
-
-            constexpr u64* Initialize(u64* storage, std::size_t size) {
-                //* Initially, everything is un-set
-                num_bits = 0;
-
-                // Calculate the needed bitmap depth
-                used_depths = static_cast<std::size_t>(GetRequiredDepth(size));
-                ASSERT(used_depths <= MaxDepth);
-
-                // Set the bitmap pointers
-                for (s32 depth{GetHighestDepthIndex()}; depth >= 0; depth--) {
-                    bit_storages[depth] = storage;
-                    size = Common::AlignUp(size, 64) / 64;
-                    storage += size;
-                }
-
-                return storage;
-            }
-
-            s64 FindFreeBlock() const {
-                uintptr_t offset{};
-                s32 depth{};
-
-                do {
-                    const u64 v{bit_storages[depth][offset]};
-                    if (v == 0) {
-                        // Non-zero depth indicates that a previous level had a free block
-                        ASSERT(depth == 0);
-                        return -1;
-                    }
-                    offset = offset * 64 + Common::CountTrailingZeroes64(v);
-                    ++depth;
-                } while (depth < static_cast<s32>(used_depths));
-
-                return static_cast<s64>(offset);
-            }
-
-            constexpr void SetBit(std::size_t offset) {
-                SetBit(GetHighestDepthIndex(), offset);
-                num_bits++;
-            }
-
-            constexpr void ClearBit(std::size_t offset) {
-                ClearBit(GetHighestDepthIndex(), offset);
-                num_bits--;
-            }
-
-            constexpr bool ClearRange(std::size_t offset, std::size_t count) {
-                const s32 depth{GetHighestDepthIndex()};
-                const auto bit_ind{offset / 64};
-                u64* bits{bit_storages[depth]};
-                if (count < 64) {
-                    const auto shift{offset % 64};
-                    ASSERT(shift + count <= 64);
-                    // Check that all the bits are set
-                    const u64 mask{((1ULL << count) - 1) << shift};
-                    u64 v{bits[bit_ind]};
-                    if ((v & mask) != mask) {
-                        return false;
-                    }
-
-                    // Clear the bits
-                    v &= ~mask;
-                    bits[bit_ind] = v;
-                    if (v == 0) {
-                        ClearBit(depth - 1, bit_ind);
-                    }
-                } else {
-                    ASSERT(offset % 64 == 0);
-                    ASSERT(count % 64 == 0);
-                    // Check that all the bits are set
-                    std::size_t remaining{count};
-                    std::size_t i = 0;
-                    do {
-                        if (bits[bit_ind + i++] != ~u64(0)) {
-                            return false;
-                        }
-                        remaining -= 64;
-                    } while (remaining > 0);
-
-                    // Clear the bits
-                    remaining = count;
-                    i = 0;
-                    do {
-                        bits[bit_ind + i] = 0;
-                        ClearBit(depth - 1, bit_ind + i);
-                        i++;
-                        remaining -= 64;
-                    } while (remaining > 0);
-                }
-
-                num_bits -= count;
-                return true;
-            }
-
-        private:
-            constexpr void SetBit(s32 depth, std::size_t offset) {
-                while (depth >= 0) {
-                    const auto ind{offset / 64};
-                    const auto which{offset % 64};
-                    const u64 mask{1ULL << which};
-
-                    u64* bit{std::addressof(bit_storages[depth][ind])};
-                    const u64 v{*bit};
-                    ASSERT((v & mask) == 0);
-                    *bit = v | mask;
-                    if (v) {
-                        break;
-                    }
-                    offset = ind;
-                    depth--;
-                }
-            }
-
-            constexpr void ClearBit(s32 depth, std::size_t offset) {
-                while (depth >= 0) {
-                    const auto ind{offset / 64};
-                    const auto which{offset % 64};
-                    const u64 mask{1ULL << which};
-
-                    u64* bit{std::addressof(bit_storages[depth][ind])};
-                    u64 v{*bit};
-                    ASSERT((v & mask) != 0);
-                    v &= ~mask;
-                    *bit = v;
-                    if (v) {
-                        break;
-                    }
-                    offset = ind;
-                    depth--;
-                }
-            }
-
-        private:
-            static constexpr s32 GetRequiredDepth(std::size_t region_size) {
-                s32 depth = 0;
-                while (true) {
-                    region_size /= 64;
-                    depth++;
-                    if (region_size == 0) {
-                        return depth;
-                    }
-                }
-            }
-
-        public:
-            static constexpr std::size_t CalculateMetadataOverheadSize(std::size_t region_size) {
-                std::size_t overhead_bits = 0;
-                for (s32 depth{GetRequiredDepth(region_size) - 1}; depth >= 0; depth--) {
-                    region_size = Common::AlignUp(region_size, 64) / 64;
-                    overhead_bits += region_size;
-                }
-                return overhead_bits * sizeof(u64);
-            }
-        };
-
-    private:
-        Bitmap bitmap;
-        VAddr heap_address{};
-        uintptr_t end_offset{};
-        std::size_t block_shift{};
-        std::size_t next_block_shift{};
-
-    public:
-        constexpr Block() = default;
-
-        constexpr std::size_t GetShift() const {
-            return block_shift;
-        }
-        constexpr std::size_t GetNextShift() const {
-            return next_block_shift;
-        }
-        constexpr std::size_t GetSize() const {
-            return static_cast<std::size_t>(1) << GetShift();
-        }
-        constexpr std::size_t GetNumPages() const {
-            return GetSize() / PageSize;
-        }
-        constexpr std::size_t GetNumFreeBlocks() const {
-            return bitmap.GetNumBits();
-        }
-        constexpr std::size_t GetNumFreePages() const {
-            return GetNumFreeBlocks() * GetNumPages();
-        }
-
-        constexpr u64* Initialize(VAddr addr, std::size_t size, std::size_t bs, std::size_t nbs,
-                                  u64* bit_storage) {
-            // Set shifts
-            block_shift = bs;
-            next_block_shift = nbs;
-
-            // Align up the address
-            VAddr end{addr + size};
-            const auto align{(next_block_shift != 0) ? (1ULL << next_block_shift)
-                                                     : (1ULL << block_shift)};
-            addr = Common::AlignDown((addr), align);
-            end = Common::AlignUp((end), align);
-
-            heap_address = addr;
-            end_offset = (end - addr) / (1ULL << block_shift);
-            return bitmap.Initialize(bit_storage, end_offset);
-        }
-
-        constexpr VAddr PushBlock(VAddr address) {
-            // Set the bit for the free block
-            std::size_t offset{(address - heap_address) >> GetShift()};
-            bitmap.SetBit(offset);
-
-            // If we have a next shift, try to clear the blocks below and return the address
-            if (GetNextShift()) {
-                const auto diff{1ULL << (GetNextShift() - GetShift())};
-                offset = Common::AlignDown(offset, diff);
-                if (bitmap.ClearRange(offset, diff)) {
-                    return heap_address + (offset << GetShift());
-                }
-            }
-
-            // We couldn't coalesce, or we're already as big as possible
-            return 0;
-        }
-
-        VAddr PopBlock() {
-            // Find a free block
-            const s64 soffset{bitmap.FindFreeBlock()};
-            if (soffset < 0) {
-                return 0;
-            }
-            const auto offset{static_cast<std::size_t>(soffset)};
-
-            // Update our tracking and return it
-            bitmap.ClearBit(offset);
-            return heap_address + (offset << GetShift());
-        }
-
-    public:
-        static constexpr std::size_t CalculateMetadataOverheadSize(std::size_t region_size,
-                                                                   std::size_t cur_block_shift,
-                                                                   std::size_t next_block_shift) {
-            const auto cur_block_size{(1ULL << cur_block_shift)};
-            const auto next_block_size{(1ULL << next_block_shift)};
-            const auto align{(next_block_shift != 0) ? next_block_size : cur_block_size};
-            return Bitmap::CalculateMetadataOverheadSize(
-                (align * 2 + Common::AlignUp(region_size, align)) / cur_block_size);
-        }
-    };
-
-public:
-    PageHeap() = default;
-
-    constexpr VAddr GetAddress() const {
-        return heap_address;
-    }
-    constexpr std::size_t GetSize() const {
-        return heap_size;
-    }
-    constexpr VAddr GetEndAddress() const {
-        return GetAddress() + GetSize();
-    }
-    constexpr std::size_t GetPageOffset(VAddr block) const {
-        return (block - GetAddress()) / PageSize;
-    }
-
-    void Initialize(VAddr heap_address, std::size_t heap_size, std::size_t metadata_size);
-    VAddr AllocateBlock(s32 index);
-    void Free(VAddr addr, std::size_t num_pages);
-
-    void UpdateUsedSize() {
-        used_size = heap_size - (GetNumFreePages() * PageSize);
-    }
-
-    static std::size_t CalculateMetadataOverheadSize(std::size_t region_size);
-
-private:
-    constexpr std::size_t GetNumFreePages() const {
-        std::size_t num_free{};
-
-        for (const auto& block : blocks) {
-            num_free += block.GetNumFreePages();
-        }
-
-        return num_free;
-    }
-
-    void FreeBlock(VAddr block, s32 index);
-
-    VAddr heap_address{};
-    std::size_t heap_size{};
-    std::size_t used_size{};
-    std::array<Block, NumMemoryBlockPageShifts> blocks{};
-    std::vector<u64> metadata;
-};
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/page_linked_list.h
+++ b/src/core/hle/kernel/memory/page_linked_list.h
@@ -1,93 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <list>
-
-#include "common/assert.h"
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "core/hle/kernel/memory/memory_types.h"
-#include "core/hle/result.h"
-
-namespace Kernel::Memory {
-
-class PageLinkedList final {
-public:
-    class Node final {
-    public:
-        constexpr Node(u64 addr, std::size_t num_pages) : addr{addr}, num_pages{num_pages} {}
-
-        constexpr u64 GetAddress() const {
-            return addr;
-        }
-
-        constexpr std::size_t GetNumPages() const {
-            return num_pages;
-        }
-
-    private:
-        u64 addr{};
-        std::size_t num_pages{};
-    };
-
-public:
-    PageLinkedList() = default;
-    PageLinkedList(u64 address, u64 num_pages) {
-        ASSERT(AddBlock(address, num_pages).IsSuccess());
-    }
-
-    constexpr std::list<Node>& Nodes() {
-        return nodes;
-    }
-
-    constexpr const std::list<Node>& Nodes() const {
-        return nodes;
-    }
-
-    std::size_t GetNumPages() const {
-        std::size_t num_pages = 0;
-        for (const Node& node : nodes) {
-            num_pages += node.GetNumPages();
-        }
-        return num_pages;
-    }
-
-    bool IsEqual(PageLinkedList& other) const {
-        auto this_node = nodes.begin();
-        auto other_node = other.nodes.begin();
-        while (this_node != nodes.end() && other_node != other.nodes.end()) {
-            if (this_node->GetAddress() != other_node->GetAddress() ||
-                this_node->GetNumPages() != other_node->GetNumPages()) {
-                return false;
-            }
-            this_node = std::next(this_node);
-            other_node = std::next(other_node);
-        }
-
-        return this_node == nodes.end() && other_node == other.nodes.end();
-    }
-
-    ResultCode AddBlock(u64 address, u64 num_pages) {
-        if (!num_pages) {
-            return RESULT_SUCCESS;
-        }
-        if (!nodes.empty()) {
-            const auto node = nodes.back();
-            if (node.GetAddress() + node.GetNumPages() * PageSize == address) {
-                address = node.GetAddress();
-                num_pages += node.GetNumPages();
-                nodes.pop_back();
-            }
-        }
-        nodes.push_back({address, num_pages});
-        return RESULT_SUCCESS;
-    }
-
-private:
-    std::list<Node> nodes;
-};
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/page_table.cpp
+++ b/src/core/hle/kernel/memory/page_table.cpp
--- a/src/core/hle/kernel/memory/page_table.h
+++ b/src/core/hle/kernel/memory/page_table.h
@@ -1,276 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <list>
-#include <memory>
-#include <mutex>
-
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/page_table.h"
-#include "core/file_sys/program_metadata.h"
-#include "core/hle/kernel/memory/memory_block.h"
-#include "core/hle/kernel/memory/memory_manager.h"
-
-namespace Core {
-class System;
-}
-
-namespace Kernel::Memory {
-
-class MemoryBlockManager;
-
-class PageTable final : NonCopyable {
-public:
-    explicit PageTable(Core::System& system);
-
-    ResultCode InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr,
-                                    VAddr code_addr, std::size_t code_size,
-                                    Memory::MemoryManager::Pool pool);
-    ResultCode MapProcessCode(VAddr addr, std::size_t pages_count, MemoryState state,
-                              MemoryPermission perm);
-    ResultCode MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
-    ResultCode UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
-    ResultCode MapPhysicalMemory(VAddr addr, std::size_t size);
-    ResultCode UnmapPhysicalMemory(VAddr addr, std::size_t size);
-    ResultCode UnmapMemory(VAddr addr, std::size_t size);
-    ResultCode Map(VAddr dst_addr, VAddr src_addr, std::size_t size);
-    ResultCode Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size);
-    ResultCode MapPages(VAddr addr, PageLinkedList& page_linked_list, MemoryState state,
-                        MemoryPermission perm);
-    ResultCode SetCodeMemoryPermission(VAddr addr, std::size_t size, MemoryPermission perm);
-    MemoryInfo QueryInfo(VAddr addr);
-    ResultCode ReserveTransferMemory(VAddr addr, std::size_t size, MemoryPermission perm);
-    ResultCode ResetTransferMemory(VAddr addr, std::size_t size);
-    ResultCode SetMemoryAttribute(VAddr addr, std::size_t size, MemoryAttribute mask,
-                                  MemoryAttribute value);
-    ResultCode SetHeapCapacity(std::size_t new_heap_capacity);
-    ResultVal<VAddr> SetHeapSize(std::size_t size);
-    ResultVal<VAddr> AllocateAndMapMemory(std::size_t needed_num_pages, std::size_t align,
-                                          bool is_map_only, VAddr region_start,
-                                          std::size_t region_num_pages, MemoryState state,
-                                          MemoryPermission perm, PAddr map_addr = 0);
-
-    Common::PageTable& PageTableImpl() {
-        return page_table_impl;
-    }
-
-    const Common::PageTable& PageTableImpl() const {
-        return page_table_impl;
-    }
-
-private:
-    enum class OperationType : u32 {
-        Map,
-        MapGroup,
-        Unmap,
-        ChangePermissions,
-        ChangePermissionsAndRefresh,
-    };
-
-    static constexpr MemoryAttribute DefaultMemoryIgnoreAttr =
-        MemoryAttribute::DontCareMask | MemoryAttribute::IpcLocked | MemoryAttribute::DeviceShared;
-
-    ResultCode InitializeMemoryLayout(VAddr start, VAddr end);
-    ResultCode MapPages(VAddr addr, const PageLinkedList& page_linked_list, MemoryPermission perm);
-    void MapPhysicalMemory(PageLinkedList& page_linked_list, VAddr start, VAddr end);
-    bool IsRegionMapped(VAddr address, u64 size);
-    bool IsRegionContiguous(VAddr addr, u64 size) const;
-    void AddRegionToPages(VAddr start, std::size_t num_pages, PageLinkedList& page_linked_list);
-    MemoryInfo QueryInfoImpl(VAddr addr);
-    VAddr AllocateVirtualMemory(VAddr start, std::size_t region_num_pages, u64 needed_num_pages,
-                                std::size_t align);
-    ResultCode Operate(VAddr addr, std::size_t num_pages, const PageLinkedList& page_group,
-                       OperationType operation);
-    ResultCode Operate(VAddr addr, std::size_t num_pages, MemoryPermission perm,
-                       OperationType operation, PAddr map_addr = 0);
-    constexpr VAddr GetRegionAddress(MemoryState state) const;
-    constexpr std::size_t GetRegionSize(MemoryState state) const;
-    constexpr bool CanContain(VAddr addr, std::size_t size, MemoryState state) const;
-
-    constexpr ResultCode CheckMemoryState(const MemoryInfo& info, MemoryState state_mask,
-                                          MemoryState state, MemoryPermission perm_mask,
-                                          MemoryPermission perm, MemoryAttribute attr_mask,
-                                          MemoryAttribute attr) const;
-    ResultCode CheckMemoryState(MemoryState* out_state, MemoryPermission* out_perm,
-                                MemoryAttribute* out_attr, VAddr addr, std::size_t size,
-                                MemoryState state_mask, MemoryState state,
-                                MemoryPermission perm_mask, MemoryPermission perm,
-                                MemoryAttribute attr_mask, MemoryAttribute attr,
-                                MemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr);
-    ResultCode CheckMemoryState(VAddr addr, std::size_t size, MemoryState state_mask,
-                                MemoryState state, MemoryPermission perm_mask,
-                                MemoryPermission perm, MemoryAttribute attr_mask,
-                                MemoryAttribute attr,
-                                MemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) {
-        return CheckMemoryState(nullptr, nullptr, nullptr, addr, size, state_mask, state, perm_mask,
-                                perm, attr_mask, attr, ignore_attr);
-    }
-
-    std::recursive_mutex page_table_lock;
-    std::unique_ptr<MemoryBlockManager> block_manager;
-
-public:
-    constexpr VAddr GetAddressSpaceStart() const {
-        return address_space_start;
-    }
-    constexpr VAddr GetAddressSpaceEnd() const {
-        return address_space_end;
-    }
-    constexpr std::size_t GetAddressSpaceSize() const {
-        return address_space_end - address_space_start;
-    }
-    constexpr VAddr GetHeapRegionStart() const {
-        return heap_region_start;
-    }
-    constexpr VAddr GetHeapRegionEnd() const {
-        return heap_region_end;
-    }
-    constexpr std::size_t GetHeapRegionSize() const {
-        return heap_region_end - heap_region_start;
-    }
-    constexpr VAddr GetAliasRegionStart() const {
-        return alias_region_start;
-    }
-    constexpr VAddr GetAliasRegionEnd() const {
-        return alias_region_end;
-    }
-    constexpr std::size_t GetAliasRegionSize() const {
-        return alias_region_end - alias_region_start;
-    }
-    constexpr VAddr GetStackRegionStart() const {
-        return stack_region_start;
-    }
-    constexpr VAddr GetStackRegionEnd() const {
-        return stack_region_end;
-    }
-    constexpr std::size_t GetStackRegionSize() const {
-        return stack_region_end - stack_region_start;
-    }
-    constexpr VAddr GetKernelMapRegionStart() const {
-        return kernel_map_region_start;
-    }
-    constexpr VAddr GetKernelMapRegionEnd() const {
-        return kernel_map_region_end;
-    }
-    constexpr VAddr GetCodeRegionStart() const {
-        return code_region_start;
-    }
-    constexpr VAddr GetCodeRegionEnd() const {
-        return code_region_end;
-    }
-    constexpr VAddr GetAliasCodeRegionStart() const {
-        return alias_code_region_start;
-    }
-    constexpr VAddr GetAliasCodeRegionSize() const {
-        return alias_code_region_end - alias_code_region_start;
-    }
-    constexpr std::size_t GetAddressSpaceWidth() const {
-        return address_space_width;
-    }
-    constexpr std::size_t GetHeapSize() {
-        return current_heap_addr - heap_region_start;
-    }
-    constexpr std::size_t GetTotalHeapSize() {
-        return GetHeapSize() + physical_memory_usage;
-    }
-    constexpr bool IsInsideAddressSpace(VAddr address, std::size_t size) const {
-        return address_space_start <= address && address + size - 1 <= address_space_end - 1;
-    }
-    constexpr bool IsOutsideAliasRegion(VAddr address, std::size_t size) const {
-        return alias_region_start > address || address + size - 1 > alias_region_end - 1;
-    }
-    constexpr bool IsOutsideStackRegion(VAddr address, std::size_t size) const {
-        return stack_region_start > address || address + size - 1 > stack_region_end - 1;
-    }
-    constexpr bool IsInvalidRegion(VAddr address, std::size_t size) const {
-        return address + size - 1 > GetAliasCodeRegionStart() + GetAliasCodeRegionSize() - 1;
-    }
-    constexpr bool IsInsideHeapRegion(VAddr address, std::size_t size) const {
-        return address + size > heap_region_start && heap_region_end > address;
-    }
-    constexpr bool IsInsideAliasRegion(VAddr address, std::size_t size) const {
-        return address + size > alias_region_start && alias_region_end > address;
-    }
-    constexpr bool IsOutsideASLRRegion(VAddr address, std::size_t size) const {
-        if (IsInvalidRegion(address, size)) {
-            return true;
-        }
-        if (IsInsideHeapRegion(address, size)) {
-            return true;
-        }
-        if (IsInsideAliasRegion(address, size)) {
-            return true;
-        }
-        return {};
-    }
-    constexpr bool IsInsideASLRRegion(VAddr address, std::size_t size) const {
-        return !IsOutsideASLRRegion(address, size);
-    }
-    constexpr PAddr GetPhysicalAddr(VAddr addr) {
-        return page_table_impl.backing_addr[addr >> Memory::PageBits] + addr;
-    }
-
-private:
-    constexpr bool Contains(VAddr addr) const {
-        return address_space_start <= addr && addr <= address_space_end - 1;
-    }
-    constexpr bool Contains(VAddr addr, std::size_t size) const {
-        return address_space_start <= addr && addr < addr + size &&
-               addr + size - 1 <= address_space_end - 1;
-    }
-    constexpr bool IsKernel() const {
-        return is_kernel;
-    }
-    constexpr bool IsAslrEnabled() const {
-        return is_aslr_enabled;
-    }
-
-    constexpr std::size_t GetNumGuardPages() const {
-        return IsKernel() ? 1 : 4;
-    }
-
-    constexpr bool ContainsPages(VAddr addr, std::size_t num_pages) const {
-        return (address_space_start <= addr) &&
-               (num_pages <= (address_space_end - address_space_start) / PageSize) &&
-               (addr + num_pages * PageSize - 1 <= address_space_end - 1);
-    }
-
-private:
-    VAddr address_space_start{};
-    VAddr address_space_end{};
-    VAddr heap_region_start{};
-    VAddr heap_region_end{};
-    VAddr current_heap_end{};
-    VAddr alias_region_start{};
-    VAddr alias_region_end{};
-    VAddr stack_region_start{};
-    VAddr stack_region_end{};
-    VAddr kernel_map_region_start{};
-    VAddr kernel_map_region_end{};
-    VAddr code_region_start{};
-    VAddr code_region_end{};
-    VAddr alias_code_region_start{};
-    VAddr alias_code_region_end{};
-    VAddr current_heap_addr{};
-
-    std::size_t heap_capacity{};
-    std::size_t physical_memory_usage{};
-    std::size_t max_heap_size{};
-    std::size_t max_physical_memory_size{};
-    std::size_t address_space_width{};
-
-    bool is_kernel{};
-    bool is_aslr_enabled{};
-
-    MemoryManager::Pool memory_pool{MemoryManager::Pool::Application};
-
-    Common::PageTable page_table_impl;
-
-    Core::System& system;
-};
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/slab_heap.h
+++ b/src/core/hle/kernel/memory/slab_heap.h
@@ -1,164 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-// This file references various implementation details from Atmosph<70>re, an open-source firmware for
-// the Nintendo Switch. Copyright 2018-2020 Atmosph<70>re-NX.
-
-#pragma once
-
-#include <atomic>
-
-#include "common/assert.h"
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-
-namespace Kernel::Memory {
-
-namespace impl {
-
-class SlabHeapImpl final : NonCopyable {
-public:
-    struct Node {
-        Node* next{};
-    };
-
-    constexpr SlabHeapImpl() = default;
-
-    void Initialize(std::size_t size) {
-        ASSERT(head == nullptr);
-        obj_size = size;
-    }
-
-    constexpr std::size_t GetObjectSize() const {
-        return obj_size;
-    }
-
-    Node* GetHead() const {
-        return head;
-    }
-
-    void* Allocate() {
-        Node* ret = head.load();
-
-        do {
-            if (ret == nullptr) {
-                break;
-            }
-        } while (!head.compare_exchange_weak(ret, ret->next));
-
-        return ret;
-    }
-
-    void Free(void* obj) {
-        Node* node = static_cast<Node*>(obj);
-
-        Node* cur_head = head.load();
-        do {
-            node->next = cur_head;
-        } while (!head.compare_exchange_weak(cur_head, node));
-    }
-
-private:
-    std::atomic<Node*> head{};
-    std::size_t obj_size{};
-};
-
-} // namespace impl
-
-class SlabHeapBase : NonCopyable {
-public:
-    constexpr SlabHeapBase() = default;
-
-    constexpr bool Contains(uintptr_t addr) const {
-        return start <= addr && addr < end;
-    }
-
-    constexpr std::size_t GetSlabHeapSize() const {
-        return (end - start) / GetObjectSize();
-    }
-
-    constexpr std::size_t GetObjectSize() const {
-        return impl.GetObjectSize();
-    }
-
-    constexpr uintptr_t GetSlabHeapAddress() const {
-        return start;
-    }
-
-    std::size_t GetObjectIndexImpl(const void* obj) const {
-        return (reinterpret_cast<uintptr_t>(obj) - start) / GetObjectSize();
-    }
-
-    std::size_t GetPeakIndex() const {
-        return GetObjectIndexImpl(reinterpret_cast<const void*>(peak));
-    }
-
-    void* AllocateImpl() {
-        return impl.Allocate();
-    }
-
-    void FreeImpl(void* obj) {
-        // Don't allow freeing an object that wasn't allocated from this heap
-        ASSERT(Contains(reinterpret_cast<uintptr_t>(obj)));
-        impl.Free(obj);
-    }
-
-    void InitializeImpl(std::size_t obj_size, void* memory, std::size_t memory_size) {
-        // Ensure we don't initialize a slab using null memory
-        ASSERT(memory != nullptr);
-
-        // Initialize the base allocator
-        impl.Initialize(obj_size);
-
-        // Set our tracking variables
-        const std::size_t num_obj = (memory_size / obj_size);
-        start = reinterpret_cast<uintptr_t>(memory);
-        end = start + num_obj * obj_size;
-        peak = start;
-
-        // Free the objects
-        u8* cur = reinterpret_cast<u8*>(end);
-
-        for (std::size_t i{}; i < num_obj; i++) {
-            cur -= obj_size;
-            impl.Free(cur);
-        }
-    }
-
-private:
-    using Impl = impl::SlabHeapImpl;
-
-    Impl impl;
-    uintptr_t peak{};
-    uintptr_t start{};
-    uintptr_t end{};
-};
-
-template <typename T>
-class SlabHeap final : public SlabHeapBase {
-public:
-    constexpr SlabHeap() : SlabHeapBase() {}
-
-    void Initialize(void* memory, std::size_t memory_size) {
-        InitializeImpl(sizeof(T), memory, memory_size);
-    }
-
-    T* Allocate() {
-        T* obj = static_cast<T*>(AllocateImpl());
-        if (obj != nullptr) {
-            new (obj) T();
-        }
-        return obj;
-    }
-
-    void Free(T* obj) {
-        FreeImpl(obj);
-    }
-
-    constexpr std::size_t GetObjectIndex(const T* obj) const {
-        return GetObjectIndexImpl(obj);
-    }
-};
-
-} // namespace Kernel::Memory
--- a/src/core/hle/kernel/memory/system_control.cpp
+++ b/src/core/hle/kernel/memory/system_control.cpp
@@ -1,41 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <random>
-
-#include "core/hle/kernel/memory/system_control.h"
-
-namespace Kernel::Memory::SystemControl {
-
-u64 GenerateRandomU64ForInit() {
-    static std::random_device device;
-    static std::mt19937 gen(device());
-    static std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
-    return distribution(gen);
-}
-
-template <typename F>
-u64 GenerateUniformRange(u64 min, u64 max, F f) {
-    /* Handle the case where the difference is too large to represent. */
-    if (max == std::numeric_limits<u64>::max() && min == std::numeric_limits<u64>::min()) {
-        return f();
-    }
-
-    /* Iterate until we get a value in range. */
-    const u64 range_size = ((max + 1) - min);
-    const u64 effective_max = (std::numeric_limits<u64>::max() / range_size) * range_size;
-    while (true) {
-        if (const u64 rnd = f(); rnd < effective_max) {
-            return min + (rnd % range_size);
-        }
-    }
-}
-
-u64 GenerateRandomRange(u64 min, u64 max) {
-    return GenerateUniformRange(min, max, GenerateRandomU64ForInit);
-}
-
-} // namespace Kernel::Memory::SystemControl
--- a/src/core/hle/kernel/memory/system_control.h
+++ b/src/core/hle/kernel/memory/system_control.h
@@ -1,18 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-
-namespace Kernel::Memory::SystemControl {
-
-u64 GenerateRandomU64ForInit();
-
-template <typename F>
-u64 GenerateUniformRange(u64 min, u64 max, F f);
-
-u64 GenerateRandomRange(u64 min, u64 max);
-
-} // namespace Kernel::Memory::SystemControl
--- a/src/core/hle/kernel/physical_core.cpp
+++ b/src/core/hle/kernel/physical_core.cpp
@@ -5,8 +5,7 @@
 #include "common/logging/log.h"
 #include "core/arm/arm_interface.h"
 #ifdef ARCHITECTURE_x86_64
-#include "core/arm/dynarmic/arm_dynarmic_32.h"
-#include "core/arm/dynarmic/arm_dynarmic_64.h"
+#include "core/arm/dynarmic/arm_dynarmic.h"
 #endif
 #include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
@@ -21,17 +20,13 @@ PhysicalCore::PhysicalCore(Core::System& system, std::size_t id,
                           Core::ExclusiveMonitor& exclusive_monitor)
    : core_index{id} {
 #ifdef ARCHITECTURE_x86_64
-    arm_interface_32 =
-        std::make_unique<Core::ARM_Dynarmic_32>(system, exclusive_monitor, core_index);
-    arm_interface_64 =
-        std::make_unique<Core::ARM_Dynarmic_64>(system, exclusive_monitor, core_index);
-
+    arm_interface = std::make_unique<Core::ARM_Dynarmic>(system, exclusive_monitor, core_index);
 #else
    arm_interface = std::make_shared<Core::ARM_Unicorn>(system);
    LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif

-    scheduler = std::make_unique<Kernel::Scheduler>(system, core_index);
+    scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface, core_index);
 }

 PhysicalCore::~PhysicalCore() = default;
@@ -53,12 +48,4 @@ void PhysicalCore::Shutdown() {
    scheduler->Shutdown();
 }

-void PhysicalCore::SetIs64Bit(bool is_64_bit) {
-    if (is_64_bit) {
-        arm_interface = arm_interface_64.get();
-    } else {
-        arm_interface = arm_interface_32.get();
-    }
-}
-
 } // namespace Kernel
--- a/src/core/hle/kernel/physical_core.h
+++ b/src/core/hle/kernel/physical_core.h
@@ -68,14 +68,10 @@ public:
        return *scheduler;
    }

-    void SetIs64Bit(bool is_64_bit);
-
 private:
    std::size_t core_index;
-    std::unique_ptr<Core::ARM_Interface> arm_interface_32;
-    std::unique_ptr<Core::ARM_Interface> arm_interface_64;
+    std::unique_ptr<Core::ARM_Interface> arm_interface;
    std::unique_ptr<Kernel::Scheduler> scheduler;
-    Core::ARM_Interface* arm_interface{};
 };

 } // namespace Kernel
--- a/src/core/hle/kernel/physical_memory.h
+++ b/src/core/hle/kernel/physical_memory.h
@@ -4,8 +4,6 @@

 #pragma once

-#include <vector>
-
 #include "common/alignment.h"

 namespace Kernel {
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -10,18 +10,15 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
-#include "core/device_memory.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/code_set.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/memory/memory_block_manager.h"
-#include "core/hle/kernel/memory/page_table.h"
-#include "core/hle/kernel/memory/slab_heap.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
+#include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"
 #include "core/settings.h"

@@ -34,8 +31,10 @@ namespace {
 * @param kernel The kernel instance to create the main thread under.
 * @param priority The priority to give the main thread
 */
-void SetupMainThread(Process& owner_process, KernelCore& kernel, u32 priority, VAddr stack_top) {
-    const VAddr entry_point = owner_process.PageTable().GetCodeRegionStart();
+void SetupMainThread(Process& owner_process, KernelCore& kernel, u32 priority) {
+    const auto& vm_manager = owner_process.VMManager();
+    const VAddr entry_point = vm_manager.GetCodeRegionBaseAddress();
+    const VAddr stack_top = vm_manager.GetTLSIORegionEndAddress();
    auto thread_res = Thread::Create(kernel, "main", entry_point, priority, 0,
                                     owner_process.GetIdealCore(), stack_top, owner_process);

@@ -43,10 +42,7 @@ void SetupMainThread(Process& owner_process, KernelCore& kernel, u32 priority, V

    // Register 1 must be a handle to the main thread
    const Handle thread_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
-    thread->GetContext32().cpu_registers[0] = 0;
-    thread->GetContext64().cpu_registers[0] = 0;
-    thread->GetContext32().cpu_registers[1] = thread_handle;
-    thread->GetContext64().cpu_registers[1] = thread_handle;
+    thread->GetContext().cpu_registers[1] = thread_handle;

    // Threads by default are dormant, wake up the main thread so it runs when the scheduler fires
    thread->ResumeFromWait();
@@ -60,8 +56,7 @@ void SetupMainThread(Process& owner_process, KernelCore& kernel, u32 priority, V
 // (whichever page happens to have an available slot).
 class TLSPage {
 public:
-    static constexpr std::size_t num_slot_entries =
-        Core::Memory::PAGE_SIZE / Core::Memory::TLS_ENTRY_SIZE;
+    static constexpr std::size_t num_slot_entries = Memory::PAGE_SIZE / Memory::TLS_ENTRY_SIZE;

    explicit TLSPage(VAddr address) : base_address{address} {}

@@ -80,7 +75,7 @@ public:
            }

            is_slot_used[i] = true;
-            return base_address + (i * Core::Memory::TLS_ENTRY_SIZE);
+            return base_address + (i * Memory::TLS_ENTRY_SIZE);
        }

        return std::nullopt;
@@ -90,15 +85,15 @@ public:
        // Ensure that all given addresses are consistent with how TLS pages
        // are intended to be used when releasing slots.
        ASSERT(IsWithinPage(address));
-        ASSERT((address % Core::Memory::TLS_ENTRY_SIZE) == 0);
+        ASSERT((address % Memory::TLS_ENTRY_SIZE) == 0);

-        const std::size_t index = (address - base_address) / Core::Memory::TLS_ENTRY_SIZE;
+        const std::size_t index = (address - base_address) / Memory::TLS_ENTRY_SIZE;
        is_slot_used[index] = false;
    }

 private:
    bool IsWithinPage(VAddr address) const {
-        return base_address <= address && address < base_address + Core::Memory::PAGE_SIZE;
+        return base_address <= address && address < base_address + Memory::PAGE_SIZE;
    }

    VAddr base_address;
@@ -110,7 +105,7 @@ std::shared_ptr<Process> Process::Create(Core::System& system, std::string name,

    std::shared_ptr<Process> process = std::make_shared<Process>(system);
    process->name = std::move(name);
-    process->resource_limit = ResourceLimit::Create(kernel);
+    process->resource_limit = kernel.GetSystemResourceLimit();
    process->status = ProcessStatus::Created;
    process->program_id = 0;
    process->process_id = type == ProcessType::KernelInternal ? kernel.CreateNewKernelProcessID()
@@ -131,14 +126,7 @@ std::shared_ptr<ResourceLimit> Process::GetResourceLimit() const {
 }

 u64 Process::GetTotalPhysicalMemoryAvailable() const {
-    const u64 capacity{resource_limit->GetCurrentResourceValue(ResourceType::PhysicalMemory) +
-                       page_table->GetTotalHeapSize() + image_size + main_thread_stack_size};
-
-    if (capacity < memory_usage_capacity) {
-        return capacity;
-    }
-
-    return memory_usage_capacity;
+    return vm_manager.GetTotalPhysicalMemoryAvailable();
 }

 u64 Process::GetTotalPhysicalMemoryAvailableWithoutSystemResource() const {
@@ -146,7 +134,8 @@ u64 Process::GetTotalPhysicalMemoryAvailableWithoutSystemResource() const {
 }

 u64 Process::GetTotalPhysicalMemoryUsed() const {
-    return image_size + main_thread_stack_size + page_table->GetTotalHeapSize();
+    return vm_manager.GetCurrentHeapSize() + main_thread_stack_size + code_memory_size +
+           GetSystemResourceUsage();
 }

 u64 Process::GetTotalPhysicalMemoryUsedWithoutSystemResource() const {
@@ -219,82 +208,33 @@ ResultCode Process::ClearSignalState() {
    return RESULT_SUCCESS;
 }

-ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata,
-                                     std::size_t code_size) {
+ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
    program_id = metadata.GetTitleID();
    ideal_core = metadata.GetMainThreadCore();
    is_64bit_process = metadata.Is64BitProgram();
    system_resource_size = metadata.GetSystemResourceSize();
-    image_size = code_size;

-    // Initialize proces address space
-    if (const ResultCode result{
-            page_table->InitializeForProcess(metadata.GetAddressSpaceType(), false, 0x8000000,
-                                             code_size, Memory::MemoryManager::Pool::Application)};
-        result.IsError()) {
-        return result;
+    vm_manager.Reset(metadata.GetAddressSpaceType());
+
+    const auto& caps = metadata.GetKernelCapabilities();
+    const auto capability_init_result =
+        capabilities.InitializeForUserProcess(caps.data(), caps.size(), vm_manager);
+    if (capability_init_result.IsError()) {
+        return capability_init_result;
    }

-    // Map process code region
-    if (const ResultCode result{page_table->MapProcessCode(
-            page_table->GetCodeRegionStart(), code_size / Memory::PageSize,
-            Memory::MemoryState::Code, Memory::MemoryPermission::None)};
-        result.IsError()) {
-        return result;
-    }
-
-    // Initialize process capabilities
-    const auto& caps{metadata.GetKernelCapabilities()};
-    if (const ResultCode result{
-            capabilities.InitializeForUserProcess(caps.data(), caps.size(), *page_table)};
-        result.IsError()) {
-        return result;
-    }
-
-    // Set memory usage capacity
-    switch (metadata.GetAddressSpaceType()) {
-    case FileSys::ProgramAddressSpaceType::Is32Bit:
-    case FileSys::ProgramAddressSpaceType::Is36Bit:
-    case FileSys::ProgramAddressSpaceType::Is39Bit:
-        memory_usage_capacity = page_table->GetHeapRegionEnd() - page_table->GetHeapRegionStart();
-        break;
-
-    case FileSys::ProgramAddressSpaceType::Is32BitNoMap:
-        memory_usage_capacity = page_table->GetHeapRegionEnd() - page_table->GetHeapRegionStart() +
-                                page_table->GetAliasRegionEnd() - page_table->GetAliasRegionStart();
-        break;
-
-    default:
-        UNREACHABLE();
-    }
-
-    // Set initial resource limits
-    resource_limit->SetLimitValue(
-        ResourceType::PhysicalMemory,
-        kernel.MemoryManager().GetSize(Memory::MemoryManager::Pool::Application));
-    resource_limit->SetLimitValue(ResourceType::Threads, 608);
-    resource_limit->SetLimitValue(ResourceType::Events, 700);
-    resource_limit->SetLimitValue(ResourceType::TransferMemory, 128);
-    resource_limit->SetLimitValue(ResourceType::Sessions, 894);
-    ASSERT(resource_limit->Reserve(ResourceType::PhysicalMemory, code_size));
-
-    // Create TLS region
-    tls_region_address = CreateTLSRegion();
-
    return handle_table.SetSize(capabilities.GetHandleTableSize());
 }

 void Process::Run(s32 main_thread_priority, u64 stack_size) {
    AllocateMainThreadStack(stack_size);
+    tls_region_address = CreateTLSRegion();

-    const std::size_t heap_capacity{memory_usage_capacity - main_thread_stack_size - image_size};
-    ASSERT(!page_table->SetHeapCapacity(heap_capacity).IsError());
+    vm_manager.LogLayout();

    ChangeStatus(ProcessStatus::Running);

-    SetupMainThread(*this, kernel, main_thread_priority, main_thread_stack_top);
-    resource_limit->Reserve(ResourceType::Threads, 1);
-    resource_limit->Reserve(ResourceType::PhysicalMemory, main_thread_stack_size);
+    SetupMainThread(*this, kernel, main_thread_priority);
 }

 void Process::PrepareForTermination() {
@@ -338,37 +278,32 @@ static auto FindTLSPageWithAvailableSlots(std::vector<TLSPage>& tls_pages) {
 }

 VAddr Process::CreateTLSRegion() {
-    if (auto tls_page_iter{FindTLSPageWithAvailableSlots(tls_pages)};
-        tls_page_iter != tls_pages.cend()) {
-        return *tls_page_iter->ReserveSlot();
+    auto tls_page_iter = FindTLSPageWithAvailableSlots(tls_pages);
+
+    if (tls_page_iter == tls_pages.cend()) {
+        const auto region_address =
+            vm_manager.FindFreeRegion(vm_manager.GetTLSIORegionBaseAddress(),
+                                      vm_manager.GetTLSIORegionEndAddress(), Memory::PAGE_SIZE);
+        ASSERT(region_address.Succeeded());
+
+        const auto map_result = vm_manager.MapMemoryBlock(
+            *region_address, std::make_shared<PhysicalMemory>(Memory::PAGE_SIZE), 0,
+            Memory::PAGE_SIZE, MemoryState::ThreadLocal);
+        ASSERT(map_result.Succeeded());
+
+        tls_pages.emplace_back(*region_address);
+
+        const auto reserve_result = tls_pages.back().ReserveSlot();
+        ASSERT(reserve_result.has_value());
+
+        return *reserve_result;
    }

-    Memory::Page* const tls_page_ptr{kernel.GetUserSlabHeapPages().Allocate()};
-    ASSERT(tls_page_ptr);
-
-    const VAddr start{page_table->GetKernelMapRegionStart()};
-    const VAddr size{page_table->GetKernelMapRegionEnd() - start};
-    const PAddr tls_map_addr{system.DeviceMemory().GetPhysicalAddr(tls_page_ptr)};
-    const VAddr tls_page_addr{
-        page_table
-            ->AllocateAndMapMemory(1, Memory::PageSize, true, start, size / Memory::PageSize,
-                                   Memory::MemoryState::ThreadLocal,
-                                   Memory::MemoryPermission::ReadAndWrite, tls_map_addr)
-            .ValueOr(0)};
-
-    ASSERT(tls_page_addr);
-
-    std::memset(tls_page_ptr, 0, Memory::PageSize);
-    tls_pages.emplace_back(tls_page_addr);
-
-    const auto reserve_result{tls_pages.back().ReserveSlot()};
-    ASSERT(reserve_result.has_value());
-
-    return *reserve_result;
+    return *tls_page_iter->ReserveSlot();
 }

 void Process::FreeTLSRegion(VAddr tls_address) {
-    const VAddr aligned_address = Common::AlignDown(tls_address, Core::Memory::PAGE_SIZE);
+    const VAddr aligned_address = Common::AlignDown(tls_address, Memory::PAGE_SIZE);
    auto iter =
        std::find_if(tls_pages.begin(), tls_pages.end(), [aligned_address](const auto& page) {
            return page.GetBaseAddress() == aligned_address;
@@ -381,22 +316,28 @@ void Process::FreeTLSRegion(VAddr tls_address) {
    iter->ReleaseSlot(tls_address);
 }

-void Process::LoadModule(CodeSet code_set, VAddr base_addr) {
-    const auto ReprotectSegment = [&](const CodeSet::Segment& segment,
-                                      Memory::MemoryPermission permission) {
-        page_table->SetCodeMemoryPermission(segment.addr + base_addr, segment.size, permission);
+void Process::LoadModule(CodeSet module_, VAddr base_addr) {
+    code_memory_size += module_.memory.size();
+
+    const auto memory = std::make_shared<PhysicalMemory>(std::move(module_.memory));
+
+    const auto MapSegment = [&](const CodeSet::Segment& segment, VMAPermission permissions,
+                                MemoryState memory_state) {
+        const auto vma = vm_manager
+                             .MapMemoryBlock(segment.addr + base_addr, memory, segment.offset,
+                                             segment.size, memory_state)
+                             .Unwrap();
+        vm_manager.Reprotect(vma, permissions);
    };

-    system.Memory().WriteBlock(*this, base_addr, code_set.memory.data(), code_set.memory.size());
-
-    ReprotectSegment(code_set.CodeSegment(), Memory::MemoryPermission::ReadAndExecute);
-    ReprotectSegment(code_set.RODataSegment(), Memory::MemoryPermission::Read);
-    ReprotectSegment(code_set.DataSegment(), Memory::MemoryPermission::ReadAndWrite);
+    // Map CodeSet segments
+    MapSegment(module_.CodeSegment(), VMAPermission::ReadExecute, MemoryState::Code);
+    MapSegment(module_.RODataSegment(), VMAPermission::Read, MemoryState::CodeData);
+    MapSegment(module_.DataSegment(), VMAPermission::ReadWrite, MemoryState::CodeData);
 }

 Process::Process(Core::System& system)
-    : SynchronizationObject{system.Kernel()}, page_table{std::make_unique<Memory::PageTable>(
-                                                  system)},
+    : SynchronizationObject{system.Kernel()}, vm_manager{system},
      address_arbiter{system}, mutex{system}, system{system} {}

 Process::~Process() = default;
@@ -419,24 +360,16 @@ void Process::ChangeStatus(ProcessStatus new_status) {
    Signal();
 }

-ResultCode Process::AllocateMainThreadStack(std::size_t stack_size) {
-    ASSERT(stack_size);
-
+void Process::AllocateMainThreadStack(u64 stack_size) {
    // The kernel always ensures that the given stack size is page aligned.
-    main_thread_stack_size = Common::AlignUp(stack_size, Memory::PageSize);
+    main_thread_stack_size = Common::AlignUp(stack_size, Memory::PAGE_SIZE);

-    const VAddr start{page_table->GetStackRegionStart()};
-    const std::size_t size{page_table->GetStackRegionEnd() - start};
-
-    CASCADE_RESULT(main_thread_stack_top,
-                   page_table->AllocateAndMapMemory(
-                       main_thread_stack_size / Memory::PageSize, Memory::PageSize, false, start,
-                       size / Memory::PageSize, Memory::MemoryState::Stack,
-                       Memory::MemoryPermission::ReadAndWrite));
-
-    main_thread_stack_top += main_thread_stack_size;
-
-    return RESULT_SUCCESS;
+    // Allocate and map the main thread stack
+    const VAddr mapping_address = vm_manager.GetTLSIORegionEndAddress() - main_thread_stack_size;
+    vm_manager
+        .MapMemoryBlock(mapping_address, std::make_shared<PhysicalMemory>(main_thread_stack_size),
+                        0, main_thread_stack_size, MemoryState::Stack)
+        .Unwrap();
 }

 } // namespace Kernel
--- a/src/core/hle/kernel/process.h
+++ b/src/core/hle/kernel/process.h
@@ -16,6 +16,7 @@
 #include "core/hle/kernel/mutex.h"
 #include "core/hle/kernel/process_capability.h"
 #include "core/hle/kernel/synchronization_object.h"
+#include "core/hle/kernel/vm_manager.h"
 #include "core/hle/result.h"

 namespace Core {
@@ -35,10 +36,6 @@ class TLSPage;

 struct CodeSet;

-namespace Memory {
-class PageTable;
-}
-
 enum class MemoryRegion : u16 {
    APPLICATION = 1,
    SYSTEM = 2,
@@ -103,14 +100,14 @@ public:
        return HANDLE_TYPE;
    }

-    /// Gets a reference to the process' page table.
-    Memory::PageTable& PageTable() {
-        return *page_table;
+    /// Gets a reference to the process' memory manager.
+    Kernel::VMManager& VMManager() {
+        return vm_manager;
    }

-    /// Gets const a reference to the process' page table.
-    const Memory::PageTable& PageTable() const {
-        return *page_table;
+    /// Gets a const reference to the process' memory manager.
+    const Kernel::VMManager& VMManager() const {
+        return vm_manager;
    }

    /// Gets a reference to the process' handle table.
@@ -276,7 +273,7 @@ public:
     * @returns RESULT_SUCCESS if all relevant metadata was able to be
     *          loaded and parsed. Otherwise, an error code is returned.
     */
-    ResultCode LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size);
+    ResultCode LoadFromMetadata(const FileSys::ProgramMetadata& metadata);

    /**
     * Starts the main application thread for this process.
@@ -292,7 +289,7 @@ public:
     */
    void PrepareForTermination();

-    void LoadModule(CodeSet code_set, VAddr base_addr);
+    void LoadModule(CodeSet module_, VAddr base_addr);

    ///////////////////////////////////////////////////////////////////////////////////////////////
    // Thread-local storage management
@@ -316,10 +313,16 @@ private:
    void ChangeStatus(ProcessStatus new_status);

    /// Allocates the main thread stack for the process, given the stack size in bytes.
-    ResultCode AllocateMainThreadStack(std::size_t stack_size);
+    void AllocateMainThreadStack(u64 stack_size);

-    /// Memory manager for this process
-    std::unique_ptr<Memory::PageTable> page_table;
+    /// Memory manager for this process.
+    Kernel::VMManager vm_manager;
+
+    /// Size of the main thread's stack in bytes.
+    u64 main_thread_stack_size = 0;
+
+    /// Size of the loaded code memory in bytes.
+    u64 code_memory_size = 0;

    /// Current status of the process
    ProcessStatus status{};
@@ -387,18 +390,6 @@ private:

    /// Name of this process
    std::string name;
-
-    /// Address of the top of the main thread's stack
-    VAddr main_thread_stack_top{};
-
-    /// Size of the main thread's stack
-    std::size_t main_thread_stack_size{};
-
-    /// Memory usage capacity for the process
-    std::size_t memory_usage_capacity{};
-
-    /// Process total image size
-    std::size_t image_size{};
 };

 } // namespace Kernel
--- a/src/core/hle/kernel/process_capability.cpp
+++ b/src/core/hle/kernel/process_capability.cpp
@@ -5,8 +5,8 @@
 #include "common/bit_util.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
-#include "core/hle/kernel/memory/page_table.h"
 #include "core/hle/kernel/process_capability.h"
+#include "core/hle/kernel/vm_manager.h"

 namespace Kernel {
 namespace {
@@ -66,7 +66,7 @@ u32 GetFlagBitOffset(CapabilityType type) {

 ResultCode ProcessCapabilities::InitializeForKernelProcess(const u32* capabilities,
                                                           std::size_t num_capabilities,
-                                                           Memory::PageTable& page_table) {
+                                                           VMManager& vm_manager) {
    Clear();

    // Allow all cores and priorities.
@@ -74,15 +74,15 @@ ResultCode ProcessCapabilities::InitializeForKernelProcess(const u32* capabiliti
    priority_mask = 0xFFFFFFFFFFFFFFFF;
    kernel_version = PackedKernelVersion;

-    return ParseCapabilities(capabilities, num_capabilities, page_table);
+    return ParseCapabilities(capabilities, num_capabilities, vm_manager);
 }

 ResultCode ProcessCapabilities::InitializeForUserProcess(const u32* capabilities,
                                                         std::size_t num_capabilities,
-                                                         Memory::PageTable& page_table) {
+                                                         VMManager& vm_manager) {
    Clear();

-    return ParseCapabilities(capabilities, num_capabilities, page_table);
+    return ParseCapabilities(capabilities, num_capabilities, vm_manager);
 }

 void ProcessCapabilities::InitializeForMetadatalessProcess() {
@@ -105,7 +105,7 @@ void ProcessCapabilities::InitializeForMetadatalessProcess() {

 ResultCode ProcessCapabilities::ParseCapabilities(const u32* capabilities,
                                                  std::size_t num_capabilities,
-                                                  Memory::PageTable& page_table) {
+                                                  VMManager& vm_manager) {
    u32 set_flags = 0;
    u32 set_svc_bits = 0;

@@ -127,13 +127,13 @@ ResultCode ProcessCapabilities::ParseCapabilities(const u32* capabilities,
                return ERR_INVALID_COMBINATION;
            }

-            const auto result = HandleMapPhysicalFlags(descriptor, size_flags, page_table);
+            const auto result = HandleMapPhysicalFlags(descriptor, size_flags, vm_manager);
            if (result.IsError()) {
                return result;
            }
        } else {
            const auto result =
-                ParseSingleFlagCapability(set_flags, set_svc_bits, descriptor, page_table);
+                ParseSingleFlagCapability(set_flags, set_svc_bits, descriptor, vm_manager);
            if (result.IsError()) {
                return result;
            }
@@ -144,7 +144,7 @@ ResultCode ProcessCapabilities::ParseCapabilities(const u32* capabilities,
 }

 ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& set_svc_bits,
-                                                          u32 flag, Memory::PageTable& page_table) {
+                                                          u32 flag, VMManager& vm_manager) {
    const auto type = GetCapabilityType(flag);

    if (type == CapabilityType::Unset) {
@@ -172,7 +172,7 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
    case CapabilityType::Syscall:
        return HandleSyscallFlags(set_svc_bits, flag);
    case CapabilityType::MapIO:
-        return HandleMapIOFlags(flag, page_table);
+        return HandleMapIOFlags(flag, vm_manager);
    case CapabilityType::Interrupt:
        return HandleInterruptFlags(flag);
    case CapabilityType::ProgramType:
@@ -269,12 +269,12 @@ ResultCode ProcessCapabilities::HandleSyscallFlags(u32& set_svc_bits, u32 flags)
 }

 ResultCode ProcessCapabilities::HandleMapPhysicalFlags(u32 flags, u32 size_flags,
-                                                       Memory::PageTable& page_table) {
+                                                       VMManager& vm_manager) {
    // TODO(Lioncache): Implement once the memory manager can handle this.
    return RESULT_SUCCESS;
 }

-ResultCode ProcessCapabilities::HandleMapIOFlags(u32 flags, Memory::PageTable& page_table) {
+ResultCode ProcessCapabilities::HandleMapIOFlags(u32 flags, VMManager& vm_manager) {
    // TODO(Lioncache): Implement once the memory manager can handle this.
    return RESULT_SUCCESS;
 }
--- a/src/core/hle/kernel/process_capability.h
+++ b/src/core/hle/kernel/process_capability.h
@@ -12,9 +12,7 @@ union ResultCode;

 namespace Kernel {

-namespace Memory {
-class PageTable;
-}
+class VMManager;

 /// The possible types of programs that may be indicated
 /// by the program type capability descriptor.
@@ -83,27 +81,27 @@ public:
    ///
    /// @param capabilities     The capabilities to parse
    /// @param num_capabilities The number of capabilities to parse.
-    /// @param page_table       The memory manager to use for handling any mapping-related
+    /// @param vm_manager       The memory manager to use for handling any mapping-related
    ///                         operations (such as mapping IO memory, etc).
    ///
    /// @returns RESULT_SUCCESS if this capabilities instance was able to be initialized,
    ///          otherwise, an error code upon failure.
    ///
    ResultCode InitializeForKernelProcess(const u32* capabilities, std::size_t num_capabilities,
-                                          Memory::PageTable& page_table);
+                                          VMManager& vm_manager);

    /// Initializes this process capabilities instance for a userland process.
    ///
    /// @param capabilities     The capabilities to parse.
    /// @param num_capabilities The total number of capabilities to parse.
-    /// @param page_table       The memory manager to use for handling any mapping-related
+    /// @param vm_manager       The memory manager to use for handling any mapping-related
    ///                         operations (such as mapping IO memory, etc).
    ///
    /// @returns RESULT_SUCCESS if this capabilities instance was able to be initialized,
    ///          otherwise, an error code upon failure.
    ///
    ResultCode InitializeForUserProcess(const u32* capabilities, std::size_t num_capabilities,
-                                        Memory::PageTable& page_table);
+                                        VMManager& vm_manager);

    /// Initializes this process capabilities instance for a process that does not
    /// have any metadata to parse.
@@ -183,13 +181,13 @@ private:
    ///
    /// @param capabilities     The sequence of capability descriptors to parse.
    /// @param num_capabilities The number of descriptors within the given sequence.
-    /// @param page_table       The memory manager that will perform any memory
+    /// @param vm_manager       The memory manager that will perform any memory
    ///                         mapping if necessary.
    ///
    /// @return RESULT_SUCCESS if no errors occur, otherwise an error code.
    ///
    ResultCode ParseCapabilities(const u32* capabilities, std::size_t num_capabilities,
-                                 Memory::PageTable& page_table);
+                                 VMManager& vm_manager);

    /// Attempts to parse a capability descriptor that is only represented by a
    /// single flag set.
@@ -198,13 +196,13 @@ private:
    ///                     flags being initialized more than once when they shouldn't be.
    /// @param set_svc_bits Running set of bits representing the allowed supervisor calls mask.
    /// @param flag         The flag to attempt to parse.
-    /// @param page_table   The memory manager that will perform any memory
+    /// @param vm_manager   The memory manager that will perform any memory
    ///                     mapping if necessary.
    ///
    /// @return RESULT_SUCCESS if no errors occurred, otherwise an error code.
    ///
    ResultCode ParseSingleFlagCapability(u32& set_flags, u32& set_svc_bits, u32 flag,
-                                         Memory::PageTable& page_table);
+                                         VMManager& vm_manager);

    /// Clears the internal state of this process capability instance. Necessary,
    /// to have a sane starting point due to us allowing running executables without
@@ -228,10 +226,10 @@ private:
    ResultCode HandleSyscallFlags(u32& set_svc_bits, u32 flags);

    /// Handles flags related to mapping physical memory pages.
-    ResultCode HandleMapPhysicalFlags(u32 flags, u32 size_flags, Memory::PageTable& page_table);
+    ResultCode HandleMapPhysicalFlags(u32 flags, u32 size_flags, VMManager& vm_manager);

    /// Handles flags related to mapping IO pages.
-    ResultCode HandleMapIOFlags(u32 flags, Memory::PageTable& page_table);
+    ResultCode HandleMapIOFlags(u32 flags, VMManager& vm_manager);

    /// Handles flags related to the interrupt capability flags.
    ResultCode HandleInterruptFlags(u32 flags);
--- a/src/core/hle/kernel/resource_limit.cpp
+++ b/src/core/hle/kernel/resource_limit.cpp
@@ -16,60 +16,26 @@ constexpr std::size_t ResourceTypeToIndex(ResourceType type) {
 ResourceLimit::ResourceLimit(KernelCore& kernel) : Object{kernel} {}
 ResourceLimit::~ResourceLimit() = default;

-bool ResourceLimit::Reserve(ResourceType resource, s64 amount) {
-    return Reserve(resource, amount, 10000000000);
-}
-
-bool ResourceLimit::Reserve(ResourceType resource, s64 amount, u64 timeout) {
-    const std::size_t index{ResourceTypeToIndex(resource)};
-
-    s64 new_value = current[index] + amount;
-    while (new_value > limit[index] && available[index] + amount <= limit[index]) {
-        // TODO(bunnei): This is wrong for multicore, we should wait the calling thread for timeout
-        new_value = current[index] + amount;
-
-        if (timeout >= 0) {
-            break;
-        }
-    }
-
-    if (new_value <= limit[index]) {
-        current[index] = new_value;
-        return true;
-    }
-    return false;
-}
-
-void ResourceLimit::Release(ResourceType resource, u64 amount) {
-    Release(resource, amount, amount);
-}
-
-void ResourceLimit::Release(ResourceType resource, u64 used_amount, u64 available_amount) {
-    const std::size_t index{ResourceTypeToIndex(resource)};
-
-    current[index] -= used_amount;
-    available[index] -= available_amount;
-}
-
 std::shared_ptr<ResourceLimit> ResourceLimit::Create(KernelCore& kernel) {
    return std::make_shared<ResourceLimit>(kernel);
 }

 s64 ResourceLimit::GetCurrentResourceValue(ResourceType resource) const {
-    return limit.at(ResourceTypeToIndex(resource)) - current.at(ResourceTypeToIndex(resource));
+    return values.at(ResourceTypeToIndex(resource));
 }

 s64 ResourceLimit::GetMaxResourceValue(ResourceType resource) const {
-    return limit.at(ResourceTypeToIndex(resource));
+    return limits.at(ResourceTypeToIndex(resource));
 }

 ResultCode ResourceLimit::SetLimitValue(ResourceType resource, s64 value) {
-    const std::size_t index{ResourceTypeToIndex(resource)};
-    if (current[index] <= value) {
-        limit[index] = value;
-        return RESULT_SUCCESS;
-    } else {
+    const auto index = ResourceTypeToIndex(resource);
+
+    if (value < values[index]) {
        return ERR_INVALID_STATE;
    }
+
+    values[index] = value;
+    return RESULT_SUCCESS;
 }
 } // namespace Kernel
--- a/src/core/hle/kernel/resource_limit.h
+++ b/src/core/hle/kernel/resource_limit.h
@@ -51,11 +51,6 @@ public:
        return HANDLE_TYPE;
    }

-    bool Reserve(ResourceType resource, s64 amount);
-    bool Reserve(ResourceType resource, s64 amount, u64 timeout);
-    void Release(ResourceType resource, u64 amount);
-    void Release(ResourceType resource, u64 used_amount, u64 available_amount);
-
    /**
     * Gets the current value for the specified resource.
     * @param resource Requested resource type
@@ -96,9 +91,10 @@ private:
    using ResourceArray =
        std::array<s64, static_cast<std::size_t>(ResourceType::ResourceTypeCount)>;

-    ResourceArray limit{};
-    ResourceArray current{};
-    ResourceArray available{};
+    /// Maximum values a resource type may reach.
+    ResourceArray limits{};
+    /// Current resource limit values.
+    ResourceArray values{};
 };

 } // namespace Kernel
--- a/src/core/hle/kernel/scheduler.cpp
+++ b/src/core/hle/kernel/scheduler.cpp
@@ -383,8 +383,8 @@ void GlobalScheduler::Unlock() {
    // TODO(Blinkhawk): Setup the interrupts and change context on current core.
 }

-Scheduler::Scheduler(Core::System& system, std::size_t core_id)
-    : system{system}, core_id{core_id} {}
+Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core, std::size_t core_id)
+    : system(system), cpu_core(cpu_core), core_id(core_id) {}

 Scheduler::~Scheduler() = default;

@@ -422,10 +422,9 @@ void Scheduler::UnloadThread() {

    // Save context for previous thread
    if (previous_thread) {
-        system.ArmInterface(core_id).SaveContext(previous_thread->GetContext32());
-        system.ArmInterface(core_id).SaveContext(previous_thread->GetContext64());
+        cpu_core.SaveContext(previous_thread->GetContext());
        // Save the TPIDR_EL0 system register in case it was modified.
-        previous_thread->SetTPIDR_EL0(system.ArmInterface(core_id).GetTPIDR_EL0());
+        previous_thread->SetTPIDR_EL0(cpu_core.GetTPIDR_EL0());

        if (previous_thread->GetStatus() == ThreadStatus::Running) {
            // This is only the case when a reschedule is triggered without the current thread
@@ -452,10 +451,9 @@ void Scheduler::SwitchContext() {

    // Save context for previous thread
    if (previous_thread) {
-        system.ArmInterface(core_id).SaveContext(previous_thread->GetContext32());
-        system.ArmInterface(core_id).SaveContext(previous_thread->GetContext64());
+        cpu_core.SaveContext(previous_thread->GetContext());
        // Save the TPIDR_EL0 system register in case it was modified.
-        previous_thread->SetTPIDR_EL0(system.ArmInterface(core_id).GetTPIDR_EL0());
+        previous_thread->SetTPIDR_EL0(cpu_core.GetTPIDR_EL0());

        if (previous_thread->GetStatus() == ThreadStatus::Running) {
            // This is only the case when a reschedule is triggered without the current thread
@@ -483,10 +481,9 @@ void Scheduler::SwitchContext() {
            system.Kernel().MakeCurrentProcess(thread_owner_process);
        }

-        system.ArmInterface(core_id).LoadContext(new_thread->GetContext32());
-        system.ArmInterface(core_id).LoadContext(new_thread->GetContext64());
-        system.ArmInterface(core_id).SetTlsAddress(new_thread->GetTLSAddress());
-        system.ArmInterface(core_id).SetTPIDR_EL0(new_thread->GetTPIDR_EL0());
+        cpu_core.LoadContext(new_thread->GetContext());
+        cpu_core.SetTlsAddress(new_thread->GetTLSAddress());
+        cpu_core.SetTPIDR_EL0(new_thread->GetTPIDR_EL0());
    } else {
        current_thread = nullptr;
        // Note: We do not reset the current process and current page table when idling because
--- a/src/core/hle/kernel/scheduler.h
+++ b/src/core/hle/kernel/scheduler.h
@@ -181,7 +181,7 @@ private:

 class Scheduler final {
 public:
-    explicit Scheduler(Core::System& system, std::size_t core_id);
+    explicit Scheduler(Core::System& system, Core::ARM_Interface& cpu_core, std::size_t core_id);
    ~Scheduler();

    /// Returns whether there are any threads that are ready to run.
@@ -235,6 +235,7 @@ private:
    std::shared_ptr<Thread> selected_thread = nullptr;

    Core::System& system;
+    Core::ARM_Interface& cpu_core;
    u64 last_context_switch_time = 0;
    u64 idle_selection_count = 0;
    const std::size_t core_id;
--- a/src/core/hle/kernel/server_session.cpp
+++ b/src/core/hle/kernel/server_session.cpp
@@ -134,8 +134,7 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
    return RESULT_SUCCESS;
 }

-ResultCode ServerSession::QueueSyncRequest(std::shared_ptr<Thread> thread,
-                                           Core::Memory::Memory& memory) {
+ResultCode ServerSession::QueueSyncRequest(std::shared_ptr<Thread> thread, Memory::Memory& memory) {
    u32* cmd_buf{reinterpret_cast<u32*>(memory.GetPointer(thread->GetTLSAddress()))};
    std::shared_ptr<Kernel::HLERequestContext> context{
        std::make_shared<Kernel::HLERequestContext>(SharedFrom(this), std::move(thread))};
@@ -179,7 +178,7 @@ ResultCode ServerSession::CompleteSyncRequest() {
 }

 ResultCode ServerSession::HandleSyncRequest(std::shared_ptr<Thread> thread,
-                                            Core::Memory::Memory& memory) {
+                                            Memory::Memory& memory) {
    Core::System::GetInstance().CoreTiming().ScheduleEvent(20000, request_event, {});
    return QueueSyncRequest(std::move(thread), memory);
 }
--- a/src/core/hle/kernel/server_session.h
+++ b/src/core/hle/kernel/server_session.h
@@ -13,7 +13,7 @@
 #include "core/hle/kernel/synchronization_object.h"
 #include "core/hle/result.h"

-namespace Core::Memory {
+namespace Memory {
 class Memory;
 }

@@ -92,7 +92,7 @@ public:
     *
     * @returns ResultCode from the operation.
     */
-    ResultCode HandleSyncRequest(std::shared_ptr<Thread> thread, Core::Memory::Memory& memory);
+    ResultCode HandleSyncRequest(std::shared_ptr<Thread> thread, Memory::Memory& memory);

    bool ShouldWait(const Thread* thread) const override;

@@ -126,7 +126,7 @@ public:

 private:
    /// Queues a sync request from the emulated application.
-    ResultCode QueueSyncRequest(std::shared_ptr<Thread> thread, Core::Memory::Memory& memory);
+    ResultCode QueueSyncRequest(std::shared_ptr<Thread> thread, Memory::Memory& memory);

    /// Completes a sync request from the emulated application.
    ResultCode CompleteSyncRequest();
--- a/Show More
+++ b/Show More