Log anisotropic filtering and gpu accuracy as readable strings

Log them as readable strings instead of their respective combobox indices. - Move Anisotropy enum to settings.h - nit Extreme(very slow) -> Extreme (very slow) in gpu accuracy combobox
2020-05-09 14:48:53 -04:00
203 changed files with 2805 additions and 8527 deletions
--- a/.ci/yuzu-patreon-step2.yml
+++ b/.ci/yuzu-patreon-step2.yml
@@ -5,7 +5,18 @@ variables:
  DisplayVersion: $[counter(variables['DisplayPrefix'], 1)]

 stages:
+- stage: format
+  displayName: 'format'
+  jobs:
+  - job: format
+    displayName: 'clang'
+    continueOnError: true
+    pool:
+      vmImage: ubuntu-latest
+    steps:
+    - template: ./templates/format-check.yml
 - stage: build
+  dependsOn: format
  displayName: 'build'
  jobs:
  - job: build
--- a/.gitmodules
+++ b/.gitmodules
@@ -13,9 +13,6 @@
 [submodule "soundtouch"]
    path = externals/soundtouch
    url = https://github.com/citra-emu/ext-soundtouch.git
-[submodule "libressl"]
-    path = externals/libressl
-    url = https://github.com/citra-emu/ext-libressl-portable.git
 [submodule "discord-rpc"]
    path = externals/discord-rpc
    url = https://github.com/discordapp/discord-rpc.git
@@ -31,6 +28,3 @@
 [submodule "libzip"]
    path = externals/libzip/libzip
    url = https://github.com/nih-at/libzip.git
-[submodule "xbyak"]
-    path = externals/xbyak
-    url = https://github.com/herumi/xbyak.git
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.11)

 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
@@ -13,7 +13,7 @@ project(yuzu)
 option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)

 option(ENABLE_QT "Enable the Qt frontend" ON)
-CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_QT;MSVC" OFF)
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" OFF "ENABLE_QT;MSVC" OFF)

 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)

@@ -152,11 +152,11 @@ macro(yuzu_find_packages)
        "Boost             1.71        boost/1.72.0"
        "Catch2            2.11        catch2/2.11.0"
        "fmt               6.2         fmt/6.2.0"
+        "OpenSSL           1.1         openssl/1.1.1f"
    # can't use until https://github.com/bincrafters/community/issues/1173
        #"libzip            1.5         libzip/1.5.2@bincrafters/stable"
        "lz4               1.8         lz4/1.9.2"
        "nlohmann_json     3.7         nlohmann_json/3.7.3"
-    # we need to be careful as the version check might be broken https://github.com/xiph/opus/issues/110
        "opus              1.3         opus/1.3.1"
        "ZLIB              1.2         zlib/1.2.11"
        "zstd              1.4         zstd/1.4.4"
@@ -311,6 +311,15 @@ elseif (TARGET Boost::boost)
    add_library(boost ALIAS Boost::boost)
 endif()

+if (NOT TARGET OpenSSL::SSL)
+    set_target_properties(OpenSSL::OpenSSL PROPERTIES IMPORTED_GLOBAL TRUE)
+    add_library(OpenSSL::SSL ALIAS OpenSSL::OpenSSL)
+endif()
+if (NOT TARGET OpenSSL::Crypto)
+    set_target_properties(OpenSSL::OpenSSL PROPERTIES IMPORTED_GLOBAL TRUE)
+    add_library(OpenSSL::Crypto ALIAS OpenSSL::OpenSSL)
+endif()
+
 if (TARGET sdl2::sdl2)
    # imported from the conan generated sdl2Config.cmake
    set_target_properties(sdl2::sdl2 PROPERTIES IMPORTED_GLOBAL TRUE)
--- a/CMakeModules/GenerateSCMRev.cmake
+++ b/CMakeModules/GenerateSCMRev.cmake
@@ -51,8 +51,6 @@ endif()
 # The variable SRC_DIR must be passed into the script (since it uses the current build directory for all values of CMAKE_*_DIR)
 set(VIDEO_CORE "${SRC_DIR}/src/video_core")
 set(HASH_FILES
-    "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.cpp"
-    "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.h"
    "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.cpp"
    "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.h"
    "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.cpp"
--- a/dist/qt_themes/qdarkstyle/style.qss
+++ b/dist/qt_themes/qdarkstyle/style.qss
@@ -673,6 +673,10 @@ QTabWidget::pane {
    border-bottom-left-radius: 2px;
 }

+QTabWidget::tab-bar {
+    overflow: visible;
+}
+
 QTabBar {
    qproperty-drawBase: 0;
    border-radius: 3px;
--- a/dist/yuzu.manifest
+++ b/dist/yuzu.manifest
@@ -1,58 +1,24 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<assembly manifestVersion="1.0"
-    xmlns="urn:schemas-microsoft-com:asm.v1"
-    xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
-  <asmv3:application>
-    <asmv3:windowsSettings>
-      <!-- Windows 7/8/8.1/10 -->
-      <dpiAware
-        xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
-        true/pm
-      </dpiAware>
-      <!-- Windows 10, version 1607 or later -->
-      <dpiAwareness
-        xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
-        PerMonitorV2
-      </dpiAwareness>
-      <!-- Windows 10, version 1703 or later -->
-      <gdiScaling
-          xmlns="http://schemas.microsoft.com/SMI/2017/WindowsSettings">
-        true
-      </gdiScaling>
-      <ws2:longPathAware
-          xmlns:ws3="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
-        true
-      </ws2:longPathAware>
-    </asmv3:windowsSettings>
-  </asmv3:application>
-  <compatibility
-      xmlns="urn:schemas-microsoft-com:compatibility.v1">
-    <application>
-      <!-- Windows 10 -->
-      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
-      <!-- Windows 8.1 -->
-      <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
-      <!-- Windows 8 -->
-      <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
-      <!-- Windows 7 -->
-      <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
-    </application>
-  </compatibility>
-  <trustInfo
-      xmlns="urn:schemas-microsoft-com:asm.v3">
-    <security>
-      <requestedPrivileges>
-        <!--
-          UAC settings:
-          - app should run at same integrity level as calling process
-          - app does not need to manipulate windows belonging to
-            higher-integrity-level processes
-          -->
-        <requestedExecutionLevel
-            level="asInvoker"
-            uiAccess="false"
-        />
-      </requestedPrivileges>
-    </security>
-  </trustInfo>
-</assembly>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+ <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+  <security>
+   <requestedPrivileges>
+    <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
+   </requestedPrivileges>
+  </security>
+ </trustInfo>
+ <application xmlns="urn:schemas-microsoft-com:asm.v3">
+  <windowsSettings>
+   <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">True/PM</dpiAware>
+   <longPathAware xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">true</longPathAware>
+  </windowsSettings>
+ </application>
+ <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+  <application>
+   <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+   <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+   <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+   <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+  </application>
+ </compatibility>
+</assembly>
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@@ -4,13 +4,6 @@ list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/externals/find-modules")
 include(DownloadExternals)

-# xbyak
-if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
-    add_library(xbyak INTERFACE)
-    target_include_directories(xbyak SYSTEM INTERFACE ./xbyak/xbyak)
-    target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES)
-endif()
-
 # Catch
 add_library(catch-single-include INTERFACE)
 target_include_directories(catch-single-include INTERFACE catch/single_include)
@@ -73,15 +66,6 @@ if (NOT LIBZIP_FOUND)
 endif()

 if (ENABLE_WEB_SERVICE)
-    # LibreSSL
-    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)
-
    # lurlparser
    add_subdirectory(lurlparser EXCLUDE_FROM_ALL)

@@ -89,5 +73,5 @@ if (ENABLE_WEB_SERVICE)
    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})
+    target_link_libraries(httplib INTERFACE OpenSSL::SSL OpenSSL::Crypto)
 endif()
--- a/externals/find-modules/FindCatch2.cmake
+++ b/externals/find-modules/FindCatch2.cmake
@@ -8,25 +8,11 @@ find_path(Catch2_INCLUDE_DIR
  PATH_SUFFIXES catch2
 )

-if(Catch2_INCLUDE_DIR)
-  file(STRINGS "${Catch2_INCLUDE_DIR}/catch.hpp" _Catch2_version_lines
-    REGEX "#define[ \t]+CATCH_VERSION_(MAJOR|MINOR|PATCH)")
-  string(REGEX REPLACE ".*CATCH_VERSION_MAJOR +\([0-9]+\).*" "\\1" _Catch2_version_major "${_Catch2_version_lines}")
-  string(REGEX REPLACE ".*CATCH_VERSION_MINOR +\([0-9]+\).*" "\\1" _Catch2_version_minor "${_Catch2_version_lines}")
-  string(REGEX REPLACE ".*CATCH_VERSION_PATCH +\([0-9]+\).*" "\\1" _Catch2_version_patch "${_Catch2_version_lines}")
-  set(Catch2_VERSION "${_Catch2_version_major}.${_Catch2_version_minor}.${_Catch2_version_patch}")
-  unset(_Catch2_version_major)
-  unset(_Catch2_version_minor)
-  unset(_Catch2_version_patch)
-  unset(_Catch2_version_lines)
-endif()
-
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Catch2
  FOUND_VAR Catch2_FOUND
  REQUIRED_VARS
    Catch2_INCLUDE_DIR
-    Catch2_VERSION
  VERSION_VAR Catch2_VERSION
 )

--- a/externals/find-modules/FindLibzip.cmake
+++ b/externals/find-modules/FindLibzip.cmake
@@ -28,16 +28,6 @@ find_library(LIBZIP_LIBRARY
  "$ENV{LIB_DIR}/lib" "$ENV{LIB}" /usr/local/lib /usr/lib
 )

-if (LIBZIP_INCLUDE_DIR_ZIPCONF)
-  FILE(READ "${LIBZIP_INCLUDE_DIR_ZIPCONF}/zipconf.h" _LIBZIP_VERSION_CONTENTS)
-  if (_LIBZIP_VERSION_CONTENTS)
-    STRING(REGEX REPLACE ".*#define LIBZIP_VERSION \"([0-9.]+)\".*" "\\1" LIBZIP_VERSION "${_LIBZIP_VERSION_CONTENTS}")
-  endif()
-  unset(_LIBZIP_VERSION_CONTENTS)
-endif()
-
-set(LIBZIP_VERSION ${LIBZIP_VERSION} CACHE STRING "Version number of libzip")
-
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Libzip
  FOUND_VAR LIBZIP_FOUND
@@ -45,10 +35,19 @@ find_package_handle_standard_args(Libzip
    LIBZIP_LIBRARY
    LIBZIP_INCLUDE_DIR
    LIBZIP_INCLUDE_DIR_ZIPCONF
-    LIBZIP_VERSION
-  VERSION_VAR LIBZIP_VERSION
 )

+set(LIBZIP_VERSION 0)
+
+if (LIBZIP_INCLUDE_DIR_ZIPCONF)
+  FILE(READ "${LIBZIP_INCLUDE_DIR_ZIPCONF}/zipconf.h" _LIBZIP_VERSION_CONTENTS)
+  if (_LIBZIP_VERSION_CONTENTS)
+    STRING(REGEX REPLACE ".*#define LIBZIP_VERSION \"([0-9.]+)\".*" "\\1" LIBZIP_VERSION "${_LIBZIP_VERSION_CONTENTS}")
+  endif()
+endif()
+
+set(LIBZIP_VERSION ${LIBZIP_VERSION} CACHE STRING "Version number of libzip")
+
 if(LIBZIP_FOUND)
  set(LIBZIP_LIBRARIES ${LIBZIP_LIBRARY})
  set(LIBZIP_INCLUDE_DIRS ${LIBZIP_INCLUDE_DIR})
@@ -66,7 +65,5 @@ endif()

 mark_as_advanced(
    LIBZIP_INCLUDE_DIR
-    LIBZIP_INCLUDE_DIR_ZIPCONF
    LIBZIP_LIBRARY
-    LIBZIP_VERSION
 )
--- a/externals/find-modules/Findfmt.cmake
+++ b/externals/find-modules/Findfmt.cmake
@@ -13,38 +13,12 @@ find_library(fmt_LIBRARY
  PATHS ${PC_fmt_LIBRARY_DIRS} ${CONAN_LIB_DIRS_fmt}
 )

-if(fmt_INCLUDE_DIR)
-  set(_fmt_version_file "${fmt_INCLUDE_DIR}/core.h")
-  if(NOT EXISTS "${_fmt_version_file}")
-    set(_fmt_version_file "${fmt_INCLUDE_DIR}/format.h")
-  endif()
-  if(EXISTS "${_fmt_version_file}")
-    # parse "#define FMT_VERSION 60200" to 6.2.0
-    file(STRINGS "${_fmt_version_file}" fmt_VERSION_LINE
-      REGEX "^#define[ \t]+FMT_VERSION[ \t]+[0-9]+$")
-    string(REGEX REPLACE "^#define[ \t]+FMT_VERSION[ \t]+([0-9]+)$"
-      "\\1" fmt_VERSION "${fmt_VERSION_LINE}")
-    foreach(ver "fmt_VERSION_PATCH" "fmt_VERSION_MINOR" "fmt_VERSION_MAJOR")
-      math(EXPR ${ver} "${fmt_VERSION} % 100")
-      math(EXPR fmt_VERSION "(${fmt_VERSION} - ${${ver}}) / 100")
-    endforeach()
-    set(fmt_VERSION
-      "${fmt_VERSION_MAJOR}.${fmt_VERSION_MINOR}.${fmt_VERSION_PATCH}")
-  endif()
-  unset(_fmt_version_file)
-  unset(fmt_VERSION_LINE)
-  unset(fmt_VERSION_MAJOR)
-  unset(fmt_VERSION_MINOR)
-  unset(fmt_VERSION_PATCH)
-endif()
-
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(fmt
  FOUND_VAR fmt_FOUND
  REQUIRED_VARS
    fmt_LIBRARY
    fmt_INCLUDE_DIR
-    fmt_VERSION
  VERSION_VAR fmt_VERSION
 )

--- a/externals/find-modules/Findnlohmann_json.cmake
+++ b/externals/find-modules/Findnlohmann_json.cmake
@@ -8,25 +8,11 @@ find_path(nlohmann_json_INCLUDE_DIR
  PATH_SUFFIXES nlohmann
 )

-if(nlohmann_json_INCLUDE_DIR)
-  file(STRINGS "${nlohmann_json_INCLUDE_DIR}/json.hpp" _nlohmann_json_version_lines
-    REGEX "#define[ \t]+NLOHMANN_JSON_VERSION_(MAJOR|MINOR|PATCH)")
-  string(REGEX REPLACE ".*NLOHMANN_JSON_VERSION_MAJOR +\([0-9]+\).*" "\\1" _nlohmann_json_version_major "${_nlohmann_json_version_lines}")
-  string(REGEX REPLACE ".*NLOHMANN_JSON_VERSION_MINOR +\([0-9]+\).*" "\\1" _nlohmann_json_version_minor "${_nlohmann_json_version_lines}")
-  string(REGEX REPLACE ".*NLOHMANN_JSON_VERSION_PATCH +\([0-9]+\).*" "\\1" _nlohmann_json_version_patch "${_nlohmann_json_version_lines}")
-  set(nlohmann_json_VERSION "${_nlohmann_json_version_major}.${_nlohmann_json_version_minor}.${_nlohmann_json_version_patch}")
-  unset(_nlohmann_json_version_major)
-  unset(_nlohmann_json_version_minor)
-  unset(_nlohmann_json_version_patch)
-  unset(_nlohmann_json_version_lines)
-endif()
-
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(nlohmann_json
  FOUND_VAR nlohmann_json_FOUND
  REQUIRED_VARS
    nlohmann_json_INCLUDE_DIR
-    nlohmann_json_VERSION
  VERSION_VAR nlohmann_json_VERSION
 )

--- a/externals/find-modules/Findzstd.cmake
+++ b/externals/find-modules/Findzstd.cmake
@@ -11,26 +11,12 @@ find_library(zstd_LIBRARY
  PATHS ${PC_zstd_LIBRARY_DIRS}
 )

-if(zstd_INCLUDE_DIR)
-  file(STRINGS "${zstd_INCLUDE_DIR}/zstd.h" _zstd_version_lines
-    REGEX "#define[ \t]+ZSTD_VERSION_(MAJOR|MINOR|RELEASE)")
-  string(REGEX REPLACE ".*ZSTD_VERSION_MAJOR *\([0-9]*\).*" "\\1" _zstd_version_major "${_zstd_version_lines}")
-  string(REGEX REPLACE ".*ZSTD_VERSION_MINOR *\([0-9]*\).*" "\\1" _zstd_version_minor "${_zstd_version_lines}")
-  string(REGEX REPLACE ".*ZSTD_VERSION_RELEASE *\([0-9]*\).*" "\\1" _zstd_version_release "${_zstd_version_lines}")
-  set(zstd_VERSION "${_zstd_version_major}.${_zstd_version_minor}.${_zstd_version_release}")
-  unset(_zstd_version_major)
-  unset(_zstd_version_minor)
-  unset(_zstd_version_release)
-  unset(_zstd_version_lines)
-endif()
-
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(zstd
  FOUND_VAR zstd_FOUND
  REQUIRED_VARS
    zstd_LIBRARY
    zstd_INCLUDE_DIR
-    zstd_VERSION
  VERSION_VAR zstd_VERSION
 )

--- a/externals/libressl
+++ b/externals/libressl
--- a/externals/sirit
+++ b/externals/sirit
--- a/externals/xbyak
+++ b/externals/xbyak
--- a/src/audio_core/audio_renderer.cpp
+++ b/src/audio_core/audio_renderer.cpp
@@ -17,7 +17,7 @@ namespace AudioCore {

 constexpr u32 STREAM_SAMPLE_RATE{48000};
 constexpr u32 STREAM_NUM_CHANNELS{2};
-using VoiceChannelHolder = std::array<VoiceResourceInformation*, 6>;
+
 class AudioRenderer::VoiceState {
 public:
    bool IsPlaying() const {
@@ -37,10 +37,9 @@ public:
    }

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

 private:
    bool is_in_use{};
@@ -80,7 +79,7 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory
                             std::shared_ptr<Kernel::WritableEvent> buffer_event,
                             std::size_t instance_number)
    : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count),
-      voice_resources(params.voice_count), effects(params.effect_count), memory{memory_} {
+      effects(params.effect_count), memory{memory_} {
    behavior_info.SetUserRevision(params.revision);
    audio_out = std::make_unique<AudioCore::AudioOut>();
    stream = audio_out->OpenStream(core_timing, STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS,
@@ -128,12 +127,6 @@ ResultVal<std::vector<u8>> AudioRenderer::UpdateAudioRenderer(const std::vector<
                input_params.data() + sizeof(UpdateDataHeader) + config.behavior_size,
                memory_pool_count * sizeof(MemoryPoolInfo));

-    // Copy voice resources
-    const std::size_t voice_resource_offset{sizeof(UpdateDataHeader) + config.behavior_size +
-                                            config.memory_pools_size};
-    std::memcpy(voice_resources.data(), input_params.data() + voice_resource_offset,
-                sizeof(VoiceResourceInformation) * voice_resources.size());
-
    // Copy VoiceInfo structs
    std::size_t voice_offset{sizeof(UpdateDataHeader) + config.behavior_size +
                             config.memory_pools_size + config.voice_resource_size};
@@ -180,12 +173,11 @@ ResultVal<std::vector<u8>> AudioRenderer::UpdateAudioRenderer(const std::vector<

    // Copy output header
    UpdateDataHeader response_data{worker_params};
-    if (behavior_info.IsElapsedFrameCountSupported()) {
-        response_data.render_info = sizeof(RendererInfo);
-        response_data.total_size += sizeof(RendererInfo);
-    }
-
    std::vector<u8> output_params(response_data.total_size);
+    if (behavior_info.IsElapsedFrameCountSupported()) {
+        response_data.frame_count = 0x10;
+        response_data.total_size += 0x10;
+    }
    std::memcpy(output_params.data(), &response_data, sizeof(UpdateDataHeader));

    // Copy output memory pool entries
@@ -220,17 +212,6 @@ ResultVal<std::vector<u8>> AudioRenderer::UpdateAudioRenderer(const std::vector<
        return Audren::ERR_INVALID_PARAMETERS;
    }

-    if (behavior_info.IsElapsedFrameCountSupported()) {
-        const std::size_t renderer_info_offset{
-            sizeof(UpdateDataHeader) + response_data.memory_pools_size + response_data.voices_size +
-            response_data.effects_size + response_data.sinks_size +
-            response_data.performance_manager_size + response_data.behavior_size};
-        RendererInfo renderer_info{};
-        renderer_info.elasped_frame_count = elapsed_frame_count;
-        std::memcpy(output_params.data() + renderer_info_offset, &renderer_info,
-                    sizeof(RendererInfo));
-    }
-
    return MakeResult(output_params);
 }

@@ -239,15 +220,14 @@ void AudioRenderer::VoiceState::SetWaveIndex(std::size_t index) {
    is_refresh_pending = true;
 }

-std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(
-    std::size_t sample_count, Core::Memory::Memory& memory,
-    const VoiceChannelHolder& voice_resources) {
+std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(std::size_t sample_count,
+                                                           Core::Memory::Memory& memory) {
    if (!IsPlaying()) {
        return {};
    }

    if (is_refresh_pending) {
-        RefreshBuffer(memory, voice_resources);
+        RefreshBuffer(memory);
    }

    const std::size_t max_size{samples.size() - offset};
@@ -291,8 +271,7 @@ void AudioRenderer::VoiceState::UpdateState() {
    is_in_use = info.is_in_use;
 }

-void AudioRenderer::VoiceState::RefreshBuffer(Core::Memory::Memory& memory,
-                                              const VoiceChannelHolder& voice_resources) {
+void AudioRenderer::VoiceState::RefreshBuffer(Core::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));
@@ -317,77 +296,17 @@ void AudioRenderer::VoiceState::RefreshBuffer(Core::Memory::Memory& memory,
    }

    switch (info.channel_count) {
-    case 1: {
+    case 1:
        // 1 channel is upsampled to 2 channel
        samples.resize(new_samples.size() * 2);
-
        for (std::size_t index = 0; index < new_samples.size(); ++index) {
-            auto sample = static_cast<float>(new_samples[index]);
-            if (voice_resources[0]->in_use) {
-                sample *= voice_resources[0]->mix_volumes[0];
-            }
-
-            samples[index * 2] = static_cast<s16>(sample * info.volume);
-            samples[index * 2 + 1] = static_cast<s16>(sample * info.volume);
+            samples[index * 2] = new_samples[index];
+            samples[index * 2 + 1] = new_samples[index];
        }
        break;
-    }
    case 2: {
        // 2 channel is played as is
        samples = std::move(new_samples);
-        const std::size_t sample_count = (samples.size() / 2);
-        for (std::size_t index = 0; index < sample_count; ++index) {
-            const std::size_t index_l = index * 2;
-            const std::size_t index_r = index * 2 + 1;
-
-            auto sample_l = static_cast<float>(samples[index_l]);
-            auto sample_r = static_cast<float>(samples[index_r]);
-
-            if (voice_resources[0]->in_use) {
-                sample_l *= voice_resources[0]->mix_volumes[0];
-            }
-
-            if (voice_resources[1]->in_use) {
-                sample_r *= voice_resources[1]->mix_volumes[1];
-            }
-
-            samples[index_l] = static_cast<s16>(sample_l * info.volume);
-            samples[index_r] = static_cast<s16>(sample_r * info.volume);
-        }
-        break;
-    }
-    case 6: {
-        samples.resize((new_samples.size() / 6) * 2);
-        const std::size_t sample_count = samples.size() / 2;
-
-        for (std::size_t index = 0; index < sample_count; ++index) {
-            auto FL = static_cast<float>(new_samples[index * 6]);
-            auto FR = static_cast<float>(new_samples[index * 6 + 1]);
-            auto FC = static_cast<float>(new_samples[index * 6 + 2]);
-            auto BL = static_cast<float>(new_samples[index * 6 + 4]);
-            auto BR = static_cast<float>(new_samples[index * 6 + 5]);
-
-            if (voice_resources[0]->in_use) {
-                FL *= voice_resources[0]->mix_volumes[0];
-            }
-            if (voice_resources[1]->in_use) {
-                FR *= voice_resources[1]->mix_volumes[1];
-            }
-            if (voice_resources[2]->in_use) {
-                FC *= voice_resources[2]->mix_volumes[2];
-            }
-            if (voice_resources[4]->in_use) {
-                BL *= voice_resources[4]->mix_volumes[4];
-            }
-            if (voice_resources[5]->in_use) {
-                BR *= voice_resources[5]->mix_volumes[5];
-            }
-
-            samples[index * 2] =
-                static_cast<s16>((0.3694f * FL + 0.2612f * FC + 0.3694f * BL) * info.volume);
-            samples[index * 2 + 1] =
-                static_cast<s16>((0.3694f * FR + 0.2612f * FC + 0.3694f * BR) * info.volume);
-        }
        break;
    }
    default:
@@ -433,17 +352,11 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
        if (!voice.IsPlaying()) {
            continue;
        }
-        VoiceChannelHolder resources{};
-        for (u32 channel = 0; channel < voice.GetInfo().channel_count; channel++) {
-            const auto channel_resource_id = voice.GetInfo().voice_channel_resource_ids[channel];
-            resources[channel] = &voice_resources[channel_resource_id];
-        }

        std::size_t offset{};
        s64 samples_remaining{BUFFER_SIZE};
        while (samples_remaining > 0) {
-            const std::vector<s16> samples{
-                voice.DequeueSamples(samples_remaining, memory, resources)};
+            const std::vector<s16> samples{voice.DequeueSamples(samples_remaining, memory)};

            if (samples.empty()) {
                break;
@@ -459,7 +372,6 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
        }
    }
    audio_out->QueueBuffer(stream, tag, std::move(buffer));
-    elapsed_frame_count++;
 }

 void AudioRenderer::ReleaseAndQueueBuffers() {
--- a/src/audio_core/audio_renderer.h
+++ b/src/audio_core/audio_renderer.h
@@ -9,7 +9,6 @@
 #include <vector>

 #include "audio_core/behavior_info.h"
-#include "audio_core/common.h"
 #include "audio_core/stream.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -117,14 +116,6 @@ struct WaveBuffer {
 };
 static_assert(sizeof(WaveBuffer) == 0x38, "WaveBuffer has wrong size");

-struct VoiceResourceInformation {
-    s32_le id{};
-    std::array<float_le, MAX_MIX_BUFFERS> mix_volumes{};
-    bool in_use{};
-    INSERT_PADDING_BYTES(11);
-};
-static_assert(sizeof(VoiceResourceInformation) == 0x70, "VoiceResourceInformation has wrong size");
-
 struct VoiceInfo {
    u32_le id;
    u32_le node_id;
@@ -196,12 +187,6 @@ struct EffectOutStatus {
 };
 static_assert(sizeof(EffectOutStatus) == 0x10, "EffectOutStatus is an invalid size");

-struct RendererInfo {
-    u64_le elasped_frame_count{};
-    INSERT_PADDING_WORDS(2);
-};
-static_assert(sizeof(RendererInfo) == 0x10, "RendererInfo is an invalid size");
-
 struct UpdateDataHeader {
    UpdateDataHeader() {}

@@ -215,7 +200,7 @@ struct UpdateDataHeader {
        mixes_size = 0x0;
        sinks_size = config.sink_count * 0x20;
        performance_manager_size = 0x10;
-        render_info = 0;
+        frame_count = 0;
        total_size = sizeof(UpdateDataHeader) + behavior_size + memory_pools_size + voices_size +
                     effects_size + sinks_size + performance_manager_size;
    }
@@ -229,8 +214,8 @@ struct UpdateDataHeader {
    u32_le mixes_size{};
    u32_le sinks_size{};
    u32_le performance_manager_size{};
-    u32_le splitter_size{};
-    u32_le render_info{};
+    INSERT_PADDING_WORDS(1);
+    u32_le frame_count{};
    INSERT_PADDING_WORDS(4);
    u32_le total_size{};
 };
@@ -259,12 +244,10 @@ private:
    AudioRendererParameter worker_params;
    std::shared_ptr<Kernel::WritableEvent> buffer_event;
    std::vector<VoiceState> voices;
-    std::vector<VoiceResourceInformation> voice_resources;
    std::vector<EffectState> effects;
    std::unique_ptr<AudioOut> audio_out;
    StreamPtr stream;
    Core::Memory::Memory& memory;
-    std::size_t elapsed_frame_count{};
 };

 } // namespace AudioCore
--- a/src/audio_core/common.h
+++ b/src/audio_core/common.h
@@ -14,7 +14,6 @@ constexpr ResultCode ERR_INVALID_PARAMETERS{ErrorModule::Audio, 41};
 }

 constexpr u32_le CURRENT_PROCESS_REVISION = Common::MakeMagic('R', 'E', 'V', '8');
-constexpr std::size_t MAX_MIX_BUFFERS = 24;

 static constexpr u32 VersionFromRevision(u32_le rev) {
    // "REV7" -> 7
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -32,8 +32,6 @@ add_custom_command(OUTPUT scm_rev.cpp
    DEPENDS
      # WARNING! It was too much work to try and make a common location for this list,
      # so if you need to change it, please update CMakeModules/GenerateSCMRev.cmake as well
-      "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.cpp"
-      "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.h"
      "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.cpp"
      "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.h"
      "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.cpp"
@@ -125,8 +123,6 @@ add_library(common STATIC
    lz4_compression.cpp
    lz4_compression.h
    math_util.h
-    memory_detect.cpp
-    memory_detect.h
    memory_hook.cpp
    memory_hook.h
    microprofile.cpp
@@ -152,8 +148,6 @@ add_library(common STATIC
    thread.h
    thread_queue_list.h
    threadsafe_queue.h
-    time_zone.cpp
-    time_zone.h
    timer.cpp
    timer.h
    uint128.cpp
@@ -173,12 +167,10 @@ if(ARCHITECTURE_x86_64)
        PRIVATE
            x64/cpu_detect.cpp
            x64/cpu_detect.h
-            x64/xbyak_abi.h
-            x64/xbyak_util.h
    )
 endif()

 create_target_directory_groups(common)

 target_link_libraries(common PUBLIC Boost::boost fmt::fmt microprofile)
-target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd xbyak)
+target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd)
--- a/src/common/memory_detect.cpp
+++ b/src/common/memory_detect.cpp
@@ -1,60 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#ifdef _WIN32
-// clang-format off
-#include <windows.h>
-#include <sysinfoapi.h>
-// clang-format on
-#else
-#include <sys/types.h>
-#ifdef __APPLE__
-#include <sys/sysctl.h>
-#else
-#include <sys/sysinfo.h>
-#endif
-#endif
-
-#include "common/memory_detect.h"
-
-namespace Common {
-
-// Detects the RAM and Swapfile sizes
-static MemoryInfo Detect() {
-    MemoryInfo mem_info{};
-
-#ifdef _WIN32
-    MEMORYSTATUSEX memorystatus;
-    memorystatus.dwLength = sizeof(memorystatus);
-    GlobalMemoryStatusEx(&memorystatus);
-    mem_info.TotalPhysicalMemory = memorystatus.ullTotalPhys;
-    mem_info.TotalSwapMemory = memorystatus.ullTotalPageFile - mem_info.TotalPhysicalMemory;
-#elif defined(__APPLE__)
-    u64 ramsize;
-    struct xsw_usage vmusage;
-    std::size_t sizeof_ramsize = sizeof(ramsize);
-    std::size_t sizeof_vmusage = sizeof(vmusage);
-    // hw and vm are defined in sysctl.h
-    // https://github.com/apple/darwin-xnu/blob/master/bsd/sys/sysctl.h#L471
-    // sysctlbyname(const char *, void *, size_t *, void *, size_t);
-    sysctlbyname("hw.memsize", &ramsize, &sizeof_ramsize, NULL, 0);
-    sysctlbyname("vm.swapusage", &vmusage, &sizeof_vmusage, NULL, 0);
-    mem_info.TotalPhysicalMemory = ramsize;
-    mem_info.TotalSwapMemory = vmusage.xsu_total;
-#else
-    struct sysinfo meminfo;
-    sysinfo(&meminfo);
-    mem_info.TotalPhysicalMemory = meminfo.totalram;
-    mem_info.TotalSwapMemory = meminfo.totalswap;
-#endif
-
-    return mem_info;
-}
-
-const MemoryInfo& GetMemInfo() {
-    static MemoryInfo mem_info = Detect();
-    return mem_info;
-}
-
-} // namespace Common
--- a/src/common/memory_detect.h
+++ b/src/common/memory_detect.h
@@ -1,22 +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 Common {
-
-struct MemoryInfo {
-    u64 TotalPhysicalMemory{};
-    u64 TotalSwapMemory{};
-};
-
-/**
- * Gets the memory info of the host system
- * @return Reference to a MemoryInfo struct with the physical and swap memory sizes in bytes
- */
-const MemoryInfo& GetMemInfo();
-
-} // namespace Common
--- a/src/common/telemetry.cpp
+++ b/src/common/telemetry.cpp
@@ -60,7 +60,6 @@ void AppendCPUInfo(FieldCollection& fc) {
    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AES", Common::GetCPUCaps().aes);
    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AVX", Common::GetCPUCaps().avx);
    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AVX2", Common::GetCPUCaps().avx2);
-    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AVX512", Common::GetCPUCaps().avx512);
    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_BMI1", Common::GetCPUCaps().bmi1);
    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_BMI2", Common::GetCPUCaps().bmi2);
    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_FMA", Common::GetCPUCaps().fma);
--- a/src/common/time_zone.cpp
+++ b/src/common/time_zone.cpp
@@ -1,49 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <chrono>
-#include <iomanip>
-#include <sstream>
-
-#include "common/logging/log.h"
-#include "common/time_zone.h"
-
-namespace Common::TimeZone {
-
-std::string GetDefaultTimeZone() {
-    return "GMT";
-}
-
-static std::string GetOsTimeZoneOffset() {
-    const std::time_t t{std::time(nullptr)};
-    const std::tm tm{*std::localtime(&t)};
-
-    std::stringstream ss;
-    ss << std::put_time(&tm, "%z"); // Get the current timezone offset, e.g. "-400", as a string
-
-    return ss.str();
-}
-
-static int ConvertOsTimeZoneOffsetToInt(const std::string& timezone) {
-    try {
-        return std::stoi(timezone);
-    } catch (const std::invalid_argument&) {
-        LOG_CRITICAL(Common, "invalid_argument with {}!", timezone);
-        return 0;
-    } catch (const std::out_of_range&) {
-        LOG_CRITICAL(Common, "out_of_range with {}!", timezone);
-        return 0;
-    }
-}
-
-std::chrono::seconds GetCurrentOffsetSeconds() {
-    const int offset{ConvertOsTimeZoneOffsetToInt(GetOsTimeZoneOffset())};
-
-    int seconds{(offset / 100) * 60 * 60}; // Convert hour component to seconds
-    seconds += (offset % 100) * 60;        // Convert minute component to seconds
-
-    return std::chrono::seconds{seconds};
-}
-
-} // namespace Common::TimeZone
--- a/src/common/time_zone.h
+++ b/src/common/time_zone.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 <chrono>
-#include <string>
-
-namespace Common::TimeZone {
-
-/// Gets the default timezone, i.e. "GMT"
-std::string GetDefaultTimeZone();
-
-/// Gets the offset of the current timezone (from the default), in seconds
-std::chrono::seconds GetCurrentOffsetSeconds();
-
-} // namespace Common::TimeZone
--- a/src/common/x64/cpu_detect.cpp
+++ b/src/common/x64/cpu_detect.cpp
@@ -110,11 +110,6 @@ static CPUCaps Detect() {
                caps.bmi1 = true;
            if ((cpu_id[1] >> 8) & 1)
                caps.bmi2 = true;
-            // Checks for AVX512F, AVX512CD, AVX512VL, AVX512DQ, AVX512BW (Intel Skylake-X/SP)
-            if ((cpu_id[1] >> 16) & 1 && (cpu_id[1] >> 28) & 1 && (cpu_id[1] >> 31) & 1 &&
-                (cpu_id[1] >> 17) & 1 && (cpu_id[1] >> 30) & 1) {
-                caps.avx512 = caps.avx2;
-            }
        }
    }

--- a/src/common/x64/cpu_detect.h
+++ b/src/common/x64/cpu_detect.h
@@ -19,7 +19,6 @@ struct CPUCaps {
    bool lzcnt;
    bool avx;
    bool avx2;
-    bool avx512;
    bool bmi1;
    bool bmi2;
    bool fma;
--- a/src/common/x64/xbyak_abi.h
+++ b/src/common/x64/xbyak_abi.h
@@ -1,229 +0,0 @@
-// Copyright 2016 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <bitset>
-#include <initializer_list>
-#include <xbyak.h>
-#include "common/assert.h"
-
-namespace Common::X64 {
-
-inline std::size_t RegToIndex(const Xbyak::Reg& reg) {
-    using Kind = Xbyak::Reg::Kind;
-    ASSERT_MSG((reg.getKind() & (Kind::REG | Kind::XMM)) != 0,
-               "RegSet only support GPRs and XMM registers.");
-    ASSERT_MSG(reg.getIdx() < 16, "RegSet only supports XXM0-15.");
-    return reg.getIdx() + (reg.getKind() == Kind::REG ? 0 : 16);
-}
-
-inline Xbyak::Reg64 IndexToReg64(std::size_t reg_index) {
-    ASSERT(reg_index < 16);
-    return Xbyak::Reg64(static_cast<int>(reg_index));
-}
-
-inline Xbyak::Xmm IndexToXmm(std::size_t reg_index) {
-    ASSERT(reg_index >= 16 && reg_index < 32);
-    return Xbyak::Xmm(static_cast<int>(reg_index - 16));
-}
-
-inline Xbyak::Reg IndexToReg(std::size_t reg_index) {
-    if (reg_index < 16) {
-        return IndexToReg64(reg_index);
-    } else {
-        return IndexToXmm(reg_index);
-    }
-}
-
-inline std::bitset<32> BuildRegSet(std::initializer_list<Xbyak::Reg> regs) {
-    std::bitset<32> bits;
-    for (const Xbyak::Reg& reg : regs) {
-        bits[RegToIndex(reg)] = true;
-    }
-    return bits;
-}
-
-const std::bitset<32> ABI_ALL_GPRS(0x0000FFFF);
-const std::bitset<32> ABI_ALL_XMMS(0xFFFF0000);
-
-#ifdef _WIN32
-
-// Microsoft x64 ABI
-const Xbyak::Reg ABI_RETURN = Xbyak::util::rax;
-const Xbyak::Reg ABI_PARAM1 = Xbyak::util::rcx;
-const Xbyak::Reg ABI_PARAM2 = Xbyak::util::rdx;
-const Xbyak::Reg ABI_PARAM3 = Xbyak::util::r8;
-const Xbyak::Reg ABI_PARAM4 = Xbyak::util::r9;
-
-const std::bitset<32> ABI_ALL_CALLER_SAVED = BuildRegSet({
-    // GPRs
-    Xbyak::util::rcx,
-    Xbyak::util::rdx,
-    Xbyak::util::r8,
-    Xbyak::util::r9,
-    Xbyak::util::r10,
-    Xbyak::util::r11,
-    // XMMs
-    Xbyak::util::xmm0,
-    Xbyak::util::xmm1,
-    Xbyak::util::xmm2,
-    Xbyak::util::xmm3,
-    Xbyak::util::xmm4,
-    Xbyak::util::xmm5,
-});
-
-const std::bitset<32> ABI_ALL_CALLEE_SAVED = BuildRegSet({
-    // GPRs
-    Xbyak::util::rbx,
-    Xbyak::util::rsi,
-    Xbyak::util::rdi,
-    Xbyak::util::rbp,
-    Xbyak::util::r12,
-    Xbyak::util::r13,
-    Xbyak::util::r14,
-    Xbyak::util::r15,
-    // XMMs
-    Xbyak::util::xmm6,
-    Xbyak::util::xmm7,
-    Xbyak::util::xmm8,
-    Xbyak::util::xmm9,
-    Xbyak::util::xmm10,
-    Xbyak::util::xmm11,
-    Xbyak::util::xmm12,
-    Xbyak::util::xmm13,
-    Xbyak::util::xmm14,
-    Xbyak::util::xmm15,
-});
-
-constexpr size_t ABI_SHADOW_SPACE = 0x20;
-
-#else
-
-// System V x86-64 ABI
-const Xbyak::Reg ABI_RETURN = Xbyak::util::rax;
-const Xbyak::Reg ABI_PARAM1 = Xbyak::util::rdi;
-const Xbyak::Reg ABI_PARAM2 = Xbyak::util::rsi;
-const Xbyak::Reg ABI_PARAM3 = Xbyak::util::rdx;
-const Xbyak::Reg ABI_PARAM4 = Xbyak::util::rcx;
-
-const std::bitset<32> ABI_ALL_CALLER_SAVED = BuildRegSet({
-    // GPRs
-    Xbyak::util::rcx,
-    Xbyak::util::rdx,
-    Xbyak::util::rdi,
-    Xbyak::util::rsi,
-    Xbyak::util::r8,
-    Xbyak::util::r9,
-    Xbyak::util::r10,
-    Xbyak::util::r11,
-    // XMMs
-    Xbyak::util::xmm0,
-    Xbyak::util::xmm1,
-    Xbyak::util::xmm2,
-    Xbyak::util::xmm3,
-    Xbyak::util::xmm4,
-    Xbyak::util::xmm5,
-    Xbyak::util::xmm6,
-    Xbyak::util::xmm7,
-    Xbyak::util::xmm8,
-    Xbyak::util::xmm9,
-    Xbyak::util::xmm10,
-    Xbyak::util::xmm11,
-    Xbyak::util::xmm12,
-    Xbyak::util::xmm13,
-    Xbyak::util::xmm14,
-    Xbyak::util::xmm15,
-});
-
-const std::bitset<32> ABI_ALL_CALLEE_SAVED = BuildRegSet({
-    // GPRs
-    Xbyak::util::rbx,
-    Xbyak::util::rbp,
-    Xbyak::util::r12,
-    Xbyak::util::r13,
-    Xbyak::util::r14,
-    Xbyak::util::r15,
-});
-
-constexpr size_t ABI_SHADOW_SPACE = 0;
-
-#endif
-
-struct ABIFrameInfo {
-    s32 subtraction;
-    s32 xmm_offset;
-};
-
-inline ABIFrameInfo ABI_CalculateFrameSize(std::bitset<32> regs, size_t rsp_alignment,
-                                           size_t needed_frame_size) {
-    const auto count = (regs & ABI_ALL_GPRS).count();
-    rsp_alignment -= count * 8;
-    size_t subtraction = 0;
-    const auto xmm_count = (regs & ABI_ALL_XMMS).count();
-    if (xmm_count) {
-        // If we have any XMMs to save, we must align the stack here.
-        subtraction = rsp_alignment & 0xF;
-    }
-    subtraction += 0x10 * xmm_count;
-    size_t xmm_base_subtraction = subtraction;
-    subtraction += needed_frame_size;
-    subtraction += ABI_SHADOW_SPACE;
-    // Final alignment.
-    rsp_alignment -= subtraction;
-    subtraction += rsp_alignment & 0xF;
-
-    return ABIFrameInfo{static_cast<s32>(subtraction),
-                        static_cast<s32>(subtraction - xmm_base_subtraction)};
-}
-
-inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::bitset<32> regs,
-                                              size_t rsp_alignment, size_t needed_frame_size = 0) {
-    auto frame_info = ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size);
-
-    for (std::size_t i = 0; i < regs.size(); ++i) {
-        if (regs[i] && ABI_ALL_GPRS[i]) {
-            code.push(IndexToReg64(i));
-        }
-    }
-
-    if (frame_info.subtraction != 0) {
-        code.sub(code.rsp, frame_info.subtraction);
-    }
-
-    for (std::size_t i = 0; i < regs.size(); ++i) {
-        if (regs[i] && ABI_ALL_XMMS[i]) {
-            code.movaps(code.xword[code.rsp + frame_info.xmm_offset], IndexToXmm(i));
-            frame_info.xmm_offset += 0x10;
-        }
-    }
-
-    return ABI_SHADOW_SPACE;
-}
-
-inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::bitset<32> regs,
-                                           size_t rsp_alignment, size_t needed_frame_size = 0) {
-    auto frame_info = ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size);
-
-    for (std::size_t i = 0; i < regs.size(); ++i) {
-        if (regs[i] && ABI_ALL_XMMS[i]) {
-            code.movaps(IndexToXmm(i), code.xword[code.rsp + frame_info.xmm_offset]);
-            frame_info.xmm_offset += 0x10;
-        }
-    }
-
-    if (frame_info.subtraction != 0) {
-        code.add(code.rsp, frame_info.subtraction);
-    }
-
-    // GPRs need to be popped in reverse order
-    for (std::size_t j = 0; j < regs.size(); ++j) {
-        const std::size_t i = regs.size() - j - 1;
-        if (regs[i] && ABI_ALL_GPRS[i]) {
-            code.pop(IndexToReg64(i));
-        }
-    }
-}
-
-} // namespace Common::X64
--- a/src/common/x64/xbyak_util.h
+++ b/src/common/x64/xbyak_util.h
@@ -1,47 +0,0 @@
-// Copyright 2016 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <type_traits>
-#include <xbyak.h>
-#include "common/x64/xbyak_abi.h"
-
-namespace Common::X64 {
-
-// Constants for use with cmpps/cmpss
-enum {
-    CMP_EQ = 0,
-    CMP_LT = 1,
-    CMP_LE = 2,
-    CMP_UNORD = 3,
-    CMP_NEQ = 4,
-    CMP_NLT = 5,
-    CMP_NLE = 6,
-    CMP_ORD = 7,
-};
-
-constexpr bool IsWithin2G(uintptr_t ref, uintptr_t target) {
-    const u64 distance = target - (ref + 5);
-    return !(distance >= 0x8000'0000ULL && distance <= ~0x8000'0000ULL);
-}
-
-inline bool IsWithin2G(const Xbyak::CodeGenerator& code, uintptr_t target) {
-    return IsWithin2G(reinterpret_cast<uintptr_t>(code.getCurr()), target);
-}
-
-template <typename T>
-inline void CallFarFunction(Xbyak::CodeGenerator& code, const T f) {
-    static_assert(std::is_pointer_v<T>, "Argument must be a (function) pointer.");
-    size_t addr = reinterpret_cast<size_t>(f);
-    if (IsWithin2G(code, addr)) {
-        code.call(f);
-    } else {
-        // ABI_RETURN is a safe temp register to use before a call
-        code.mov(ABI_RETURN, addr);
-        code.call(ABI_RETURN);
-    }
-}
-
-} // namespace Common::X64
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -606,11 +606,11 @@ endif()
 create_target_directory_groups(core)

 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::Opus unicorn zip)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls Opus::Opus unicorn)

 if (YUZU_ENABLE_BOXCAT)
    target_compile_definitions(core PRIVATE -DYUZU_ENABLE_BOXCAT)
-    target_link_libraries(core PRIVATE httplib nlohmann_json::nlohmann_json)
+    target_link_libraries(core PRIVATE httplib nlohmann_json::nlohmann_json zip)
 endif()

 if (ENABLE_WEB_SERVICE)
--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
@@ -50,8 +50,7 @@ public:
    }

    void InterpreterFallback(u32 pc, std::size_t num_instructions) override {
-        UNIMPLEMENTED_MSG("This should never happen, pc = {:08X}, code = {:08X}", pc,
-                          MemoryReadCode(pc));
+        UNIMPLEMENTED();
    }

    void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override {
@@ -62,7 +61,7 @@ public:
        case Dynarmic::A32::Exception::Breakpoint:
            break;
        }
-        LOG_CRITICAL(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
+        LOG_CRITICAL(HW_GPU, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
                     static_cast<std::size_t>(exception), pc, MemoryReadCode(pc));
        UNIMPLEMENTED();
    }
@@ -90,6 +89,8 @@ public:

    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,
@@ -98,7 +99,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable&
    config.callbacks = cb.get();
    // TODO(bunnei): Implement page table for 32-bit
    // config.page_table = &page_table.pointers;
-    config.coprocessors[15] = cp15;
+    config.coprocessors[15] = std::make_shared<DynarmicCP15>((u32*)&CP15_regs[0]);
    config.define_unpredictable_behaviour = true;
    return std::make_unique<Dynarmic::A32::Jit>(config);
 }
@@ -111,13 +112,13 @@ void ARM_Dynarmic_32::Run() {
 }

 void ARM_Dynarmic_32::Step() {
-    jit->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)),
-      cp15(std::make_shared<DynarmicCP15>(*this)), core_index{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;
@@ -153,19 +154,19 @@ void ARM_Dynarmic_32::SetPSTATE(u32 cpsr) {
 }

 u64 ARM_Dynarmic_32::GetTlsAddress() const {
-    return cp15->uro;
+    return CP15_regs[static_cast<std::size_t>(CP15Register::CP15_THREAD_URO)];
 }

 void ARM_Dynarmic_32::SetTlsAddress(VAddr address) {
-    cp15->uro = static_cast<u32>(address);
+    CP15_regs[static_cast<std::size_t>(CP15Register::CP15_THREAD_URO)] = static_cast<u32>(address);
 }

 u64 ARM_Dynarmic_32::GetTPIDR_EL0() const {
-    return cp15->uprw;
+    return cb->tpidr_el0;
 }

 void ARM_Dynarmic_32::SetTPIDR_EL0(u64 value) {
-    cp15->uprw = static_cast<u32>(value);
+    cb->tpidr_el0 = value;
 }

 void ARM_Dynarmic_32::SaveContext(ThreadContext32& ctx) {
--- a/src/core/arm/dynarmic/arm_dynarmic_32.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.h
@@ -22,7 +22,6 @@ class Memory;
 namespace Core {

 class DynarmicCallbacks32;
-class DynarmicCP15;
 class DynarmicExclusiveMonitor;
 class System;

@@ -67,14 +66,12 @@ private:
        std::unordered_map<JitCacheKey, std::shared_ptr<Dynarmic::A32::Jit>, Common::PairHash>;

    friend class DynarmicCallbacks32;
-    friend class DynarmicCP15;
-
    std::unique_ptr<DynarmicCallbacks32> cb;
    JitCacheType jit_cache;
    std::shared_ptr<Dynarmic::A32::Jit> jit;
-    std::shared_ptr<DynarmicCP15> cp15;
    std::size_t core_index;
    DynarmicExclusiveMonitor& exclusive_monitor;
+    std::array<u32, 84> CP15_regs{};
 };

 } // namespace Core
--- a/src/core/arm/dynarmic/arm_dynarmic_64.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.cpp
@@ -98,8 +98,8 @@ public:
            }
            [[fallthrough]];
        default:
-            ASSERT_MSG(false, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
-                       static_cast<std::size_t>(exception), pc, MemoryReadCode(pc));
+            ASSERT_MSG(false, "ExceptionRaised(exception = {}, pc = {:X})",
+                       static_cast<std::size_t>(exception), pc);
        }
    }

--- a/src/core/arm/dynarmic/arm_dynarmic_cp15.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_cp15.cpp
@@ -2,132 +2,79 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include <fmt/format.h>
-#include "common/logging/log.h"
-#include "core/arm/dynarmic/arm_dynarmic_32.h"
 #include "core/arm/dynarmic/arm_dynarmic_cp15.h"
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/core_timing_util.h"

 using Callback = Dynarmic::A32::Coprocessor::Callback;
 using CallbackOrAccessOneWord = Dynarmic::A32::Coprocessor::CallbackOrAccessOneWord;
 using CallbackOrAccessTwoWords = Dynarmic::A32::Coprocessor::CallbackOrAccessTwoWords;

-template <>
-struct fmt::formatter<Dynarmic::A32::CoprocReg> {
-    constexpr auto parse(format_parse_context& ctx) {
-        return ctx.begin();
-    }
-    template <typename FormatContext>
-    auto format(const Dynarmic::A32::CoprocReg& reg, FormatContext& ctx) {
-        return format_to(ctx.out(), "cp{}", static_cast<size_t>(reg));
-    }
-};
-
-namespace Core {
-
-static u32 dummy_value;
-
 std::optional<Callback> DynarmicCP15::CompileInternalOperation(bool two, unsigned opc1,
                                                               CoprocReg CRd, CoprocReg CRn,
                                                               CoprocReg CRm, unsigned opc2) {
-    LOG_CRITICAL(Core_ARM, "CP15: cdp{} p15, {}, {}, {}, {}, {}", two ? "2" : "", opc1, CRd, CRn,
-                 CRm, 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) {
-        // CP15_FLUSH_PREFETCH_BUFFER
        // This is a dummy write, we ignore the value written here.
-        return &dummy_value;
+        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:
-            // CP15_DATA_SYNC_BARRIER
            // This is a dummy write, we ignore the value written here.
-            return &dummy_value;
+            return &CP15[static_cast<std::size_t>(CP15Register::CP15_DATA_SYNC_BARRIER)];
        case 5:
-            // CP15_DATA_MEMORY_BARRIER
            // This is a dummy write, we ignore the value written here.
-            return &dummy_value;
+            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) {
-        // CP15_THREAD_UPRW
-        return &uprw;
+        return &CP15[static_cast<std::size_t>(CP15Register::CP15_THREAD_UPRW)];
    }

-    LOG_CRITICAL(Core_ARM, "CP15: mcr{} p15, {}, <Rt>, {}, {}, {}", two ? "2" : "", opc1, CRn, CRm,
-                 opc2);
    return {};
 }

 CallbackOrAccessTwoWords DynarmicCP15::CompileSendTwoWords(bool two, unsigned opc, CoprocReg CRm) {
-    LOG_CRITICAL(Core_ARM, "CP15: mcrr{} p15, {}, <Rt>, <Rt2>, {}", two ? "2" : "", opc, 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:
-            // CP15_THREAD_UPRW
-            return &uprw;
+            return &CP15[static_cast<std::size_t>(CP15Register::CP15_THREAD_UPRW)];
        case 3:
-            // CP15_THREAD_URO
-            return &uro;
+            return &CP15[static_cast<std::size_t>(CP15Register::CP15_THREAD_URO)];
+        default:
+            return {};
        }
    }

-    LOG_CRITICAL(Core_ARM, "CP15: mrc{} p15, {}, <Rt>, {}, {}, {}", two ? "2" : "", opc1, CRn, CRm,
-                 opc2);
    return {};
 }

 CallbackOrAccessTwoWords DynarmicCP15::CompileGetTwoWords(bool two, unsigned opc, CoprocReg CRm) {
-    if (!two && opc == 0 && CRm == CoprocReg::C14) {
-        // CNTPCT
-        const auto callback = static_cast<u64 (*)(Dynarmic::A32::Jit*, void*, u32, u32)>(
-            [](Dynarmic::A32::Jit*, void* arg, u32, u32) -> u64 {
-                ARM_Dynarmic_32& parent = *(ARM_Dynarmic_32*)arg;
-                return Timing::CpuCyclesToClockCycles(parent.system.CoreTiming().GetTicks());
-            });
-        return Dynarmic::A32::Coprocessor::Callback{callback, (void*)&parent};
-    }
-
-    LOG_CRITICAL(Core_ARM, "CP15: mrrc{} p15, {}, <Rt>, <Rt2>, {}", two ? "2" : "", opc, CRm);
    return {};
 }

 std::optional<Callback> DynarmicCP15::CompileLoadWords(bool two, bool long_transfer, CoprocReg CRd,
                                                       std::optional<u8> option) {
-    if (option) {
-        LOG_CRITICAL(Core_ARM, "CP15: mrrc{}{} p15, {}, [...], {}", two ? "2" : "",
-                     long_transfer ? "l" : "", CRd, *option);
-    } else {
-        LOG_CRITICAL(Core_ARM, "CP15: mrrc{}{} p15, {}, [...]", two ? "2" : "",
-                     long_transfer ? "l" : "", CRd);
-    }
    return {};
 }

 std::optional<Callback> DynarmicCP15::CompileStoreWords(bool two, bool long_transfer, CoprocReg CRd,
                                                        std::optional<u8> option) {
-    if (option) {
-        LOG_CRITICAL(Core_ARM, "CP15: mrrc{}{} p15, {}, [...], {}", two ? "2" : "",
-                     long_transfer ? "l" : "", CRd, *option);
-    } else {
-        LOG_CRITICAL(Core_ARM, "CP15: mrrc{}{} p15, {}, [...]", two ? "2" : "",
-                     long_transfer ? "l" : "", CRd);
-    }
    return {};
 }
-
-} // namespace Core
--- a/src/core/arm/dynarmic/arm_dynarmic_cp15.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_cp15.h
@@ -10,15 +10,128 @@
 #include <dynarmic/A32/coprocessor.h>
 #include "common/common_types.h"

-namespace Core {
+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,

-class ARM_Dynarmic_32;
+    // 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(ARM_Dynarmic_32& parent) : parent(parent) {}
+    explicit DynarmicCP15(u32* cp15) : CP15(cp15){};

    std::optional<Callback> CompileInternalOperation(bool two, unsigned opc1, CoprocReg CRd,
                                                     CoprocReg CRn, CoprocReg CRm,
@@ -34,9 +147,6 @@ public:
    std::optional<Callback> CompileStoreWords(bool two, bool long_transfer, CoprocReg CRd,
                                              std::optional<u8> option) override;

-    ARM_Dynarmic_32& parent;
-    u32 uprw;
-    u32 uro;
+private:
+    u32* CP15{};
 };
-
-} // namespace Core
--- a/src/core/file_sys/control_metadata.cpp
+++ b/src/core/file_sys/control_metadata.cpp
@@ -95,10 +95,6 @@ u32 NACP::GetSupportedLanguages() const {
    return raw.supported_languages;
 }

-u64 NACP::GetDeviceSaveDataSize() const {
-    return raw.device_save_data_size;
-}
-
 std::vector<u8> NACP::GetRawBytes() const {
    std::vector<u8> out(sizeof(RawNACP));
    std::memcpy(out.data(), &raw, sizeof(RawNACP));
--- a/src/core/file_sys/control_metadata.h
+++ b/src/core/file_sys/control_metadata.h
@@ -113,7 +113,6 @@ public:
    u32 GetSupportedLanguages() const;
    std::vector<u8> GetRawBytes() const;
    bool GetUserAccountSwitchLock() const;
-    u64 GetDeviceSaveDataSize() const;

 private:
    RawNACP raw{};
--- a/src/core/file_sys/patch_manager.cpp
+++ b/src/core/file_sys/patch_manager.cpp
@@ -10,7 +10,6 @@
 #include "common/file_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
-#include "common/string_util.h"
 #include "core/core.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
@@ -49,23 +48,6 @@ std::string FormatTitleVersion(u32 version, TitleVersionFormat format) {
    return fmt::format("v{}.{}.{}", bytes[3], bytes[2], bytes[1]);
 }

-std::shared_ptr<VfsDirectory> FindSubdirectoryCaseless(const std::shared_ptr<VfsDirectory> dir,
-                                                       std::string_view name) {
-#ifdef _WIN32
-    return dir->GetSubdirectory(name);
-#else
-    const auto subdirs = dir->GetSubdirectories();
-    for (const auto& subdir : subdirs) {
-        std::string dir_name = Common::ToLower(subdir->GetName());
-        if (dir_name == name) {
-            return subdir;
-        }
-    }
-
-    return nullptr;
-#endif
-}
-
 PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}

 PatchManager::~PatchManager() = default;
@@ -122,7 +104,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
            if (std::find(disabled.begin(), disabled.end(), subdir->GetName()) != disabled.end())
                continue;

-            auto exefs_dir = FindSubdirectoryCaseless(subdir, "exefs");
+            auto exefs_dir = subdir->GetSubdirectory("exefs");
            if (exefs_dir != nullptr)
                layers.push_back(std::move(exefs_dir));
        }
@@ -148,7 +130,7 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
        if (std::find(disabled.cbegin(), disabled.cend(), subdir->GetName()) != disabled.cend())
            continue;

-        auto exefs_dir = FindSubdirectoryCaseless(subdir, "exefs");
+        auto exefs_dir = subdir->GetSubdirectory("exefs");
        if (exefs_dir != nullptr) {
            for (const auto& file : exefs_dir->GetFiles()) {
                if (file->GetExtension() == "ips") {
@@ -313,7 +295,7 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
            continue;
        }

-        auto cheats_dir = FindSubdirectoryCaseless(subdir, "cheats");
+        auto cheats_dir = subdir->GetSubdirectory("cheats");
        if (cheats_dir != nullptr) {
            auto res = ReadCheatFileFromFolder(system, title_id, build_id_, cheats_dir, true);
            if (res.has_value()) {
@@ -358,11 +340,11 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
            continue;
        }

-        auto romfs_dir = FindSubdirectoryCaseless(subdir, "romfs");
+        auto romfs_dir = subdir->GetSubdirectory("romfs");
        if (romfs_dir != nullptr)
            layers.push_back(std::move(romfs_dir));

-        auto ext_dir = FindSubdirectoryCaseless(subdir, "romfs_ext");
+        auto ext_dir = subdir->GetSubdirectory("romfs_ext");
        if (ext_dir != nullptr)
            layers_ext.push_back(std::move(ext_dir));
    }
@@ -488,7 +470,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
        for (const auto& mod : mod_dir->GetSubdirectories()) {
            std::string types;

-            const auto exefs_dir = FindSubdirectoryCaseless(mod, "exefs");
+            const auto exefs_dir = mod->GetSubdirectory("exefs");
            if (IsDirValidAndNonEmpty(exefs_dir)) {
                bool ips = false;
                bool ipswitch = false;
@@ -512,9 +494,9 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
                if (layeredfs)
                    AppendCommaIfNotEmpty(types, "LayeredExeFS");
            }
-            if (IsDirValidAndNonEmpty(FindSubdirectoryCaseless(mod, "romfs")))
+            if (IsDirValidAndNonEmpty(mod->GetSubdirectory("romfs")))
                AppendCommaIfNotEmpty(types, "LayeredFS");
-            if (IsDirValidAndNonEmpty(FindSubdirectoryCaseless(mod, "cheats")))
+            if (IsDirValidAndNonEmpty(mod->GetSubdirectory("cheats")))
                AppendCommaIfNotEmpty(types, "Cheats");

            if (types.empty())
--- a/src/core/file_sys/patch_manager.h
+++ b/src/core/file_sys/patch_manager.h
@@ -29,11 +29,6 @@ enum class TitleVersionFormat : u8 {
 std::string FormatTitleVersion(u32 version,
                               TitleVersionFormat format = TitleVersionFormat::ThreeElements);

-// Returns a directory with name matching name case-insensitive. Returns nullptr if directory
-// doesn't have a directory with name.
-std::shared_ptr<VfsDirectory> FindSubdirectoryCaseless(const std::shared_ptr<VfsDirectory> dir,
-                                                       std::string_view name);
-
 // A centralized class to manage patches to games.
 class PatchManager {
 public:
--- a/src/core/file_sys/savedata_factory.cpp
+++ b/src/core/file_sys/savedata_factory.cpp
@@ -57,8 +57,7 @@ void PrintSaveDataDescriptorWarnings(SaveDataDescriptor meta) {
 bool ShouldSaveDataBeAutomaticallyCreated(SaveDataSpaceId space, const SaveDataDescriptor& desc) {
    return desc.type == SaveDataType::CacheStorage || desc.type == SaveDataType::TemporaryStorage ||
           (space == SaveDataSpaceId::NandUser && ///< Normal Save Data -- Current Title & User
-            (desc.type == SaveDataType::SaveData || desc.type == SaveDataType::DeviceSaveData) &&
-            desc.title_id == 0 && desc.save_id == 0);
+            desc.type == SaveDataType::SaveData && desc.title_id == 0 && desc.save_id == 0);
 }

 } // Anonymous namespace
@@ -140,10 +139,8 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
                                         u128 user_id, u64 save_id) {
    // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
    // be interpreted as the title id of the current process.
-    if (type == SaveDataType::SaveData || type == SaveDataType::DeviceSaveData) {
-        if (title_id == 0) {
-            title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
-        }
+    if (type == SaveDataType::SaveData && title_id == 0) {
+        title_id = Core::System::GetInstance().CurrentProcess()->GetTitleID();
    }

    std::string out = GetSaveDataSpaceIdPath(space);
--- a/src/core/file_sys/system_archive/mii_model.cpp
+++ b/src/core/file_sys/system_archive/mii_model.cpp
@@ -40,7 +40,7 @@ VirtualDir MiiModel() {
    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::SHAPE_MID.size()>>(
        MiiModelData::SHAPE_MID, "ShapeMid.dat"));

-    return out;
+    return std::move(out);
 }

 } // namespace FileSys::SystemArchive
--- a/src/core/file_sys/system_archive/shared_font.cpp
+++ b/src/core/file_sys/system_archive/shared_font.cpp
@@ -23,7 +23,7 @@ VirtualFile PackBFTTF(const std::array<u8, Size>& data, const std::string& name)

    std::vector<u8> bfttf(Size + sizeof(u64));

-    size_t offset = 0;
+    u64 offset = 0;
    Service::NS::EncryptSharedFont(vec, bfttf, offset);
    return std::make_shared<VectorVfsFile>(std::move(bfttf), name);
 }
--- a/src/core/file_sys/system_archive/system_version.cpp
+++ b/src/core/file_sys/system_archive/system_version.cpp
@@ -12,17 +12,17 @@ namespace SystemVersionData {
 // This section should reflect the best system version to describe yuzu's HLE api.
 // TODO(DarkLordZach): Update when HLE gets better.

-constexpr u8 VERSION_MAJOR = 10;
-constexpr u8 VERSION_MINOR = 0;
-constexpr u8 VERSION_MICRO = 2;
+constexpr u8 VERSION_MAJOR = 5;
+constexpr u8 VERSION_MINOR = 1;
+constexpr u8 VERSION_MICRO = 0;

-constexpr u8 REVISION_MAJOR = 1;
+constexpr u8 REVISION_MAJOR = 3;
 constexpr u8 REVISION_MINOR = 0;

 constexpr char PLATFORM_STRING[] = "NX";
-constexpr char VERSION_HASH[] = "f90143fa8bbc061d4f68c35f95f04f8080c0ecdc";
-constexpr char DISPLAY_VERSION[] = "10.0.2";
-constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 10.0.2-1.0";
+constexpr char VERSION_HASH[] = "23f9df53e25709d756e0c76effcb2473bd3447dd";
+constexpr char DISPLAY_VERSION[] = "5.1.0";
+constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 5.1.0-3.0";

 } // namespace SystemVersionData

--- a/src/core/frontend/emu_window.cpp
+++ b/src/core/frontend/emu_window.cpp
@@ -46,7 +46,7 @@ private:
 EmuWindow::EmuWindow() {
    // TODO: Find a better place to set this.
    config.min_client_area_size =
-        std::make_pair(Layout::MinimumSize::Width, Layout::MinimumSize::Height);
+        std::make_pair(Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height);
    active_config = config;
    touch_state = std::make_shared<TouchState>();
    Input::RegisterFactory<Input::TouchDevice>("emu_window", touch_state);
--- a/src/core/frontend/framebuffer_layout.h
+++ b/src/core/frontend/framebuffer_layout.h
@@ -8,11 +8,6 @@

 namespace Layout {

-namespace MinimumSize {
-constexpr u32 Width = 640;
-constexpr u32 Height = 360;
-} // namespace MinimumSize
-
 namespace ScreenUndocked {
 constexpr u32 Width = 1280;
 constexpr u32 Height = 720;
--- a/src/core/hle/kernel/memory/memory_manager.cpp
+++ b/src/core/hle/kernel/memory/memory_manager.cpp
@@ -104,7 +104,7 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
    // Ensure that we don't leave anything un-freed
    auto group_guard = detail::ScopeExit([&] {
        for (const auto& it : page_list.Nodes()) {
-            const auto min_num_pages{std::min<size_t>(
+            const auto min_num_pages{std::min(
                it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
            chosen_manager.Free(it.GetAddress(), min_num_pages);
        }
@@ -165,7 +165,7 @@ ResultCode MemoryManager::Free(PageLinkedList& page_list, std::size_t num_pages,

    // Free all of the pages
    for (const auto& it : page_list.Nodes()) {
-        const auto min_num_pages{std::min<size_t>(
+        const auto min_num_pages{std::min(
            it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
        chosen_manager.Free(it.GetAddress(), min_num_pages);
    }
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -132,8 +132,7 @@ std::shared_ptr<ResourceLimit> Process::GetResourceLimit() const {

 u64 Process::GetTotalPhysicalMemoryAvailable() const {
    const u64 capacity{resource_limit->GetCurrentResourceValue(ResourceType::PhysicalMemory) +
-                       page_table->GetTotalHeapSize() + GetSystemResourceSize() + image_size +
-                       main_thread_stack_size};
+                       page_table->GetTotalHeapSize() + image_size + main_thread_stack_size};

    if (capacity < memory_usage_capacity) {
        return capacity;
@@ -147,8 +146,7 @@ u64 Process::GetTotalPhysicalMemoryAvailableWithoutSystemResource() const {
 }

 u64 Process::GetTotalPhysicalMemoryUsed() const {
-    return image_size + main_thread_stack_size + page_table->GetTotalHeapSize() +
-           GetSystemResourceSize();
+    return image_size + main_thread_stack_size + page_table->GetTotalHeapSize();
 }

 u64 Process::GetTotalPhysicalMemoryUsedWithoutSystemResource() const {
--- a/src/core/hle/kernel/readable_event.cpp
+++ b/src/core/hle/kernel/readable_event.cpp
@@ -38,7 +38,7 @@ void ReadableEvent::Clear() {

 ResultCode ReadableEvent::Reset() {
    if (!is_signaled) {
-        LOG_TRACE(Kernel, "Handle is not signaled! object_id={}, object_type={}, object_name={}",
+        LOG_ERROR(Kernel, "Handle is not signaled! object_id={}, object_type={}, object_name={}",
                  GetObjectId(), GetTypeName(), GetName());
        return ERR_INVALID_STATE;
    }
--- a/src/core/hle/kernel/resource_limit.cpp
+++ b/src/core/hle/kernel/resource_limit.cpp
@@ -24,9 +24,13 @@ bool ResourceLimit::Reserve(ResourceType resource, s64 amount, u64 timeout) {
    const std::size_t index{ResourceTypeToIndex(resource)};

    s64 new_value = current[index] + amount;
-    if (new_value > limit[index] && available[index] + amount <= limit[index]) {
+    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]) {
--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -44,218 +44,6 @@ static constexpr u32 SanitizeJPEGSize(std::size_t size) {
    return static_cast<u32>(std::min(size, max_jpeg_image_size));
 }

-class IManagerForSystemService final : public ServiceFramework<IManagerForSystemService> {
-public:
-    explicit IManagerForSystemService(Common::UUID user_id)
-        : ServiceFramework("IManagerForSystemService") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "CheckAvailability"},
-            {1, nullptr, "GetAccountId"},
-            {2, nullptr, "EnsureIdTokenCacheAsync"},
-            {3, nullptr, "LoadIdTokenCache"},
-            {100, nullptr, "SetSystemProgramIdentification"},
-            {101, nullptr, "RefreshNotificationTokenAsync"}, // 7.0.0+
-            {110, nullptr, "GetServiceEntryRequirementCache"}, // 4.0.0+
-            {111, nullptr, "InvalidateServiceEntryRequirementCache"}, // 4.0.0+
-            {112, nullptr, "InvalidateTokenCache"}, // 4.0.0 - 6.2.0
-            {113, nullptr, "GetServiceEntryRequirementCacheForOnlinePlay"}, // 6.1.0+
-            {120, nullptr, "GetNintendoAccountId"},
-            {121, nullptr, "CalculateNintendoAccountAuthenticationFingerprint"}, // 9.0.0+
-            {130, nullptr, "GetNintendoAccountUserResourceCache"},
-            {131, nullptr, "RefreshNintendoAccountUserResourceCacheAsync"},
-            {132, nullptr, "RefreshNintendoAccountUserResourceCacheAsyncIfSecondsElapsed"},
-            {133, nullptr, "GetNintendoAccountVerificationUrlCache"}, // 9.0.0+
-            {134, nullptr, "RefreshNintendoAccountVerificationUrlCache"}, // 9.0.0+
-            {135, nullptr, "RefreshNintendoAccountVerificationUrlCacheAsyncIfSecondsElapsed"}, // 9.0.0+
-            {140, nullptr, "GetNetworkServiceLicenseCache"}, // 5.0.0+
-            {141, nullptr, "RefreshNetworkServiceLicenseCacheAsync"}, // 5.0.0+
-            {142, nullptr, "RefreshNetworkServiceLicenseCacheAsyncIfSecondsElapsed"}, // 5.0.0+
-            {150, nullptr, "CreateAuthorizationRequest"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-// 3.0.0+
-class IFloatingRegistrationRequest final : public ServiceFramework<IFloatingRegistrationRequest> {
-public:
-    explicit IFloatingRegistrationRequest(Common::UUID user_id)
-        : ServiceFramework("IFloatingRegistrationRequest") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetSessionId"},
-            {12, nullptr, "GetAccountId"},
-            {13, nullptr, "GetLinkedNintendoAccountId"},
-            {14, nullptr, "GetNickname"},
-            {15, nullptr, "GetProfileImage"},
-            {21, nullptr, "LoadIdTokenCache"},
-            {100, nullptr, "RegisterUser"}, // [1.0.0-3.0.2] RegisterAsync
-            {101, nullptr, "RegisterUserWithUid"}, // [1.0.0-3.0.2] RegisterWithUidAsync
-            {102, nullptr, "RegisterNetworkServiceAccountAsync"}, // 4.0.0+
-            {103, nullptr, "RegisterNetworkServiceAccountWithUidAsync"}, // 4.0.0+
-            {110, nullptr, "SetSystemProgramIdentification"},
-            {111, nullptr, "EnsureIdTokenCacheAsync"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class IAdministrator final : public ServiceFramework<IAdministrator> {
-public:
-    explicit IAdministrator(Common::UUID user_id) : ServiceFramework("IAdministrator") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "CheckAvailability"},
-            {1, nullptr, "GetAccountId"},
-            {2, nullptr, "EnsureIdTokenCacheAsync"},
-            {3, nullptr, "LoadIdTokenCache"},
-            {100, nullptr, "SetSystemProgramIdentification"},
-            {101, nullptr, "RefreshNotificationTokenAsync"}, // 7.0.0+
-            {110, nullptr, "GetServiceEntryRequirementCache"}, // 4.0.0+
-            {111, nullptr, "InvalidateServiceEntryRequirementCache"}, // 4.0.0+
-            {112, nullptr, "InvalidateTokenCache"}, // 4.0.0 - 6.2.0
-            {113, nullptr, "GetServiceEntryRequirementCacheForOnlinePlay"}, // 6.1.0+
-            {120, nullptr, "GetNintendoAccountId"},
-            {121, nullptr, "CalculateNintendoAccountAuthenticationFingerprint"}, // 9.0.0+
-            {130, nullptr, "GetNintendoAccountUserResourceCache"},
-            {131, nullptr, "RefreshNintendoAccountUserResourceCacheAsync"},
-            {132, nullptr, "RefreshNintendoAccountUserResourceCacheAsyncIfSecondsElapsed"},
-            {133, nullptr, "GetNintendoAccountVerificationUrlCache"}, // 9.0.0+
-            {134, nullptr, "RefreshNintendoAccountVerificationUrlCacheAsync"}, // 9.0.0+
-            {135, nullptr, "RefreshNintendoAccountVerificationUrlCacheAsyncIfSecondsElapsed"}, // 9.0.0+
-            {140, nullptr, "GetNetworkServiceLicenseCache"}, // 5.0.0+
-            {141, nullptr, "RefreshNetworkServiceLicenseCacheAsync"}, // 5.0.0+
-            {142, nullptr, "RefreshNetworkServiceLicenseCacheAsyncIfSecondsElapsed"}, // 5.0.0+
-            {150, nullptr, "CreateAuthorizationRequest"},
-            {200, nullptr, "IsRegistered"},
-            {201, nullptr, "RegisterAsync"},
-            {202, nullptr, "UnregisterAsync"},
-            {203, nullptr, "DeleteRegistrationInfoLocally"},
-            {220, nullptr, "SynchronizeProfileAsync"},
-            {221, nullptr, "UploadProfileAsync"},
-            {222, nullptr, "SynchronizaProfileAsyncIfSecondsElapsed"},
-            {250, nullptr, "IsLinkedWithNintendoAccount"},
-            {251, nullptr, "CreateProcedureToLinkWithNintendoAccount"},
-            {252, nullptr, "ResumeProcedureToLinkWithNintendoAccount"},
-            {255, nullptr, "CreateProcedureToUpdateLinkageStateOfNintendoAccount"},
-            {256, nullptr, "ResumeProcedureToUpdateLinkageStateOfNintendoAccount"},
-            {260, nullptr, "CreateProcedureToLinkNnidWithNintendoAccount"}, // 3.0.0+
-            {261, nullptr, "ResumeProcedureToLinkNnidWithNintendoAccount"}, // 3.0.0+
-            {280, nullptr, "ProxyProcedureToAcquireApplicationAuthorizationForNintendoAccount"},
-            {290, nullptr, "GetRequestForNintendoAccountUserResourceView"}, // 8.0.0+
-            {300, nullptr, "TryRecoverNintendoAccountUserStateAsync"}, // 6.0.0+
-            {400, nullptr, "IsServiceEntryRequirementCacheRefreshRequiredForOnlinePlay"}, // 6.1.0+
-            {401, nullptr, "RefreshServiceEntryRequirementCacheForOnlinePlayAsync"}, // 6.1.0+
-            {900, nullptr, "GetAuthenticationInfoForWin"}, // 9.0.0+
-            {901, nullptr, "ImportAsyncForWin"}, // 9.0.0+
-            {997, nullptr, "DebugUnlinkNintendoAccountAsync"},
-            {998, nullptr, "DebugSetAvailabilityErrorDetail"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class IAuthorizationRequest final : public ServiceFramework<IAuthorizationRequest> {
-public:
-    explicit IAuthorizationRequest(Common::UUID user_id)
-        : ServiceFramework("IAuthorizationRequest") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetSessionId"},
-            {10, nullptr, "InvokeWithoutInteractionAsync"},
-            {19, nullptr, "IsAuthorized"},
-            {20, nullptr, "GetAuthorizationCode"},
-            {21, nullptr, "GetIdToken"},
-            {22, nullptr, "GetState"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class IOAuthProcedure final : public ServiceFramework<IOAuthProcedure> {
-public:
-    explicit IOAuthProcedure(Common::UUID user_id) : ServiceFramework("IOAuthProcedure") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "PrepareAsync"},
-            {1, nullptr, "GetRequest"},
-            {2, nullptr, "ApplyResponse"},
-            {3, nullptr, "ApplyResponseAsync"},
-            {10, nullptr, "Suspend"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-// 3.0.0+
-class IOAuthProcedureForExternalNsa final : public ServiceFramework<IOAuthProcedureForExternalNsa> {
-public:
-    explicit IOAuthProcedureForExternalNsa(Common::UUID user_id)
-        : ServiceFramework("IOAuthProcedureForExternalNsa") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "PrepareAsync"},
-            {1, nullptr, "GetRequest"},
-            {2, nullptr, "ApplyResponse"},
-            {3, nullptr, "ApplyResponseAsync"},
-            {10, nullptr, "Suspend"},
-            {100, nullptr, "GetAccountId"},
-            {101, nullptr, "GetLinkedNintendoAccountId"},
-            {102, nullptr, "GetNickname"},
-            {103, nullptr, "GetProfileImage"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class IOAuthProcedureForNintendoAccountLinkage final
-    : public ServiceFramework<IOAuthProcedureForNintendoAccountLinkage> {
-public:
-    explicit IOAuthProcedureForNintendoAccountLinkage(Common::UUID user_id)
-        : ServiceFramework("IOAuthProcedureForNintendoAccountLinkage") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "PrepareAsync"},
-            {1, nullptr, "GetRequest"},
-            {2, nullptr, "ApplyResponse"},
-            {3, nullptr, "ApplyResponseAsync"},
-            {10, nullptr, "Suspend"},
-            {100, nullptr, "GetRequestWithTheme"},
-            {101, nullptr, "IsNetworkServiceAccountReplaced"},
-            {199, nullptr, "GetUrlForIntroductionOfExtraMembership"}, // 2.0.0 - 5.1.0
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class INotifier final : public ServiceFramework<INotifier> {
-public:
-    explicit INotifier(Common::UUID user_id) : ServiceFramework("INotifier") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetSystemEvent"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
 class IProfileCommon : public ServiceFramework<IProfileCommon> {
 public:
    explicit IProfileCommon(const char* name, bool editor_commands, Common::UUID user_id,
@@ -438,54 +226,6 @@ public:
        : IProfileCommon("IProfileEditor", true, user_id, profile_manager) {}
 };

-class IAsyncContext final : public ServiceFramework<IAsyncContext> {
-public:
-    explicit IAsyncContext(Common::UUID user_id) : ServiceFramework("IAsyncContext") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetSystemEvent"},
-            {1, nullptr, "Cancel"},
-            {2, nullptr, "HasDone"},
-            {3, nullptr, "GetResult"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class ISessionObject final : public ServiceFramework<ISessionObject> {
-public:
-    explicit ISessionObject(Common::UUID user_id) : ServiceFramework("ISessionObject") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {999, nullptr, "Dummy"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class IGuestLoginRequest final : public ServiceFramework<IGuestLoginRequest> {
-public:
-    explicit IGuestLoginRequest(Common::UUID) : ServiceFramework("IGuestLoginRequest") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetSessionId"},
-            {11, nullptr, "Unknown"}, // 1.0.0 - 2.3.0 (the name is blank on Switchbrew)
-            {12, nullptr, "GetAccountId"},
-            {13, nullptr, "GetLinkedNintendoAccountId"},
-            {14, nullptr, "GetNickname"},
-            {15, nullptr, "GetProfileImage"},
-            {21, nullptr, "LoadIdTokenCache"}, // 3.0.0+
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
 public:
    explicit IManagerForApplication(Common::UUID user_id)
@@ -525,87 +265,6 @@ private:
    Common::UUID user_id;
 };

-// 6.0.0+
-class IAsyncNetworkServiceLicenseKindContext final
-    : public ServiceFramework<IAsyncNetworkServiceLicenseKindContext> {
-public:
-    explicit IAsyncNetworkServiceLicenseKindContext(Common::UUID user_id)
-        : ServiceFramework("IAsyncNetworkServiceLicenseKindContext") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetSystemEvent"},
-            {1, nullptr, "Cancel"},
-            {2, nullptr, "HasDone"},
-            {3, nullptr, "GetResult"},
-            {4, nullptr, "GetNetworkServiceLicenseKind"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-// 8.0.0+
-class IOAuthProcedureForUserRegistration final
-    : public ServiceFramework<IOAuthProcedureForUserRegistration> {
-public:
-    explicit IOAuthProcedureForUserRegistration(Common::UUID user_id)
-        : ServiceFramework("IOAuthProcedureForUserRegistration") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "PrepareAsync"},
-            {1, nullptr, "GetRequest"},
-            {2, nullptr, "ApplyResponse"},
-            {3, nullptr, "ApplyResponseAsync"},
-            {10, nullptr, "Suspend"},
-            {100, nullptr, "GetAccountId"},
-            {101, nullptr, "GetLinkedNintendoAccountId"},
-            {102, nullptr, "GetNickname"},
-            {103, nullptr, "GetProfileImage"},
-            {110, nullptr, "RegisterUserAsync"},
-            {111, nullptr, "GetUid"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-class DAUTH_O final : public ServiceFramework<DAUTH_O> {
-public:
-    explicit DAUTH_O(Common::UUID) : ServiceFramework("dauth:o") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "EnsureAuthenticationTokenCacheAsync"}, // [5.0.0-5.1.0] GeneratePostData
-            {1, nullptr, "LoadAuthenticationTokenCache"}, // 6.0.0+
-            {2, nullptr, "InvalidateAuthenticationTokenCache"}, // 6.0.0+
-            {10, nullptr, "EnsureEdgeTokenCacheAsync"}, // 6.0.0+
-            {11, nullptr, "LoadEdgeTokenCache"}, // 6.0.0+
-            {12, nullptr, "InvalidateEdgeTokenCache"}, // 6.0.0+
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
-// 6.0.0+
-class IAsyncResult final : public ServiceFramework<IAsyncResult> {
-public:
-    explicit IAsyncResult(Common::UUID user_id) : ServiceFramework("IAsyncResult") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetResult"},
-            {1, nullptr, "Cancel"},
-            {2, nullptr, "IsAvailable"},
-            {3, nullptr, "GetSystemEvent"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-};
-
 void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_ACC, "called");
    IPC::ResponseBuilder rb{ctx, 3};
--- a/src/core/hle/service/acc/acc_aa.cpp
+++ b/src/core/hle/service/acc/acc_aa.cpp
@@ -13,8 +13,8 @@ ACC_AA::ACC_AA(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {0, nullptr, "EnsureCacheAsync"},
        {1, nullptr, "LoadCache"},
        {2, nullptr, "GetDeviceAccountId"},
-        {50, nullptr, "RegisterNotificationTokenAsync"},   // 1.0.0 - 6.2.0
-        {51, nullptr, "UnregisterNotificationTokenAsync"}, // 1.0.0 - 6.2.0
+        {50, nullptr, "RegisterNotificationTokenAsync"},
+        {51, nullptr, "UnregisterNotificationTokenAsync"},
    };
    RegisterHandlers(functions);
 }
--- a/src/core/hle/service/acc/acc_su.cpp
+++ b/src/core/hle/service/acc/acc_su.cpp
@@ -17,28 +17,28 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {3, &ACC_SU::ListOpenUsers, "ListOpenUsers"},
        {4, &ACC_SU::GetLastOpenedUser, "GetLastOpenedUser"},
        {5, &ACC_SU::GetProfile, "GetProfile"},
-        {6, nullptr, "GetProfileDigest"}, // 3.0.0+
+        {6, nullptr, "GetProfileDigest"},
        {50, &ACC_SU::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
        {51, &ACC_SU::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
-        {60, nullptr, "ListOpenContextStoredUsers"}, // 5.0.0 - 5.1.0
-        {99, nullptr, "DebugActivateOpenContextRetention"}, // 6.0.0+
+        {60, nullptr, "ListOpenContextStoredUsers"},
+        {99, nullptr, "DebugActivateOpenContextRetention"},
        {100, nullptr, "GetUserRegistrationNotifier"},
        {101, nullptr, "GetUserStateChangeNotifier"},
        {102, nullptr, "GetBaasAccountManagerForSystemService"},
        {103, nullptr, "GetBaasUserAvailabilityChangeNotifier"},
        {104, nullptr, "GetProfileUpdateNotifier"},
-        {105, nullptr, "CheckNetworkServiceAvailabilityAsync"}, // 4.0.0+
-        {106, nullptr, "GetProfileSyncNotifier"}, // 9.0.0+
+        {105, nullptr, "CheckNetworkServiceAvailabilityAsync"},
+        {106, nullptr, "GetProfileSyncNotifier"},
        {110, nullptr, "StoreSaveDataThumbnail"},
        {111, nullptr, "ClearSaveDataThumbnail"},
        {112, nullptr, "LoadSaveDataThumbnail"},
-        {113, nullptr, "GetSaveDataThumbnailExistence"}, // 5.0.0+
-        {120, nullptr, "ListOpenUsersInApplication"}, // 10.0.0+
-        {130, nullptr, "ActivateOpenContextRetention"}, // 6.0.0+
-        {140, &ACC_SU::ListQualifiedUsers, "ListQualifiedUsers"}, // 6.0.0+
-        {150, nullptr, "AuthenticateApplicationAsync"}, // 10.0.0+
-        {190, nullptr, "GetUserLastOpenedApplication"}, // 1.0.0 - 9.2.0
-        {191, nullptr, "ActivateOpenContextHolder"}, // 7.0.0+
+        {113, nullptr, "GetSaveDataThumbnailExistence"},
+        {120, nullptr, "ListOpenUsersInApplication"},
+        {130, nullptr, "ActivateOpenContextRetention"},
+        {140, &ACC_SU::ListQualifiedUsers, "ListQualifiedUsers"},
+        {150, nullptr, "AuthenticateApplicationAsync"},
+        {190, nullptr, "GetUserLastOpenedApplication"},
+        {191, nullptr, "ActivateOpenContextHolder"},
        {200, nullptr, "BeginUserRegistration"},
        {201, nullptr, "CompleteUserRegistration"},
        {202, nullptr, "CancelUserRegistration"},
@@ -46,15 +46,15 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {204, nullptr, "SetUserPosition"},
        {205, &ACC_SU::GetProfileEditor, "GetProfileEditor"},
        {206, nullptr, "CompleteUserRegistrationForcibly"},
-        {210, nullptr, "CreateFloatingRegistrationRequest"}, // 3.0.0+
-        {211, nullptr, "CreateProcedureToRegisterUserWithNintendoAccount"}, // 8.0.0+
-        {212, nullptr, "ResumeProcedureToRegisterUserWithNintendoAccount"}, // 8.0.0+
+        {210, nullptr, "CreateFloatingRegistrationRequest"},
+        {211, nullptr, "CreateProcedureToRegisterUserWithNintendoAccount"},
+        {212, nullptr, "ResumeProcedureToRegisterUserWithNintendoAccount"},
        {230, nullptr, "AuthenticateServiceAsync"},
        {250, nullptr, "GetBaasAccountAdministrator"},
        {290, nullptr, "ProxyProcedureForGuestLoginWithNintendoAccount"},
-        {291, nullptr, "ProxyProcedureForFloatingRegistrationWithNintendoAccount"}, // 3.0.0+
+        {291, nullptr, "ProxyProcedureForFloatingRegistrationWithNintendoAccount"},
        {299, nullptr, "SuspendBackgroundDaemon"},
-        {997, nullptr, "DebugInvalidateTokenCacheForUser"}, // 3.0.0+
+        {997, nullptr, "DebugInvalidateTokenCacheForUser"},
        {998, nullptr, "DebugSetUserStateClose"},
        {999, nullptr, "DebugSetUserStateOpen"},
    };
--- a/src/core/hle/service/acc/acc_u0.cpp
+++ b/src/core/hle/service/acc/acc_u0.cpp
@@ -17,23 +17,23 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {3, &ACC_U0::ListOpenUsers, "ListOpenUsers"},
        {4, &ACC_U0::GetLastOpenedUser, "GetLastOpenedUser"},
        {5, &ACC_U0::GetProfile, "GetProfile"},
-        {6, nullptr, "GetProfileDigest"}, // 3.0.0+
+        {6, nullptr, "GetProfileDigest"},
        {50, &ACC_U0::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
        {51, &ACC_U0::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
-        {60, nullptr, "ListOpenContextStoredUsers"}, // 5.0.0 - 5.1.0
-        {99, nullptr, "DebugActivateOpenContextRetention"}, // 6.0.0+
+        {60, nullptr, "ListOpenContextStoredUsers"},
+        {99, nullptr, "DebugActivateOpenContextRetention"},
        {100, &ACC_U0::InitializeApplicationInfo, "InitializeApplicationInfo"},
        {101, &ACC_U0::GetBaasAccountManagerForApplication, "GetBaasAccountManagerForApplication"},
        {102, nullptr, "AuthenticateApplicationAsync"},
-        {103, nullptr, "CheckNetworkServiceAvailabilityAsync"}, // 4.0.0+
+        {103, nullptr, "CheckNetworkServiceAvailabilityAsync"},
        {110, nullptr, "StoreSaveDataThumbnail"},
        {111, nullptr, "ClearSaveDataThumbnail"},
        {120, nullptr, "CreateGuestLoginRequest"},
-        {130, nullptr, "LoadOpenContext"}, // 5.0.0+
-        {131, nullptr, "ListOpenContextStoredUsers"}, // 6.0.0+
-        {140, &ACC_U0::InitializeApplicationInfoRestricted, "InitializeApplicationInfoRestricted"}, // 6.0.0+
-        {141, &ACC_U0::ListQualifiedUsers, "ListQualifiedUsers"}, // 6.0.0+
-        {150, &ACC_U0::IsUserAccountSwitchLocked, "IsUserAccountSwitchLocked"}, // 6.0.0+
+        {130, nullptr, "LoadOpenContext"},
+        {131, nullptr, "ListOpenContextStoredUsers"},
+        {140, &ACC_U0::InitializeApplicationInfoRestricted, "InitializeApplicationInfoRestricted"},
+        {141, &ACC_U0::ListQualifiedUsers, "ListQualifiedUsers"},
+        {150, &ACC_U0::IsUserAccountSwitchLocked, "IsUserAccountSwitchLocked"},
    };
    // clang-format on

--- a/src/core/hle/service/acc/acc_u1.cpp
+++ b/src/core/hle/service/acc/acc_u1.cpp
@@ -17,29 +17,28 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {3, &ACC_U1::ListOpenUsers, "ListOpenUsers"},
        {4, &ACC_U1::GetLastOpenedUser, "GetLastOpenedUser"},
        {5, &ACC_U1::GetProfile, "GetProfile"},
-        {6, nullptr, "GetProfileDigest"}, // 3.0.0+
+        {6, nullptr, "GetProfileDigest"},
        {50, &ACC_U1::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
        {51, &ACC_U1::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
-        {60, nullptr, "ListOpenContextStoredUsers"}, // 5.0.0 - 5.1.0
-        {99, nullptr, "DebugActivateOpenContextRetention"}, // 6.0.0+
+        {60, nullptr, "ListOpenContextStoredUsers"},
+        {99, nullptr, "DebugActivateOpenContextRetention"},
        {100, nullptr, "GetUserRegistrationNotifier"},
        {101, nullptr, "GetUserStateChangeNotifier"},
        {102, nullptr, "GetBaasAccountManagerForSystemService"},
-        {103, nullptr, "GetBaasUserAvailabilityChangeNotifier"},
-        {104, nullptr, "GetProfileUpdateNotifier"},
-        {105, nullptr, "CheckNetworkServiceAvailabilityAsync"}, // 4.0.0+
-        {106, nullptr, "GetProfileSyncNotifier"}, // 9.0.0+
+        {103, nullptr, "GetProfileUpdateNotifier"},
+        {104, nullptr, "CheckNetworkServiceAvailabilityAsync"},
+        {105, nullptr, "GetBaasUserAvailabilityChangeNotifier"},
+        {106, nullptr, "GetProfileSyncNotifier"},
        {110, nullptr, "StoreSaveDataThumbnail"},
        {111, nullptr, "ClearSaveDataThumbnail"},
        {112, nullptr, "LoadSaveDataThumbnail"},
-        {113, nullptr, "GetSaveDataThumbnailExistence"}, // 5.0.0+
-        {120, nullptr, "ListOpenUsersInApplication"}, // 10.0.0+
-        {130, nullptr, "ActivateOpenContextRetention"}, // 6.0.0+
-        {140, &ACC_U1::ListQualifiedUsers, "ListQualifiedUsers"}, // 6.0.0+
-        {150, nullptr, "AuthenticateApplicationAsync"}, // 10.0.0+
-        {190, nullptr, "GetUserLastOpenedApplication"}, // 1.0.0 - 9.2.0
-        {191, nullptr, "ActivateOpenContextHolder"}, // 7.0.0+
-        {997, nullptr, "DebugInvalidateTokenCacheForUser"}, // 3.0.0+
+        {113, nullptr, "GetSaveDataThumbnailExistence"},
+        {130, nullptr, "ActivateOpenContextRetention"},
+        {140, &ACC_U1::ListQualifiedUsers, "ListQualifiedUsers"},
+        {150, nullptr, "AuthenticateApplicationAsync"},
+        {190, nullptr, "GetUserLastOpenedApplication"},
+        {191, nullptr, "ActivateOpenContextHolder"},
+        {997, nullptr, "DebugInvalidateTokenCacheForUser"},
        {998, nullptr, "DebugSetUserStateClose"},
        {999, nullptr, "DebugSetUserStateOpen"},
    };
--- a/src/core/hle/service/am/applets/software_keyboard.cpp
+++ b/src/core/hle/service/am/applets/software_keyboard.cpp
@@ -30,7 +30,7 @@ static Core::Frontend::SoftwareKeyboardParameters ConvertToFrontendParameters(
                                                                       config.sub_text.size());
    params.guide_text = Common::UTF16StringFromFixedZeroTerminatedBuffer(config.guide_text.data(),
                                                                         config.guide_text.size());
-    params.initial_text = std::move(initial_text);
+    params.initial_text = initial_text;
    params.max_length = config.length_limit == 0 ? DEFAULT_MAX_LENGTH : config.length_limit;
    params.password = static_cast<bool>(config.is_password);
    params.cursor_at_beginning = static_cast<bool>(config.initial_cursor_position);
@@ -109,7 +109,7 @@ void SoftwareKeyboard::Execute() {

    const auto parameters = ConvertToFrontendParameters(config, initial_text);

-    frontend.RequestText([this](std::optional<std::u16string> text) { WriteText(std::move(text)); },
+    frontend.RequestText([this](std::optional<std::u16string> text) { WriteText(text); },
                         parameters);
 }

--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -767,7 +767,7 @@ FSP_SRV::FSP_SRV(FileSystemController& fsc, const Core::Reporter& reporter)
        {1014, nullptr, "OutputMultiProgramTagAccessLog"},
        {1100, nullptr, "OverrideSaveDataTransferTokenSignVerificationKey"},
        {1110, nullptr, "CorruptSaveDataFileSystemBySaveDataSpaceId2"},
-        {1200, &FSP_SRV::OpenMultiCommitManager, "OpenMultiCommitManager"},
+        {1200, nullptr, "OpenMultiCommitManager"},
        {1300, nullptr, "OpenBisWiper"},
    };
    // clang-format on
@@ -988,40 +988,4 @@ void FSP_SRV::GetAccessLogVersionInfo(Kernel::HLERequestContext& ctx) {
    rb.Push(access_log_program_index);
 }

-class IMultiCommitManager final : public ServiceFramework<IMultiCommitManager> {
-public:
-    explicit IMultiCommitManager() : ServiceFramework("IMultiCommitManager") {
-        static const FunctionInfo functions[] = {
-            {1, &IMultiCommitManager::Add, "Add"},
-            {2, &IMultiCommitManager::Commit, "Commit"},
-        };
-        RegisterHandlers(functions);
-    }
-
-private:
-    FileSys::VirtualFile backend;
-
-    void Add(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_FS, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void Commit(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_FS, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-};
-
-void FSP_SRV::OpenMultiCommitManager(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_FS, "called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IMultiCommitManager>(std::make_shared<IMultiCommitManager>());
-}
-
 } // namespace Service::FileSystem
--- a/src/core/hle/service/filesystem/fsp_srv.h
+++ b/src/core/hle/service/filesystem/fsp_srv.h
@@ -50,7 +50,6 @@ private:
    void OpenPatchDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
    void OutputAccessLogToSdCard(Kernel::HLERequestContext& ctx);
    void GetAccessLogVersionInfo(Kernel::HLERequestContext& ctx);
-    void OpenMultiCommitManager(Kernel::HLERequestContext& ctx);

    FileSystemController& fsc;

--- a/src/core/hle/service/hid/controllers/keyboard.cpp
+++ b/src/core/hle/service/hid/controllers/keyboard.cpp
@@ -38,11 +38,10 @@ void Controller_Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing,
    cur_entry.sampling_number = last_entry.sampling_number + 1;
    cur_entry.sampling_number2 = cur_entry.sampling_number;

-    cur_entry.key.fill(0);
-    cur_entry.modifier = 0;
-
    for (std::size_t i = 0; i < keyboard_keys.size(); ++i) {
-        cur_entry.key[i / KEYS_PER_BYTE] |= (keyboard_keys[i]->GetStatus() << (i % KEYS_PER_BYTE));
+        for (std::size_t k = 0; k < KEYS_PER_BYTE; ++k) {
+            cur_entry.key[i / KEYS_PER_BYTE] |= (keyboard_keys[i]->GetStatus() << k);
+        }
    }

    for (std::size_t i = 0; i < keyboard_mods.size(); ++i) {
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -566,14 +566,6 @@ void Controller_NPad::DisconnectNPad(u32 npad_id) {
    connected_controllers[NPadIdToIndex(npad_id)].is_connected = false;
 }

-void Controller_NPad::SetGyroscopeZeroDriftMode(GyroscopeZeroDriftMode drift_mode) {
-    gyroscope_zero_drift_mode = drift_mode;
-}
-
-Controller_NPad::GyroscopeZeroDriftMode Controller_NPad::GetGyroscopeZeroDriftMode() const {
-    return gyroscope_zero_drift_mode;
-}
-
 void Controller_NPad::StartLRAssignmentMode() {
    // Nothing internally is used for lr assignment mode. Since we have the ability to set the
    // controller types from boot, it doesn't really matter about showing a selection screen
--- a/src/core/hle/service/hid/controllers/npad.h
+++ b/src/core/hle/service/hid/controllers/npad.h
@@ -58,12 +58,6 @@ public:
    };
    static_assert(sizeof(Vibration) == 0x10, "Vibration is an invalid size");

-    enum class GyroscopeZeroDriftMode : u32 {
-        Loose = 0,
-        Standard = 1,
-        Tight = 2,
-    };
-
    enum class NpadHoldType : u64 {
        Vertical = 0,
        Horizontal = 1,
@@ -123,8 +117,6 @@ public:

    void ConnectNPad(u32 npad_id);
    void DisconnectNPad(u32 npad_id);
-    void SetGyroscopeZeroDriftMode(GyroscopeZeroDriftMode drift_mode);
-    GyroscopeZeroDriftMode GetGyroscopeZeroDriftMode() const;
    LedPattern GetLedPattern(u32 npad_id);
    void SetVibrationEnabled(bool can_vibrate);
    bool IsVibrationEnabled() const;
@@ -332,8 +324,8 @@ private:
    std::array<Kernel::EventPair, 10> styleset_changed_events;
    Vibration last_processed_vibration{};
    std::array<ControllerHolder, 10> connected_controllers{};
-    GyroscopeZeroDriftMode gyroscope_zero_drift_mode{GyroscopeZeroDriftMode::Standard};
    bool can_controllers_vibrate{true};
+
    std::array<ControllerPad, 10> npad_pad_states{};
    bool is_in_lr_assignment_mode{false};
    Core::System& system;
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -157,11 +157,11 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
        {11, &Hid::ActivateTouchScreen, "ActivateTouchScreen"},
        {21, &Hid::ActivateMouse, "ActivateMouse"},
        {31, &Hid::ActivateKeyboard, "ActivateKeyboard"},
-        {32, &Hid::SendKeyboardLockKeyEvent, "SendKeyboardLockKeyEvent"},
+        {32, nullptr, "SendKeyboardLockKeyEvent"},
        {40, nullptr, "AcquireXpadIdEventHandle"},
        {41, nullptr, "ReleaseXpadIdEventHandle"},
        {51, &Hid::ActivateXpad, "ActivateXpad"},
-        {55, &Hid::GetXpadIDs, "GetXpadIds"},
+        {55, nullptr, "GetXpadIds"},
        {56, nullptr, "ActivateJoyXpad"},
        {58, nullptr, "GetJoyXpadLifoHandle"},
        {59, nullptr, "GetJoyXpadIds"},
@@ -185,8 +185,8 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
        {77, nullptr, "GetAccelerometerPlayMode"},
        {78, nullptr, "ResetAccelerometerPlayMode"},
        {79, &Hid::SetGyroscopeZeroDriftMode, "SetGyroscopeZeroDriftMode"},
-        {80, &Hid::GetGyroscopeZeroDriftMode, "GetGyroscopeZeroDriftMode"},
-        {81, &Hid::ResetGyroscopeZeroDriftMode, "ResetGyroscopeZeroDriftMode"},
+        {80, nullptr, "GetGyroscopeZeroDriftMode"},
+        {81, nullptr, "ResetGyroscopeZeroDriftMode"},
        {82, &Hid::IsSixAxisSensorAtRest, "IsSixAxisSensorAtRest"},
        {83, nullptr, "IsFirmwareUpdateAvailableForSixAxisSensor"},
        {91, &Hid::ActivateGesture, "ActivateGesture"},
@@ -230,15 +230,15 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
        {211, nullptr, "IsVibrationDeviceMounted"},
        {300, &Hid::ActivateConsoleSixAxisSensor, "ActivateConsoleSixAxisSensor"},
        {301, &Hid::StartConsoleSixAxisSensor, "StartConsoleSixAxisSensor"},
-        {302, &Hid::StopConsoleSixAxisSensor, "StopConsoleSixAxisSensor"},
-        {303, &Hid::ActivateSevenSixAxisSensor, "ActivateSevenSixAxisSensor"},
-        {304, &Hid::StartSevenSixAxisSensor, "StartSevenSixAxisSensor"},
+        {302, nullptr, "StopConsoleSixAxisSensor"},
+        {303, nullptr, "ActivateSevenSixAxisSensor"},
+        {304, nullptr, "StartSevenSixAxisSensor"},
        {305, &Hid::StopSevenSixAxisSensor, "StopSevenSixAxisSensor"},
        {306, &Hid::InitializeSevenSixAxisSensor, "InitializeSevenSixAxisSensor"},
-        {307, &Hid::FinalizeSevenSixAxisSensor, "FinalizeSevenSixAxisSensor"},
+        {307, nullptr, "FinalizeSevenSixAxisSensor"},
        {308, nullptr, "SetSevenSixAxisSensorFusionStrength"},
        {309, nullptr, "GetSevenSixAxisSensorFusionStrength"},
-        {310, &Hid::ResetSevenSixAxisSensorTimestamp, "ResetSevenSixAxisSensorTimestamp"},
+        {310, nullptr, "ResetSevenSixAxisSensorTimestamp"},
        {400, nullptr, "IsUsbFullKeyControllerEnabled"},
        {401, nullptr, "EnableUsbFullKeyController"},
        {402, nullptr, "IsUsbFullKeyControllerConnected"},
@@ -319,17 +319,6 @@ void Hid::ActivateXpad(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
 }

-void Hid::GetXpadIDs(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_DEBUG(Service_HID, "(STUBBED) called, applet_resource_user_id={}", applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(0);
-}
-
 void Hid::ActivateDebugPad(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto applet_resource_user_id{rp.Pop<u64>()};
@@ -374,15 +363,6 @@ void Hid::ActivateKeyboard(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
 }

-void Hid::SendKeyboardLockKeyEvent(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto flags{rp.Pop<u32>()};
-    LOG_WARNING(Service_HID, "(STUBBED) called. flags={}", flags);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 void Hid::ActivateGesture(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto unknown{rp.Pop<u32>()};
@@ -422,59 +402,15 @@ void Hid::StartSixAxisSensor(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
 }

-void Hid::StopSixAxisSensor(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto handle{rp.Pop<u32>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_WARNING(Service_HID, "(STUBBED) called, handle={}, applet_resource_user_id={}", handle,
-                applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 void Hid::SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto handle{rp.Pop<u32>()};
    const auto drift_mode{rp.Pop<u32>()};
    const auto applet_resource_user_id{rp.Pop<u64>()};

-    applet_resource->GetController<Controller_NPad>(HidController::NPad)
-        .SetGyroscopeZeroDriftMode(Controller_NPad::GyroscopeZeroDriftMode{drift_mode});
-
-    LOG_DEBUG(Service_HID, "called, handle={}, drift_mode={}, applet_resource_user_id={}", handle,
-              drift_mode, applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void Hid::GetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto handle{rp.Pop<u32>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_DEBUG(Service_HID, "called, handle={}, applet_resource_user_id={}", handle,
-              applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(
-        static_cast<u32>(applet_resource->GetController<Controller_NPad>(HidController::NPad)
-                             .GetGyroscopeZeroDriftMode()));
-}
-
-void Hid::ResetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto handle{rp.Pop<u32>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    applet_resource->GetController<Controller_NPad>(HidController::NPad)
-        .SetGyroscopeZeroDriftMode(Controller_NPad::GyroscopeZeroDriftMode::Standard);
-
-    LOG_DEBUG(Service_HID, "called, handle={}, applet_resource_user_id={}", handle,
-              applet_resource_user_id);
+    LOG_WARNING(Service_HID,
+                "(STUBBED) called, handle={}, drift_mode={}, applet_resource_user_id={}", handle,
+                drift_mode, applet_resource_user_id);

    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
@@ -885,35 +821,33 @@ void Hid::StartConsoleSixAxisSensor(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
 }

-void Hid::StopConsoleSixAxisSensor(Kernel::HLERequestContext& ctx) {
+void Hid::StopSixAxisSensor(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto handle{rp.Pop<u32>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};

-    LOG_WARNING(Service_HID, "(STUBBED) called, handle={}, applet_resource_user_id={}", handle,
-                applet_resource_user_id);
+    LOG_WARNING(Service_HID, "(STUBBED) called, handle={}", handle);

    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }

-void Hid::ActivateSevenSixAxisSensor(Kernel::HLERequestContext& ctx) {
+void Hid::SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto applet_resource_user_id{rp.Pop<u64>()};
+    const auto unknown{rp.Pop<u32>()};

-    LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}",
-                applet_resource_user_id);
+    LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}, unknown={}",
+                applet_resource_user_id, unknown);

    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
 }

-void Hid::StartSevenSixAxisSensor(Kernel::HLERequestContext& ctx) {
+void Hid::SetPalmaBoostMode(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
+    const auto unknown{rp.Pop<u32>()};

-    LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}",
-                applet_resource_user_id);
+    LOG_WARNING(Service_HID, "(STUBBED) called, unknown={}", unknown);

    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
@@ -937,51 +871,6 @@ void Hid::InitializeSevenSixAxisSensor(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
 }

-void Hid::FinalizeSevenSixAxisSensor(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}",
-                applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void Hid::ResetSevenSixAxisSensorTimestamp(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}",
-                applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void Hid::SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-    const auto is_palma_all_connectable{rp.Pop<bool>()};
-
-    LOG_WARNING(Service_HID,
-                "(STUBBED) called, applet_resource_user_id={}, is_palma_all_connectable={}",
-                applet_resource_user_id, is_palma_all_connectable);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void Hid::SetPalmaBoostMode(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto palma_boost_mode{rp.Pop<bool>()};
-
-    LOG_WARNING(Service_HID, "(STUBBED) called, palma_boost_mode={}", palma_boost_mode);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 class HidDbg final : public ServiceFramework<HidDbg> {
 public:
    explicit HidDbg() : ServiceFramework{"hid:dbg"} {
--- a/src/core/hle/service/hid/hid.h
+++ b/src/core/hle/service/hid/hid.h
@@ -86,19 +86,14 @@ public:
 private:
    void CreateAppletResource(Kernel::HLERequestContext& ctx);
    void ActivateXpad(Kernel::HLERequestContext& ctx);
-    void GetXpadIDs(Kernel::HLERequestContext& ctx);
    void ActivateDebugPad(Kernel::HLERequestContext& ctx);
    void ActivateTouchScreen(Kernel::HLERequestContext& ctx);
    void ActivateMouse(Kernel::HLERequestContext& ctx);
    void ActivateKeyboard(Kernel::HLERequestContext& ctx);
-    void SendKeyboardLockKeyEvent(Kernel::HLERequestContext& ctx);
    void ActivateGesture(Kernel::HLERequestContext& ctx);
    void ActivateNpadWithRevision(Kernel::HLERequestContext& ctx);
    void StartSixAxisSensor(Kernel::HLERequestContext& ctx);
-    void StopSixAxisSensor(Kernel::HLERequestContext& ctx);
    void SetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx);
-    void GetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx);
-    void ResetGyroscopeZeroDriftMode(Kernel::HLERequestContext& ctx);
    void IsSixAxisSensorAtRest(Kernel::HLERequestContext& ctx);
    void SetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx);
    void GetSupportedNpadStyleSet(Kernel::HLERequestContext& ctx);
@@ -130,15 +125,11 @@ private:
    void IsVibrationPermitted(Kernel::HLERequestContext& ctx);
    void ActivateConsoleSixAxisSensor(Kernel::HLERequestContext& ctx);
    void StartConsoleSixAxisSensor(Kernel::HLERequestContext& ctx);
-    void StopConsoleSixAxisSensor(Kernel::HLERequestContext& ctx);
-    void ActivateSevenSixAxisSensor(Kernel::HLERequestContext& ctx);
-    void StartSevenSixAxisSensor(Kernel::HLERequestContext& ctx);
-    void StopSevenSixAxisSensor(Kernel::HLERequestContext& ctx);
-    void InitializeSevenSixAxisSensor(Kernel::HLERequestContext& ctx);
-    void FinalizeSevenSixAxisSensor(Kernel::HLERequestContext& ctx);
-    void ResetSevenSixAxisSensorTimestamp(Kernel::HLERequestContext& ctx);
+    void StopSixAxisSensor(Kernel::HLERequestContext& ctx);
    void SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx);
    void SetPalmaBoostMode(Kernel::HLERequestContext& ctx);
+    void StopSevenSixAxisSensor(Kernel::HLERequestContext& ctx);
+    void InitializeSevenSixAxisSensor(Kernel::HLERequestContext& ctx);

    std::shared_ptr<IAppletResource> applet_resource;
    Core::System& system;
--- a/src/core/hle/service/lm/manager.cpp
+++ b/src/core/hle/service/lm/manager.cpp
@@ -86,8 +86,7 @@ std::string FormatField(Field type, const std::vector<u8>& data) {
        return Common::StringFromFixedZeroTerminatedBuffer(
            reinterpret_cast<const char*>(data.data()), data.size());
    default:
-        UNIMPLEMENTED_MSG("Unimplemented field type={}", type);
-        return "";
+        UNIMPLEMENTED();
    }
 }

--- a/src/core/hle/service/nifm/nifm.cpp
+++ b/src/core/hle/service/nifm/nifm.cpp
@@ -177,8 +177,7 @@ private:
    void CreateTemporaryNetworkProfile(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_NIFM, "called");

-        ASSERT_MSG(ctx.GetReadBufferSize() == 0x17c,
-                   "SfNetworkProfileData is not the correct size");
+        ASSERT_MSG(ctx.GetReadBufferSize() == 0x17c, "NetworkProfileData is not the correct size");
        u128 uuid{};
        auto buffer = ctx.ReadBuffer();
        std::memcpy(&uuid, buffer.data() + 8, sizeof(u128));
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
@@ -25,7 +25,7 @@ u32 nvhost_ctrl_gpu::ioctl(Ioctl command, const std::vector<u8>& input,
    case IoctlCommand::IocGetCharacteristicsCommand:
        return GetCharacteristics(input, output, output2, version);
    case IoctlCommand::IocGetTPCMasksCommand:
-        return GetTPCMasks(input, output, output2, version);
+        return GetTPCMasks(input, output);
    case IoctlCommand::IocGetActiveSlotMaskCommand:
        return GetActiveSlotMask(input, output);
    case IoctlCommand::IocZcullGetCtxSizeCommand:
@@ -98,22 +98,17 @@ u32 nvhost_ctrl_gpu::GetCharacteristics(const std::vector<u8>& input, std::vecto
    return 0;
 }

-u32 nvhost_ctrl_gpu::GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output,
-                                 std::vector<u8>& output2, IoctlVersion version) {
+u32 nvhost_ctrl_gpu::GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output) {
    IoctlGpuGetTpcMasksArgs params{};
    std::memcpy(&params, input.data(), input.size());
-    LOG_DEBUG(Service_NVDRV, "called, mask_buffer_size=0x{:X}", params.mask_buffer_size);
-    if (params.mask_buffer_size != 0) {
-        params.tcp_mask = 3;
-    }
-
-    if (version == IoctlVersion::Version3) {
-        std::memcpy(output.data(), input.data(), output.size());
-        std::memcpy(output2.data(), &params.tcp_mask, output2.size());
-    } else {
-        std::memcpy(output.data(), &params, output.size());
-    }
-
+    LOG_INFO(Service_NVDRV, "called, mask=0x{:X}, mask_buf_addr=0x{:X}", params.mask_buf_size,
+             params.mask_buf_addr);
+    // TODO(ogniK): Confirm value on hardware
+    if (params.mask_buf_size)
+        params.tpc_mask_size = 4 * 1; // 4 * num_gpc
+    else
+        params.tpc_mask_size = 0;
+    std::memcpy(output.data(), &params, sizeof(params));
    return 0;
 }

--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl_gpu.h
@@ -92,11 +92,16 @@ private:
                  "IoctlCharacteristics is incorrect size");

    struct IoctlGpuGetTpcMasksArgs {
-        u32_le mask_buffer_size{};
-        INSERT_PADDING_WORDS(1);
-        u64_le mask_buffer_address{};
-        u32_le tcp_mask{};
-        INSERT_PADDING_WORDS(1);
+        /// [in]  TPC mask buffer size reserved by userspace. Should be at least
+        /// sizeof(__u32) * fls(gpc_mask) to receive TPC mask for each GPC.
+        /// [out] full kernel buffer size
+        u32_le mask_buf_size;
+        u32_le reserved;
+
+        /// [in]  pointer to TPC mask buffer. It will receive one 32-bit TPC mask per GPC or 0 if
+        /// GPC is not enabled or not present. This parameter is ignored if mask_buf_size is 0.
+        u64_le mask_buf_addr;
+        u64_le tpc_mask_size; // Nintendo add this?
    };
    static_assert(sizeof(IoctlGpuGetTpcMasksArgs) == 24,
                  "IoctlGpuGetTpcMasksArgs is incorrect size");
@@ -161,8 +166,7 @@ private:

    u32 GetCharacteristics(const std::vector<u8>& input, std::vector<u8>& output,
                           std::vector<u8>& output2, IoctlVersion version);
-    u32 GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output, std::vector<u8>& output2,
-                    IoctlVersion version);
+    u32 GetTPCMasks(const std::vector<u8>& input, std::vector<u8>& output);
    u32 GetActiveSlotMask(const std::vector<u8>& input, std::vector<u8>& output);
    u32 ZCullGetCtxSize(const std::vector<u8>& input, std::vector<u8>& output);
    u32 ZCullGetInfo(const std::vector<u8>& input, std::vector<u8>& output);
--- a/src/core/hle/service/nvflinger/buffer_queue.cpp
+++ b/src/core/hle/service/nvflinger/buffer_queue.cpp
@@ -138,7 +138,9 @@ u32 BufferQueue::Query(QueryType type) {

    switch (type) {
    case QueryType::NativeWindowFormat:
-        return static_cast<u32>(PixelFormat::RGBA8888);
+        // TODO(Subv): Use an enum for this
+        static constexpr u32 FormatABGR8 = 1;
+        return FormatABGR8;
    }

    UNIMPLEMENTED();
--- a/src/core/hle/service/nvflinger/buffer_queue.h
+++ b/src/core/hle/service/nvflinger/buffer_queue.h
@@ -66,16 +66,6 @@ public:
        Rotate270 = 0x07,
    };

-    enum class PixelFormat : u32 {
-        RGBA8888 = 1,
-        RGBX8888 = 2,
-        RGB888 = 3,
-        RGB565 = 4,
-        BGRA8888 = 5,
-        RGBA5551 = 6,
-        RRGBA4444 = 7,
-    };
-
    struct Buffer {
        enum class Status { Free = 0, Queued = 1, Dequeued = 2, Acquired = 3 };

--- a/src/core/hle/service/time/time_manager.cpp
+++ b/src/core/hle/service/time/time_manager.cpp
@@ -5,7 +5,6 @@
 #include <chrono>
 #include <ctime>

-#include "common/time_zone.h"
 #include "core/hle/service/time/ephemeral_network_system_clock_context_writer.h"
 #include "core/hle/service/time/local_system_clock_context_writer.h"
 #include "core/hle/service/time/network_system_clock_context_writer.h"
@@ -22,16 +21,8 @@ static std::chrono::seconds GetSecondsSinceEpoch() {
           Settings::values.custom_rtc_differential;
 }

-static s64 GetExternalTimeZoneOffset() {
-    // With "auto" timezone setting, we use the external system's timezone offset
-    if (Settings::GetTimeZoneString() == "auto") {
-        return Common::TimeZone::GetCurrentOffsetSeconds().count();
-    }
-    return 0;
-}
-
 static s64 GetExternalRtcValue() {
-    return GetSecondsSinceEpoch().count() + GetExternalTimeZoneOffset();
+    return GetSecondsSinceEpoch().count();
 }

 TimeManager::TimeManager(Core::System& system)
--- a/src/core/hle/service/time/time_zone_content_manager.cpp
+++ b/src/core/hle/service/time/time_zone_content_manager.cpp
@@ -5,7 +5,6 @@
 #include <sstream>

 #include "common/logging/log.h"
-#include "common/time_zone.h"
 #include "core/core.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
@@ -15,7 +14,6 @@
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/time/time_manager.h"
 #include "core/hle/service/time/time_zone_content_manager.h"
-#include "core/settings.h"

 namespace Service::Time::TimeZone {

@@ -70,22 +68,10 @@ static std::vector<std::string> BuildLocationNameCache(Core::System& system) {

 TimeZoneContentManager::TimeZoneContentManager(TimeManager& time_manager, Core::System& system)
    : system{system}, location_name_cache{BuildLocationNameCache(system)} {
-
-    std::string location_name;
-    const auto timezone_setting = Settings::GetTimeZoneString();
-    if (timezone_setting == "auto") {
-        location_name = Common::TimeZone::GetDefaultTimeZone();
-    } else if (timezone_setting == "default") {
-        location_name = location_name;
-    } else {
-        location_name = timezone_setting;
-    }
-
-    if (FileSys::VirtualFile vfs_file;
-        GetTimeZoneInfoFile(location_name, vfs_file) == RESULT_SUCCESS) {
+    if (FileSys::VirtualFile vfs_file; GetTimeZoneInfoFile("GMT", vfs_file) == RESULT_SUCCESS) {
        const auto time_point{
            time_manager.GetStandardSteadyClockCore().GetCurrentTimePoint(system)};
-        time_manager.SetupTimeZoneManager(location_name, time_point, location_name_cache.size(), {},
+        time_manager.SetupTimeZoneManager("GMT", time_point, location_name_cache.size(), {},
                                          vfs_file);
    } else {
        time_zone_manager.MarkAsInitialized();
@@ -127,12 +113,6 @@ ResultCode TimeZoneContentManager::GetTimeZoneInfoFile(const std::string& locati
    }

    vfs_file = zoneinfo_dir->GetFile(location_name);
-    if (!vfs_file) {
-        LOG_ERROR(Service_Time, "{:016X} has no file \"{}\"! Using default timezone.",
-                  time_zone_binary_titleid, location_name);
-        vfs_file = zoneinfo_dir->GetFile(Common::TimeZone::GetDefaultTimeZone());
-    }
-
    if (!vfs_file) {
        LOG_ERROR(Service_Time, "{:016X} has no file \"{}\"!", time_zone_binary_titleid,
                  location_name);
--- a/src/core/settings.cpp
+++ b/src/core/settings.cpp
@@ -63,21 +63,6 @@ const std::array<const char*, NumMouseButtons> mapping = {{

 Values values = {};

-std::string GetTimeZoneString() {
-    static constexpr std::array<const char*, 46> timezones{{
-        "auto",      "default",   "CET", "CST6CDT", "Cuba",    "EET",    "Egypt",     "Eire",
-        "EST",       "EST5EDT",   "GB",  "GB-Eire", "GMT",     "GMT+0",  "GMT-0",     "GMT0",
-        "Greenwich", "Hongkong",  "HST", "Iceland", "Iran",    "Israel", "Jamaica",   "Japan",
-        "Kwajalein", "Libya",     "MET", "MST",     "MST7MDT", "Navajo", "NZ",        "NZ-CHAT",
-        "Poland",    "Portugal",  "PRC", "PST8PDT", "ROC",     "ROK",    "Singapore", "Turkey",
-        "UCT",       "Universal", "UTC", "W-SU",    "WET",     "Zulu",
-    }};
-
-    ASSERT(Settings::values.time_zone_index < timezones.size());
-
-    return timezones[Settings::values.time_zone_index];
-}
-
 void Apply() {
    GDBStub::SetServerPort(values.gdbstub_port);
    GDBStub::ToggleServer(values.use_gdbstub);
@@ -102,18 +87,17 @@ void LogSettings() {
    LogSetting("System_CurrentUser", Settings::values.current_user);
    LogSetting("System_LanguageIndex", Settings::values.language_index);
    LogSetting("System_RegionIndex", Settings::values.region_index);
-    LogSetting("System_TimeZoneIndex", Settings::values.time_zone_index);
    LogSetting("Core_UseMultiCore", Settings::values.use_multi_core);
    LogSetting("Renderer_UseResolutionFactor", Settings::values.resolution_factor);
    LogSetting("Renderer_UseFrameLimit", Settings::values.use_frame_limit);
    LogSetting("Renderer_FrameLimit", Settings::values.frame_limit);
    LogSetting("Renderer_UseDiskShaderCache", Settings::values.use_disk_shader_cache);
-    LogSetting("Renderer_GPUAccuracyLevel", Settings::values.gpu_accuracy);
+    LogSetting("Renderer_GPUAccuracyLevel", GPUAccuracyLevelToChar(Settings::values.gpu_accuracy));
    LogSetting("Renderer_UseAsynchronousGpuEmulation",
               Settings::values.use_asynchronous_gpu_emulation);
    LogSetting("Renderer_UseVsync", Settings::values.use_vsync);
-    LogSetting("Renderer_UseAssemblyShaders", Settings::values.use_assembly_shaders);
-    LogSetting("Renderer_AnisotropicFilteringLevel", Settings::values.max_anisotropy);
+    LogSetting("Renderer_AnisotropicFilteringLevel",
+               AnisotropicFilteringLevelToChar(Settings::values.max_anisotropy));
    LogSetting("Audio_OutputEngine", Settings::values.sink_id);
    LogSetting("Audio_EnableAudioStretching", Settings::values.enable_audio_stretching);
    LogSetting("Audio_OutputDevice", Settings::values.audio_device_id);
@@ -127,6 +111,33 @@ void LogSettings() {
    LogSetting("Services_BCATBoxcatLocal", Settings::values.bcat_boxcat_local);
 }

+const char* GPUAccuracyLevelToChar(GPUAccuracy gpu_accuracy) {
+    switch (gpu_accuracy) {
+    case GPUAccuracy::Normal:
+        return "Normal";
+    case GPUAccuracy::High:
+        return "High";
+    case GPUAccuracy::Extreme:
+        return "Extreme";
+    }
+    return "Unknown";
+}
+
+const char* AnisotropicFilteringLevelToChar(Anisotropy anisotropy) {
+    switch (anisotropy) {
+    case Anisotropy::Default:
+        return "Default";
+    case Anisotropy::Filter2x:
+        return "2x";
+    case Anisotropy::Filter4x:
+        return "4x";
+    case Anisotropy::Filter8x:
+        return "8x";
+    case Anisotropy::Filter16x:
+        return "16x";
+    }
+}
+
 bool IsGPULevelExtreme() {
    return values.gpu_accuracy == GPUAccuracy::Extreme;
 }
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -382,6 +382,14 @@ enum class GPUAccuracy : u32 {
    Extreme = 2,
 };

+enum class Anisotropy {
+    Default = 0,
+    Filter2x = 1,
+    Filter4x = 2,
+    Filter8x = 3,
+    Filter16x = 4,
+};
+
 struct Values {
    // System
    bool use_docked_mode;
@@ -394,7 +402,6 @@ struct Values {
    s32 current_user;
    s32 language_index;
    s32 region_index;
-    s32 time_zone_index;
    s32 sound_index;

    // Controls
@@ -437,16 +444,15 @@ struct Values {
    bool renderer_debug;
    int vulkan_device;

-    u16 resolution_factor{1};
+    float resolution_factor;
    int aspect_ratio;
-    int max_anisotropy;
+    Anisotropy max_anisotropy;
    bool use_frame_limit;
    u16 frame_limit;
    bool use_disk_shader_cache;
    GPUAccuracy gpu_accuracy;
    bool use_asynchronous_gpu_emulation;
    bool use_vsync;
-    bool use_assembly_shaders;
    bool force_30fps_mode;
    bool use_fast_gpu_time;

@@ -474,7 +480,6 @@ struct Values {
    bool reporting_services;
    bool quest_flag;
    bool disable_cpu_opt;
-    bool disable_macro_jit;

    // BCAT
    std::string bcat_backend;
@@ -490,12 +495,13 @@ struct Values {
    std::map<u64, std::vector<std::string>> disabled_addons;
 } extern values;

+const char* GPUAccuracyLevelToChar(GPUAccuracy gpu_accuracy);
+
+const char* AnisotropicFilteringLevelToChar(Anisotropy anisotropy);
+
 bool IsGPULevelExtreme();
 bool IsGPULevelHigh();

-std::string GetTimeZoneString();
-
 void Apply();
 void LogSettings();
-
 } // namespace Settings
--- a/src/core/telemetry_session.cpp
+++ b/src/core/telemetry_session.cpp
@@ -201,7 +201,6 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
    AddField(field_type, "Renderer_UseAsynchronousGpuEmulation",
             Settings::values.use_asynchronous_gpu_emulation);
    AddField(field_type, "Renderer_UseVsync", Settings::values.use_vsync);
-    AddField(field_type, "Renderer_UseAssemblyShaders", Settings::values.use_assembly_shaders);
    AddField(field_type, "System_UseDockedMode", Settings::values.use_docked_mode);
 }

--- a/src/input_common/keyboard.cpp
+++ b/src/input_common/keyboard.cpp
@@ -76,7 +76,7 @@ std::unique_ptr<Input::ButtonDevice> Keyboard::Create(const Common::ParamPackage
    int key_code = params.Get("code", 0);
    std::unique_ptr<KeyButton> button = std::make_unique<KeyButton>(key_button_list);
    key_button_list->AddKeyButton(key_code, button.get());
-    return button;
+    return std::move(button);
 }

 void Keyboard::PressKey(int key_code) {
--- a/src/input_common/motion_emu.cpp
+++ b/src/input_common/motion_emu.cpp
@@ -145,7 +145,7 @@ std::unique_ptr<Input::MotionDevice> MotionEmu::Create(const Common::ParamPackag
    // Previously created device is disconnected here. Having two motion devices for 3DS is not
    // expected.
    current_device = device_wrapper->device;
-    return device_wrapper;
+    return std::move(device_wrapper);
 }

 void MotionEmu::BeginTilt(int x, int y) {
--- a/src/video_core/CMakeLists.txt
+++ b/src/video_core/CMakeLists.txt
@@ -1,7 +1,6 @@
 add_library(video_core STATIC
    buffer_cache/buffer_block.h
    buffer_cache/buffer_cache.h
-    buffer_cache/map_interval.cpp
    buffer_cache/map_interval.h
    dirty_flags.cpp
    dirty_flags.h
@@ -25,14 +24,6 @@ add_library(video_core STATIC
    engines/shader_bytecode.h
    engines/shader_header.h
    engines/shader_type.h
-    macro/macro.cpp
-    macro/macro.h
-    macro/macro_hle.cpp
-    macro/macro_hle.h
-    macro/macro_interpreter.cpp
-    macro/macro_interpreter.h
-    macro/macro_jit_x64.cpp
-    macro/macro_jit_x64.h
    fence_manager.h
    gpu.cpp
    gpu.h
@@ -44,6 +35,8 @@ add_library(video_core STATIC
    gpu_thread.h
    guest_driver.cpp
    guest_driver.h
+    macro_interpreter.cpp
+    macro_interpreter.h
    memory_manager.cpp
    memory_manager.h
    morton.cpp
@@ -51,11 +44,11 @@ add_library(video_core STATIC
    query_cache.h
    rasterizer_accelerated.cpp
    rasterizer_accelerated.h
+    rasterizer_cache.cpp
+    rasterizer_cache.h
    rasterizer_interface.h
    renderer_base.cpp
    renderer_base.h
-    renderer_opengl/gl_arb_decompiler.cpp
-    renderer_opengl/gl_arb_decompiler.h
    renderer_opengl/gl_buffer_cache.cpp
    renderer_opengl/gl_buffer_cache.h
    renderer_opengl/gl_device.cpp
@@ -95,7 +88,6 @@ add_library(video_core STATIC
    renderer_opengl/utils.h
    sampler_cache.cpp
    sampler_cache.h
-    shader_cache.h
    shader/decode/arithmetic.cpp
    shader/decode/arithmetic_immediate.cpp
    shader/decode/bfe.cpp
@@ -236,7 +228,7 @@ endif()
 create_target_directory_groups(video_core)

 target_link_libraries(video_core PUBLIC common core)
-target_link_libraries(video_core PRIVATE glad xbyak)
+target_link_libraries(video_core PRIVATE glad)

 if (ENABLE_VULKAN)
    target_include_directories(video_core PRIVATE sirit ../../externals/Vulkan-Headers/include)
--- a/src/video_core/buffer_cache/buffer_block.h
+++ b/src/video_core/buffer_cache/buffer_block.h
@@ -15,48 +15,49 @@ namespace VideoCommon {

 class BufferBlock {
 public:
-    bool Overlaps(VAddr start, VAddr end) const {
+    bool Overlaps(const VAddr start, const VAddr end) const {
        return (cpu_addr < end) && (cpu_addr_end > start);
    }

-    bool IsInside(VAddr other_start, VAddr other_end) const {
+    bool IsInside(const VAddr other_start, const VAddr other_end) const {
        return cpu_addr <= other_start && other_end <= cpu_addr_end;
    }

-    std::size_t Offset(VAddr in_addr) const {
+    std::size_t GetOffset(const VAddr in_addr) {
        return static_cast<std::size_t>(in_addr - cpu_addr);
    }

-    VAddr CpuAddr() const {
+    VAddr GetCpuAddr() const {
        return cpu_addr;
    }

-    VAddr CpuAddrEnd() const {
+    VAddr GetCpuAddrEnd() const {
        return cpu_addr_end;
    }

-    void SetCpuAddr(VAddr new_addr) {
+    void SetCpuAddr(const VAddr new_addr) {
        cpu_addr = new_addr;
        cpu_addr_end = new_addr + size;
    }

-    std::size_t Size() const {
+    std::size_t GetSize() const {
        return size;
    }

-    u64 Epoch() const {
-        return epoch;
-    }
-
    void SetEpoch(u64 new_epoch) {
        epoch = new_epoch;
    }

-protected:
-    explicit BufferBlock(VAddr cpu_addr_, std::size_t size_) : size{size_} {
-        SetCpuAddr(cpu_addr_);
+    u64 GetEpoch() {
+        return epoch;
    }

+protected:
+    explicit BufferBlock(VAddr cpu_addr, const std::size_t size) : size{size} {
+        SetCpuAddr(cpu_addr);
+    }
+    ~BufferBlock() = default;
+
 private:
    VAddr cpu_addr{};
    VAddr cpu_addr_end{};
--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@@ -12,12 +12,11 @@
 #include <utility>
 #include <vector>

-#include <boost/container/small_vector.hpp>
+#include <boost/icl/interval_map.hpp>
 #include <boost/icl/interval_set.hpp>
-#include <boost/intrusive/set.hpp>
+#include <boost/range/iterator_range.hpp>

 #include "common/alignment.h"
-#include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/core.h"
@@ -30,124 +29,102 @@

 namespace VideoCommon {

-template <typename Buffer, typename BufferType, typename StreamBuffer>
+using MapInterval = std::shared_ptr<MapIntervalBase>;
+
+template <typename OwnerBuffer, typename BufferType, typename StreamBuffer>
 class BufferCache {
-    using IntervalSet = boost::icl::interval_set<VAddr>;
-    using IntervalType = typename IntervalSet::interval_type;
-    using VectorMapInterval = boost::container::small_vector<MapInterval*, 1>;
-
-    static constexpr u64 WRITE_PAGE_BIT = 11;
-    static constexpr u64 BLOCK_PAGE_BITS = 21;
-    static constexpr u64 BLOCK_PAGE_SIZE = 1ULL << BLOCK_PAGE_BITS;
-
 public:
-    struct BufferInfo {
-        BufferType handle;
-        u64 offset;
-        u64 address;
-    };
+    using BufferInfo = std::pair<BufferType, u64>;

    BufferInfo UploadMemory(GPUVAddr gpu_addr, std::size_t size, std::size_t alignment = 4,
                            bool is_written = false, bool use_fast_cbuf = false) {
        std::lock_guard lock{mutex};

-        auto& memory_manager = system.GPU().MemoryManager();
-        const std::optional<VAddr> cpu_addr_opt = memory_manager.GpuToCpuAddress(gpu_addr);
+        const std::optional<VAddr> cpu_addr_opt =
+            system.GPU().MemoryManager().GpuToCpuAddress(gpu_addr);
+
        if (!cpu_addr_opt) {
-            return GetEmptyBuffer(size);
+            return {GetEmptyBuffer(size), 0};
        }
-        const VAddr cpu_addr = *cpu_addr_opt;
+
+        VAddr cpu_addr = *cpu_addr_opt;

        // Cache management is a big overhead, so only cache entries with a given size.
        // TODO: Figure out which size is the best for given games.
        constexpr std::size_t max_stream_size = 0x800;
        if (use_fast_cbuf || size < max_stream_size) {
            if (!is_written && !IsRegionWritten(cpu_addr, cpu_addr + size - 1)) {
-                const bool is_granular = memory_manager.IsGranularRange(gpu_addr, size);
+                auto& memory_manager = system.GPU().MemoryManager();
                if (use_fast_cbuf) {
-                    u8* dest;
-                    if (is_granular) {
-                        dest = memory_manager.GetPointer(gpu_addr);
+                    if (memory_manager.IsGranularRange(gpu_addr, size)) {
+                        const auto host_ptr = memory_manager.GetPointer(gpu_addr);
+                        return ConstBufferUpload(host_ptr, size);
                    } else {
                        staging_buffer.resize(size);
-                        dest = staging_buffer.data();
-                        memory_manager.ReadBlockUnsafe(gpu_addr, dest, size);
+                        memory_manager.ReadBlockUnsafe(gpu_addr, staging_buffer.data(), size);
+                        return ConstBufferUpload(staging_buffer.data(), size);
                    }
-                    return ConstBufferUpload(dest, size);
-                }
-                if (is_granular) {
-                    u8* const host_ptr = memory_manager.GetPointer(gpu_addr);
-                    return StreamBufferUpload(size, alignment, [host_ptr, size](u8* dest) {
-                        std::memcpy(dest, host_ptr, size);
-                    });
                } else {
-                    return StreamBufferUpload(
-                        size, alignment, [&memory_manager, gpu_addr, size](u8* dest) {
-                            memory_manager.ReadBlockUnsafe(gpu_addr, dest, size);
-                        });
+                    if (memory_manager.IsGranularRange(gpu_addr, size)) {
+                        const auto host_ptr = memory_manager.GetPointer(gpu_addr);
+                        return StreamBufferUpload(host_ptr, size, alignment);
+                    } else {
+                        staging_buffer.resize(size);
+                        memory_manager.ReadBlockUnsafe(gpu_addr, staging_buffer.data(), size);
+                        return StreamBufferUpload(staging_buffer.data(), size, alignment);
+                    }
                }
            }
        }

-        Buffer* const block = GetBlock(cpu_addr, size);
-        MapInterval* const map = MapAddress(block, gpu_addr, cpu_addr, size);
-        if (!map) {
-            return GetEmptyBuffer(size);
-        }
+        auto block = GetBlock(cpu_addr, size);
+        auto map = MapAddress(block, gpu_addr, cpu_addr, size);
        if (is_written) {
            map->MarkAsModified(true, GetModifiedTicks());
            if (Settings::IsGPULevelHigh() && Settings::values.use_asynchronous_gpu_emulation) {
                MarkForAsyncFlush(map);
            }
-            if (!map->is_written) {
-                map->is_written = true;
-                MarkRegionAsWritten(map->start, map->end - 1);
+            if (!map->IsWritten()) {
+                map->MarkAsWritten(true);
+                MarkRegionAsWritten(map->GetStart(), map->GetEnd() - 1);
            }
        }

-        return BufferInfo{block->Handle(), block->Offset(cpu_addr), block->Address()};
+        return {ToHandle(block), static_cast<u64>(block->GetOffset(cpu_addr))};
    }

    /// Uploads from a host memory. Returns the OpenGL buffer where it's located and its offset.
    BufferInfo UploadHostMemory(const void* raw_pointer, std::size_t size,
                                std::size_t alignment = 4) {
        std::lock_guard lock{mutex};
-        return StreamBufferUpload(size, alignment, [raw_pointer, size](u8* dest) {
-            std::memcpy(dest, raw_pointer, size);
-        });
+        return StreamBufferUpload(raw_pointer, size, alignment);
    }

-    /// Prepares the buffer cache for data uploading
-    /// @param max_size Maximum number of bytes that will be uploaded
-    /// @return True when a stream buffer invalidation was required, false otherwise
-    bool Map(std::size_t max_size) {
+    void Map(std::size_t max_size) {
        std::lock_guard lock{mutex};

-        bool invalidated;
        std::tie(buffer_ptr, buffer_offset_base, invalidated) = stream_buffer->Map(max_size, 4);
        buffer_offset = buffer_offset_base;
-
-        return invalidated;
    }

-    /// Finishes the upload stream
-    void Unmap() {
+    /// Finishes the upload stream, returns true on bindings invalidation.
+    bool Unmap() {
        std::lock_guard lock{mutex};
+
        stream_buffer->Unmap(buffer_offset - buffer_offset_base);
+        return std::exchange(invalidated, false);
    }

-    /// Function called at the end of each frame, inteded for deferred operations
    void TickFrame() {
        ++epoch;
-
        while (!pending_destruction.empty()) {
            // Delay at least 4 frames before destruction.
            // This is due to triple buffering happening on some drivers.
            static constexpr u64 epochs_to_destroy = 5;
-            if (pending_destruction.front()->Epoch() + epochs_to_destroy > epoch) {
+            if (pending_destruction.front()->GetEpoch() + epochs_to_destroy > epoch) {
                break;
            }
-            pending_destruction.pop();
+            pending_destruction.pop_front();
        }
    }

@@ -155,11 +132,12 @@ public:
    void FlushRegion(VAddr addr, std::size_t size) {
        std::lock_guard lock{mutex};

-        VectorMapInterval objects = GetMapsInRange(addr, size);
-        std::sort(objects.begin(), objects.end(),
-                  [](MapInterval* lhs, MapInterval* rhs) { return lhs->ticks < rhs->ticks; });
-        for (MapInterval* object : objects) {
-            if (object->is_modified && object->is_registered) {
+        std::vector<MapInterval> objects = GetMapsInRange(addr, size);
+        std::sort(objects.begin(), objects.end(), [](const MapInterval& a, const MapInterval& b) {
+            return a->GetModificationTick() < b->GetModificationTick();
+        });
+        for (auto& object : objects) {
+            if (object->IsModified() && object->IsRegistered()) {
                mutex.unlock();
                FlushMap(object);
                mutex.lock();
@@ -170,9 +148,9 @@ public:
    bool MustFlushRegion(VAddr addr, std::size_t size) {
        std::lock_guard lock{mutex};

-        const VectorMapInterval objects = GetMapsInRange(addr, size);
-        return std::any_of(objects.cbegin(), objects.cend(), [](const MapInterval* map) {
-            return map->is_modified && map->is_registered;
+        const std::vector<MapInterval> objects = GetMapsInRange(addr, size);
+        return std::any_of(objects.cbegin(), objects.cend(), [](const MapInterval& map) {
+            return map->IsModified() && map->IsRegistered();
        });
    }

@@ -180,8 +158,9 @@ public:
    void InvalidateRegion(VAddr addr, u64 size) {
        std::lock_guard lock{mutex};

-        for (auto& object : GetMapsInRange(addr, size)) {
-            if (object->is_registered) {
+        std::vector<MapInterval> objects = GetMapsInRange(addr, size);
+        for (auto& object : objects) {
+            if (object->IsRegistered()) {
                Unregister(object);
            }
        }
@@ -190,10 +169,10 @@ public:
    void OnCPUWrite(VAddr addr, std::size_t size) {
        std::lock_guard lock{mutex};

-        for (MapInterval* object : GetMapsInRange(addr, size)) {
-            if (object->is_memory_marked && object->is_registered) {
+        for (const auto& object : GetMapsInRange(addr, size)) {
+            if (object->IsMemoryMarked() && object->IsRegistered()) {
                UnmarkMemory(object);
-                object->is_sync_pending = true;
+                object->SetSyncPending(true);
                marked_for_unregister.emplace_back(object);
            }
        }
@@ -202,9 +181,9 @@ public:
    void SyncGuestHost() {
        std::lock_guard lock{mutex};

-        for (auto& object : marked_for_unregister) {
-            if (object->is_registered) {
-                object->is_sync_pending = false;
+        for (const auto& object : marked_for_unregister) {
+            if (object->IsRegistered()) {
+                object->SetSyncPending(false);
                Unregister(object);
            }
        }
@@ -213,9 +192,9 @@ public:

    void CommitAsyncFlushes() {
        if (uncommitted_flushes) {
-            auto commit_list = std::make_shared<std::list<MapInterval*>>();
-            for (MapInterval* map : *uncommitted_flushes) {
-                if (map->is_registered && map->is_modified) {
+            auto commit_list = std::make_shared<std::list<MapInterval>>();
+            for (auto& map : *uncommitted_flushes) {
+                if (map->IsRegistered() && map->IsModified()) {
                    // TODO(Blinkhawk): Implement backend asynchronous flushing
                    // AsyncFlushMap(map)
                    commit_list->push_back(map);
@@ -249,8 +228,8 @@ public:
            committed_flushes.pop_front();
            return;
        }
-        for (MapInterval* map : *flush_list) {
-            if (map->is_registered) {
+        for (MapInterval& map : *flush_list) {
+            if (map->IsRegistered()) {
                // TODO(Blinkhawk): Replace this for reading the asynchronous flush
                FlushMap(map);
            }
@@ -258,90 +237,104 @@ public:
        committed_flushes.pop_front();
    }

-    virtual BufferInfo GetEmptyBuffer(std::size_t size) = 0;
+    virtual BufferType GetEmptyBuffer(std::size_t size) = 0;

 protected:
    explicit BufferCache(VideoCore::RasterizerInterface& rasterizer, Core::System& system,
                         std::unique_ptr<StreamBuffer> stream_buffer)
-        : rasterizer{rasterizer}, system{system}, stream_buffer{std::move(stream_buffer)} {}
+        : rasterizer{rasterizer}, system{system}, stream_buffer{std::move(stream_buffer)},
+          stream_buffer_handle{this->stream_buffer->GetHandle()} {}

    ~BufferCache() = default;

-    virtual std::shared_ptr<Buffer> CreateBlock(VAddr cpu_addr, std::size_t size) = 0;
+    virtual BufferType ToHandle(const OwnerBuffer& storage) = 0;
+
+    virtual OwnerBuffer CreateBlock(VAddr cpu_addr, std::size_t size) = 0;
+
+    virtual void UploadBlockData(const OwnerBuffer& buffer, std::size_t offset, std::size_t size,
+                                 const u8* data) = 0;
+
+    virtual void DownloadBlockData(const OwnerBuffer& buffer, std::size_t offset, std::size_t size,
+                                   u8* data) = 0;
+
+    virtual void CopyBlock(const OwnerBuffer& src, const OwnerBuffer& dst, std::size_t src_offset,
+                           std::size_t dst_offset, std::size_t size) = 0;

    virtual BufferInfo ConstBufferUpload(const void* raw_pointer, std::size_t size) {
        return {};
    }

    /// Register an object into the cache
-    MapInterval* Register(MapInterval new_map, bool inherit_written = false) {
-        const VAddr cpu_addr = new_map.start;
+    void Register(const MapInterval& new_map, bool inherit_written = false) {
+        const VAddr cpu_addr = new_map->GetStart();
        if (!cpu_addr) {
            LOG_CRITICAL(HW_GPU, "Failed to register buffer with unmapped gpu_address 0x{:016x}",
-                         new_map.gpu_addr);
-            return nullptr;
-        }
-        const std::size_t size = new_map.end - new_map.start;
-        new_map.is_registered = true;
-        rasterizer.UpdatePagesCachedCount(cpu_addr, size, 1);
-        new_map.is_memory_marked = true;
-        if (inherit_written) {
-            MarkRegionAsWritten(new_map.start, new_map.end - 1);
-            new_map.is_written = true;
-        }
-        MapInterval* const storage = mapped_addresses_allocator.Allocate();
-        *storage = new_map;
-        mapped_addresses.insert(*storage);
-        return storage;
-    }
-
-    void UnmarkMemory(MapInterval* map) {
-        if (!map->is_memory_marked) {
+                         new_map->GetGpuAddress());
            return;
        }
-        const std::size_t size = map->end - map->start;
-        rasterizer.UpdatePagesCachedCount(map->start, size, -1);
-        map->is_memory_marked = false;
+        const std::size_t size = new_map->GetEnd() - new_map->GetStart();
+        new_map->MarkAsRegistered(true);
+        const IntervalType interval{new_map->GetStart(), new_map->GetEnd()};
+        mapped_addresses.insert({interval, new_map});
+        rasterizer.UpdatePagesCachedCount(cpu_addr, size, 1);
+        new_map->SetMemoryMarked(true);
+        if (inherit_written) {
+            MarkRegionAsWritten(new_map->GetStart(), new_map->GetEnd() - 1);
+            new_map->MarkAsWritten(true);
+        }
+    }
+
+    void UnmarkMemory(const MapInterval& map) {
+        if (!map->IsMemoryMarked()) {
+            return;
+        }
+        const std::size_t size = map->GetEnd() - map->GetStart();
+        rasterizer.UpdatePagesCachedCount(map->GetStart(), size, -1);
+        map->SetMemoryMarked(false);
    }

    /// Unregisters an object from the cache
-    void Unregister(MapInterval* map) {
+    void Unregister(const MapInterval& map) {
        UnmarkMemory(map);
-        map->is_registered = false;
-        if (map->is_sync_pending) {
-            map->is_sync_pending = false;
+        map->MarkAsRegistered(false);
+        if (map->IsSyncPending()) {
            marked_for_unregister.remove(map);
+            map->SetSyncPending(false);
        }
-        if (map->is_written) {
-            UnmarkRegionAsWritten(map->start, map->end - 1);
+        if (map->IsWritten()) {
+            UnmarkRegionAsWritten(map->GetStart(), map->GetEnd() - 1);
        }
-        const auto it = mapped_addresses.find(*map);
-        ASSERT(it != mapped_addresses.end());
-        mapped_addresses.erase(it);
-        mapped_addresses_allocator.Release(map);
+        const IntervalType delete_interval{map->GetStart(), map->GetEnd()};
+        mapped_addresses.erase(delete_interval);
    }

 private:
-    MapInterval* MapAddress(const Buffer* block, GPUVAddr gpu_addr, VAddr cpu_addr,
-                            std::size_t size) {
-        const VectorMapInterval overlaps = GetMapsInRange(cpu_addr, size);
+    MapInterval CreateMap(const VAddr start, const VAddr end, const GPUVAddr gpu_addr) {
+        return std::make_shared<MapIntervalBase>(start, end, gpu_addr);
+    }
+
+    MapInterval MapAddress(const OwnerBuffer& block, const GPUVAddr gpu_addr, const VAddr cpu_addr,
+                           const std::size_t size) {
+        std::vector<MapInterval> overlaps = GetMapsInRange(cpu_addr, size);
        if (overlaps.empty()) {
            auto& memory_manager = system.GPU().MemoryManager();
            const VAddr cpu_addr_end = cpu_addr + size;
+            MapInterval new_map = CreateMap(cpu_addr, cpu_addr_end, gpu_addr);
            if (memory_manager.IsGranularRange(gpu_addr, size)) {
                u8* host_ptr = memory_manager.GetPointer(gpu_addr);
-                block->Upload(block->Offset(cpu_addr), size, host_ptr);
+                UploadBlockData(block, block->GetOffset(cpu_addr), size, host_ptr);
            } else {
                staging_buffer.resize(size);
                memory_manager.ReadBlockUnsafe(gpu_addr, staging_buffer.data(), size);
-                block->Upload(block->Offset(cpu_addr), size, staging_buffer.data());
+                UploadBlockData(block, block->GetOffset(cpu_addr), size, staging_buffer.data());
            }
-            return Register(MapInterval(cpu_addr, cpu_addr_end, gpu_addr));
+            Register(new_map);
+            return new_map;
        }

        const VAddr cpu_addr_end = cpu_addr + size;
        if (overlaps.size() == 1) {
-            MapInterval* const current_map = overlaps[0];
+            MapInterval& current_map = overlaps[0];
            if (current_map->IsInside(cpu_addr, cpu_addr_end)) {
                return current_map;
            }
@@ -351,70 +344,60 @@ private:
        bool write_inheritance = false;
        bool modified_inheritance = false;
        // Calculate new buffer parameters
-        for (MapInterval* overlap : overlaps) {
-            new_start = std::min(overlap->start, new_start);
-            new_end = std::max(overlap->end, new_end);
-            write_inheritance |= overlap->is_written;
-            modified_inheritance |= overlap->is_modified;
+        for (auto& overlap : overlaps) {
+            new_start = std::min(overlap->GetStart(), new_start);
+            new_end = std::max(overlap->GetEnd(), new_end);
+            write_inheritance |= overlap->IsWritten();
+            modified_inheritance |= overlap->IsModified();
        }
        GPUVAddr new_gpu_addr = gpu_addr + new_start - cpu_addr;
        for (auto& overlap : overlaps) {
            Unregister(overlap);
        }
        UpdateBlock(block, new_start, new_end, overlaps);
-
-        const MapInterval new_map{new_start, new_end, new_gpu_addr};
-        MapInterval* const map = Register(new_map, write_inheritance);
-        if (!map) {
-            return nullptr;
-        }
+        MapInterval new_map = CreateMap(new_start, new_end, new_gpu_addr);
        if (modified_inheritance) {
-            map->MarkAsModified(true, GetModifiedTicks());
+            new_map->MarkAsModified(true, GetModifiedTicks());
            if (Settings::IsGPULevelHigh() && Settings::values.use_asynchronous_gpu_emulation) {
-                MarkForAsyncFlush(map);
+                MarkForAsyncFlush(new_map);
            }
        }
-        return map;
+        Register(new_map, write_inheritance);
+        return new_map;
    }

-    void UpdateBlock(const Buffer* block, VAddr start, VAddr end,
-                     const VectorMapInterval& overlaps) {
+    void UpdateBlock(const OwnerBuffer& block, VAddr start, VAddr end,
+                     std::vector<MapInterval>& overlaps) {
        const IntervalType base_interval{start, end};
        IntervalSet interval_set{};
        interval_set.add(base_interval);
        for (auto& overlap : overlaps) {
-            const IntervalType subtract{overlap->start, overlap->end};
+            const IntervalType subtract{overlap->GetStart(), overlap->GetEnd()};
            interval_set.subtract(subtract);
        }
        for (auto& interval : interval_set) {
-            const std::size_t size = interval.upper() - interval.lower();
-            if (size == 0) {
-                continue;
+            std::size_t size = interval.upper() - interval.lower();
+            if (size > 0) {
+                staging_buffer.resize(size);
+                system.Memory().ReadBlockUnsafe(interval.lower(), staging_buffer.data(), size);
+                UploadBlockData(block, block->GetOffset(interval.lower()), size,
+                                staging_buffer.data());
            }
-            staging_buffer.resize(size);
-            system.Memory().ReadBlockUnsafe(interval.lower(), staging_buffer.data(), size);
-            block->Upload(block->Offset(interval.lower()), size, staging_buffer.data());
        }
    }

-    VectorMapInterval GetMapsInRange(VAddr addr, std::size_t size) {
-        VectorMapInterval result;
+    std::vector<MapInterval> GetMapsInRange(VAddr addr, std::size_t size) {
        if (size == 0) {
-            return result;
+            return {};
        }

-        const VAddr addr_end = addr + size;
-        auto it = mapped_addresses.lower_bound(addr);
-        if (it != mapped_addresses.begin()) {
-            --it;
+        std::vector<MapInterval> objects{};
+        const IntervalType interval{addr, addr + size};
+        for (auto& pair : boost::make_iterator_range(mapped_addresses.equal_range(interval))) {
+            objects.push_back(pair.second);
        }
-        while (it != mapped_addresses.end() && it->start < addr_end) {
-            if (it->Overlaps(addr, addr_end)) {
-                result.push_back(&*it);
-            }
-            ++it;
-        }
-        return result;
+
+        return objects;
    }

    /// Returns a ticks counter used for tracking when cached objects were last modified
@@ -422,28 +405,24 @@ private:
        return ++modified_ticks;
    }

-    void FlushMap(MapInterval* map) {
-        const auto it = blocks.find(map->start >> BLOCK_PAGE_BITS);
-        ASSERT_OR_EXECUTE(it != blocks.end(), return;);
-
-        std::shared_ptr<Buffer> block = it->second;
-
-        const std::size_t size = map->end - map->start;
+    void FlushMap(MapInterval map) {
+        std::size_t size = map->GetEnd() - map->GetStart();
+        OwnerBuffer block = blocks[map->GetStart() >> block_page_bits];
        staging_buffer.resize(size);
-        block->Download(block->Offset(map->start), size, staging_buffer.data());
-        system.Memory().WriteBlockUnsafe(map->start, staging_buffer.data(), size);
+        DownloadBlockData(block, block->GetOffset(map->GetStart()), size, staging_buffer.data());
+        system.Memory().WriteBlockUnsafe(map->GetStart(), staging_buffer.data(), size);
        map->MarkAsModified(false, 0);
    }

-    template <typename Callable>
-    BufferInfo StreamBufferUpload(std::size_t size, std::size_t alignment, Callable&& callable) {
+    BufferInfo StreamBufferUpload(const void* raw_pointer, std::size_t size,
+                                  std::size_t alignment) {
        AlignBuffer(alignment);
        const std::size_t uploaded_offset = buffer_offset;
-        callable(buffer_ptr);
+        std::memcpy(buffer_ptr, raw_pointer, size);

        buffer_ptr += size;
        buffer_offset += size;
-        return BufferInfo{stream_buffer->Handle(), uploaded_offset, stream_buffer->Address()};
+        return {stream_buffer_handle, uploaded_offset};
    }

    void AlignBuffer(std::size_t alignment) {
@@ -453,89 +432,97 @@ private:
        buffer_offset = offset_aligned;
    }

-    std::shared_ptr<Buffer> EnlargeBlock(std::shared_ptr<Buffer> buffer) {
-        const std::size_t old_size = buffer->Size();
-        const std::size_t new_size = old_size + BLOCK_PAGE_SIZE;
-        const VAddr cpu_addr = buffer->CpuAddr();
-        std::shared_ptr<Buffer> new_buffer = CreateBlock(cpu_addr, new_size);
-        new_buffer->CopyFrom(*buffer, 0, 0, old_size);
-        QueueDestruction(std::move(buffer));
-
+    OwnerBuffer EnlargeBlock(OwnerBuffer buffer) {
+        const std::size_t old_size = buffer->GetSize();
+        const std::size_t new_size = old_size + block_page_size;
+        const VAddr cpu_addr = buffer->GetCpuAddr();
+        OwnerBuffer new_buffer = CreateBlock(cpu_addr, new_size);
+        CopyBlock(buffer, new_buffer, 0, 0, old_size);
+        buffer->SetEpoch(epoch);
+        pending_destruction.push_back(buffer);
        const VAddr cpu_addr_end = cpu_addr + new_size - 1;
-        const u64 page_end = cpu_addr_end >> BLOCK_PAGE_BITS;
-        for (u64 page_start = cpu_addr >> BLOCK_PAGE_BITS; page_start <= page_end; ++page_start) {
-            blocks.insert_or_assign(page_start, new_buffer);
+        u64 page_start = cpu_addr >> block_page_bits;
+        const u64 page_end = cpu_addr_end >> block_page_bits;
+        while (page_start <= page_end) {
+            blocks[page_start] = new_buffer;
+            ++page_start;
        }
-
        return new_buffer;
    }

-    std::shared_ptr<Buffer> MergeBlocks(std::shared_ptr<Buffer> first,
-                                        std::shared_ptr<Buffer> second) {
-        const std::size_t size_1 = first->Size();
-        const std::size_t size_2 = second->Size();
-        const VAddr first_addr = first->CpuAddr();
-        const VAddr second_addr = second->CpuAddr();
+    OwnerBuffer MergeBlocks(OwnerBuffer first, OwnerBuffer second) {
+        const std::size_t size_1 = first->GetSize();
+        const std::size_t size_2 = second->GetSize();
+        const VAddr first_addr = first->GetCpuAddr();
+        const VAddr second_addr = second->GetCpuAddr();
        const VAddr new_addr = std::min(first_addr, second_addr);
        const std::size_t new_size = size_1 + size_2;
-
-        std::shared_ptr<Buffer> new_buffer = CreateBlock(new_addr, new_size);
-        new_buffer->CopyFrom(*first, 0, new_buffer->Offset(first_addr), size_1);
-        new_buffer->CopyFrom(*second, 0, new_buffer->Offset(second_addr), size_2);
-        QueueDestruction(std::move(first));
-        QueueDestruction(std::move(second));
-
+        OwnerBuffer new_buffer = CreateBlock(new_addr, new_size);
+        CopyBlock(first, new_buffer, 0, new_buffer->GetOffset(first_addr), size_1);
+        CopyBlock(second, new_buffer, 0, new_buffer->GetOffset(second_addr), size_2);
+        first->SetEpoch(epoch);
+        second->SetEpoch(epoch);
+        pending_destruction.push_back(first);
+        pending_destruction.push_back(second);
        const VAddr cpu_addr_end = new_addr + new_size - 1;
-        const u64 page_end = cpu_addr_end >> BLOCK_PAGE_BITS;
-        for (u64 page_start = new_addr >> BLOCK_PAGE_BITS; page_start <= page_end; ++page_start) {
-            blocks.insert_or_assign(page_start, new_buffer);
+        u64 page_start = new_addr >> block_page_bits;
+        const u64 page_end = cpu_addr_end >> block_page_bits;
+        while (page_start <= page_end) {
+            blocks[page_start] = new_buffer;
+            ++page_start;
        }
        return new_buffer;
    }

-    Buffer* GetBlock(VAddr cpu_addr, std::size_t size) {
-        std::shared_ptr<Buffer> found;
-
+    OwnerBuffer GetBlock(const VAddr cpu_addr, const std::size_t size) {
+        OwnerBuffer found;
        const VAddr cpu_addr_end = cpu_addr + size - 1;
-        const u64 page_end = cpu_addr_end >> BLOCK_PAGE_BITS;
-        for (u64 page_start = cpu_addr >> BLOCK_PAGE_BITS; page_start <= page_end; ++page_start) {
+        u64 page_start = cpu_addr >> block_page_bits;
+        const u64 page_end = cpu_addr_end >> block_page_bits;
+        while (page_start <= page_end) {
            auto it = blocks.find(page_start);
            if (it == blocks.end()) {
                if (found) {
                    found = EnlargeBlock(found);
-                    continue;
+                } else {
+                    const VAddr start_addr = (page_start << block_page_bits);
+                    found = CreateBlock(start_addr, block_page_size);
+                    blocks[page_start] = found;
+                }
+            } else {
+                if (found) {
+                    if (found == it->second) {
+                        ++page_start;
+                        continue;
+                    }
+                    found = MergeBlocks(found, it->second);
+                } else {
+                    found = it->second;
                }
-                const VAddr start_addr = page_start << BLOCK_PAGE_BITS;
-                found = CreateBlock(start_addr, BLOCK_PAGE_SIZE);
-                blocks.insert_or_assign(page_start, found);
-                continue;
-            }
-            if (!found) {
-                found = it->second;
-                continue;
-            }
-            if (found != it->second) {
-                found = MergeBlocks(std::move(found), it->second);
            }
+            ++page_start;
        }
-        return found.get();
+        return found;
    }

-    void MarkRegionAsWritten(VAddr start, VAddr end) {
-        const u64 page_end = end >> WRITE_PAGE_BIT;
-        for (u64 page_start = start >> WRITE_PAGE_BIT; page_start <= page_end; ++page_start) {
+    void MarkRegionAsWritten(const VAddr start, const VAddr end) {
+        u64 page_start = start >> write_page_bit;
+        const u64 page_end = end >> write_page_bit;
+        while (page_start <= page_end) {
            auto it = written_pages.find(page_start);
            if (it != written_pages.end()) {
                it->second = it->second + 1;
            } else {
-                written_pages.insert_or_assign(page_start, 1);
+                written_pages[page_start] = 1;
            }
+            page_start++;
        }
    }

-    void UnmarkRegionAsWritten(VAddr start, VAddr end) {
-        const u64 page_end = end >> WRITE_PAGE_BIT;
-        for (u64 page_start = start >> WRITE_PAGE_BIT; page_start <= page_end; ++page_start) {
+    void UnmarkRegionAsWritten(const VAddr start, const VAddr end) {
+        u64 page_start = start >> write_page_bit;
+        const u64 page_end = end >> write_page_bit;
+        while (page_start <= page_end) {
            auto it = written_pages.find(page_start);
            if (it != written_pages.end()) {
                if (it->second > 1) {
@@ -544,27 +531,25 @@ private:
                    written_pages.erase(it);
                }
            }
+            page_start++;
        }
    }

-    bool IsRegionWritten(VAddr start, VAddr end) const {
-        const u64 page_end = end >> WRITE_PAGE_BIT;
-        for (u64 page_start = start >> WRITE_PAGE_BIT; page_start <= page_end; ++page_start) {
+    bool IsRegionWritten(const VAddr start, const VAddr end) const {
+        u64 page_start = start >> write_page_bit;
+        const u64 page_end = end >> write_page_bit;
+        while (page_start <= page_end) {
            if (written_pages.count(page_start) > 0) {
                return true;
            }
+            page_start++;
        }
        return false;
    }

-    void QueueDestruction(std::shared_ptr<Buffer> buffer) {
-        buffer->SetEpoch(epoch);
-        pending_destruction.push(std::move(buffer));
-    }
-
-    void MarkForAsyncFlush(MapInterval* map) {
+    void MarkForAsyncFlush(MapInterval& map) {
        if (!uncommitted_flushes) {
-            uncommitted_flushes = std::make_shared<std::unordered_set<MapInterval*>>();
+            uncommitted_flushes = std::make_shared<std::unordered_set<MapInterval>>();
        }
        uncommitted_flushes->insert(map);
    }
@@ -573,29 +558,35 @@ private:
    Core::System& system;

    std::unique_ptr<StreamBuffer> stream_buffer;
-    BufferType stream_buffer_handle;
+    BufferType stream_buffer_handle{};
+
+    bool invalidated = false;

    u8* buffer_ptr = nullptr;
    u64 buffer_offset = 0;
    u64 buffer_offset_base = 0;

-    MapIntervalAllocator mapped_addresses_allocator;
-    boost::intrusive::set<MapInterval, boost::intrusive::compare<MapIntervalCompare>>
-        mapped_addresses;
+    using IntervalSet = boost::icl::interval_set<VAddr>;
+    using IntervalCache = boost::icl::interval_map<VAddr, MapInterval>;
+    using IntervalType = typename IntervalCache::interval_type;
+    IntervalCache mapped_addresses;

+    static constexpr u64 write_page_bit = 11;
    std::unordered_map<u64, u32> written_pages;
-    std::unordered_map<u64, std::shared_ptr<Buffer>> blocks;

-    std::queue<std::shared_ptr<Buffer>> pending_destruction;
+    static constexpr u64 block_page_bits = 21;
+    static constexpr u64 block_page_size = 1ULL << block_page_bits;
+    std::unordered_map<u64, OwnerBuffer> blocks;
+
+    std::list<OwnerBuffer> pending_destruction;
    u64 epoch = 0;
    u64 modified_ticks = 0;

    std::vector<u8> staging_buffer;
+    std::list<MapInterval> marked_for_unregister;

-    std::list<MapInterval*> marked_for_unregister;
-
-    std::shared_ptr<std::unordered_set<MapInterval*>> uncommitted_flushes;
-    std::list<std::shared_ptr<std::list<MapInterval*>>> committed_flushes;
+    std::shared_ptr<std::unordered_set<MapInterval>> uncommitted_flushes{};
+    std::list<std::shared_ptr<std::list<MapInterval>>> committed_flushes;

    std::recursive_mutex mutex;
 };
--- a/src/video_core/buffer_cache/map_interval.cpp
+++ b/src/video_core/buffer_cache/map_interval.cpp
@@ -1,33 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <memory>
-
-#include "video_core/buffer_cache/map_interval.h"
-
-namespace VideoCommon {
-
-MapIntervalAllocator::MapIntervalAllocator() {
-    FillFreeList(first_chunk);
-}
-
-MapIntervalAllocator::~MapIntervalAllocator() = default;
-
-void MapIntervalAllocator::AllocateNewChunk() {
-    *new_chunk = std::make_unique<Chunk>();
-    FillFreeList(**new_chunk);
-    new_chunk = &(*new_chunk)->next;
-}
-
-void MapIntervalAllocator::FillFreeList(Chunk& chunk) {
-    const std::size_t old_size = free_list.size();
-    free_list.resize(old_size + chunk.data.size());
-    std::transform(chunk.data.rbegin(), chunk.data.rend(), free_list.begin() + old_size,
-                   [](MapInterval& interval) { return &interval; });
-}
-
-} // namespace VideoCommon
--- a/src/video_core/buffer_cache/map_interval.h
+++ b/src/video_core/buffer_cache/map_interval.h
@@ -4,89 +4,104 @@

 #pragma once

-#include <array>
-#include <cstddef>
-#include <memory>
-#include <vector>
-
-#include <boost/intrusive/set_hook.hpp>
-
 #include "common/common_types.h"
 #include "video_core/gpu.h"

 namespace VideoCommon {

-struct MapInterval : public boost::intrusive::set_base_hook<boost::intrusive::optimize_size<true>> {
-    MapInterval() = default;
-
-    /*implicit*/ MapInterval(VAddr start_) noexcept : start{start_} {}
-
-    explicit MapInterval(VAddr start_, VAddr end_, GPUVAddr gpu_addr_) noexcept
-        : start{start_}, end{end_}, gpu_addr{gpu_addr_} {}
-
-    bool IsInside(VAddr other_start, VAddr other_end) const noexcept {
-        return start <= other_start && other_end <= end;
-    }
-
-    bool Overlaps(VAddr other_start, VAddr other_end) const noexcept {
-        return start < other_end && other_start < end;
-    }
-
-    void MarkAsModified(bool is_modified_, u64 ticks_) noexcept {
-        is_modified = is_modified_;
-        ticks = ticks_;
-    }
-
-    boost::intrusive::set_member_hook<> member_hook_;
-    VAddr start = 0;
-    VAddr end = 0;
-    GPUVAddr gpu_addr = 0;
-    u64 ticks = 0;
-    bool is_written = false;
-    bool is_modified = false;
-    bool is_registered = false;
-    bool is_memory_marked = false;
-    bool is_sync_pending = false;
-};
-
-struct MapIntervalCompare {
-    constexpr bool operator()(const MapInterval& lhs, const MapInterval& rhs) const noexcept {
-        return lhs.start < rhs.start;
-    }
-};
-
-class MapIntervalAllocator {
+class MapIntervalBase {
 public:
-    MapIntervalAllocator();
-    ~MapIntervalAllocator();
+    MapIntervalBase(const VAddr start, const VAddr end, const GPUVAddr gpu_addr)
+        : start{start}, end{end}, gpu_addr{gpu_addr} {}

-    MapInterval* Allocate() {
-        if (free_list.empty()) {
-            AllocateNewChunk();
-        }
-        MapInterval* const interval = free_list.back();
-        free_list.pop_back();
-        return interval;
+    void SetCpuAddress(VAddr new_cpu_addr) {
+        cpu_addr = new_cpu_addr;
    }

-    void Release(MapInterval* interval) {
-        free_list.push_back(interval);
+    VAddr GetCpuAddress() const {
+        return cpu_addr;
+    }
+
+    GPUVAddr GetGpuAddress() const {
+        return gpu_addr;
+    }
+
+    bool IsInside(const VAddr other_start, const VAddr other_end) const {
+        return (start <= other_start && other_end <= end);
+    }
+
+    bool operator==(const MapIntervalBase& rhs) const {
+        return std::tie(start, end) == std::tie(rhs.start, rhs.end);
+    }
+
+    bool operator!=(const MapIntervalBase& rhs) const {
+        return !operator==(rhs);
+    }
+
+    void MarkAsRegistered(const bool registered) {
+        is_registered = registered;
+    }
+
+    bool IsRegistered() const {
+        return is_registered;
+    }
+
+    void SetMemoryMarked(bool is_memory_marked_) {
+        is_memory_marked = is_memory_marked_;
+    }
+
+    bool IsMemoryMarked() const {
+        return is_memory_marked;
+    }
+
+    void SetSyncPending(bool is_sync_pending_) {
+        is_sync_pending = is_sync_pending_;
+    }
+
+    bool IsSyncPending() const {
+        return is_sync_pending;
+    }
+
+    VAddr GetStart() const {
+        return start;
+    }
+
+    VAddr GetEnd() const {
+        return end;
+    }
+
+    void MarkAsModified(const bool is_modified_, const u64 tick) {
+        is_modified = is_modified_;
+        ticks = tick;
+    }
+
+    bool IsModified() const {
+        return is_modified;
+    }
+
+    u64 GetModificationTick() const {
+        return ticks;
+    }
+
+    void MarkAsWritten(const bool is_written_) {
+        is_written = is_written_;
+    }
+
+    bool IsWritten() const {
+        return is_written;
    }

 private:
-    struct Chunk {
-        std::unique_ptr<Chunk> next;
-        std::array<MapInterval, 0x8000> data;
-    };
-
-    void AllocateNewChunk();
-
-    void FillFreeList(Chunk& chunk);
-
-    std::vector<MapInterval*> free_list;
-    std::unique_ptr<Chunk>* new_chunk = &first_chunk.next;
-
-    Chunk first_chunk;
+    VAddr start;
+    VAddr end;
+    GPUVAddr gpu_addr;
+    VAddr cpu_addr{};
+    bool is_written{};
+    bool is_modified{};
+    bool is_registered{};
+    bool is_memory_marked{};
+    bool is_sync_pending{};
+    u64 ticks{};
 };

 } // namespace VideoCommon
--- a/src/video_core/dma_pusher.cpp
+++ b/src/video_core/dma_pusher.cpp
@@ -54,7 +54,9 @@ bool DmaPusher::Step() {
        return true;
    });
    const CommandListHeader command_list_header{command_list[dma_pushbuffer_subindex++]};
-    const GPUVAddr dma_get = command_list_header.addr;
+    GPUVAddr dma_get = command_list_header.addr;
+    GPUVAddr dma_put = dma_get + command_list_header.size * sizeof(u32);
+    bool non_main = command_list_header.is_non_main;

    if (dma_pushbuffer_subindex >= command_list.size()) {
        // We've gone through the current list, remove it from the queue
@@ -131,6 +133,11 @@ bool DmaPusher::Step() {
        index++;
    }

+    if (!non_main) {
+        // TODO (degasus): This is dead code, as dma_mget is never read.
+        dma_mget = dma_put;
+    }
+
    return true;
 }

--- a/src/video_core/dma_pusher.h
+++ b/src/video_core/dma_pusher.h
@@ -102,6 +102,7 @@ private:
    DmaState dma_state{};
    bool dma_increment_once{};

+    GPUVAddr dma_mget{};  ///< main pushbuffer last read address
    bool ib_enable{true}; ///< IB mode enabled

    std::array<Tegra::Engines::EngineInterface*, max_subchannels> subchannels{};
--- a/src/video_core/engines/const_buffer_engine_interface.h
+++ b/src/video_core/engines/const_buffer_engine_interface.h
@@ -93,7 +93,6 @@ public:
    virtual SamplerDescriptor AccessBoundSampler(ShaderType stage, u64 offset) const = 0;
    virtual SamplerDescriptor AccessBindlessSampler(ShaderType stage, u64 const_buffer,
                                                    u64 offset) const = 0;
-    virtual SamplerDescriptor AccessSampler(u32 handle) const = 0;
    virtual u32 GetBoundBuffer() const = 0;

    virtual VideoCore::GuestDriverProfile& AccessGuestDriverProfile() = 0;
--- a/src/video_core/engines/kepler_compute.cpp
+++ b/src/video_core/engines/kepler_compute.cpp
@@ -92,11 +92,8 @@ SamplerDescriptor KeplerCompute::AccessBindlessSampler(ShaderType stage, u64 con
    ASSERT(stage == ShaderType::Compute);
    const auto& tex_info_buffer = launch_description.const_buffer_config[const_buffer];
    const GPUVAddr tex_info_address = tex_info_buffer.Address() + offset;
-    return AccessSampler(memory_manager.Read<u32>(tex_info_address));
-}

-SamplerDescriptor KeplerCompute::AccessSampler(u32 handle) const {
-    const Texture::TextureHandle tex_handle{handle};
+    const Texture::TextureHandle tex_handle{memory_manager.Read<u32>(tex_info_address)};
    const Texture::FullTextureInfo tex_info = GetTextureInfo(tex_handle);
    SamplerDescriptor result = SamplerDescriptor::FromTIC(tex_info.tic);
    result.is_shadow.Assign(tex_info.tsc.depth_compare_enabled.Value());
--- a/src/video_core/engines/kepler_compute.h
+++ b/src/video_core/engines/kepler_compute.h
@@ -219,8 +219,6 @@ public:
    SamplerDescriptor AccessBindlessSampler(ShaderType stage, u64 const_buffer,
                                            u64 offset) const override;

-    SamplerDescriptor AccessSampler(u32 handle) const override;
-
    u32 GetBoundBuffer() const override {
        return regs.tex_cb_index;
    }
--- a/src/video_core/engines/maxwell_3d.cpp
+++ b/src/video_core/engines/maxwell_3d.cpp
@@ -25,8 +25,9 @@ constexpr u32 MacroRegistersStart = 0xE00;
 Maxwell3D::Maxwell3D(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
                     MemoryManager& memory_manager)
    : system{system}, rasterizer{rasterizer}, memory_manager{memory_manager},
-      macro_engine{GetMacroEngine(*this)}, upload_state{memory_manager, regs.upload} {
+      macro_interpreter{*this}, upload_state{memory_manager, regs.upload} {
    dirty.flags.flip();
+
    InitializeRegisterDefaults();
 }

@@ -105,11 +106,7 @@ void Maxwell3D::InitializeRegisterDefaults() {
    regs.rasterize_enable = 1;
    regs.rt_separate_frag_data = 1;
    regs.framebuffer_srgb = 1;
-    regs.line_width_aliased = 1.0f;
-    regs.line_width_smooth = 1.0f;
    regs.front_face = Maxwell3D::Regs::FrontFace::ClockWise;
-    regs.polygon_mode_back = Maxwell3D::Regs::PolygonMode::Fill;
-    regs.polygon_mode_front = Maxwell3D::Regs::PolygonMode::Fill;

    shadow_state = regs;

@@ -119,7 +116,7 @@ void Maxwell3D::InitializeRegisterDefaults() {
    mme_inline[MAXWELL3D_REG_INDEX(index_array.count)] = true;
 }

-void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters) {
+void Maxwell3D::CallMacroMethod(u32 method, std::size_t num_parameters, const u32* parameters) {
    // Reset the current macro.
    executing_macro = 0;

@@ -128,7 +125,7 @@ void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters)
        ((method - MacroRegistersStart) >> 1) % static_cast<u32>(macro_positions.size());

    // Execute the current macro.
-    macro_engine->Execute(*this, macro_positions[entry], parameters);
+    macro_interpreter.Execute(macro_positions[entry], num_parameters, parameters);
    if (mme_draw.current_mode != MMEDrawMode::Undefined) {
        FlushMMEInlineDraw();
    }
@@ -164,7 +161,7 @@ void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {

        // Call the macro when there are no more parameters in the command buffer
        if (is_last_call) {
-            CallMacroMethod(executing_macro, macro_params);
+            CallMacroMethod(executing_macro, macro_params.size(), macro_params.data());
            macro_params.clear();
        }
        return;
@@ -200,7 +197,7 @@ void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
        break;
    }
    case MAXWELL3D_REG_INDEX(macros.data): {
-        macro_engine->AddCode(regs.macros.upload_address, arg);
+        ProcessMacroUpload(arg);
        break;
    }
    case MAXWELL3D_REG_INDEX(macros.bind): {
@@ -309,7 +306,7 @@ void Maxwell3D::CallMultiMethod(u32 method, const u32* base_start, u32 amount,

        // Call the macro when there are no more parameters in the command buffer
        if (amount == methods_pending) {
-            CallMacroMethod(executing_macro, macro_params);
+            CallMacroMethod(executing_macro, macro_params.size(), macro_params.data());
            macro_params.clear();
        }
        return;
@@ -423,7 +420,9 @@ void Maxwell3D::FlushMMEInlineDraw() {
 }

 void Maxwell3D::ProcessMacroUpload(u32 data) {
-    macro_engine->AddCode(regs.macros.upload_address++, data);
+    ASSERT_MSG(regs.macros.upload_address < macro_memory.size(),
+               "upload_address exceeded macro_memory size!");
+    macro_memory[regs.macros.upload_address++] = data;
 }

 void Maxwell3D::ProcessMacroBind(u32 data) {
@@ -458,9 +457,8 @@ void Maxwell3D::StampQueryResult(u64 payload, bool long_query) {

 void Maxwell3D::ProcessQueryGet() {
    // TODO(Subv): Support the other query units.
-    if (regs.query.query_get.unit != Regs::QueryUnit::Crop) {
-        LOG_DEBUG(HW_GPU, "Units other than CROP are unimplemented");
-    }
+    ASSERT_MSG(regs.query.query_get.unit == Regs::QueryUnit::Crop,
+               "Units other than CROP are unimplemented");

    switch (regs.query.query_get.operation) {
    case Regs::QueryOperation::Release:
@@ -536,8 +534,8 @@ void Maxwell3D::ProcessCounterReset() {
        rasterizer.ResetCounter(QueryType::SamplesPassed);
        break;
    default:
-        LOG_DEBUG(Render_OpenGL, "Unimplemented counter reset={}",
-                  static_cast<int>(regs.counter_reset));
+        LOG_WARNING(Render_OpenGL, "Unimplemented counter reset={}",
+                    static_cast<int>(regs.counter_reset));
        break;
    }
 }
@@ -594,8 +592,8 @@ std::optional<u64> Maxwell3D::GetQueryResult() {
                         system.GPU().GetTicks());
        return {};
    default:
-        LOG_DEBUG(HW_GPU, "Unimplemented query select type {}",
-                  static_cast<u32>(regs.query.query_get.select.Value()));
+        UNIMPLEMENTED_MSG("Unimplemented query select type {}",
+                          static_cast<u32>(regs.query.query_get.select.Value()));
        return 1;
    }
 }
@@ -740,11 +738,8 @@ SamplerDescriptor Maxwell3D::AccessBindlessSampler(ShaderType stage, u64 const_b
    const auto& shader = state.shader_stages[static_cast<std::size_t>(stage)];
    const auto& tex_info_buffer = shader.const_buffers[const_buffer];
    const GPUVAddr tex_info_address = tex_info_buffer.address + offset;
-    return AccessSampler(memory_manager.Read<u32>(tex_info_address));
-}

-SamplerDescriptor Maxwell3D::AccessSampler(u32 handle) const {
-    const Texture::TextureHandle tex_handle{handle};
+    const Texture::TextureHandle tex_handle{memory_manager.Read<u32>(tex_info_address)};
    const Texture::FullTextureInfo tex_info = GetTextureInfo(tex_handle);
    SamplerDescriptor result = SamplerDescriptor::FromTIC(tex_info.tic);
    result.is_shadow.Assign(tex_info.tsc.depth_compare_enabled.Value());
--- a/src/video_core/engines/maxwell_3d.h
+++ b/src/video_core/engines/maxwell_3d.h
@@ -23,7 +23,7 @@
 #include "video_core/engines/engine_upload.h"
 #include "video_core/engines/shader_type.h"
 #include "video_core/gpu.h"
-#include "video_core/macro/macro.h"
+#include "video_core/macro_interpreter.h"
 #include "video_core/textures/texture.h"

 namespace Core {
@@ -598,7 +598,6 @@ public:
                BitField<4, 3, u32> block_height;
                BitField<8, 3, u32> block_depth;
                BitField<12, 1, InvMemoryLayout> type;
-                BitField<16, 1, u32> is_3d;
            } memory_layout;
            union {
                BitField<0, 16, u32> layers;
@@ -1404,8 +1403,6 @@ public:
    SamplerDescriptor AccessBindlessSampler(ShaderType stage, u64 const_buffer,
                                            u64 offset) const override;

-    SamplerDescriptor AccessSampler(u32 handle) const override;
-
    u32 GetBoundBuffer() const override {
        return regs.tex_cb_index;
    }
@@ -1414,18 +1411,19 @@ public:

    const VideoCore::GuestDriverProfile& AccessGuestDriverProfile() const override;

+    /// Memory for macro code - it's undetermined how big this is, however 1MB is much larger than
+    /// we've seen used.
+    using MacroMemory = std::array<u32, 0x40000>;
+
+    /// Gets a reference to macro memory.
+    const MacroMemory& GetMacroMemory() const {
+        return macro_memory;
+    }
+
    bool ShouldExecute() const {
        return execute_on;
    }

-    VideoCore::RasterizerInterface& GetRasterizer() {
-        return rasterizer;
-    }
-
-    const VideoCore::RasterizerInterface& GetRasterizer() const {
-        return rasterizer;
-    }
-
    /// Notify a memory write has happened.
    void OnMemoryWrite() {
        dirty.flags |= dirty.on_write_stores;
@@ -1470,13 +1468,16 @@ private:

    std::array<bool, Regs::NUM_REGS> mme_inline{};

+    /// Memory for macro code
+    MacroMemory macro_memory;
+
    /// Macro method that is currently being executed / being fed parameters.
    u32 executing_macro = 0;
    /// Parameters that have been submitted to the macro call so far.
    std::vector<u32> macro_params;

    /// Interpreter for the macro codes uploaded to the GPU.
-    std::unique_ptr<MacroEngine> macro_engine;
+    MacroInterpreter macro_interpreter;

    static constexpr u32 null_cb_data = 0xFFFFFFFF;
    struct {
@@ -1505,7 +1506,7 @@ private:
     * @param num_parameters Number of arguments
     * @param parameters Arguments to the method call
     */
-    void CallMacroMethod(u32 method, const std::vector<u32>& parameters);
+    void CallMacroMethod(u32 method, std::size_t num_parameters, const u32* parameters);

    /// Handles writes to the macro uploading register.
    void ProcessMacroUpload(u32 data);
--- a/src/video_core/engines/shader_bytecode.h
+++ b/src/video_core/engines/shader_bytecode.h
@@ -168,22 +168,18 @@ enum class Pred : u64 {
 };

 enum class PredCondition : u64 {
-    F = 0,    // Always false
-    LT = 1,   // Ordered less than
-    EQ = 2,   // Ordered equal
-    LE = 3,   // Ordered less than or equal
-    GT = 4,   // Ordered greater than
-    NE = 5,   // Ordered not equal
-    GE = 6,   // Ordered greater than or equal
-    NUM = 7,  // Ordered
-    NAN_ = 8, // Unordered
-    LTU = 9,  // Unordered less than
-    EQU = 10, // Unordered equal
-    LEU = 11, // Unordered less than or equal
-    GTU = 12, // Unordered greater than
-    NEU = 13, // Unordered not equal
-    GEU = 14, // Unordered greater than or equal
-    T = 15,   // Always true
+    LessThan = 1,
+    Equal = 2,
+    LessEqual = 3,
+    GreaterThan = 4,
+    NotEqual = 5,
+    GreaterEqual = 6,
+    LessThanWithNan = 9,
+    LessEqualWithNan = 11,
+    GreaterThanWithNan = 12,
+    NotEqualWithNan = 13,
+    GreaterEqualWithNan = 14,
+    // TODO(Subv): Other condition types
 };

 enum class PredOperation : u64 {
--- a/src/video_core/macro/macro.cpp
+++ b/src/video_core/macro/macro.cpp
@@ -1,72 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <boost/container_hash/hash.hpp>
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/settings.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/macro/macro.h"
-#include "video_core/macro/macro_hle.h"
-#include "video_core/macro/macro_interpreter.h"
-#include "video_core/macro/macro_jit_x64.h"
-
-namespace Tegra {
-
-MacroEngine::MacroEngine(Engines::Maxwell3D& maxwell3d)
-    : hle_macros{std::make_unique<Tegra::HLEMacro>(maxwell3d)} {}
-
-MacroEngine::~MacroEngine() = default;
-
-void MacroEngine::AddCode(u32 method, u32 data) {
-    uploaded_macro_code[method].push_back(data);
-}
-
-void MacroEngine::Execute(Engines::Maxwell3D& maxwell3d, u32 method,
-                          const std::vector<u32>& parameters) {
-    auto compiled_macro = macro_cache.find(method);
-    if (compiled_macro != macro_cache.end()) {
-        const auto& cache_info = compiled_macro->second;
-        if (cache_info.has_hle_program) {
-            cache_info.hle_program->Execute(parameters, method);
-        } else {
-            cache_info.lle_program->Execute(parameters, method);
-        }
-    } else {
-        // Macro not compiled, check if it's uploaded and if so, compile it
-        auto macro_code = uploaded_macro_code.find(method);
-        if (macro_code == uploaded_macro_code.end()) {
-            UNREACHABLE_MSG("Macro 0x{0:x} was not uploaded", method);
-            return;
-        }
-        auto& cache_info = macro_cache[method];
-        cache_info.hash = boost::hash_value(macro_code->second);
-        cache_info.lle_program = Compile(macro_code->second);
-
-        auto hle_program = hle_macros->GetHLEProgram(cache_info.hash);
-        if (hle_program.has_value()) {
-            cache_info.has_hle_program = true;
-            cache_info.hle_program = std::move(hle_program.value());
-        }
-
-        if (cache_info.has_hle_program) {
-            cache_info.hle_program->Execute(parameters, method);
-        } else {
-            cache_info.lle_program->Execute(parameters, method);
-        }
-    }
-}
-
-std::unique_ptr<MacroEngine> GetMacroEngine(Engines::Maxwell3D& maxwell3d) {
-    if (Settings::values.disable_macro_jit) {
-        return std::make_unique<MacroInterpreter>(maxwell3d);
-    }
-#ifdef ARCHITECTURE_x86_64
-    return std::make_unique<MacroJITx64>(maxwell3d);
-#else
-    return std::make_unique<MacroInterpreter>(maxwell3d);
-#endif
-}
-
-} // namespace Tegra
--- a/src/video_core/macro/macro.h
+++ b/src/video_core/macro/macro.h
@@ -1,141 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <unordered_map>
-#include <vector>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-
-namespace Tegra {
-
-namespace Engines {
-class Maxwell3D;
-}
-
-namespace Macro {
-constexpr std::size_t NUM_MACRO_REGISTERS = 8;
-enum class Operation : u32 {
-    ALU = 0,
-    AddImmediate = 1,
-    ExtractInsert = 2,
-    ExtractShiftLeftImmediate = 3,
-    ExtractShiftLeftRegister = 4,
-    Read = 5,
-    Unused = 6, // This operation doesn't seem to be a valid encoding.
-    Branch = 7,
-};
-
-enum class ALUOperation : u32 {
-    Add = 0,
-    AddWithCarry = 1,
-    Subtract = 2,
-    SubtractWithBorrow = 3,
-    // Operations 4-7 don't seem to be valid encodings.
-    Xor = 8,
-    Or = 9,
-    And = 10,
-    AndNot = 11,
-    Nand = 12
-};
-
-enum class ResultOperation : u32 {
-    IgnoreAndFetch = 0,
-    Move = 1,
-    MoveAndSetMethod = 2,
-    FetchAndSend = 3,
-    MoveAndSend = 4,
-    FetchAndSetMethod = 5,
-    MoveAndSetMethodFetchAndSend = 6,
-    MoveAndSetMethodSend = 7
-};
-
-enum class BranchCondition : u32 {
-    Zero = 0,
-    NotZero = 1,
-};
-
-union Opcode {
-    u32 raw;
-    BitField<0, 3, Operation> operation;
-    BitField<4, 3, ResultOperation> result_operation;
-    BitField<4, 1, BranchCondition> branch_condition;
-    // If set on a branch, then the branch doesn't have a delay slot.
-    BitField<5, 1, u32> branch_annul;
-    BitField<7, 1, u32> is_exit;
-    BitField<8, 3, u32> dst;
-    BitField<11, 3, u32> src_a;
-    BitField<14, 3, u32> src_b;
-    // The signed immediate overlaps the second source operand and the alu operation.
-    BitField<14, 18, s32> immediate;
-
-    BitField<17, 5, ALUOperation> alu_operation;
-
-    // Bitfield instructions data
-    BitField<17, 5, u32> bf_src_bit;
-    BitField<22, 5, u32> bf_size;
-    BitField<27, 5, u32> bf_dst_bit;
-
-    u32 GetBitfieldMask() const {
-        return (1 << bf_size) - 1;
-    }
-
-    s32 GetBranchTarget() const {
-        return static_cast<s32>(immediate * sizeof(u32));
-    }
-};
-
-union MethodAddress {
-    u32 raw;
-    BitField<0, 12, u32> address;
-    BitField<12, 6, u32> increment;
-};
-
-} // namespace Macro
-
-class HLEMacro;
-
-class CachedMacro {
-public:
-    virtual ~CachedMacro() = default;
-    /**
-     * Executes the macro code with the specified input parameters.
-     * @param code The macro byte code to execute
-     * @param parameters The parameters of the macro
-     */
-    virtual void Execute(const std::vector<u32>& parameters, u32 method) = 0;
-};
-
-class MacroEngine {
-public:
-    explicit MacroEngine(Engines::Maxwell3D& maxwell3d);
-    virtual ~MacroEngine();
-
-    // Store the uploaded macro code to compile them when they're called.
-    void AddCode(u32 method, u32 data);
-
-    // Compiles the macro if its not in the cache, and executes the compiled macro
-    void Execute(Engines::Maxwell3D& maxwell3d, u32 method, const std::vector<u32>& parameters);
-
-protected:
-    virtual std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) = 0;
-
-private:
-    struct CacheInfo {
-        std::unique_ptr<CachedMacro> lle_program{};
-        std::unique_ptr<CachedMacro> hle_program{};
-        u64 hash{};
-        bool has_hle_program{};
-    };
-
-    std::unordered_map<u32, CacheInfo> macro_cache;
-    std::unordered_map<u32, std::vector<u32>> uploaded_macro_code;
-    std::unique_ptr<HLEMacro> hle_macros;
-};
-
-std::unique_ptr<MacroEngine> GetMacroEngine(Engines::Maxwell3D& maxwell3d);
-
-} // namespace Tegra
--- a/src/video_core/macro/macro_hle.cpp
+++ b/src/video_core/macro/macro_hle.cpp
@@ -1,113 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <array>
-#include <vector>
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/macro/macro_hle.h"
-#include "video_core/rasterizer_interface.h"
-
-namespace Tegra {
-
-namespace {
-// HLE'd functions
-static void HLE_771BB18C62444DA0(Engines::Maxwell3D& maxwell3d,
-                                 const std::vector<u32>& parameters) {
-    const u32 instance_count = parameters[2] & maxwell3d.GetRegisterValue(0xD1B);
-
-    maxwell3d.regs.draw.topology.Assign(
-        static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0] &
-                                                                        ~(0x3ffffff << 26)));
-    maxwell3d.regs.vb_base_instance = parameters[5];
-    maxwell3d.mme_draw.instance_count = instance_count;
-    maxwell3d.regs.vb_element_base = parameters[3];
-    maxwell3d.regs.index_array.count = parameters[1];
-    maxwell3d.regs.index_array.first = parameters[4];
-
-    if (maxwell3d.ShouldExecute()) {
-        maxwell3d.GetRasterizer().Draw(true, true);
-    }
-    maxwell3d.regs.index_array.count = 0;
-    maxwell3d.mme_draw.instance_count = 0;
-    maxwell3d.mme_draw.current_mode = Engines::Maxwell3D::MMEDrawMode::Undefined;
-}
-
-static void HLE_0D61FC9FAAC9FCAD(Engines::Maxwell3D& maxwell3d,
-                                 const std::vector<u32>& parameters) {
-    const u32 count = (maxwell3d.GetRegisterValue(0xD1B) & parameters[2]);
-
-    maxwell3d.regs.vertex_buffer.first = parameters[3];
-    maxwell3d.regs.vertex_buffer.count = parameters[1];
-    maxwell3d.regs.vb_base_instance = parameters[4];
-    maxwell3d.regs.draw.topology.Assign(
-        static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0]));
-    maxwell3d.mme_draw.instance_count = count;
-
-    if (maxwell3d.ShouldExecute()) {
-        maxwell3d.GetRasterizer().Draw(false, true);
-    }
-    maxwell3d.regs.vertex_buffer.count = 0;
-    maxwell3d.mme_draw.instance_count = 0;
-    maxwell3d.mme_draw.current_mode = Engines::Maxwell3D::MMEDrawMode::Undefined;
-}
-
-static void HLE_0217920100488FF7(Engines::Maxwell3D& maxwell3d,
-                                 const std::vector<u32>& parameters) {
-    const u32 instance_count = (maxwell3d.GetRegisterValue(0xD1B) & parameters[2]);
-    const u32 element_base = parameters[4];
-    const u32 base_instance = parameters[5];
-    maxwell3d.regs.index_array.first = parameters[3];
-    maxwell3d.regs.reg_array[0x446] = element_base; // vertex id base?
-    maxwell3d.regs.index_array.count = parameters[1];
-    maxwell3d.regs.vb_element_base = element_base;
-    maxwell3d.regs.vb_base_instance = base_instance;
-    maxwell3d.mme_draw.instance_count = instance_count;
-    maxwell3d.CallMethodFromMME(0x8e3, 0x640);
-    maxwell3d.CallMethodFromMME(0x8e4, element_base);
-    maxwell3d.CallMethodFromMME(0x8e5, base_instance);
-    maxwell3d.regs.draw.topology.Assign(
-        static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0]));
-    if (maxwell3d.ShouldExecute()) {
-        maxwell3d.GetRasterizer().Draw(true, true);
-    }
-    maxwell3d.regs.reg_array[0x446] = 0x0; // vertex id base?
-    maxwell3d.regs.index_array.count = 0;
-    maxwell3d.regs.vb_element_base = 0x0;
-    maxwell3d.regs.vb_base_instance = 0x0;
-    maxwell3d.mme_draw.instance_count = 0;
-    maxwell3d.CallMethodFromMME(0x8e3, 0x640);
-    maxwell3d.CallMethodFromMME(0x8e4, 0x0);
-    maxwell3d.CallMethodFromMME(0x8e5, 0x0);
-    maxwell3d.mme_draw.current_mode = Engines::Maxwell3D::MMEDrawMode::Undefined;
-}
-} // namespace
-
-constexpr std::array<std::pair<u64, HLEFunction>, 3> hle_funcs{{
-    std::make_pair<u64, HLEFunction>(0x771BB18C62444DA0, &HLE_771BB18C62444DA0),
-    std::make_pair<u64, HLEFunction>(0x0D61FC9FAAC9FCAD, &HLE_0D61FC9FAAC9FCAD),
-    std::make_pair<u64, HLEFunction>(0x0217920100488FF7, &HLE_0217920100488FF7),
-}};
-
-HLEMacro::HLEMacro(Engines::Maxwell3D& maxwell3d) : maxwell3d(maxwell3d) {}
-HLEMacro::~HLEMacro() = default;
-
-std::optional<std::unique_ptr<CachedMacro>> HLEMacro::GetHLEProgram(u64 hash) const {
-    const auto it = std::find_if(hle_funcs.cbegin(), hle_funcs.cend(),
-                                 [hash](const auto& pair) { return pair.first == hash; });
-    if (it == hle_funcs.end()) {
-        return std::nullopt;
-    }
-    return std::make_unique<HLEMacroImpl>(maxwell3d, it->second);
-}
-
-HLEMacroImpl::~HLEMacroImpl() = default;
-
-HLEMacroImpl::HLEMacroImpl(Engines::Maxwell3D& maxwell3d, HLEFunction func)
-    : maxwell3d(maxwell3d), func(func) {}
-
-void HLEMacroImpl::Execute(const std::vector<u32>& parameters, u32 method) {
-    func(maxwell3d, parameters);
-}
-
-} // namespace Tegra
--- a/src/video_core/macro/macro_hle.h
+++ b/src/video_core/macro/macro_hle.h
@@ -1,44 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <vector>
-#include "common/common_types.h"
-#include "video_core/macro/macro.h"
-
-namespace Tegra {
-
-namespace Engines {
-class Maxwell3D;
-}
-
-using HLEFunction = void (*)(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters);
-
-class HLEMacro {
-public:
-    explicit HLEMacro(Engines::Maxwell3D& maxwell3d);
-    ~HLEMacro();
-
-    std::optional<std::unique_ptr<CachedMacro>> GetHLEProgram(u64 hash) const;
-
-private:
-    Engines::Maxwell3D& maxwell3d;
-};
-
-class HLEMacroImpl : public CachedMacro {
-public:
-    explicit HLEMacroImpl(Engines::Maxwell3D& maxwell3d, HLEFunction func);
-    ~HLEMacroImpl();
-
-    void Execute(const std::vector<u32>& parameters, u32 method) override;
-
-private:
-    Engines::Maxwell3D& maxwell3d;
-    HLEFunction func;
-};
-
-} // namespace Tegra
--- a/src/video_core/macro/macro_jit_x64.cpp
+++ b/src/video_core/macro/macro_jit_x64.cpp
@@ -1,621 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "common/microprofile.h"
-#include "common/x64/xbyak_util.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/macro/macro_interpreter.h"
-#include "video_core/macro/macro_jit_x64.h"
-
-MICROPROFILE_DEFINE(MacroJitCompile, "GPU", "Compile macro JIT", MP_RGB(173, 255, 47));
-MICROPROFILE_DEFINE(MacroJitExecute, "GPU", "Execute macro JIT", MP_RGB(255, 255, 0));
-
-namespace Tegra {
-static const Xbyak::Reg64 STATE = Xbyak::util::rbx;
-static const Xbyak::Reg32 RESULT = Xbyak::util::ebp;
-static const Xbyak::Reg64 PARAMETERS = Xbyak::util::r12;
-static const Xbyak::Reg32 METHOD_ADDRESS = Xbyak::util::r14d;
-static const Xbyak::Reg64 BRANCH_HOLDER = Xbyak::util::r15;
-
-static const std::bitset<32> PERSISTENT_REGISTERS = Common::X64::BuildRegSet({
-    STATE,
-    RESULT,
-    PARAMETERS,
-    METHOD_ADDRESS,
-    BRANCH_HOLDER,
-});
-
-MacroJITx64::MacroJITx64(Engines::Maxwell3D& maxwell3d)
-    : MacroEngine::MacroEngine(maxwell3d), maxwell3d(maxwell3d) {}
-
-std::unique_ptr<CachedMacro> MacroJITx64::Compile(const std::vector<u32>& code) {
-    return std::make_unique<MacroJITx64Impl>(maxwell3d, code);
-}
-
-MacroJITx64Impl::MacroJITx64Impl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code)
-    : Xbyak::CodeGenerator(MAX_CODE_SIZE), code(code), maxwell3d(maxwell3d) {
-    Compile();
-}
-
-MacroJITx64Impl::~MacroJITx64Impl() = default;
-
-void MacroJITx64Impl::Execute(const std::vector<u32>& parameters, u32 method) {
-    MICROPROFILE_SCOPE(MacroJitExecute);
-    ASSERT_OR_EXECUTE(program != nullptr, { return; });
-    JITState state{};
-    state.maxwell3d = &maxwell3d;
-    state.registers = {};
-    program(&state, parameters.data());
-}
-
-void MacroJITx64Impl::Compile_ALU(Macro::Opcode opcode) {
-    const bool is_a_zero = opcode.src_a == 0;
-    const bool is_b_zero = opcode.src_b == 0;
-    const bool valid_operation = !is_a_zero && !is_b_zero;
-    [[maybe_unused]] const bool is_move_operation = !is_a_zero && is_b_zero;
-    const bool has_zero_register = is_a_zero || is_b_zero;
-    const bool no_zero_reg_skip = opcode.alu_operation == Macro::ALUOperation::AddWithCarry ||
-                                  opcode.alu_operation == Macro::ALUOperation::SubtractWithBorrow;
-
-    Xbyak::Reg32 src_a;
-    Xbyak::Reg32 src_b;
-
-    if (!optimizer.zero_reg_skip || no_zero_reg_skip) {
-        src_a = Compile_GetRegister(opcode.src_a, RESULT);
-        src_b = Compile_GetRegister(opcode.src_b, eax);
-    } else {
-        if (!is_a_zero) {
-            src_a = Compile_GetRegister(opcode.src_a, RESULT);
-        }
-        if (!is_b_zero) {
-            src_b = Compile_GetRegister(opcode.src_b, eax);
-        }
-    }
-
-    bool has_emitted = false;
-
-    switch (opcode.alu_operation) {
-    case Macro::ALUOperation::Add:
-        if (optimizer.zero_reg_skip) {
-            if (valid_operation) {
-                add(src_a, src_b);
-            }
-        } else {
-            add(src_a, src_b);
-        }
-
-        if (!optimizer.can_skip_carry) {
-            setc(byte[STATE + offsetof(JITState, carry_flag)]);
-        }
-        break;
-    case Macro::ALUOperation::AddWithCarry:
-        bt(dword[STATE + offsetof(JITState, carry_flag)], 0);
-        adc(src_a, src_b);
-        setc(byte[STATE + offsetof(JITState, carry_flag)]);
-        break;
-    case Macro::ALUOperation::Subtract:
-        if (optimizer.zero_reg_skip) {
-            if (valid_operation) {
-                sub(src_a, src_b);
-                has_emitted = true;
-            }
-        } else {
-            sub(src_a, src_b);
-            has_emitted = true;
-        }
-        if (!optimizer.can_skip_carry && has_emitted) {
-            setc(byte[STATE + offsetof(JITState, carry_flag)]);
-        }
-        break;
-    case Macro::ALUOperation::SubtractWithBorrow:
-        bt(dword[STATE + offsetof(JITState, carry_flag)], 0);
-        sbb(src_a, src_b);
-        setc(byte[STATE + offsetof(JITState, carry_flag)]);
-        break;
-    case Macro::ALUOperation::Xor:
-        if (optimizer.zero_reg_skip) {
-            if (valid_operation) {
-                xor_(src_a, src_b);
-            }
-        } else {
-            xor_(src_a, src_b);
-        }
-        break;
-    case Macro::ALUOperation::Or:
-        if (optimizer.zero_reg_skip) {
-            if (valid_operation) {
-                or_(src_a, src_b);
-            }
-        } else {
-            or_(src_a, src_b);
-        }
-        break;
-    case Macro::ALUOperation::And:
-        if (optimizer.zero_reg_skip) {
-            if (!has_zero_register) {
-                and_(src_a, src_b);
-            }
-        } else {
-            and_(src_a, src_b);
-        }
-        break;
-    case Macro::ALUOperation::AndNot:
-        if (optimizer.zero_reg_skip) {
-            if (!is_a_zero) {
-                not_(src_b);
-                and_(src_a, src_b);
-            }
-        } else {
-            not_(src_b);
-            and_(src_a, src_b);
-        }
-        break;
-    case Macro::ALUOperation::Nand:
-        if (optimizer.zero_reg_skip) {
-            if (!is_a_zero) {
-                and_(src_a, src_b);
-                not_(src_a);
-            }
-        } else {
-            and_(src_a, src_b);
-            not_(src_a);
-        }
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented ALU operation {}",
-                          static_cast<std::size_t>(opcode.alu_operation.Value()));
-        break;
-    }
-    Compile_ProcessResult(opcode.result_operation, opcode.dst);
-}
-
-void MacroJITx64Impl::Compile_AddImmediate(Macro::Opcode opcode) {
-    if (optimizer.skip_dummy_addimmediate) {
-        // Games tend to use this as an exit instruction placeholder. It's to encode an instruction
-        // without doing anything. In our case we can just not emit anything.
-        if (opcode.result_operation == Macro::ResultOperation::Move && opcode.dst == 0) {
-            return;
-        }
-    }
-    // Check for redundant moves
-    if (optimizer.optimize_for_method_move &&
-        opcode.result_operation == Macro::ResultOperation::MoveAndSetMethod) {
-        if (next_opcode.has_value()) {
-            const auto next = *next_opcode;
-            if (next.result_operation == Macro::ResultOperation::MoveAndSetMethod &&
-                opcode.dst == next.dst) {
-                return;
-            }
-        }
-    }
-    if (optimizer.zero_reg_skip && opcode.src_a == 0) {
-        if (opcode.immediate == 0) {
-            xor_(RESULT, RESULT);
-        } else {
-            mov(RESULT, opcode.immediate);
-        }
-    } else {
-        auto result = Compile_GetRegister(opcode.src_a, RESULT);
-        if (opcode.immediate > 2) {
-            add(result, opcode.immediate);
-        } else if (opcode.immediate == 1) {
-            inc(result);
-        } else if (opcode.immediate < 0) {
-            sub(result, opcode.immediate * -1);
-        }
-    }
-    Compile_ProcessResult(opcode.result_operation, opcode.dst);
-}
-
-void MacroJITx64Impl::Compile_ExtractInsert(Macro::Opcode opcode) {
-    auto dst = Compile_GetRegister(opcode.src_a, RESULT);
-    auto src = Compile_GetRegister(opcode.src_b, eax);
-
-    if (opcode.bf_src_bit != 0 && opcode.bf_src_bit != 31) {
-        shr(src, opcode.bf_src_bit);
-    } else if (opcode.bf_src_bit == 31) {
-        xor_(src, src);
-    }
-    // Don't bother masking the whole register since we're using a 32 bit register
-    if (opcode.bf_size != 31 && opcode.bf_size != 0) {
-        and_(src, opcode.GetBitfieldMask());
-    } else if (opcode.bf_size == 0) {
-        xor_(src, src);
-    }
-    if (opcode.bf_dst_bit != 31 && opcode.bf_dst_bit != 0) {
-        shl(src, opcode.bf_dst_bit);
-    } else if (opcode.bf_dst_bit == 31) {
-        xor_(src, src);
-    }
-
-    const u32 mask = ~(opcode.GetBitfieldMask() << opcode.bf_dst_bit);
-    if (mask != 0xffffffff) {
-        and_(dst, mask);
-    }
-    or_(dst, src);
-    Compile_ProcessResult(opcode.result_operation, opcode.dst);
-}
-
-void MacroJITx64Impl::Compile_ExtractShiftLeftImmediate(Macro::Opcode opcode) {
-    const auto dst = Compile_GetRegister(opcode.src_a, ecx);
-    const auto src = Compile_GetRegister(opcode.src_b, RESULT);
-
-    shr(src, dst.cvt8());
-    if (opcode.bf_size != 0 && opcode.bf_size != 31) {
-        and_(src, opcode.GetBitfieldMask());
-    } else if (opcode.bf_size == 0) {
-        xor_(src, src);
-    }
-
-    if (opcode.bf_dst_bit != 0 && opcode.bf_dst_bit != 31) {
-        shl(src, opcode.bf_dst_bit);
-    } else if (opcode.bf_dst_bit == 31) {
-        xor_(src, src);
-    }
-    Compile_ProcessResult(opcode.result_operation, opcode.dst);
-}
-
-void MacroJITx64Impl::Compile_ExtractShiftLeftRegister(Macro::Opcode opcode) {
-    const auto dst = Compile_GetRegister(opcode.src_a, ecx);
-    const auto src = Compile_GetRegister(opcode.src_b, RESULT);
-
-    if (opcode.bf_src_bit != 0) {
-        shr(src, opcode.bf_src_bit);
-    }
-
-    if (opcode.bf_size != 31) {
-        and_(src, opcode.GetBitfieldMask());
-    }
-    shl(src, dst.cvt8());
-
-    Compile_ProcessResult(opcode.result_operation, opcode.dst);
-}
-
-void MacroJITx64Impl::Compile_Read(Macro::Opcode opcode) {
-    if (optimizer.zero_reg_skip && opcode.src_a == 0) {
-        if (opcode.immediate == 0) {
-            xor_(RESULT, RESULT);
-        } else {
-            mov(RESULT, opcode.immediate);
-        }
-    } else {
-        auto result = Compile_GetRegister(opcode.src_a, RESULT);
-        if (opcode.immediate > 2) {
-            add(result, opcode.immediate);
-        } else if (opcode.immediate == 1) {
-            inc(result);
-        } else if (opcode.immediate < 0) {
-            sub(result, opcode.immediate * -1);
-        }
-    }
-
-    // Equivalent to Engines::Maxwell3D::GetRegisterValue:
-    if (optimizer.enable_asserts) {
-        Xbyak::Label pass_range_check;
-        cmp(RESULT, static_cast<u32>(Engines::Maxwell3D::Regs::NUM_REGS));
-        jb(pass_range_check);
-        int3();
-        L(pass_range_check);
-    }
-    mov(rax, qword[STATE]);
-    mov(RESULT,
-        dword[rax + offsetof(Engines::Maxwell3D, regs) +
-              offsetof(Engines::Maxwell3D::Regs, reg_array) + RESULT.cvt64() * sizeof(u32)]);
-
-    Compile_ProcessResult(opcode.result_operation, opcode.dst);
-}
-
-static void Send(Engines::Maxwell3D* maxwell3d, Macro::MethodAddress method_address, u32 value) {
-    maxwell3d->CallMethodFromMME(method_address.address, value);
-}
-
-void Tegra::MacroJITx64Impl::Compile_Send(Xbyak::Reg32 value) {
-    Common::X64::ABI_PushRegistersAndAdjustStack(*this, PersistentCallerSavedRegs(), 0);
-    mov(Common::X64::ABI_PARAM1, qword[STATE]);
-    mov(Common::X64::ABI_PARAM2, METHOD_ADDRESS);
-    mov(Common::X64::ABI_PARAM3, value);
-    Common::X64::CallFarFunction(*this, &Send);
-    Common::X64::ABI_PopRegistersAndAdjustStack(*this, PersistentCallerSavedRegs(), 0);
-
-    Xbyak::Label dont_process{};
-    // Get increment
-    test(METHOD_ADDRESS, 0x3f000);
-    // If zero, method address doesn't update
-    je(dont_process);
-
-    mov(ecx, METHOD_ADDRESS);
-    and_(METHOD_ADDRESS, 0xfff);
-    shr(ecx, 12);
-    and_(ecx, 0x3f);
-    lea(eax, ptr[rcx + METHOD_ADDRESS.cvt64()]);
-    sal(ecx, 12);
-    or_(eax, ecx);
-
-    mov(METHOD_ADDRESS, eax);
-
-    L(dont_process);
-}
-
-void Tegra::MacroJITx64Impl::Compile_Branch(Macro::Opcode opcode) {
-    ASSERT_MSG(!is_delay_slot, "Executing a branch in a delay slot is not valid");
-    const s32 jump_address =
-        static_cast<s32>(pc) + static_cast<s32>(opcode.GetBranchTarget() / sizeof(s32));
-
-    Xbyak::Label end;
-    auto value = Compile_GetRegister(opcode.src_a, eax);
-    test(value, value);
-    if (optimizer.has_delayed_pc) {
-        switch (opcode.branch_condition) {
-        case Macro::BranchCondition::Zero:
-            jne(end, T_NEAR);
-            break;
-        case Macro::BranchCondition::NotZero:
-            je(end, T_NEAR);
-            break;
-        }
-
-        if (opcode.branch_annul) {
-            xor_(BRANCH_HOLDER, BRANCH_HOLDER);
-            jmp(labels[jump_address], T_NEAR);
-        } else {
-            Xbyak::Label handle_post_exit{};
-            Xbyak::Label skip{};
-            jmp(skip, T_NEAR);
-            if (opcode.is_exit) {
-                L(handle_post_exit);
-                // Execute 1 instruction
-                mov(BRANCH_HOLDER, end_of_code);
-                // Jump to next instruction to skip delay slot check
-                jmp(labels[jump_address], T_NEAR);
-            } else {
-                L(handle_post_exit);
-                xor_(BRANCH_HOLDER, BRANCH_HOLDER);
-                jmp(labels[jump_address], T_NEAR);
-            }
-            L(skip);
-            mov(BRANCH_HOLDER, handle_post_exit);
-            jmp(delay_skip[pc], T_NEAR);
-        }
-    } else {
-        switch (opcode.branch_condition) {
-        case Macro::BranchCondition::Zero:
-            je(labels[jump_address], T_NEAR);
-            break;
-        case Macro::BranchCondition::NotZero:
-            jne(labels[jump_address], T_NEAR);
-            break;
-        }
-    }
-
-    L(end);
-}
-
-void Tegra::MacroJITx64Impl::Optimizer_ScanFlags() {
-    optimizer.can_skip_carry = true;
-    optimizer.has_delayed_pc = false;
-    for (auto raw_op : code) {
-        Macro::Opcode op{};
-        op.raw = raw_op;
-
-        if (op.operation == Macro::Operation::ALU) {
-            // Scan for any ALU operations which actually use the carry flag, if they don't exist in
-            // our current code we can skip emitting the carry flag handling operations
-            if (op.alu_operation == Macro::ALUOperation::AddWithCarry ||
-                op.alu_operation == Macro::ALUOperation::SubtractWithBorrow) {
-                optimizer.can_skip_carry = false;
-            }
-        }
-
-        if (op.operation == Macro::Operation::Branch) {
-            if (!op.branch_annul) {
-                optimizer.has_delayed_pc = true;
-            }
-        }
-    }
-}
-
-void MacroJITx64Impl::Compile() {
-    MICROPROFILE_SCOPE(MacroJitCompile);
-    bool keep_executing = true;
-    labels.fill(Xbyak::Label());
-
-    Common::X64::ABI_PushRegistersAndAdjustStack(*this, Common::X64::ABI_ALL_CALLEE_SAVED, 8);
-    // JIT state
-    mov(STATE, Common::X64::ABI_PARAM1);
-    mov(PARAMETERS, Common::X64::ABI_PARAM2);
-    xor_(RESULT, RESULT);
-    xor_(METHOD_ADDRESS, METHOD_ADDRESS);
-    xor_(BRANCH_HOLDER, BRANCH_HOLDER);
-
-    mov(dword[STATE + offsetof(JITState, registers) + 4], Compile_FetchParameter());
-
-    // Track get register for zero registers and mark it as no-op
-    optimizer.zero_reg_skip = true;
-
-    // AddImmediate tends to be used as a NOP instruction, if we detect this we can
-    // completely skip the entire code path and no emit anything
-    optimizer.skip_dummy_addimmediate = true;
-
-    // SMO tends to emit a lot of unnecessary method moves, we can mitigate this by only emitting
-    // one if our register isn't "dirty"
-    optimizer.optimize_for_method_move = true;
-
-    // Enable run-time assertions in JITted code
-    optimizer.enable_asserts = false;
-
-    // Check to see if we can skip emitting certain instructions
-    Optimizer_ScanFlags();
-
-    const u32 op_count = static_cast<u32>(code.size());
-    for (u32 i = 0; i < op_count; i++) {
-        if (i < op_count - 1) {
-            pc = i + 1;
-            next_opcode = GetOpCode();
-        } else {
-            next_opcode = {};
-        }
-        pc = i;
-        Compile_NextInstruction();
-    }
-
-    L(end_of_code);
-
-    Common::X64::ABI_PopRegistersAndAdjustStack(*this, Common::X64::ABI_ALL_CALLEE_SAVED, 8);
-    ret();
-    ready();
-    program = getCode<ProgramType>();
-}
-
-bool MacroJITx64Impl::Compile_NextInstruction() {
-    const auto opcode = GetOpCode();
-    if (labels[pc].getAddress()) {
-        return false;
-    }
-
-    L(labels[pc]);
-
-    switch (opcode.operation) {
-    case Macro::Operation::ALU:
-        Compile_ALU(opcode);
-        break;
-    case Macro::Operation::AddImmediate:
-        Compile_AddImmediate(opcode);
-        break;
-    case Macro::Operation::ExtractInsert:
-        Compile_ExtractInsert(opcode);
-        break;
-    case Macro::Operation::ExtractShiftLeftImmediate:
-        Compile_ExtractShiftLeftImmediate(opcode);
-        break;
-    case Macro::Operation::ExtractShiftLeftRegister:
-        Compile_ExtractShiftLeftRegister(opcode);
-        break;
-    case Macro::Operation::Read:
-        Compile_Read(opcode);
-        break;
-    case Macro::Operation::Branch:
-        Compile_Branch(opcode);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented opcode {}", opcode.operation.Value());
-        break;
-    }
-
-    if (optimizer.has_delayed_pc) {
-        if (opcode.is_exit) {
-            mov(rax, end_of_code);
-            test(BRANCH_HOLDER, BRANCH_HOLDER);
-            cmove(BRANCH_HOLDER, rax);
-            // Jump to next instruction to skip delay slot check
-            je(labels[pc + 1], T_NEAR);
-        } else {
-            // TODO(ogniK): Optimize delay slot branching
-            Xbyak::Label no_delay_slot{};
-            test(BRANCH_HOLDER, BRANCH_HOLDER);
-            je(no_delay_slot, T_NEAR);
-            mov(rax, BRANCH_HOLDER);
-            xor_(BRANCH_HOLDER, BRANCH_HOLDER);
-            jmp(rax);
-            L(no_delay_slot);
-        }
-        L(delay_skip[pc]);
-        if (opcode.is_exit) {
-            return false;
-        }
-    } else {
-        test(BRANCH_HOLDER, BRANCH_HOLDER);
-        jne(end_of_code, T_NEAR);
-        if (opcode.is_exit) {
-            inc(BRANCH_HOLDER);
-            return false;
-        }
-    }
-    return true;
-}
-
-Xbyak::Reg32 Tegra::MacroJITx64Impl::Compile_FetchParameter() {
-    mov(eax, dword[PARAMETERS]);
-    add(PARAMETERS, sizeof(u32));
-    return eax;
-}
-
-Xbyak::Reg32 MacroJITx64Impl::Compile_GetRegister(u32 index, Xbyak::Reg32 dst) {
-    if (index == 0) {
-        // Register 0 is always zero
-        xor_(dst, dst);
-    } else {
-        mov(dst, dword[STATE + offsetof(JITState, registers) + index * sizeof(u32)]);
-    }
-
-    return dst;
-}
-
-void MacroJITx64Impl::Compile_ProcessResult(Macro::ResultOperation operation, u32 reg) {
-    const auto SetRegister = [this](u32 reg, const Xbyak::Reg32& result) {
-        // Register 0 is supposed to always return 0. NOP is implemented as a store to the zero
-        // register.
-        if (reg == 0) {
-            return;
-        }
-        mov(dword[STATE + offsetof(JITState, registers) + reg * sizeof(u32)], result);
-    };
-    const auto SetMethodAddress = [this](const Xbyak::Reg32& reg) { mov(METHOD_ADDRESS, reg); };
-
-    switch (operation) {
-    case Macro::ResultOperation::IgnoreAndFetch:
-        SetRegister(reg, Compile_FetchParameter());
-        break;
-    case Macro::ResultOperation::Move:
-        SetRegister(reg, RESULT);
-        break;
-    case Macro::ResultOperation::MoveAndSetMethod:
-        SetRegister(reg, RESULT);
-        SetMethodAddress(RESULT);
-        break;
-    case Macro::ResultOperation::FetchAndSend:
-        // Fetch parameter and send result.
-        SetRegister(reg, Compile_FetchParameter());
-        Compile_Send(RESULT);
-        break;
-    case Macro::ResultOperation::MoveAndSend:
-        // Move and send result.
-        SetRegister(reg, RESULT);
-        Compile_Send(RESULT);
-        break;
-    case Macro::ResultOperation::FetchAndSetMethod:
-        // Fetch parameter and use result as Method Address.
-        SetRegister(reg, Compile_FetchParameter());
-        SetMethodAddress(RESULT);
-        break;
-    case Macro::ResultOperation::MoveAndSetMethodFetchAndSend:
-        // Move result and use as Method Address, then fetch and send parameter.
-        SetRegister(reg, RESULT);
-        SetMethodAddress(RESULT);
-        Compile_Send(Compile_FetchParameter());
-        break;
-    case Macro::ResultOperation::MoveAndSetMethodSend:
-        // Move result and use as Method Address, then send bits 12:17 of result.
-        SetRegister(reg, RESULT);
-        SetMethodAddress(RESULT);
-        shr(RESULT, 12);
-        and_(RESULT, 0b111111);
-        Compile_Send(RESULT);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented macro operation {}", static_cast<std::size_t>(operation));
-    }
-}
-
-Macro::Opcode MacroJITx64Impl::GetOpCode() const {
-    ASSERT(pc < code.size());
-    return {code[pc]};
-}
-
-std::bitset<32> MacroJITx64Impl::PersistentCallerSavedRegs() const {
-    return PERSISTENT_REGISTERS & Common::X64::ABI_ALL_CALLER_SAVED;
-}
-
-} // namespace Tegra
--- a/src/video_core/macro/macro_jit_x64.h
+++ b/src/video_core/macro/macro_jit_x64.h
@@ -1,98 +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 <bitset>
-#include <xbyak.h>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-#include "common/x64/xbyak_abi.h"
-#include "video_core/macro/macro.h"
-
-namespace Tegra {
-
-namespace Engines {
-class Maxwell3D;
-}
-
-/// MAX_CODE_SIZE is arbitrarily chosen based on current booting games
-constexpr size_t MAX_CODE_SIZE = 0x10000;
-
-class MacroJITx64 final : public MacroEngine {
-public:
-    explicit MacroJITx64(Engines::Maxwell3D& maxwell3d);
-
-protected:
-    std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) override;
-
-private:
-    Engines::Maxwell3D& maxwell3d;
-};
-
-class MacroJITx64Impl : public Xbyak::CodeGenerator, public CachedMacro {
-public:
-    MacroJITx64Impl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code);
-    ~MacroJITx64Impl();
-
-    void Execute(const std::vector<u32>& parameters, u32 method) override;
-
-    void Compile_ALU(Macro::Opcode opcode);
-    void Compile_AddImmediate(Macro::Opcode opcode);
-    void Compile_ExtractInsert(Macro::Opcode opcode);
-    void Compile_ExtractShiftLeftImmediate(Macro::Opcode opcode);
-    void Compile_ExtractShiftLeftRegister(Macro::Opcode opcode);
-    void Compile_Read(Macro::Opcode opcode);
-    void Compile_Branch(Macro::Opcode opcode);
-
-private:
-    void Optimizer_ScanFlags();
-
-    void Compile();
-    bool Compile_NextInstruction();
-
-    Xbyak::Reg32 Compile_FetchParameter();
-    Xbyak::Reg32 Compile_GetRegister(u32 index, Xbyak::Reg32 dst);
-
-    void Compile_ProcessResult(Macro::ResultOperation operation, u32 reg);
-    void Compile_Send(Xbyak::Reg32 value);
-
-    Macro::Opcode GetOpCode() const;
-    std::bitset<32> PersistentCallerSavedRegs() const;
-
-    struct JITState {
-        Engines::Maxwell3D* maxwell3d{};
-        std::array<u32, Macro::NUM_MACRO_REGISTERS> registers{};
-        u32 carry_flag{};
-    };
-    static_assert(offsetof(JITState, maxwell3d) == 0, "Maxwell3D is not at 0x0");
-    using ProgramType = void (*)(JITState*, const u32*);
-
-    struct OptimizerState {
-        bool can_skip_carry{};
-        bool has_delayed_pc{};
-        bool zero_reg_skip{};
-        bool skip_dummy_addimmediate{};
-        bool optimize_for_method_move{};
-        bool enable_asserts{};
-    };
-    OptimizerState optimizer{};
-
-    std::optional<Macro::Opcode> next_opcode{};
-    ProgramType program{nullptr};
-
-    std::array<Xbyak::Label, MAX_CODE_SIZE> labels;
-    std::array<Xbyak::Label, MAX_CODE_SIZE> delay_skip;
-    Xbyak::Label end_of_code{};
-
-    bool is_delay_slot{};
-    u32 pc{};
-    std::optional<u32> delayed_pc;
-
-    const std::vector<u32>& code;
-    Engines::Maxwell3D& maxwell3d;
-};
-
-} // namespace Tegra
--- a/src/video_core/macro/macro_interpreter.cpp
+++ b/src/video_core/macro/macro_interpreter.cpp
@@ -1,4 +1,4 @@
-// Copyright 2020 yuzu Emulator Project
+// Copyright 2018 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

@@ -6,47 +6,109 @@
 #include "common/logging/log.h"
 #include "common/microprofile.h"
 #include "video_core/engines/maxwell_3d.h"
-#include "video_core/macro/macro_interpreter.h"
+#include "video_core/macro_interpreter.h"

 MICROPROFILE_DEFINE(MacroInterp, "GPU", "Execute macro interpreter", MP_RGB(128, 128, 192));

 namespace Tegra {
-MacroInterpreter::MacroInterpreter(Engines::Maxwell3D& maxwell3d)
-    : MacroEngine::MacroEngine(maxwell3d), maxwell3d(maxwell3d) {}
+namespace {
+enum class Operation : u32 {
+    ALU = 0,
+    AddImmediate = 1,
+    ExtractInsert = 2,
+    ExtractShiftLeftImmediate = 3,
+    ExtractShiftLeftRegister = 4,
+    Read = 5,
+    Unused = 6, // This operation doesn't seem to be a valid encoding.
+    Branch = 7,
+};
+} // Anonymous namespace

-std::unique_ptr<CachedMacro> MacroInterpreter::Compile(const std::vector<u32>& code) {
-    return std::make_unique<MacroInterpreterImpl>(maxwell3d, code);
-}
+enum class MacroInterpreter::ALUOperation : u32 {
+    Add = 0,
+    AddWithCarry = 1,
+    Subtract = 2,
+    SubtractWithBorrow = 3,
+    // Operations 4-7 don't seem to be valid encodings.
+    Xor = 8,
+    Or = 9,
+    And = 10,
+    AndNot = 11,
+    Nand = 12
+};

-MacroInterpreterImpl::MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d,
-                                           const std::vector<u32>& code)
-    : maxwell3d(maxwell3d), code(code) {}
+enum class MacroInterpreter::ResultOperation : u32 {
+    IgnoreAndFetch = 0,
+    Move = 1,
+    MoveAndSetMethod = 2,
+    FetchAndSend = 3,
+    MoveAndSend = 4,
+    FetchAndSetMethod = 5,
+    MoveAndSetMethodFetchAndSend = 6,
+    MoveAndSetMethodSend = 7
+};

-void MacroInterpreterImpl::Execute(const std::vector<u32>& parameters, u32 method) {
+enum class MacroInterpreter::BranchCondition : u32 {
+    Zero = 0,
+    NotZero = 1,
+};
+
+union MacroInterpreter::Opcode {
+    u32 raw;
+    BitField<0, 3, Operation> operation;
+    BitField<4, 3, ResultOperation> result_operation;
+    BitField<4, 1, BranchCondition> branch_condition;
+    // If set on a branch, then the branch doesn't have a delay slot.
+    BitField<5, 1, u32> branch_annul;
+    BitField<7, 1, u32> is_exit;
+    BitField<8, 3, u32> dst;
+    BitField<11, 3, u32> src_a;
+    BitField<14, 3, u32> src_b;
+    // The signed immediate overlaps the second source operand and the alu operation.
+    BitField<14, 18, s32> immediate;
+
+    BitField<17, 5, ALUOperation> alu_operation;
+
+    // Bitfield instructions data
+    BitField<17, 5, u32> bf_src_bit;
+    BitField<22, 5, u32> bf_size;
+    BitField<27, 5, u32> bf_dst_bit;
+
+    u32 GetBitfieldMask() const {
+        return (1 << bf_size) - 1;
+    }
+
+    s32 GetBranchTarget() const {
+        return static_cast<s32>(immediate * sizeof(u32));
+    }
+};
+
+MacroInterpreter::MacroInterpreter(Engines::Maxwell3D& maxwell3d) : maxwell3d(maxwell3d) {}
+
+void MacroInterpreter::Execute(u32 offset, std::size_t num_parameters, const u32* parameters) {
    MICROPROFILE_SCOPE(MacroInterp);
    Reset();

    registers[1] = parameters[0];
-    num_parameters = parameters.size();

    if (num_parameters > parameters_capacity) {
        parameters_capacity = num_parameters;
        this->parameters = std::make_unique<u32[]>(num_parameters);
    }
-    std::memcpy(this->parameters.get(), parameters.data(), num_parameters * sizeof(u32));
+    std::memcpy(this->parameters.get(), parameters, num_parameters * sizeof(u32));
    this->num_parameters = num_parameters;

    // Execute the code until we hit an exit condition.
    bool keep_executing = true;
    while (keep_executing) {
-        keep_executing = Step(false);
+        keep_executing = Step(offset, false);
    }

    // Assert the the macro used all the input parameters
    ASSERT(next_parameter_index == num_parameters);
 }

-void MacroInterpreterImpl::Reset() {
+void MacroInterpreter::Reset() {
    registers = {};
    pc = 0;
    delayed_pc = {};
@@ -58,10 +120,10 @@ void MacroInterpreterImpl::Reset() {
    carry_flag = false;
 }

-bool MacroInterpreterImpl::Step(bool is_delay_slot) {
+bool MacroInterpreter::Step(u32 offset, bool is_delay_slot) {
    u32 base_address = pc;

-    Macro::Opcode opcode = GetOpcode();
+    Opcode opcode = GetOpcode(offset);
    pc += 4;

    // Update the program counter if we were delayed
@@ -72,18 +134,18 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
    }

    switch (opcode.operation) {
-    case Macro::Operation::ALU: {
+    case Operation::ALU: {
        u32 result = GetALUResult(opcode.alu_operation, GetRegister(opcode.src_a),
                                  GetRegister(opcode.src_b));
        ProcessResult(opcode.result_operation, opcode.dst, result);
        break;
    }
-    case Macro::Operation::AddImmediate: {
+    case Operation::AddImmediate: {
        ProcessResult(opcode.result_operation, opcode.dst,
                      GetRegister(opcode.src_a) + opcode.immediate);
        break;
    }
-    case Macro::Operation::ExtractInsert: {
+    case Operation::ExtractInsert: {
        u32 dst = GetRegister(opcode.src_a);
        u32 src = GetRegister(opcode.src_b);

@@ -93,7 +155,7 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
        ProcessResult(opcode.result_operation, opcode.dst, dst);
        break;
    }
-    case Macro::Operation::ExtractShiftLeftImmediate: {
+    case Operation::ExtractShiftLeftImmediate: {
        u32 dst = GetRegister(opcode.src_a);
        u32 src = GetRegister(opcode.src_b);

@@ -102,7 +164,7 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
        ProcessResult(opcode.result_operation, opcode.dst, result);
        break;
    }
-    case Macro::Operation::ExtractShiftLeftRegister: {
+    case Operation::ExtractShiftLeftRegister: {
        u32 dst = GetRegister(opcode.src_a);
        u32 src = GetRegister(opcode.src_b);

@@ -111,12 +173,12 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
        ProcessResult(opcode.result_operation, opcode.dst, result);
        break;
    }
-    case Macro::Operation::Read: {
+    case Operation::Read: {
        u32 result = Read(GetRegister(opcode.src_a) + opcode.immediate);
        ProcessResult(opcode.result_operation, opcode.dst, result);
        break;
    }
-    case Macro::Operation::Branch: {
+    case Operation::Branch: {
        ASSERT_MSG(!is_delay_slot, "Executing a branch in a delay slot is not valid");
        u32 value = GetRegister(opcode.src_a);
        bool taken = EvaluateBranchCondition(opcode.branch_condition, value);
@@ -129,7 +191,7 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {

            delayed_pc = base_address + opcode.GetBranchTarget();
            // Execute one more instruction due to the delay slot.
-            return Step(true);
+            return Step(offset, true);
        }
        break;
    }
@@ -142,44 +204,51 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
    // cause an exit if it's executed inside a delay slot.
    if (opcode.is_exit && !is_delay_slot) {
        // Exit has a delay slot, execute the next instruction
-        Step(true);
+        Step(offset, true);
        return false;
    }

    return true;
 }

-u32 MacroInterpreterImpl::GetALUResult(Macro::ALUOperation operation, u32 src_a, u32 src_b) {
+MacroInterpreter::Opcode MacroInterpreter::GetOpcode(u32 offset) const {
+    const auto& macro_memory{maxwell3d.GetMacroMemory()};
+    ASSERT((pc % sizeof(u32)) == 0);
+    ASSERT((pc + offset) < macro_memory.size() * sizeof(u32));
+    return {macro_memory[offset + pc / sizeof(u32)]};
+}
+
+u32 MacroInterpreter::GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) {
    switch (operation) {
-    case Macro::ALUOperation::Add: {
+    case ALUOperation::Add: {
        const u64 result{static_cast<u64>(src_a) + src_b};
        carry_flag = result > 0xffffffff;
        return static_cast<u32>(result);
    }
-    case Macro::ALUOperation::AddWithCarry: {
+    case ALUOperation::AddWithCarry: {
        const u64 result{static_cast<u64>(src_a) + src_b + (carry_flag ? 1ULL : 0ULL)};
        carry_flag = result > 0xffffffff;
        return static_cast<u32>(result);
    }
-    case Macro::ALUOperation::Subtract: {
+    case ALUOperation::Subtract: {
        const u64 result{static_cast<u64>(src_a) - src_b};
        carry_flag = result < 0x100000000;
        return static_cast<u32>(result);
    }
-    case Macro::ALUOperation::SubtractWithBorrow: {
+    case ALUOperation::SubtractWithBorrow: {
        const u64 result{static_cast<u64>(src_a) - src_b - (carry_flag ? 0ULL : 1ULL)};
        carry_flag = result < 0x100000000;
        return static_cast<u32>(result);
    }
-    case Macro::ALUOperation::Xor:
+    case ALUOperation::Xor:
        return src_a ^ src_b;
-    case Macro::ALUOperation::Or:
+    case ALUOperation::Or:
        return src_a | src_b;
-    case Macro::ALUOperation::And:
+    case ALUOperation::And:
        return src_a & src_b;
-    case Macro::ALUOperation::AndNot:
+    case ALUOperation::AndNot:
        return src_a & ~src_b;
-    case Macro::ALUOperation::Nand:
+    case ALUOperation::Nand:
        return ~(src_a & src_b);

    default:
@@ -188,43 +257,43 @@ u32 MacroInterpreterImpl::GetALUResult(Macro::ALUOperation operation, u32 src_a,
    }
 }

-void MacroInterpreterImpl::ProcessResult(Macro::ResultOperation operation, u32 reg, u32 result) {
+void MacroInterpreter::ProcessResult(ResultOperation operation, u32 reg, u32 result) {
    switch (operation) {
-    case Macro::ResultOperation::IgnoreAndFetch:
+    case ResultOperation::IgnoreAndFetch:
        // Fetch parameter and ignore result.
        SetRegister(reg, FetchParameter());
        break;
-    case Macro::ResultOperation::Move:
+    case ResultOperation::Move:
        // Move result.
        SetRegister(reg, result);
        break;
-    case Macro::ResultOperation::MoveAndSetMethod:
+    case ResultOperation::MoveAndSetMethod:
        // Move result and use as Method Address.
        SetRegister(reg, result);
        SetMethodAddress(result);
        break;
-    case Macro::ResultOperation::FetchAndSend:
+    case ResultOperation::FetchAndSend:
        // Fetch parameter and send result.
        SetRegister(reg, FetchParameter());
        Send(result);
        break;
-    case Macro::ResultOperation::MoveAndSend:
+    case ResultOperation::MoveAndSend:
        // Move and send result.
        SetRegister(reg, result);
        Send(result);
        break;
-    case Macro::ResultOperation::FetchAndSetMethod:
+    case ResultOperation::FetchAndSetMethod:
        // Fetch parameter and use result as Method Address.
        SetRegister(reg, FetchParameter());
        SetMethodAddress(result);
        break;
-    case Macro::ResultOperation::MoveAndSetMethodFetchAndSend:
+    case ResultOperation::MoveAndSetMethodFetchAndSend:
        // Move result and use as Method Address, then fetch and send parameter.
        SetRegister(reg, result);
        SetMethodAddress(result);
        Send(FetchParameter());
        break;
-    case Macro::ResultOperation::MoveAndSetMethodSend:
+    case ResultOperation::MoveAndSetMethodSend:
        // Move result and use as Method Address, then send bits 12:17 of result.
        SetRegister(reg, result);
        SetMethodAddress(result);
@@ -235,28 +304,16 @@ void MacroInterpreterImpl::ProcessResult(Macro::ResultOperation operation, u32 r
    }
 }

-bool MacroInterpreterImpl::EvaluateBranchCondition(Macro::BranchCondition cond, u32 value) const {
-    switch (cond) {
-    case Macro::BranchCondition::Zero:
-        return value == 0;
-    case Macro::BranchCondition::NotZero:
-        return value != 0;
-    }
-    UNREACHABLE();
-    return true;
+u32 MacroInterpreter::FetchParameter() {
+    ASSERT(next_parameter_index < num_parameters);
+    return parameters[next_parameter_index++];
 }

-Macro::Opcode MacroInterpreterImpl::GetOpcode() const {
-    ASSERT((pc % sizeof(u32)) == 0);
-    ASSERT(pc < code.size() * sizeof(u32));
-    return {code[pc / sizeof(u32)]};
-}
-
-u32 MacroInterpreterImpl::GetRegister(u32 register_id) const {
+u32 MacroInterpreter::GetRegister(u32 register_id) const {
    return registers.at(register_id);
 }

-void MacroInterpreterImpl::SetRegister(u32 register_id, u32 value) {
+void MacroInterpreter::SetRegister(u32 register_id, u32 value) {
    // Register 0 is hardwired as the zero register.
    // Ensure no writes to it actually occur.
    if (register_id == 0) {
@@ -266,24 +323,30 @@ void MacroInterpreterImpl::SetRegister(u32 register_id, u32 value) {
    registers.at(register_id) = value;
 }

-void MacroInterpreterImpl::SetMethodAddress(u32 address) {
+void MacroInterpreter::SetMethodAddress(u32 address) {
    method_address.raw = address;
 }

-void MacroInterpreterImpl::Send(u32 value) {
+void MacroInterpreter::Send(u32 value) {
    maxwell3d.CallMethodFromMME(method_address.address, value);
    // Increment the method address by the method increment.
    method_address.address.Assign(method_address.address.Value() +
                                  method_address.increment.Value());
 }

-u32 MacroInterpreterImpl::Read(u32 method) const {
+u32 MacroInterpreter::Read(u32 method) const {
    return maxwell3d.GetRegisterValue(method);
 }

-u32 MacroInterpreterImpl::FetchParameter() {
-    ASSERT(next_parameter_index < num_parameters);
-    return parameters[next_parameter_index++];
+bool MacroInterpreter::EvaluateBranchCondition(BranchCondition cond, u32 value) const {
+    switch (cond) {
+    case BranchCondition::Zero:
+        return value == 0;
+    case BranchCondition::NotZero:
+        return value != 0;
+    }
+    UNREACHABLE();
+    return true;
 }

 } // namespace Tegra
--- a/src/video_core/macro/macro_interpreter.h
+++ b/src/video_core/macro/macro_interpreter.h
@@ -1,37 +1,44 @@
-// Copyright 2020 yuzu Emulator Project
+// Copyright 2018 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

 #pragma once
+
 #include <array>
 #include <optional>
-#include <vector>
+
 #include "common/bit_field.h"
 #include "common/common_types.h"
-#include "video_core/macro/macro.h"

 namespace Tegra {
 namespace Engines {
 class Maxwell3D;
 }

-class MacroInterpreter final : public MacroEngine {
+class MacroInterpreter final {
 public:
    explicit MacroInterpreter(Engines::Maxwell3D& maxwell3d);

-protected:
-    std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) override;
+    /**
+     * Executes the macro code with the specified input parameters.
+     * @param offset Offset to start execution at.
+     * @param parameters The parameters of the macro.
+     */
+    void Execute(u32 offset, std::size_t num_parameters, const u32* parameters);

 private:
-    Engines::Maxwell3D& maxwell3d;
-};
+    enum class ALUOperation : u32;
+    enum class BranchCondition : u32;
+    enum class ResultOperation : u32;

-class MacroInterpreterImpl : public CachedMacro {
-public:
-    MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code);
-    void Execute(const std::vector<u32>& parameters, u32 method) override;
+    union Opcode;
+
+    union MethodAddress {
+        u32 raw;
+        BitField<0, 12, u32> address;
+        BitField<12, 6, u32> increment;
+    };

-private:
    /// Resets the execution engine state, zeroing registers, etc.
    void Reset();

@@ -42,20 +49,20 @@ private:
     * @param is_delay_slot Whether the current step is being executed due to a delay slot in a
     * previous instruction.
     */
-    bool Step(bool is_delay_slot);
+    bool Step(u32 offset, bool is_delay_slot);

    /// Calculates the result of an ALU operation. src_a OP src_b;
-    u32 GetALUResult(Macro::ALUOperation operation, u32 src_a, u32 src_b);
+    u32 GetALUResult(ALUOperation operation, u32 src_a, u32 src_b);

    /// Performs the result operation on the input result and stores it in the specified register
    /// (if necessary).
-    void ProcessResult(Macro::ResultOperation operation, u32 reg, u32 result);
+    void ProcessResult(ResultOperation operation, u32 reg, u32 result);

    /// Evaluates the branch condition and returns whether the branch should be taken or not.
-    bool EvaluateBranchCondition(Macro::BranchCondition cond, u32 value) const;
+    bool EvaluateBranchCondition(BranchCondition cond, u32 value) const;

    /// Reads an opcode at the current program counter location.
-    Macro::Opcode GetOpcode() const;
+    Opcode GetOpcode(u32 offset) const;

    /// Returns the specified register's value. Register 0 is hardcoded to always return 0.
    u32 GetRegister(u32 register_id) const;
@@ -82,11 +89,13 @@ private:
    /// Program counter to execute at after the delay slot is executed.
    std::optional<u32> delayed_pc;

+    static constexpr std::size_t NumMacroRegisters = 8;
+
    /// General purpose macro registers.
-    std::array<u32, Macro::NUM_MACRO_REGISTERS> registers = {};
+    std::array<u32, NumMacroRegisters> registers = {};

    /// Method address to use for the next Send instruction.
-    Macro::MethodAddress method_address = {};
+    MethodAddress method_address = {};

    /// Input parameters of the current macro.
    std::unique_ptr<u32[]> parameters;
@@ -96,7 +105,5 @@ private:
    u32 next_parameter_index = 0;

    bool carry_flag = false;
-    const std::vector<u32>& code;
 };
-
 } // namespace Tegra
--- a/src/video_core/memory_manager.cpp
+++ b/src/video_core/memory_manager.cpp
@@ -210,11 +210,10 @@ bool MemoryManager::IsBlockContinuous(const GPUVAddr start, const std::size_t si
    return range == inner_size;
 }

-void MemoryManager::ReadBlock(GPUVAddr gpu_src_addr, void* dest_buffer,
-                              const std::size_t size) const {
+void MemoryManager::ReadBlock(GPUVAddr src_addr, void* dest_buffer, const std::size_t size) const {
    std::size_t remaining_size{size};
-    std::size_t page_index{gpu_src_addr >> page_bits};
-    std::size_t page_offset{gpu_src_addr & page_mask};
+    std::size_t page_index{src_addr >> page_bits};
+    std::size_t page_offset{src_addr & page_mask};

    auto& memory = system.Memory();

@@ -235,11 +234,11 @@ void MemoryManager::ReadBlock(GPUVAddr gpu_src_addr, void* dest_buffer,
    }
 }

-void MemoryManager::ReadBlockUnsafe(GPUVAddr gpu_src_addr, void* dest_buffer,
+void MemoryManager::ReadBlockUnsafe(GPUVAddr src_addr, void* dest_buffer,
                                    const std::size_t size) const {
    std::size_t remaining_size{size};
-    std::size_t page_index{gpu_src_addr >> page_bits};
-    std::size_t page_offset{gpu_src_addr & page_mask};
+    std::size_t page_index{src_addr >> page_bits};
+    std::size_t page_offset{src_addr & page_mask};

    auto& memory = system.Memory();

@@ -260,11 +259,10 @@ void MemoryManager::ReadBlockUnsafe(GPUVAddr gpu_src_addr, void* dest_buffer,
    }
 }

-void MemoryManager::WriteBlock(GPUVAddr gpu_dest_addr, const void* src_buffer,
-                               const std::size_t size) {
+void MemoryManager::WriteBlock(GPUVAddr dest_addr, const void* src_buffer, const std::size_t size) {
    std::size_t remaining_size{size};
-    std::size_t page_index{gpu_dest_addr >> page_bits};
-    std::size_t page_offset{gpu_dest_addr & page_mask};
+    std::size_t page_index{dest_addr >> page_bits};
+    std::size_t page_offset{dest_addr & page_mask};

    auto& memory = system.Memory();

@@ -285,11 +283,11 @@ void MemoryManager::WriteBlock(GPUVAddr gpu_dest_addr, const void* src_buffer,
    }
 }

-void MemoryManager::WriteBlockUnsafe(GPUVAddr gpu_dest_addr, const void* src_buffer,
+void MemoryManager::WriteBlockUnsafe(GPUVAddr dest_addr, const void* src_buffer,
                                     const std::size_t size) {
    std::size_t remaining_size{size};
-    std::size_t page_index{gpu_dest_addr >> page_bits};
-    std::size_t page_offset{gpu_dest_addr & page_mask};
+    std::size_t page_index{dest_addr >> page_bits};
+    std::size_t page_offset{dest_addr & page_mask};

    auto& memory = system.Memory();

@@ -308,18 +306,16 @@ void MemoryManager::WriteBlockUnsafe(GPUVAddr gpu_dest_addr, const void* src_buf
    }
 }

-void MemoryManager::CopyBlock(GPUVAddr gpu_dest_addr, GPUVAddr gpu_src_addr,
-                              const std::size_t size) {
+void MemoryManager::CopyBlock(GPUVAddr dest_addr, GPUVAddr src_addr, const std::size_t size) {
    std::vector<u8> tmp_buffer(size);
-    ReadBlock(gpu_src_addr, tmp_buffer.data(), size);
-    WriteBlock(gpu_dest_addr, tmp_buffer.data(), size);
+    ReadBlock(src_addr, tmp_buffer.data(), size);
+    WriteBlock(dest_addr, tmp_buffer.data(), size);
 }

-void MemoryManager::CopyBlockUnsafe(GPUVAddr gpu_dest_addr, GPUVAddr gpu_src_addr,
-                                    const std::size_t size) {
+void MemoryManager::CopyBlockUnsafe(GPUVAddr dest_addr, GPUVAddr src_addr, const std::size_t size) {
    std::vector<u8> tmp_buffer(size);
-    ReadBlockUnsafe(gpu_src_addr, tmp_buffer.data(), size);
-    WriteBlockUnsafe(gpu_dest_addr, tmp_buffer.data(), size);
+    ReadBlockUnsafe(src_addr, tmp_buffer.data(), size);
+    WriteBlockUnsafe(dest_addr, tmp_buffer.data(), size);
 }

 bool MemoryManager::IsGranularRange(GPUVAddr gpu_addr, std::size_t size) {
--- a/src/video_core/memory_manager.h
+++ b/src/video_core/memory_manager.h
@@ -79,9 +79,9 @@ public:
     * in the Host Memory counterpart. Note: This functions cause Host GPU Memory
     * Flushes and Invalidations, respectively to each operation.
     */
-    void ReadBlock(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size) const;
-    void WriteBlock(GPUVAddr gpu_dest_addr, const void* src_buffer, std::size_t size);
-    void CopyBlock(GPUVAddr gpu_dest_addr, GPUVAddr gpu_src_addr, std::size_t size);
+    void ReadBlock(GPUVAddr src_addr, void* dest_buffer, std::size_t size) const;
+    void WriteBlock(GPUVAddr dest_addr, const void* src_buffer, std::size_t size);
+    void CopyBlock(GPUVAddr dest_addr, GPUVAddr src_addr, std::size_t size);

    /**
     * ReadBlockUnsafe and WriteBlockUnsafe are special versions of ReadBlock and
@@ -93,9 +93,9 @@ public:
     * WriteBlockUnsafe instead of WriteBlock since it shouldn't invalidate the texture
     * being flushed.
     */
-    void ReadBlockUnsafe(GPUVAddr gpu_src_addr, void* dest_buffer, std::size_t size) const;
-    void WriteBlockUnsafe(GPUVAddr gpu_dest_addr, const void* src_buffer, std::size_t size);
-    void CopyBlockUnsafe(GPUVAddr gpu_dest_addr, GPUVAddr gpu_src_addr, std::size_t size);
+    void ReadBlockUnsafe(GPUVAddr src_addr, void* dest_buffer, std::size_t size) const;
+    void WriteBlockUnsafe(GPUVAddr dest_addr, const void* src_buffer, std::size_t size);
+    void CopyBlockUnsafe(GPUVAddr dest_addr, GPUVAddr src_addr, std::size_t size);

    /**
     * IsGranularRange checks if a gpu region can be simply read with a pointer
--- a/src/video_core/query_cache.h
+++ b/src/video_core/query_cache.h
@@ -220,8 +220,8 @@ private:
            return cache_begin < addr_end && addr_begin < cache_end;
        };

-        const u64 page_end = addr_end >> PAGE_BITS;
-        for (u64 page = addr_begin >> PAGE_BITS; page <= page_end; ++page) {
+        const u64 page_end = addr_end >> PAGE_SHIFT;
+        for (u64 page = addr_begin >> PAGE_SHIFT; page <= page_end; ++page) {
            const auto& it = cached_queries.find(page);
            if (it == std::end(cached_queries)) {
                continue;
@@ -242,14 +242,14 @@ private:
    /// Registers the passed parameters as cached and returns a pointer to the stored cached query.
    CachedQuery* Register(VideoCore::QueryType type, VAddr cpu_addr, u8* host_ptr, bool timestamp) {
        rasterizer.UpdatePagesCachedCount(cpu_addr, CachedQuery::SizeInBytes(timestamp), 1);
-        const u64 page = static_cast<u64>(cpu_addr) >> PAGE_BITS;
+        const u64 page = static_cast<u64>(cpu_addr) >> PAGE_SHIFT;
        return &cached_queries[page].emplace_back(static_cast<QueryCache&>(*this), type, cpu_addr,
                                                  host_ptr);
    }

    /// Tries to a get a cached query. Returns nullptr on failure.
    CachedQuery* TryGet(VAddr addr) {
-        const u64 page = static_cast<u64>(addr) >> PAGE_BITS;
+        const u64 page = static_cast<u64>(addr) >> PAGE_SHIFT;
        const auto it = cached_queries.find(page);
        if (it == std::end(cached_queries)) {
            return nullptr;
@@ -268,7 +268,7 @@ private:
    }

    static constexpr std::uintptr_t PAGE_SIZE = 4096;
-    static constexpr unsigned PAGE_BITS = 12;
+    static constexpr unsigned PAGE_SHIFT = 12;

    Core::System& system;
    VideoCore::RasterizerInterface& rasterizer;
--- a/src/video_core/rasterizer_cache.cpp
+++ b/src/video_core/rasterizer_cache.cpp
@@ -0,0 +1,7 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "video_core/rasterizer_cache.h"
+
+RasterizerCacheObject::~RasterizerCacheObject() = default;
--- a/src/video_core/rasterizer_cache.h
+++ b/src/video_core/rasterizer_cache.h
@@ -0,0 +1,197 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <mutex>
+#include <set>
+#include <unordered_map>
+
+#include <boost/icl/interval_map.hpp>
+#include <boost/range/iterator_range_core.hpp>
+
+#include "common/common_types.h"
+#include "core/settings.h"
+#include "video_core/gpu.h"
+#include "video_core/rasterizer_interface.h"
+
+class RasterizerCacheObject {
+public:
+    explicit RasterizerCacheObject(const VAddr cpu_addr) : cpu_addr{cpu_addr} {}
+
+    virtual ~RasterizerCacheObject();
+
+    VAddr GetCpuAddr() const {
+        return cpu_addr;
+    }
+
+    /// Gets the size of the shader in guest memory, required for cache management
+    virtual std::size_t GetSizeInBytes() const = 0;
+
+    /// Sets whether the cached object should be considered registered
+    void SetIsRegistered(bool registered) {
+        is_registered = registered;
+    }
+
+    /// Returns true if the cached object is registered
+    bool IsRegistered() const {
+        return is_registered;
+    }
+
+    /// Returns true if the cached object is dirty
+    bool IsDirty() const {
+        return is_dirty;
+    }
+
+    /// Returns ticks from when this cached object was last modified
+    u64 GetLastModifiedTicks() const {
+        return last_modified_ticks;
+    }
+
+    /// Marks an object as recently modified, used to specify whether it is clean or dirty
+    template <class T>
+    void MarkAsModified(bool dirty, T& cache) {
+        is_dirty = dirty;
+        last_modified_ticks = cache.GetModifiedTicks();
+    }
+
+private:
+    bool is_registered{};      ///< Whether the object is currently registered with the cache
+    bool is_dirty{};           ///< Whether the object is dirty (out of sync with guest memory)
+    u64 last_modified_ticks{}; ///< When the object was last modified, used for in-order flushing
+    VAddr cpu_addr{};          ///< Cpu address memory, unique from emulated virtual address space
+};
+
+template <class T>
+class RasterizerCache : NonCopyable {
+    friend class RasterizerCacheObject;
+
+public:
+    explicit RasterizerCache(VideoCore::RasterizerInterface& rasterizer) : rasterizer{rasterizer} {}
+
+    /// Write any cached resources overlapping the specified region back to memory
+    void FlushRegion(VAddr addr, std::size_t size) {
+        std::lock_guard lock{mutex};
+
+        const auto& objects{GetSortedObjectsFromRegion(addr, size)};
+        for (auto& object : objects) {
+            FlushObject(object);
+        }
+    }
+
+    /// Mark the specified region as being invalidated
+    void InvalidateRegion(VAddr addr, u64 size) {
+        std::lock_guard lock{mutex};
+
+        const auto& objects{GetSortedObjectsFromRegion(addr, size)};
+        for (auto& object : objects) {
+            if (!object->IsRegistered()) {
+                // Skip duplicates
+                continue;
+            }
+            Unregister(object);
+        }
+    }
+
+    /// Invalidates everything in the cache
+    void InvalidateAll() {
+        std::lock_guard lock{mutex};
+
+        while (interval_cache.begin() != interval_cache.end()) {
+            Unregister(*interval_cache.begin()->second.begin());
+        }
+    }
+
+protected:
+    /// Tries to get an object from the cache with the specified cache address
+    T TryGet(VAddr addr) const {
+        const auto iter = map_cache.find(addr);
+        if (iter != map_cache.end())
+            return iter->second;
+        return nullptr;
+    }
+
+    /// Register an object into the cache
+    virtual void Register(const T& object) {
+        std::lock_guard lock{mutex};
+
+        object->SetIsRegistered(true);
+        interval_cache.add({GetInterval(object), ObjectSet{object}});
+        map_cache.insert({object->GetCpuAddr(), object});
+        rasterizer.UpdatePagesCachedCount(object->GetCpuAddr(), object->GetSizeInBytes(), 1);
+    }
+
+    /// Unregisters an object from the cache
+    virtual void Unregister(const T& object) {
+        std::lock_guard lock{mutex};
+
+        object->SetIsRegistered(false);
+        rasterizer.UpdatePagesCachedCount(object->GetCpuAddr(), object->GetSizeInBytes(), -1);
+        const VAddr addr = object->GetCpuAddr();
+        interval_cache.subtract({GetInterval(object), ObjectSet{object}});
+        map_cache.erase(addr);
+    }
+
+    /// Returns a ticks counter used for tracking when cached objects were last modified
+    u64 GetModifiedTicks() {
+        std::lock_guard lock{mutex};
+
+        return ++modified_ticks;
+    }
+
+    virtual void FlushObjectInner(const T& object) = 0;
+
+    /// Flushes the specified object, updating appropriate cache state as needed
+    void FlushObject(const T& object) {
+        std::lock_guard lock{mutex};
+
+        if (!object->IsDirty()) {
+            return;
+        }
+        FlushObjectInner(object);
+        object->MarkAsModified(false, *this);
+    }
+
+    std::recursive_mutex mutex;
+
+private:
+    /// Returns a list of cached objects from the specified memory region, ordered by access time
+    std::vector<T> GetSortedObjectsFromRegion(VAddr addr, u64 size) {
+        if (size == 0) {
+            return {};
+        }
+
+        std::vector<T> objects;
+        const ObjectInterval interval{addr, addr + size};
+        for (auto& pair : boost::make_iterator_range(interval_cache.equal_range(interval))) {
+            for (auto& cached_object : pair.second) {
+                if (!cached_object) {
+                    continue;
+                }
+                objects.push_back(cached_object);
+            }
+        }
+
+        std::sort(objects.begin(), objects.end(), [](const T& a, const T& b) -> bool {
+            return a->GetLastModifiedTicks() < b->GetLastModifiedTicks();
+        });
+
+        return objects;
+    }
+
+    using ObjectSet = std::set<T>;
+    using ObjectCache = std::unordered_map<VAddr, T>;
+    using IntervalCache = boost::icl::interval_map<VAddr, ObjectSet>;
+    using ObjectInterval = typename IntervalCache::interval_type;
+
+    static auto GetInterval(const T& object) {
+        return ObjectInterval::right_open(object->GetCpuAddr(),
+                                          object->GetCpuAddr() + object->GetSizeInBytes());
+    }
+
+    ObjectCache map_cache;
+    IntervalCache interval_cache; ///< Cache of objects
+    u64 modified_ticks{};         ///< Counter of cache state ticks, used for in-order flushing
+    VideoCore::RasterizerInterface& rasterizer;
+};
--- a/Show More
+++ b/Show More