implement invert

.travis.yml

@@ -20,7 +20,6 @@ matrix:
       install: "./.travis/linux/deps.sh"
       script: "./.travis/linux/build.sh"
       after_success: "./.travis/linux/upload.sh"
-      cache: ccache
     - os: osx
       env: NAME="macos build"
       sudo: false
@@ -28,7 +27,6 @@ matrix:
       install: "./.travis/macos/deps.sh"
       script: "./.travis/macos/build.sh"
       after_success: "./.travis/macos/upload.sh"
-      cache: ccache
 
 deploy:
   provider: releases
@@ -44,3 +42,7 @@ notifications:
   webhooks:
     urls:
       - https://api.yuzu-emu.org/code/travis/notify
+
+cache:
+  directories:
+    - $HOME/.ccache

.travis/common/travis-ci.env

@@ -1,12 +0,0 @@
-# List of environment variables to be shared with Docker containers
-CI
-TRAVIS
-CONTINUOUS_INTEGRATION
-TRAVIS_BRANCH
-TRAVIS_BUILD_ID
-TRAVIS_BUILD_NUMBER
-TRAVIS_COMMIT
-TRAVIS_JOB_ID
-TRAVIS_JOB_NUMBER
-TRAVIS_REPO_SLUG
-TRAVIS_TAG

.travis/linux/build.sh

@@ -1,4 +1,3 @@
 #!/bin/bash -ex
 
-mkdir -p "$HOME/.ccache"
-docker run --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache ubuntu:18.04 /bin/bash /yuzu/.travis/linux/docker.sh
+docker run -e CCACHE_DIR=/ccache -v $HOME/.ccache:/ccache -v $(pwd):/yuzu ubuntu:18.04 /bin/bash /yuzu/.travis/linux/docker.sh

.travis/linux/docker.sh

@@ -5,8 +5,14 @@ apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev
 
 cd /yuzu
 
+export PATH=/usr/lib/ccache:$PATH
+ln -sf /usr/bin/ccache /usr/lib/ccache/cc
+ln -sf /usr/bin/ccache /usr/lib/ccache/c++
 mkdir build && cd build
-cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -G Ninja
+ccache --show-stats > ccache_before
+cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -G Ninja
 ninja
+ccache --show-stats > ccache_after
+diff -U100 ccache_before ccache_after || true
 
 ctest -VV -C Release

.travis/macos/build.sh

@@ -5,11 +5,14 @@ set -o pipefail
 export MACOSX_DEPLOYMENT_TARGET=10.12
 export Qt5_DIR=$(brew --prefix)/opt/qt5
 export UNICORNDIR=$(pwd)/externals/unicorn
-export PATH="/usr/local/opt/ccache/libexec:$PATH"
 
 mkdir build && cd build
+export PATH=/usr/local/opt/ccache/libexec:$PATH
+ccache --show-stats > ccache_before
 cmake --version
-cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON
+cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release
 make -j4
+ccache --show-stats > ccache_after
+diff -U100 ccache_before ccache_after || true
 
 ctest -VV -C Release

CMakeLists.txt

@@ -41,19 +41,6 @@ function(check_submodules_present)
 endfunction()
 check_submodules_present()
 
-configure_file(${CMAKE_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
-               ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
-               COPYONLY)
-if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
-    message(STATUS "Downloading compatibility list for yuzu...")
-    file(DOWNLOAD
-        https://api.yuzu-emu.org/gamedb/
-        "${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
-endif()
-if (NOT EXISTS ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
-    file(WRITE ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
-endif()
-
 # Detect current compilation architecture and create standard definitions
 # =======================================================================
 

appveyor.yml

@@ -41,9 +41,9 @@ before_build:
   - ps: |
         if ($env:BUILD_TYPE -eq 'msvc') {
           # redirect stderr and change the exit code to prevent powershell from cancelling the build if cmake prints a warning
-          cmd /C 'cmake -G "Visual Studio 15 2017 Win64" -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON .. 2>&1 && exit 0'
+          cmd /C 'cmake -G "Visual Studio 15 2017 Win64" -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_BUNDLED_UNICORN=1 .. 2>&1 && exit 0'
         } else {
-          C:\msys64\usr\bin\bash.exe -lc "cmake -G 'MSYS Makefiles' -DYUZU_BUILD_UNICORN=1 -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON .. 2>&1"
+          C:\msys64\usr\bin\bash.exe -lc "cmake -G 'MSYS Makefiles' -DYUZU_BUILD_UNICORN=1 -DCMAKE_BUILD_TYPE=Release .. 2>&1"
         }
   - cd ..
 

dist/compatibility_list/compatibility_list.qrc

@@ -1,5 +0,0 @@
-<RCC>
-  <qresource prefix="compatibility_list">
-      <file>compatibility_list.json</file>
-  </qresource>
-</RCC>

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -9,7 +9,6 @@
 #include "common/logging/log.h"
 #include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc.h"

src/core/core.cpp

@@ -2,35 +2,24 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <array>
-#include <map>
 #include <memory>
-#include <thread>
 #include <utility>
-
 #include "common/logging/log.h"
 #include "common/string_util.h"
-#include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/controller.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
-#include "core/perf_stats.h"
 #include "core/settings.h"
-#include "core/telemetry_session.h"
 #include "file_sys/vfs_concat.h"
 #include "file_sys/vfs_real.h"
-#include "video_core/debug_utils/debug_utils.h"
-#include "video_core/gpu.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 
@@ -38,9 +27,71 @@ namespace Core {
 
 /*static*/ System System::s_instance;
 
-namespace {
-FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
-                                         const std::string& path) {
+System::System() = default;
+
+System::~System() = default;
+
+/// Runs a CPU core while the system is powered on
+static void RunCpuCore(std::shared_ptr<Cpu> cpu_state) {
+    while (Core::System::GetInstance().IsPoweredOn()) {
+        cpu_state->RunLoop(true);
+    }
+}
+
+Cpu& System::CurrentCpuCore() {
+    // If multicore is enabled, use host thread to figure out the current CPU core
+    if (Settings::values.use_multi_core) {
+        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
+        ASSERT(search != thread_to_cpu.end());
+        ASSERT(search->second);
+        return *search->second;
+    }
+
+    // Otherwise, use single-threaded mode active_core variable
+    return *cpu_cores[active_core];
+}
+
+System::ResultStatus System::RunLoop(bool tight_loop) {
+    status = ResultStatus::Success;
+
+    // Update thread_to_cpu in case Core 0 is run from a different host thread
+    thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0];
+
+    if (GDBStub::IsServerEnabled()) {
+        GDBStub::HandlePacket();
+
+        // If the loop is halted and we want to step, use a tiny (1) number of instructions to
+        // execute. Otherwise, get out of the loop function.
+        if (GDBStub::GetCpuHaltFlag()) {
+            if (GDBStub::GetCpuStepFlag()) {
+                tight_loop = false;
+            } else {
+                return ResultStatus::Success;
+            }
+        }
+    }
+
+    for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
+        cpu_cores[active_core]->RunLoop(tight_loop);
+        if (Settings::values.use_multi_core) {
+            // Cores 1-3 are run on other threads in this mode
+            break;
+        }
+    }
+
+    if (GDBStub::IsServerEnabled()) {
+        GDBStub::SetCpuStepFlag(false);
+    }
+
+    return status;
+}
+
+System::ResultStatus System::SingleStep() {
+    return RunLoop(false);
+}
+
+static FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
+                                                const std::string& path) {
     // To account for split 00+01+etc files.
     std::string dir_name;
     std::string filename;
@@ -70,402 +121,165 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
     return vfs->OpenFile(path, FileSys::Mode::Read);
 }
 
-/// Runs a CPU core while the system is powered on
-void RunCpuCore(std::shared_ptr<Cpu> cpu_state) {
-    while (Core::System::GetInstance().IsPoweredOn()) {
-        cpu_state->RunLoop(true);
-    }
-}
-} // Anonymous namespace
-
-struct System::Impl {
-    Cpu& CurrentCpuCore() {
-        if (Settings::values.use_multi_core) {
-            const auto& search = thread_to_cpu.find(std::this_thread::get_id());
-            ASSERT(search != thread_to_cpu.end());
-            ASSERT(search->second);
-            return *search->second;
-        }
-
-        // Otherwise, use single-threaded mode active_core variable
-        return *cpu_cores[active_core];
-    }
-
-    ResultStatus RunLoop(bool tight_loop) {
-        status = ResultStatus::Success;
-
-        // Update thread_to_cpu in case Core 0 is run from a different host thread
-        thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0];
-
-        if (GDBStub::IsServerEnabled()) {
-            GDBStub::HandlePacket();
-
-            // If the loop is halted and we want to step, use a tiny (1) number of instructions to
-            // execute. Otherwise, get out of the loop function.
-            if (GDBStub::GetCpuHaltFlag()) {
-                if (GDBStub::GetCpuStepFlag()) {
-                    tight_loop = false;
-                } else {
-                    return ResultStatus::Success;
-                }
-            }
-        }
-
-        for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
-            cpu_cores[active_core]->RunLoop(tight_loop);
-            if (Settings::values.use_multi_core) {
-                // Cores 1-3 are run on other threads in this mode
-                break;
-            }
-        }
-
-        if (GDBStub::IsServerEnabled()) {
-            GDBStub::SetCpuStepFlag(false);
-        }
-
-        return status;
-    }
-
-    ResultStatus Init(Frontend::EmuWindow& emu_window) {
-        LOG_DEBUG(HW_Memory, "initialized OK");
-
-        CoreTiming::Init();
-        kernel.Initialize();
-
-        // Create a default fs if one doesn't already exist.
-        if (virtual_filesystem == nullptr)
-            virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
-
-        current_process = Kernel::Process::Create(kernel, "main");
-
-        cpu_barrier = std::make_shared<CpuBarrier>();
-        cpu_exclusive_monitor = Cpu::MakeExclusiveMonitor(cpu_cores.size());
-        for (size_t index = 0; index < cpu_cores.size(); ++index) {
-            cpu_cores[index] = std::make_shared<Cpu>(cpu_exclusive_monitor, cpu_barrier, index);
-        }
-
-        telemetry_session = std::make_unique<Core::TelemetrySession>();
-        service_manager = std::make_shared<Service::SM::ServiceManager>();
-
-        Service::Init(service_manager, virtual_filesystem);
-        GDBStub::Init();
-
-        renderer = VideoCore::CreateRenderer(emu_window);
-        if (!renderer->Init()) {
-            return ResultStatus::ErrorVideoCore;
-        }
-
-        gpu_core = std::make_unique<Tegra::GPU>(renderer->Rasterizer());
-
-        // Create threads for CPU cores 1-3, and build thread_to_cpu map
-        // CPU core 0 is run on the main thread
-        thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0];
-        if (Settings::values.use_multi_core) {
-            for (size_t index = 0; index < cpu_core_threads.size(); ++index) {
-                cpu_core_threads[index] =
-                    std::make_unique<std::thread>(RunCpuCore, cpu_cores[index + 1]);
-                thread_to_cpu[cpu_core_threads[index]->get_id()] = cpu_cores[index + 1];
-            }
-        }
-
-        LOG_DEBUG(Core, "Initialized OK");
-
-        // Reset counters and set time origin to current frame
-        GetAndResetPerfStats();
-        perf_stats.BeginSystemFrame();
-
-        return ResultStatus::Success;
-    }
-
-    ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
-        app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
-
-        if (!app_loader) {
-            LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
-            return ResultStatus::ErrorGetLoader;
-        }
-        std::pair<boost::optional<u32>, Loader::ResultStatus> system_mode =
-            app_loader->LoadKernelSystemMode();
-
-        if (system_mode.second != Loader::ResultStatus::Success) {
-            LOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
-                         static_cast<int>(system_mode.second));
-
-            return ResultStatus::ErrorSystemMode;
-        }
-
-        ResultStatus init_result{Init(emu_window)};
-        if (init_result != ResultStatus::Success) {
-            LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
-                         static_cast<int>(init_result));
-            Shutdown();
-            return init_result;
-        }
-
-        const Loader::ResultStatus load_result{app_loader->Load(current_process)};
-        if (load_result != Loader::ResultStatus::Success) {
-            LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
-            Shutdown();
-
-            return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
-                                             static_cast<u32>(load_result));
-        }
-        status = ResultStatus::Success;
-        return status;
-    }
-
-    void Shutdown() {
-        // Log last frame performance stats
-        auto perf_results = GetAndResetPerfStats();
-        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_EmulationSpeed",
-                             perf_results.emulation_speed * 100.0);
-        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Framerate",
-                             perf_results.game_fps);
-        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
-                             perf_results.frametime * 1000.0);
-
-        // Shutdown emulation session
-        renderer.reset();
-        GDBStub::Shutdown();
-        Service::Shutdown();
-        service_manager.reset();
-        telemetry_session.reset();
-        gpu_core.reset();
-
-        // Close all CPU/threading state
-        cpu_barrier->NotifyEnd();
-        if (Settings::values.use_multi_core) {
-            for (auto& thread : cpu_core_threads) {
-                thread->join();
-                thread.reset();
-            }
-        }
-        thread_to_cpu.clear();
-        for (auto& cpu_core : cpu_cores) {
-            cpu_core.reset();
-        }
-        cpu_barrier.reset();
-
-        // Shutdown kernel and core timing
-        kernel.Shutdown();
-        CoreTiming::Shutdown();
-
-        // Close app loader
-        app_loader.reset();
-
-        LOG_DEBUG(Core, "Shutdown OK");
-    }
-
-    Loader::ResultStatus GetGameName(std::string& out) const {
-        if (app_loader == nullptr)
-            return Loader::ResultStatus::ErrorNotInitialized;
-        return app_loader->ReadTitle(out);
-    }
-
-    void SetStatus(ResultStatus new_status, const char* details = nullptr) {
-        status = new_status;
-        if (details) {
-            status_details = details;
-        }
-    }
-
-    PerfStatsResults GetAndResetPerfStats() {
-        return perf_stats.GetAndResetStats(CoreTiming::GetGlobalTimeUs());
-    }
-
-    Kernel::KernelCore kernel;
-    /// RealVfsFilesystem instance
-    FileSys::VirtualFilesystem virtual_filesystem;
-    /// AppLoader used to load the current executing application
-    std::unique_ptr<Loader::AppLoader> app_loader;
-    std::unique_ptr<VideoCore::RendererBase> renderer;
-    std::unique_ptr<Tegra::GPU> gpu_core;
-    std::shared_ptr<Tegra::DebugContext> debug_context;
-    Kernel::SharedPtr<Kernel::Process> current_process;
-    std::shared_ptr<ExclusiveMonitor> cpu_exclusive_monitor;
-    std::shared_ptr<CpuBarrier> cpu_barrier;
-    std::array<std::shared_ptr<Cpu>, NUM_CPU_CORES> cpu_cores;
-    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> cpu_core_threads;
-    size_t active_core{}; ///< Active core, only used in single thread mode
-
-    /// Service manager
-    std::shared_ptr<Service::SM::ServiceManager> service_manager;
-
-    /// Telemetry session for this emulation session
-    std::unique_ptr<Core::TelemetrySession> telemetry_session;
-
-    ResultStatus status = ResultStatus::Success;
-    std::string status_details = "";
-
-    /// Map of guest threads to CPU cores
-    std::map<std::thread::id, std::shared_ptr<Cpu>> thread_to_cpu;
-
-    Core::PerfStats perf_stats;
-    Core::FrameLimiter frame_limiter;
-};
-
-System::System() : impl{std::make_unique<Impl>()} {}
-System::~System() = default;
-
-Cpu& System::CurrentCpuCore() {
-    return impl->CurrentCpuCore();
-}
-
-System::ResultStatus System::RunLoop(bool tight_loop) {
-    return impl->RunLoop(tight_loop);
-}
-
-System::ResultStatus System::SingleStep() {
-    return RunLoop(false);
-}
-
-void System::InvalidateCpuInstructionCaches() {
-    for (auto& cpu : impl->cpu_cores) {
-        cpu->ArmInterface().ClearInstructionCache();
-    }
-}
-
 System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
-    return impl->Load(emu_window, filepath);
-}
+    app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
 
-bool System::IsPoweredOn() const {
-    return impl->cpu_barrier && impl->cpu_barrier->IsAlive();
+    if (!app_loader) {
+        LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
+        return ResultStatus::ErrorGetLoader;
+    }
+    std::pair<boost::optional<u32>, Loader::ResultStatus> system_mode =
+        app_loader->LoadKernelSystemMode();
+
+    if (system_mode.second != Loader::ResultStatus::Success) {
+        LOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
+                     static_cast<int>(system_mode.second));
+
+        return ResultStatus::ErrorSystemMode;
+    }
+
+    ResultStatus init_result{Init(emu_window)};
+    if (init_result != ResultStatus::Success) {
+        LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
+                     static_cast<int>(init_result));
+        System::Shutdown();
+        return init_result;
+    }
+
+    const Loader::ResultStatus load_result{app_loader->Load(current_process)};
+    if (load_result != Loader::ResultStatus::Success) {
+        LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
+        System::Shutdown();
+
+        return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
+                                         static_cast<u32>(load_result));
+    }
+    status = ResultStatus::Success;
+    return status;
 }
 
 void System::PrepareReschedule() {
     CurrentCpuCore().PrepareReschedule();
 }
 
-PerfStatsResults System::GetAndResetPerfStats() {
-    return impl->GetAndResetPerfStats();
-}
-
-Core::TelemetrySession& System::TelemetrySession() const {
-    return *impl->telemetry_session;
-}
-
-ARM_Interface& System::CurrentArmInterface() {
-    return CurrentCpuCore().ArmInterface();
-}
-
-size_t System::CurrentCoreIndex() {
-    return CurrentCpuCore().CoreIndex();
-}
-
-Kernel::Scheduler& System::CurrentScheduler() {
-    return *CurrentCpuCore().Scheduler();
+PerfStats::Results System::GetAndResetPerfStats() {
+    return perf_stats.GetAndResetStats(CoreTiming::GetGlobalTimeUs());
 }
 
 const std::shared_ptr<Kernel::Scheduler>& System::Scheduler(size_t core_index) {
     ASSERT(core_index < NUM_CPU_CORES);
-    return impl->cpu_cores[core_index]->Scheduler();
-}
-
-Kernel::SharedPtr<Kernel::Process>& System::CurrentProcess() {
-    return impl->current_process;
+    return cpu_cores[core_index]->Scheduler();
 }
 
 ARM_Interface& System::ArmInterface(size_t core_index) {
     ASSERT(core_index < NUM_CPU_CORES);
-    return impl->cpu_cores[core_index]->ArmInterface();
+    return cpu_cores[core_index]->ArmInterface();
 }
 
 Cpu& System::CpuCore(size_t core_index) {
     ASSERT(core_index < NUM_CPU_CORES);
-    return *impl->cpu_cores[core_index];
-}
-
-ExclusiveMonitor& System::Monitor() {
-    return *impl->cpu_exclusive_monitor;
-}
-
-Tegra::GPU& System::GPU() {
-    return *impl->gpu_core;
-}
-
-const Tegra::GPU& System::GPU() const {
-    return *impl->gpu_core;
-}
-
-VideoCore::RendererBase& System::Renderer() {
-    return *impl->renderer;
-}
-
-const VideoCore::RendererBase& System::Renderer() const {
-    return *impl->renderer;
-}
-
-Kernel::KernelCore& System::Kernel() {
-    return impl->kernel;
-}
-
-const Kernel::KernelCore& System::Kernel() const {
-    return impl->kernel;
-}
-
-Core::PerfStats& System::GetPerfStats() {
-    return impl->perf_stats;
-}
-
-const Core::PerfStats& System::GetPerfStats() const {
-    return impl->perf_stats;
-}
-
-Core::FrameLimiter& System::FrameLimiter() {
-    return impl->frame_limiter;
-}
-
-const Core::FrameLimiter& System::FrameLimiter() const {
-    return impl->frame_limiter;
-}
-
-Loader::ResultStatus System::GetGameName(std::string& out) const {
-    return impl->GetGameName(out);
-}
-
-void System::SetStatus(ResultStatus new_status, const char* details) {
-    impl->SetStatus(new_status, details);
-}
-
-const std::string& System::GetStatusDetails() const {
-    return impl->status_details;
-}
-
-Loader::AppLoader& System::GetAppLoader() const {
-    return *impl->app_loader;
-}
-
-void System::SetGPUDebugContext(std::shared_ptr<Tegra::DebugContext> context) {
-    impl->debug_context = std::move(context);
-}
-
-std::shared_ptr<Tegra::DebugContext> System::GetGPUDebugContext() const {
-    return impl->debug_context;
-}
-
-void System::SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs) {
-    impl->virtual_filesystem = std::move(vfs);
-}
-
-std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
-    return impl->virtual_filesystem;
+    return *cpu_cores[core_index];
 }
 
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
-    return impl->Init(emu_window);
+    LOG_DEBUG(HW_Memory, "initialized OK");
+
+    CoreTiming::Init();
+
+    // Create a default fs if one doesn't already exist.
+    if (virtual_filesystem == nullptr)
+        virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
+
+    current_process = Kernel::Process::Create("main");
+
+    cpu_barrier = std::make_shared<CpuBarrier>();
+    cpu_exclusive_monitor = Cpu::MakeExclusiveMonitor(cpu_cores.size());
+    for (size_t index = 0; index < cpu_cores.size(); ++index) {
+        cpu_cores[index] = std::make_shared<Cpu>(cpu_exclusive_monitor, cpu_barrier, index);
+    }
+
+    telemetry_session = std::make_unique<Core::TelemetrySession>();
+    service_manager = std::make_shared<Service::SM::ServiceManager>();
+
+    Kernel::Init();
+    Service::Init(service_manager, virtual_filesystem);
+    GDBStub::Init();
+
+    renderer = VideoCore::CreateRenderer(emu_window);
+    if (!renderer->Init()) {
+        return ResultStatus::ErrorVideoCore;
+    }
+
+    gpu_core = std::make_unique<Tegra::GPU>(renderer->Rasterizer());
+
+    // Create threads for CPU cores 1-3, and build thread_to_cpu map
+    // CPU core 0 is run on the main thread
+    thread_to_cpu[std::this_thread::get_id()] = cpu_cores[0];
+    if (Settings::values.use_multi_core) {
+        for (size_t index = 0; index < cpu_core_threads.size(); ++index) {
+            cpu_core_threads[index] =
+                std::make_unique<std::thread>(RunCpuCore, cpu_cores[index + 1]);
+            thread_to_cpu[cpu_core_threads[index]->get_id()] = cpu_cores[index + 1];
+        }
+    }
+
+    LOG_DEBUG(Core, "Initialized OK");
+
+    // Reset counters and set time origin to current frame
+    GetAndResetPerfStats();
+    perf_stats.BeginSystemFrame();
+
+    return ResultStatus::Success;
 }
 
 void System::Shutdown() {
-    impl->Shutdown();
+    // Log last frame performance stats
+    auto perf_results = GetAndResetPerfStats();
+    Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_EmulationSpeed",
+                         perf_results.emulation_speed * 100.0);
+    Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Framerate",
+                         perf_results.game_fps);
+    Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
+                         perf_results.frametime * 1000.0);
+
+    // Shutdown emulation session
+    renderer.reset();
+    GDBStub::Shutdown();
+    Service::Shutdown();
+    Kernel::Shutdown();
+    service_manager.reset();
+    telemetry_session.reset();
+    gpu_core.reset();
+
+    // Close all CPU/threading state
+    cpu_barrier->NotifyEnd();
+    if (Settings::values.use_multi_core) {
+        for (auto& thread : cpu_core_threads) {
+            thread->join();
+            thread.reset();
+        }
+    }
+    thread_to_cpu.clear();
+    for (auto& cpu_core : cpu_cores) {
+        cpu_core.reset();
+    }
+    cpu_barrier.reset();
+
+    // Close core timing
+    CoreTiming::Shutdown();
+
+    // Close app loader
+    app_loader.reset();
+
+    LOG_DEBUG(Core, "Shutdown OK");
 }
 
 Service::SM::ServiceManager& System::ServiceManager() {
-    return *impl->service_manager;
+    return *service_manager;
 }
 
 const Service::SM::ServiceManager& System::ServiceManager() const {
-    return *impl->service_manager;
+    return *service_manager;
 }
 
 } // namespace Core

src/core/core.h

@@ -4,55 +4,40 @@
 
 #pragma once
 
-#include <cstddef>
+#include <array>
+#include <map>
 #include <memory>
 #include <string>
-
+#include <thread>
 #include "common/common_types.h"
+#include "core/arm/exclusive_monitor.h"
+#include "core/core_cpu.h"
 #include "core/hle/kernel/object.h"
+#include "core/hle/kernel/scheduler.h"
+#include "core/loader/loader.h"
+#include "core/memory.h"
+#include "core/perf_stats.h"
+#include "core/telemetry_session.h"
+#include "file_sys/vfs_real.h"
+#include "hle/service/filesystem/filesystem.h"
+#include "video_core/debug_utils/debug_utils.h"
+#include "video_core/gpu.h"
 
 namespace Core::Frontend {
 class EmuWindow;
-} // namespace Core::Frontend
-
-namespace FileSys {
-class VfsFilesystem;
-} // namespace FileSys
-
-namespace Kernel {
-class KernelCore;
-class Process;
-class Scheduler;
-} // namespace Kernel
-
-namespace Loader {
-class AppLoader;
-enum class ResultStatus : u16;
-} // namespace Loader
+}
 
 namespace Service::SM {
 class ServiceManager;
-} // namespace Service::SM
-
-namespace Tegra {
-class DebugContext;
-class GPU;
-} // namespace Tegra
+}
 
 namespace VideoCore {
 class RendererBase;
-} // namespace VideoCore
+}
 
 namespace Core {
 
 class ARM_Interface;
-class Cpu;
-class ExclusiveMonitor;
-class FrameLimiter;
-class PerfStats;
-class TelemetrySession;
-
-struct PerfStatsResults;
 
 class System {
 public:
@@ -108,7 +93,11 @@ public:
      * This function should only be used by GDB Stub to support breakpoints, memory updates and
      * step/continue commands.
      */
-    void InvalidateCpuInstructionCaches();
+    void InvalidateCpuInstructionCaches() {
+        for (auto& cpu : cpu_cores) {
+            cpu->ArmInterface().ClearInstructionCache();
+        }
+    }
 
     /// Shutdown the emulated system.
     void Shutdown();
@@ -127,28 +116,33 @@ public:
      * application).
      * @returns True if the emulated system is powered on, otherwise false.
      */
-    bool IsPoweredOn() const;
+    bool IsPoweredOn() const {
+        return cpu_barrier && cpu_barrier->IsAlive();
+    }
 
     /**
      * Returns a reference to the telemetry session for this emulation session.
      * @returns Reference to the telemetry session.
      */
-    Core::TelemetrySession& TelemetrySession() const;
+    Core::TelemetrySession& TelemetrySession() const {
+        return *telemetry_session;
+    }
 
     /// Prepare the core emulation for a reschedule
     void PrepareReschedule();
 
     /// Gets and resets core performance statistics
-    PerfStatsResults GetAndResetPerfStats();
+    PerfStats::Results GetAndResetPerfStats();
 
     /// Gets an ARM interface to the CPU core that is currently running
-    ARM_Interface& CurrentArmInterface();
+    ARM_Interface& CurrentArmInterface() {
+        return CurrentCpuCore().ArmInterface();
+    }
 
     /// Gets the index of the currently running CPU core
-    size_t CurrentCoreIndex();
-
-    /// Gets the scheduler for the CPU core that is currently running
-    Kernel::Scheduler& CurrentScheduler();
+    size_t CurrentCoreIndex() {
+        return CurrentCpuCore().CoreIndex();
+    }
 
     /// Gets an ARM interface to the CPU core with the specified index
     ARM_Interface& ArmInterface(size_t core_index);
@@ -156,64 +150,87 @@ public:
     /// Gets a CPU interface to the CPU core with the specified index
     Cpu& CpuCore(size_t core_index);
 
-    /// Gets the exclusive monitor
-    ExclusiveMonitor& Monitor();
-
     /// Gets a mutable reference to the GPU interface
-    Tegra::GPU& GPU();
+    Tegra::GPU& GPU() {
+        return *gpu_core;
+    }
 
     /// Gets an immutable reference to the GPU interface.
-    const Tegra::GPU& GPU() const;
+    const Tegra::GPU& GPU() const {
+        return *gpu_core;
+    }
 
     /// Gets a mutable reference to the renderer.
-    VideoCore::RendererBase& Renderer();
+    VideoCore::RendererBase& Renderer() {
+        return *renderer;
+    }
 
     /// Gets an immutable reference to the renderer.
-    const VideoCore::RendererBase& Renderer() const;
+    const VideoCore::RendererBase& Renderer() const {
+        return *renderer;
+    }
+
+    /// Gets the scheduler for the CPU core that is currently running
+    Kernel::Scheduler& CurrentScheduler() {
+        return *CurrentCpuCore().Scheduler();
+    }
+
+    /// Gets the exclusive monitor
+    ExclusiveMonitor& Monitor() {
+        return *cpu_exclusive_monitor;
+    }
 
     /// Gets the scheduler for the CPU core with the specified index
     const std::shared_ptr<Kernel::Scheduler>& Scheduler(size_t core_index);
 
     /// Gets the current process
-    Kernel::SharedPtr<Kernel::Process>& CurrentProcess();
-
-    /// Provides a reference to the kernel instance.
-    Kernel::KernelCore& Kernel();
-
-    /// Provides a constant reference to the kernel instance.
-    const Kernel::KernelCore& Kernel() const;
-
-    /// Provides a reference to the internal PerfStats instance.
-    Core::PerfStats& GetPerfStats();
-
-    /// Provides a constant reference to the internal PerfStats instance.
-    const Core::PerfStats& GetPerfStats() const;
-
-    /// Provides a reference to the frame limiter;
-    Core::FrameLimiter& FrameLimiter();
-
-    /// Provides a constant referent to the frame limiter
-    const Core::FrameLimiter& FrameLimiter() const;
+    Kernel::SharedPtr<Kernel::Process>& CurrentProcess() {
+        return current_process;
+    }
 
     /// Gets the name of the current game
-    Loader::ResultStatus GetGameName(std::string& out) const;
+    Loader::ResultStatus GetGameName(std::string& out) const {
+        if (app_loader == nullptr)
+            return Loader::ResultStatus::ErrorNotInitialized;
+        return app_loader->ReadTitle(out);
+    }
 
-    void SetStatus(ResultStatus new_status, const char* details);
+    PerfStats perf_stats;
+    FrameLimiter frame_limiter;
 
-    const std::string& GetStatusDetails() const;
+    void SetStatus(ResultStatus new_status, const char* details = nullptr) {
+        status = new_status;
+        if (details) {
+            status_details = details;
+        }
+    }
 
-    Loader::AppLoader& GetAppLoader() const;
+    const std::string& GetStatusDetails() const {
+        return status_details;
+    }
+
+    Loader::AppLoader& GetAppLoader() const {
+        return *app_loader;
+    }
 
     Service::SM::ServiceManager& ServiceManager();
     const Service::SM::ServiceManager& ServiceManager() const;
 
-    void SetGPUDebugContext(std::shared_ptr<Tegra::DebugContext> context);
+    void SetGPUDebugContext(std::shared_ptr<Tegra::DebugContext> context) {
+        debug_context = std::move(context);
+    }
 
-    std::shared_ptr<Tegra::DebugContext> GetGPUDebugContext() const;
+    std::shared_ptr<Tegra::DebugContext> GetGPUDebugContext() const {
+        return debug_context;
+    }
 
-    void SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs);
+    void SetFilesystem(FileSys::VirtualFilesystem vfs) {
+        virtual_filesystem = std::move(vfs);
+    }
 
-    std::shared_ptr<FileSys::VfsFilesystem> GetFilesystem() const;
+    FileSys::VirtualFilesystem GetFilesystem() const {
+        return virtual_filesystem;
+    }
 
 private:
     System();
@@ -229,10 +246,33 @@ private:
      */
     ResultStatus Init(Frontend::EmuWindow& emu_window);
 
-    struct Impl;
-    std::unique_ptr<Impl> impl;
+    /// RealVfsFilesystem instance
+    FileSys::VirtualFilesystem virtual_filesystem;
+    /// AppLoader used to load the current executing application
+    std::unique_ptr<Loader::AppLoader> app_loader;
+    std::unique_ptr<VideoCore::RendererBase> renderer;
+    std::unique_ptr<Tegra::GPU> gpu_core;
+    std::shared_ptr<Tegra::DebugContext> debug_context;
+    Kernel::SharedPtr<Kernel::Process> current_process;
+    std::shared_ptr<ExclusiveMonitor> cpu_exclusive_monitor;
+    std::shared_ptr<CpuBarrier> cpu_barrier;
+    std::array<std::shared_ptr<Cpu>, NUM_CPU_CORES> cpu_cores;
+    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> cpu_core_threads;
+    size_t active_core{}; ///< Active core, only used in single thread mode
+
+    /// Service manager
+    std::shared_ptr<Service::SM::ServiceManager> service_manager;
+
+    /// Telemetry session for this emulation session
+    std::unique_ptr<Core::TelemetrySession> telemetry_session;
 
     static System s_instance;
+
+    ResultStatus status = ResultStatus::Success;
+    std::string status_details = "";
+
+    /// Map of guest threads to CPU cores
+    std::map<std::thread::id, std::shared_ptr<Cpu>> thread_to_cpu;
 };
 
 inline ARM_Interface& CurrentArmInterface() {

src/core/file_sys/savedata_factory.cpp

@@ -7,7 +7,6 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/file_sys/savedata_factory.h"
-#include "core/file_sys/vfs.h"
 #include "core/hle/kernel/process.h"
 
 namespace FileSys {

src/core/file_sys/savedata_factory.h

@@ -8,7 +8,6 @@
 #include <string>
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
 
 namespace FileSys {

src/core/hle/ipc_helpers.h

@@ -12,7 +12,6 @@
 #include <utility>
 #include "common/assert.h"
 #include "common/common_types.h"
-#include "core/core.h"
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
@@ -136,9 +135,7 @@ public:
         if (context->Session()->IsDomain()) {
             context->AddDomainObject(std::move(iface));
         } else {
-            auto& kernel = Core::System::GetInstance().Kernel();
-            auto sessions =
-                Kernel::ServerSession::CreateSessionPair(kernel, iface->GetServiceName());
+            auto sessions = Kernel::ServerSession::CreateSessionPair(iface->GetServiceName());
             auto server = std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions);
             auto client = std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions);
             iface->ClientConnected(server);

src/core/hle/kernel/address_arbiter.cpp

@@ -8,11 +8,9 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/result.h"
 #include "core/memory.h"

src/core/hle/kernel/client_port.cpp

@@ -14,7 +14,7 @@
 
 namespace Kernel {
 
-ClientPort::ClientPort(KernelCore& kernel) : Object{kernel} {}
+ClientPort::ClientPort() = default;
 ClientPort::~ClientPort() = default;
 
 ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
@@ -27,7 +27,7 @@ ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
     active_sessions++;
 
     // Create a new session pair, let the created sessions inherit the parent port's HLE handler.
-    auto sessions = ServerSession::CreateSessionPair(kernel, server_port->GetName(), this);
+    auto sessions = ServerSession::CreateSessionPair(server_port->GetName(), this);
 
     if (server_port->hle_handler)
         server_port->hle_handler->ClientConnected(std::get<SharedPtr<ServerSession>>(sessions));

src/core/hle/kernel/client_port.h

@@ -11,9 +11,8 @@
 
 namespace Kernel {
 
-class ClientSession;
-class KernelCore;
 class ServerPort;
+class ClientSession;
 
 class ClientPort final : public Object {
 public:
@@ -45,7 +44,7 @@ public:
     void ConnectionClosed();
 
 private:
-    explicit ClientPort(KernelCore& kernel);
+    ClientPort();
     ~ClientPort() override;
 
     SharedPtr<ServerPort> server_port; ///< ServerPort associated with this client port.

src/core/hle/kernel/client_session.cpp

@@ -11,7 +11,7 @@
 
 namespace Kernel {
 
-ClientSession::ClientSession(KernelCore& kernel) : Object{kernel} {}
+ClientSession::ClientSession() = default;
 ClientSession::~ClientSession() {
     // This destructor will be called automatically when the last ClientSession handle is closed by
     // the emulated application.

src/core/hle/kernel/client_session.h

@@ -12,9 +12,8 @@
 
 namespace Kernel {
 
-class KernelCore;
-class Session;
 class ServerSession;
+class Session;
 class Thread;
 
 class ClientSession final : public Object {
@@ -42,7 +41,7 @@ public:
     std::shared_ptr<Session> parent;
 
 private:
-    explicit ClientSession(KernelCore& kernel);
+    ClientSession();
     ~ClientSession() override;
 };
 

src/core/hle/kernel/event.cpp

@@ -10,11 +10,11 @@
 
 namespace Kernel {
 
-Event::Event(KernelCore& kernel) : WaitObject{kernel} {}
-Event::~Event() = default;
+Event::Event() {}
+Event::~Event() {}
 
-SharedPtr<Event> Event::Create(KernelCore& kernel, ResetType reset_type, std::string name) {
-    SharedPtr<Event> evt(new Event(kernel));
+SharedPtr<Event> Event::Create(ResetType reset_type, std::string name) {
+    SharedPtr<Event> evt(new Event);
 
     evt->signaled = false;
     evt->reset_type = reset_type;

src/core/hle/kernel/event.h

@@ -10,18 +10,14 @@
 
 namespace Kernel {
 
-class KernelCore;
-
 class Event final : public WaitObject {
 public:
     /**
      * Creates an event
-     * @param kernel The kernel instance to create this event under.
      * @param reset_type ResetType describing how to create event
      * @param name Optional name of event
      */
-    static SharedPtr<Event> Create(KernelCore& kernel, ResetType reset_type,
-                                   std::string name = "Unknown");
+    static SharedPtr<Event> Create(ResetType reset_type, std::string name = "Unknown");
 
     std::string GetTypeName() const override {
         return "Event";
@@ -48,7 +44,7 @@ public:
     void Clear();
 
 private:
-    explicit Event(KernelCore& kernel);
+    Event();
     ~Event() override;
 
     ResetType reset_type; ///< Current ResetType

src/core/hle/kernel/handle_table.cpp

@@ -13,6 +13,8 @@
 
 namespace Kernel {
 
+HandleTable g_handle_table;
+
 HandleTable::HandleTable() {
     next_generation = 1;
     Clear();

src/core/hle/kernel/handle_table.h

@@ -121,4 +121,6 @@ private:
     u16 next_free_slot;
 };
 
+extern HandleTable g_handle_table;
+
 } // namespace Kernel

src/core/hle/kernel/hle_ipc.cpp

@@ -13,12 +13,10 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/server_session.h"
@@ -53,9 +51,7 @@ SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> thread,
 
     if (!event) {
         // Create event if not provided
-        auto& kernel = Core::System::GetInstance().Kernel();
-        event =
-            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
+        event = Kernel::Event::Create(Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
     }
 
     event->Clear();
@@ -94,14 +90,12 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
             rp.Skip(2, false);
         }
         if (incoming) {
-            auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
-
             // Populate the object lists with the data in the IPC request.
             for (u32 handle = 0; handle < handle_descriptor_header->num_handles_to_copy; ++handle) {
-                copy_objects.push_back(handle_table.GetGeneric(rp.Pop<Handle>()));
+                copy_objects.push_back(Kernel::g_handle_table.GetGeneric(rp.Pop<Handle>()));
             }
             for (u32 handle = 0; handle < handle_descriptor_header->num_handles_to_move; ++handle) {
-                move_objects.push_back(handle_table.GetGeneric(rp.Pop<Handle>()));
+                move_objects.push_back(Kernel::g_handle_table.GetGeneric(rp.Pop<Handle>()));
             }
         } else {
             // For responses we just ignore the handles, they're empty and will be populated when
@@ -236,19 +230,17 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(const Thread& thread)
         ASSERT(copy_objects.size() == handle_descriptor_header->num_handles_to_copy);
         ASSERT(move_objects.size() == handle_descriptor_header->num_handles_to_move);
 
-        auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
-
         // We don't make a distinction between copy and move handles when translating since HLE
         // services don't deal with handles directly. However, the guest applications might check
         // for specific values in each of these descriptors.
         for (auto& object : copy_objects) {
             ASSERT(object != nullptr);
-            dst_cmdbuf[current_offset++] = handle_table.Create(object).Unwrap();
+            dst_cmdbuf[current_offset++] = Kernel::g_handle_table.Create(object).Unwrap();
         }
 
         for (auto& object : move_objects) {
             ASSERT(object != nullptr);
-            dst_cmdbuf[current_offset++] = handle_table.Create(object).Unwrap();
+            dst_cmdbuf[current_offset++] = Kernel::g_handle_table.Create(object).Unwrap();
         }
     }
 

src/core/hle/kernel/kernel.cpp

@@ -2,291 +2,38 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <array>
-#include <atomic>
-#include <memory>
-#include <mutex>
-#include <utility>
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-
-#include "core/core.h"
-#include "core/core_timing.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
-#include "core/hle/lock.h"
-#include "core/hle/result.h"
 
 namespace Kernel {
 
-/**
- * Callback that will wake up the thread it was scheduled for
- * @param thread_handle The handle of the thread that's been awoken
- * @param cycles_late The number of CPU cycles that have passed since the desired wakeup time
- */
-static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] int cycles_late) {
-    const auto proper_handle = static_cast<Handle>(thread_handle);
-    auto& system = Core::System::GetInstance();
+std::atomic<u32> Object::next_object_id{0};
 
-    // Lock the global kernel mutex when we enter the kernel HLE.
-    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
+/// Initialize the kernel
+void Init() {
+    Kernel::ResourceLimitsInit();
+    Kernel::ThreadingInit();
+    Kernel::TimersInit();
 
-    SharedPtr<Thread> thread =
-        system.Kernel().RetrieveThreadFromWakeupCallbackHandleTable(proper_handle);
-    if (thread == nullptr) {
-        LOG_CRITICAL(Kernel, "Callback fired for invalid thread {:08X}", proper_handle);
-        return;
-    }
-
-    bool resume = true;
-
-    if (thread->status == ThreadStatus::WaitSynchAny ||
-        thread->status == ThreadStatus::WaitSynchAll ||
-        thread->status == ThreadStatus::WaitHLEEvent) {
-        // Remove the thread from each of its waiting objects' waitlists
-        for (auto& object : thread->wait_objects) {
-            object->RemoveWaitingThread(thread.get());
-        }
-        thread->wait_objects.clear();
-
-        // Invoke the wakeup callback before clearing the wait objects
-        if (thread->wakeup_callback) {
-            resume = thread->wakeup_callback(ThreadWakeupReason::Timeout, thread, nullptr, 0);
-        }
-    }
-
-    if (thread->mutex_wait_address != 0 || thread->condvar_wait_address != 0 ||
-        thread->wait_handle) {
-        ASSERT(thread->status == ThreadStatus::WaitMutex);
-        thread->mutex_wait_address = 0;
-        thread->condvar_wait_address = 0;
-        thread->wait_handle = 0;
-
-        auto lock_owner = thread->lock_owner;
-        // Threads waking up by timeout from WaitProcessWideKey do not perform priority inheritance
-        // and don't have a lock owner unless SignalProcessWideKey was called first and the thread
-        // wasn't awakened due to the mutex already being acquired.
-        if (lock_owner) {
-            lock_owner->RemoveMutexWaiter(thread);
-        }
-    }
-
-    if (thread->arb_wait_address != 0) {
-        ASSERT(thread->status == ThreadStatus::WaitArb);
-        thread->arb_wait_address = 0;
-    }
-
-    if (resume) {
-        thread->ResumeFromWait();
-    }
-}
-
-/// The timer callback event, called when a timer is fired
-static void TimerCallback(u64 timer_handle, int cycles_late) {
-    const auto proper_handle = static_cast<Handle>(timer_handle);
-    auto& system = Core::System::GetInstance();
-    SharedPtr<Timer> timer = system.Kernel().RetrieveTimerFromCallbackHandleTable(proper_handle);
-
-    if (timer == nullptr) {
-        LOG_CRITICAL(Kernel, "Callback fired for invalid timer {:016X}", timer_handle);
-        return;
-    }
-
-    timer->Signal(cycles_late);
-}
-
-struct KernelCore::Impl {
-    void Initialize(KernelCore& kernel) {
-        Shutdown();
-
-        InitializeResourceLimits(kernel);
-        InitializeThreads();
-        InitializeTimers();
-    }
-
-    void Shutdown() {
-        next_object_id = 0;
-        next_process_id = 10;
-        next_thread_id = 1;
-
-        process_list.clear();
-
-        handle_table.Clear();
-        resource_limits.fill(nullptr);
-
-        thread_wakeup_callback_handle_table.Clear();
-        thread_wakeup_event_type = nullptr;
-
-        timer_callback_handle_table.Clear();
-        timer_callback_event_type = nullptr;
-    }
-
-    void InitializeResourceLimits(KernelCore& kernel) {
-        // Create the four resource limits that the system uses
-        // Create the APPLICATION resource limit
-        SharedPtr<ResourceLimit> resource_limit = ResourceLimit::Create(kernel, "Applications");
-        resource_limit->max_priority = 0x18;
-        resource_limit->max_commit = 0x4000000;
-        resource_limit->max_threads = 0x20;
-        resource_limit->max_events = 0x20;
-        resource_limit->max_mutexes = 0x20;
-        resource_limit->max_semaphores = 0x8;
-        resource_limit->max_timers = 0x8;
-        resource_limit->max_shared_mems = 0x10;
-        resource_limit->max_address_arbiters = 0x2;
-        resource_limit->max_cpu_time = 0x1E;
-        resource_limits[static_cast<u8>(ResourceLimitCategory::APPLICATION)] = resource_limit;
-
-        // Create the SYS_APPLET resource limit
-        resource_limit = ResourceLimit::Create(kernel, "System Applets");
-        resource_limit->max_priority = 0x4;
-        resource_limit->max_commit = 0x5E00000;
-        resource_limit->max_threads = 0x1D;
-        resource_limit->max_events = 0xB;
-        resource_limit->max_mutexes = 0x8;
-        resource_limit->max_semaphores = 0x4;
-        resource_limit->max_timers = 0x4;
-        resource_limit->max_shared_mems = 0x8;
-        resource_limit->max_address_arbiters = 0x3;
-        resource_limit->max_cpu_time = 0x2710;
-        resource_limits[static_cast<u8>(ResourceLimitCategory::SYS_APPLET)] = resource_limit;
-
-        // Create the LIB_APPLET resource limit
-        resource_limit = ResourceLimit::Create(kernel, "Library Applets");
-        resource_limit->max_priority = 0x4;
-        resource_limit->max_commit = 0x600000;
-        resource_limit->max_threads = 0xE;
-        resource_limit->max_events = 0x8;
-        resource_limit->max_mutexes = 0x8;
-        resource_limit->max_semaphores = 0x4;
-        resource_limit->max_timers = 0x4;
-        resource_limit->max_shared_mems = 0x8;
-        resource_limit->max_address_arbiters = 0x1;
-        resource_limit->max_cpu_time = 0x2710;
-        resource_limits[static_cast<u8>(ResourceLimitCategory::LIB_APPLET)] = resource_limit;
-
-        // Create the OTHER resource limit
-        resource_limit = ResourceLimit::Create(kernel, "Others");
-        resource_limit->max_priority = 0x4;
-        resource_limit->max_commit = 0x2180000;
-        resource_limit->max_threads = 0xE1;
-        resource_limit->max_events = 0x108;
-        resource_limit->max_mutexes = 0x25;
-        resource_limit->max_semaphores = 0x43;
-        resource_limit->max_timers = 0x2C;
-        resource_limit->max_shared_mems = 0x1F;
-        resource_limit->max_address_arbiters = 0x2D;
-        resource_limit->max_cpu_time = 0x3E8;
-        resource_limits[static_cast<u8>(ResourceLimitCategory::OTHER)] = resource_limit;
-    }
-
-    void InitializeThreads() {
-        thread_wakeup_event_type =
-            CoreTiming::RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
-    }
-
-    void InitializeTimers() {
-        timer_callback_handle_table.Clear();
-        timer_callback_event_type = CoreTiming::RegisterEvent("TimerCallback", TimerCallback);
-    }
-
-    std::atomic<u32> next_object_id{0};
+    Object::next_object_id = 0;
     // TODO(Subv): Start the process ids from 10 for now, as lower PIDs are
     // reserved for low-level services
-    std::atomic<u32> next_process_id{10};
-    std::atomic<u32> next_thread_id{1};
-
-    // Lists all processes that exist in the current session.
-    std::vector<SharedPtr<Process>> process_list;
-
-    Kernel::HandleTable handle_table;
-    std::array<SharedPtr<ResourceLimit>, 4> resource_limits;
-
-    /// The event type of the generic timer callback event
-    CoreTiming::EventType* timer_callback_event_type = nullptr;
-    // TODO(yuriks): This can be removed if Timer objects are explicitly pooled in the future,
-    // allowing us to simply use a pool index or similar.
-    Kernel::HandleTable timer_callback_handle_table;
-
-    CoreTiming::EventType* thread_wakeup_event_type = nullptr;
-    // TODO(yuriks): This can be removed if Thread objects are explicitly pooled in the future,
-    // allowing us to simply use a pool index or similar.
-    Kernel::HandleTable thread_wakeup_callback_handle_table;
-};
-
-KernelCore::KernelCore() : impl{std::make_unique<Impl>()} {}
-KernelCore::~KernelCore() {
-    Shutdown();
+    Process::next_process_id = 10;
 }
 
-void KernelCore::Initialize() {
-    impl->Initialize(*this);
-}
+/// Shutdown the kernel
+void Shutdown() {
+    // Free all kernel objects
+    g_handle_table.Clear();
 
-void KernelCore::Shutdown() {
-    impl->Shutdown();
-}
+    Kernel::ThreadingShutdown();
 
-Kernel::HandleTable& KernelCore::HandleTable() {
-    return impl->handle_table;
-}
-
-const Kernel::HandleTable& KernelCore::HandleTable() const {
-    return impl->handle_table;
-}
-
-SharedPtr<ResourceLimit> KernelCore::ResourceLimitForCategory(
-    ResourceLimitCategory category) const {
-    return impl->resource_limits.at(static_cast<std::size_t>(category));
-}
-
-SharedPtr<Thread> KernelCore::RetrieveThreadFromWakeupCallbackHandleTable(Handle handle) const {
-    return impl->thread_wakeup_callback_handle_table.Get<Thread>(handle);
-}
-
-SharedPtr<Timer> KernelCore::RetrieveTimerFromCallbackHandleTable(Handle handle) const {
-    return impl->timer_callback_handle_table.Get<Timer>(handle);
-}
-
-void KernelCore::AppendNewProcess(SharedPtr<Process> process) {
-    impl->process_list.push_back(std::move(process));
-}
-
-u32 KernelCore::CreateNewObjectID() {
-    return impl->next_object_id++;
-}
-
-u32 KernelCore::CreateNewThreadID() {
-    return impl->next_thread_id++;
-}
-
-u32 KernelCore::CreateNewProcessID() {
-    return impl->next_process_id++;
-}
-
-ResultVal<Handle> KernelCore::CreateTimerCallbackHandle(const SharedPtr<Timer>& timer) {
-    return impl->timer_callback_handle_table.Create(timer);
-}
-
-CoreTiming::EventType* KernelCore::ThreadWakeupCallbackEventType() const {
-    return impl->thread_wakeup_event_type;
-}
-
-CoreTiming::EventType* KernelCore::TimerCallbackEventType() const {
-    return impl->timer_callback_event_type;
-}
-
-Kernel::HandleTable& KernelCore::ThreadWakeupCallbackHandleTable() {
-    return impl->thread_wakeup_callback_handle_table;
-}
-
-const Kernel::HandleTable& KernelCore::ThreadWakeupCallbackHandleTable() const {
-    return impl->thread_wakeup_callback_handle_table;
+    Kernel::TimersShutdown();
+    Kernel::ResourceLimitsShutdown();
 }
 
 } // namespace Kernel

src/core/hle/kernel/kernel.h

@@ -4,93 +4,14 @@
 
 #pragma once
 
-#include "core/hle/kernel/object.h"
-
-template <typename T>
-class ResultVal;
-
-namespace CoreTiming {
-struct EventType;
-}
+#include "common/common_types.h"
 
 namespace Kernel {
 
-class HandleTable;
-class Process;
-class ResourceLimit;
-class Thread;
-class Timer;
+/// Initialize the kernel with the specified system mode.
+void Init();
 
-enum class ResourceLimitCategory : u8;
-
-/// Represents a single instance of the kernel.
-class KernelCore {
-public:
-    KernelCore();
-    ~KernelCore();
-
-    KernelCore(const KernelCore&) = delete;
-    KernelCore& operator=(const KernelCore&) = delete;
-
-    KernelCore(KernelCore&&) = delete;
-    KernelCore& operator=(KernelCore&&) = delete;
-
-    /// Resets the kernel to a clean slate for use.
-    void Initialize();
-
-    /// Clears all resources in use by the kernel instance.
-    void Shutdown();
-
-    /// Provides a reference to the handle table.
-    Kernel::HandleTable& HandleTable();
-
-    /// Provides a const reference to the handle table.
-    const Kernel::HandleTable& HandleTable() const;
-
-    /// Retrieves a shared pointer to a ResourceLimit identified by the given category.
-    SharedPtr<ResourceLimit> ResourceLimitForCategory(ResourceLimitCategory category) const;
-
-    /// Retrieves a shared pointer to a Thread instance within the thread wakeup handle table.
-    SharedPtr<Thread> RetrieveThreadFromWakeupCallbackHandleTable(Handle handle) const;
-
-    /// Retrieves a shared pointer to a Timer instance within the timer callback handle table.
-    SharedPtr<Timer> RetrieveTimerFromCallbackHandleTable(Handle handle) const;
-
-    /// Adds the given shared pointer to an internal list of active processes.
-    void AppendNewProcess(SharedPtr<Process> process);
-
-private:
-    friend class Object;
-    friend class Process;
-    friend class Thread;
-    friend class Timer;
-
-    /// Creates a new object ID, incrementing the internal object ID counter.
-    u32 CreateNewObjectID();
-
-    /// Creates a new process ID, incrementing the internal process ID counter;
-    u32 CreateNewProcessID();
-
-    /// Creates a new thread ID, incrementing the internal thread ID counter.
-    u32 CreateNewThreadID();
-
-    /// Creates a timer callback handle for the given timer.
-    ResultVal<Handle> CreateTimerCallbackHandle(const SharedPtr<Timer>& timer);
-
-    /// Retrieves the event type used for thread wakeup callbacks.
-    CoreTiming::EventType* ThreadWakeupCallbackEventType() const;
-
-    /// Retrieves the event type used for timer callbacks.
-    CoreTiming::EventType* TimerCallbackEventType() const;
-
-    /// Provides a reference to the thread wakeup callback handle table.
-    Kernel::HandleTable& ThreadWakeupCallbackHandleTable();
-
-    /// Provides a const reference to the thread wakeup callback handle table.
-    const Kernel::HandleTable& ThreadWakeupCallbackHandleTable() const;
-
-    struct Impl;
-    std::unique_ptr<Impl> impl;
-};
+/// Shutdown the kernel
+void Shutdown();
 
 } // namespace Kernel

src/core/hle/kernel/mutex.cpp

@@ -58,15 +58,15 @@ static void TransferMutexOwnership(VAddr mutex_addr, SharedPtr<Thread> current_t
     }
 }
 
-ResultCode Mutex::TryAcquire(HandleTable& handle_table, VAddr address, Handle holding_thread_handle,
+ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
                              Handle requesting_thread_handle) {
     // The mutex address must be 4-byte aligned
     if ((address % sizeof(u32)) != 0) {
         return ResultCode(ErrorModule::Kernel, ErrCodes::InvalidAddress);
     }
 
-    SharedPtr<Thread> holding_thread = handle_table.Get<Thread>(holding_thread_handle);
-    SharedPtr<Thread> requesting_thread = handle_table.Get<Thread>(requesting_thread_handle);
+    SharedPtr<Thread> holding_thread = g_handle_table.Get<Thread>(holding_thread_handle);
+    SharedPtr<Thread> requesting_thread = g_handle_table.Get<Thread>(requesting_thread_handle);
 
     // TODO(Subv): It is currently unknown if it is possible to lock a mutex in behalf of another
     // thread.

src/core/hle/kernel/mutex.h

@@ -11,7 +11,6 @@ union ResultCode;
 
 namespace Kernel {
 
-class HandleTable;
 class Thread;
 
 class Mutex final {
@@ -22,8 +21,8 @@ public:
     static constexpr u32 MutexOwnerMask = 0xBFFFFFFF;
 
     /// Attempts to acquire a mutex at the specified address.
-    static ResultCode TryAcquire(HandleTable& handle_table, VAddr address,
-                                 Handle holding_thread_handle, Handle requesting_thread_handle);
+    static ResultCode TryAcquire(VAddr address, Handle holding_thread_handle,
+                                 Handle requesting_thread_handle);
 
     /// Releases the mutex at the specified address.
     static ResultCode Release(VAddr address);

src/core/hle/kernel/object.cpp

@@ -3,12 +3,10 @@
 // Refer to the license.txt file included.
 
 #include "common/assert.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/object.h"
 
 namespace Kernel {
 
-Object::Object(KernelCore& kernel) : kernel{kernel}, object_id{kernel.CreateNewObjectID()} {}
 Object::~Object() = default;
 
 bool Object::IsWaitable() const {

src/core/hle/kernel/object.h

@@ -14,8 +14,6 @@
 
 namespace Kernel {
 
-class KernelCore;
-
 using Handle = u32;
 
 enum class HandleType : u32 {
@@ -42,7 +40,6 @@ enum class ResetType {
 
 class Object : NonCopyable {
 public:
-    explicit Object(KernelCore& kernel);
     virtual ~Object();
 
     /// Returns a unique identifier for the object. For debugging purposes only.
@@ -64,16 +61,15 @@ public:
      */
     bool IsWaitable() const;
 
-protected:
-    /// The kernel instance this object was created under.
-    KernelCore& kernel;
+public:
+    static std::atomic<u32> next_object_id;
 
 private:
     friend void intrusive_ptr_add_ref(Object*);
     friend void intrusive_ptr_release(Object*);
 
     std::atomic<u32> ref_count{0};
-    std::atomic<u32> object_id{0};
+    std::atomic<u32> object_id{next_object_id++};
 };
 
 // Special functions used by boost::instrusive_ptr to do automatic ref-counting

src/core/hle/kernel/process.cpp

@@ -8,7 +8,6 @@
 #include "common/common_funcs.h"
 #include "common/logging/log.h"
 #include "core/hle/kernel/errors.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/thread.h"
@@ -17,26 +16,30 @@
 
 namespace Kernel {
 
-SharedPtr<CodeSet> CodeSet::Create(KernelCore& kernel, std::string name) {
-    SharedPtr<CodeSet> codeset(new CodeSet(kernel));
+// Lists all processes that exist in the current session.
+static std::vector<SharedPtr<Process>> process_list;
+
+SharedPtr<CodeSet> CodeSet::Create(std::string name) {
+    SharedPtr<CodeSet> codeset(new CodeSet);
     codeset->name = std::move(name);
     return codeset;
 }
 
-CodeSet::CodeSet(KernelCore& kernel) : Object{kernel} {}
-CodeSet::~CodeSet() = default;
+CodeSet::CodeSet() {}
+CodeSet::~CodeSet() {}
 
-SharedPtr<Process> Process::Create(KernelCore& kernel, std::string&& name) {
-    SharedPtr<Process> process(new Process(kernel));
+u32 Process::next_process_id;
+
+SharedPtr<Process> Process::Create(std::string&& name) {
+    SharedPtr<Process> process(new Process);
 
     process->name = std::move(name);
     process->flags.raw = 0;
     process->flags.memory_region.Assign(MemoryRegion::APPLICATION);
     process->status = ProcessStatus::Created;
     process->program_id = 0;
-    process->process_id = kernel.CreateNewProcessID();
 
-    kernel.AppendNewProcess(process);
+    process_list.push_back(process);
     return process;
 }
 
@@ -125,7 +128,7 @@ void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) {
     vm_manager.LogLayout();
     status = ProcessStatus::Running;
 
-    Kernel::SetupMainThread(kernel, entry_point, main_thread_priority, this);
+    Kernel::SetupMainThread(entry_point, main_thread_priority, this);
 }
 
 void Process::LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr) {
@@ -228,7 +231,22 @@ ResultCode Process::UnmapMemory(VAddr dst_addr, VAddr /*src_addr*/, u64 size) {
     return vm_manager.UnmapRange(dst_addr, size);
 }
 
-Kernel::Process::Process(KernelCore& kernel) : Object{kernel} {}
+Kernel::Process::Process() {}
 Kernel::Process::~Process() {}
 
+void ClearProcessList() {
+    process_list.clear();
+}
+
+SharedPtr<Process> GetProcessById(u32 process_id) {
+    auto itr = std::find_if(
+        process_list.begin(), process_list.end(),
+        [&](const SharedPtr<Process>& process) { return process->process_id == process_id; });
+
+    if (itr == process_list.end())
+        return nullptr;
+
+    return *itr;
+}
+
 } // namespace Kernel

src/core/hle/kernel/process.h

@@ -19,8 +19,6 @@
 
 namespace Kernel {
 
-class KernelCore;
-
 struct AddressMapping {
     // Address and size must be page-aligned
     VAddr address;
@@ -64,7 +62,7 @@ struct CodeSet final : public Object {
         u32 size = 0;
     };
 
-    static SharedPtr<CodeSet> Create(KernelCore& kernel, std::string name);
+    static SharedPtr<CodeSet> Create(std::string name);
 
     std::string GetTypeName() const override {
         return "CodeSet";
@@ -111,13 +109,13 @@ struct CodeSet final : public Object {
     std::string name;
 
 private:
-    explicit CodeSet(KernelCore& kernel);
+    CodeSet();
     ~CodeSet() override;
 };
 
 class Process final : public Object {
 public:
-    static SharedPtr<Process> Create(KernelCore& kernel, std::string&& name);
+    static SharedPtr<Process> Create(std::string&& name);
 
     std::string GetTypeName() const override {
         return "Process";
@@ -131,6 +129,8 @@ public:
         return HANDLE_TYPE;
     }
 
+    static u32 next_process_id;
+
     /// Title ID corresponding to the process
     u64 program_id;
 
@@ -157,8 +157,8 @@ public:
     /// Current status of the process
     ProcessStatus status;
 
-    /// The ID of this process
-    u32 process_id = 0;
+    /// The id of this process
+    u32 process_id = next_process_id++;
 
     /**
      * Parses a list of kernel capability descriptors (as found in the ExHeader) and applies them
@@ -206,8 +206,13 @@ public:
     ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size);
 
 private:
-    explicit Process(KernelCore& kernel);
+    Process();
     ~Process() override;
 };
 
+void ClearProcessList();
+
+/// Retrieves a process from the current list of processes.
+SharedPtr<Process> GetProcessById(u32 process_id);
+
 } // namespace Kernel

src/core/hle/kernel/resource_limit.cpp

@@ -9,16 +9,31 @@
 
 namespace Kernel {
 
-ResourceLimit::ResourceLimit(KernelCore& kernel) : Object{kernel} {}
-ResourceLimit::~ResourceLimit() = default;
+static SharedPtr<ResourceLimit> resource_limits[4];
 
-SharedPtr<ResourceLimit> ResourceLimit::Create(KernelCore& kernel, std::string name) {
-    SharedPtr<ResourceLimit> resource_limit(new ResourceLimit(kernel));
+ResourceLimit::ResourceLimit() {}
+ResourceLimit::~ResourceLimit() {}
+
+SharedPtr<ResourceLimit> ResourceLimit::Create(std::string name) {
+    SharedPtr<ResourceLimit> resource_limit(new ResourceLimit);
 
     resource_limit->name = std::move(name);
     return resource_limit;
 }
 
+SharedPtr<ResourceLimit> ResourceLimit::GetForCategory(ResourceLimitCategory category) {
+    switch (category) {
+    case ResourceLimitCategory::APPLICATION:
+    case ResourceLimitCategory::SYS_APPLET:
+    case ResourceLimitCategory::LIB_APPLET:
+    case ResourceLimitCategory::OTHER:
+        return resource_limits[static_cast<u8>(category)];
+    default:
+        LOG_CRITICAL(Kernel, "Unknown resource limit category");
+        UNREACHABLE();
+    }
+}
+
 s32 ResourceLimit::GetCurrentResourceValue(ResourceType resource) const {
     switch (resource) {
     case ResourceType::Commit:
@@ -74,4 +89,66 @@ u32 ResourceLimit::GetMaxResourceValue(ResourceType resource) const {
         return 0;
     }
 }
+
+void ResourceLimitsInit() {
+    // Create the four resource limits that the system uses
+    // Create the APPLICATION resource limit
+    SharedPtr<ResourceLimit> resource_limit = ResourceLimit::Create("Applications");
+    resource_limit->max_priority = 0x18;
+    resource_limit->max_commit = 0x4000000;
+    resource_limit->max_threads = 0x20;
+    resource_limit->max_events = 0x20;
+    resource_limit->max_mutexes = 0x20;
+    resource_limit->max_semaphores = 0x8;
+    resource_limit->max_timers = 0x8;
+    resource_limit->max_shared_mems = 0x10;
+    resource_limit->max_address_arbiters = 0x2;
+    resource_limit->max_cpu_time = 0x1E;
+    resource_limits[static_cast<u8>(ResourceLimitCategory::APPLICATION)] = resource_limit;
+
+    // Create the SYS_APPLET resource limit
+    resource_limit = ResourceLimit::Create("System Applets");
+    resource_limit->max_priority = 0x4;
+    resource_limit->max_commit = 0x5E00000;
+    resource_limit->max_threads = 0x1D;
+    resource_limit->max_events = 0xB;
+    resource_limit->max_mutexes = 0x8;
+    resource_limit->max_semaphores = 0x4;
+    resource_limit->max_timers = 0x4;
+    resource_limit->max_shared_mems = 0x8;
+    resource_limit->max_address_arbiters = 0x3;
+    resource_limit->max_cpu_time = 0x2710;
+    resource_limits[static_cast<u8>(ResourceLimitCategory::SYS_APPLET)] = resource_limit;
+
+    // Create the LIB_APPLET resource limit
+    resource_limit = ResourceLimit::Create("Library Applets");
+    resource_limit->max_priority = 0x4;
+    resource_limit->max_commit = 0x600000;
+    resource_limit->max_threads = 0xE;
+    resource_limit->max_events = 0x8;
+    resource_limit->max_mutexes = 0x8;
+    resource_limit->max_semaphores = 0x4;
+    resource_limit->max_timers = 0x4;
+    resource_limit->max_shared_mems = 0x8;
+    resource_limit->max_address_arbiters = 0x1;
+    resource_limit->max_cpu_time = 0x2710;
+    resource_limits[static_cast<u8>(ResourceLimitCategory::LIB_APPLET)] = resource_limit;
+
+    // Create the OTHER resource limit
+    resource_limit = ResourceLimit::Create("Others");
+    resource_limit->max_priority = 0x4;
+    resource_limit->max_commit = 0x2180000;
+    resource_limit->max_threads = 0xE1;
+    resource_limit->max_events = 0x108;
+    resource_limit->max_mutexes = 0x25;
+    resource_limit->max_semaphores = 0x43;
+    resource_limit->max_timers = 0x2C;
+    resource_limit->max_shared_mems = 0x1F;
+    resource_limit->max_address_arbiters = 0x2D;
+    resource_limit->max_cpu_time = 0x3E8;
+    resource_limits[static_cast<u8>(ResourceLimitCategory::OTHER)] = resource_limit;
+}
+
+void ResourceLimitsShutdown() {}
+
 } // namespace Kernel

src/core/hle/kernel/resource_limit.h

@@ -9,8 +9,6 @@
 
 namespace Kernel {
 
-class KernelCore;
-
 enum class ResourceLimitCategory : u8 {
     APPLICATION = 0,
     SYS_APPLET = 1,
@@ -36,7 +34,14 @@ public:
     /**
      * Creates a resource limit object.
      */
-    static SharedPtr<ResourceLimit> Create(KernelCore& kernel, std::string name = "Unknown");
+    static SharedPtr<ResourceLimit> Create(std::string name = "Unknown");
+
+    /**
+     * Retrieves the resource limit associated with the specified resource limit category.
+     * @param category The resource limit category
+     * @returns The resource limit associated with the category
+     */
+    static SharedPtr<ResourceLimit> GetForCategory(ResourceLimitCategory category);
 
     std::string GetTypeName() const override {
         return "ResourceLimit";
@@ -108,8 +113,14 @@ public:
     s32 current_cpu_time = 0;
 
 private:
-    explicit ResourceLimit(KernelCore& kernel);
+    ResourceLimit();
     ~ResourceLimit() override;
 };
 
+/// Initializes the resource limits
+void ResourceLimitsInit();
+
+// Destroys the resource limits
+void ResourceLimitsShutdown();
+
 } // namespace Kernel

src/core/hle/kernel/server_port.cpp

@@ -13,8 +13,8 @@
 
 namespace Kernel {
 
-ServerPort::ServerPort(KernelCore& kernel) : WaitObject{kernel} {}
-ServerPort::~ServerPort() = default;
+ServerPort::ServerPort() {}
+ServerPort::~ServerPort() {}
 
 ResultVal<SharedPtr<ServerSession>> ServerPort::Accept() {
     if (pending_sessions.empty()) {
@@ -36,10 +36,10 @@ void ServerPort::Acquire(Thread* thread) {
 }
 
 std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> ServerPort::CreatePortPair(
-    KernelCore& kernel, u32 max_sessions, std::string name) {
+    u32 max_sessions, std::string name) {
 
-    SharedPtr<ServerPort> server_port(new ServerPort(kernel));
-    SharedPtr<ClientPort> client_port(new ClientPort(kernel));
+    SharedPtr<ServerPort> server_port(new ServerPort);
+    SharedPtr<ClientPort> client_port(new ClientPort);
 
     server_port->name = name + "_Server";
     client_port->name = name + "_Client";

src/core/hle/kernel/server_port.h

@@ -15,7 +15,6 @@
 namespace Kernel {
 
 class ClientPort;
-class KernelCore;
 class ServerSession;
 class SessionRequestHandler;
 
@@ -24,13 +23,12 @@ public:
     /**
      * Creates a pair of ServerPort and an associated ClientPort.
      *
-     * @param kernel The kernel instance to create the port pair under.
      * @param max_sessions Maximum number of sessions to the port
      * @param name Optional name of the ports
      * @return The created port tuple
      */
     static std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> CreatePortPair(
-        KernelCore& kernel, u32 max_sessions, std::string name = "UnknownPort");
+        u32 max_sessions, std::string name = "UnknownPort");
 
     std::string GetTypeName() const override {
         return "ServerPort";
@@ -71,7 +69,7 @@ public:
     void Acquire(Thread* thread) override;
 
 private:
-    explicit ServerPort(KernelCore& kernel);
+    ServerPort();
     ~ServerPort() override;
 };
 

src/core/hle/kernel/server_session.cpp

@@ -13,7 +13,6 @@
 #include "core/hle/kernel/client_session.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/session.h"
@@ -21,7 +20,7 @@
 
 namespace Kernel {
 
-ServerSession::ServerSession(KernelCore& kernel) : WaitObject{kernel} {}
+ServerSession::ServerSession() = default;
 ServerSession::~ServerSession() {
     // This destructor will be called automatically when the last ServerSession handle is closed by
     // the emulated application.
@@ -36,8 +35,8 @@ ServerSession::~ServerSession() {
     parent->server = nullptr;
 }
 
-ResultVal<SharedPtr<ServerSession>> ServerSession::Create(KernelCore& kernel, std::string name) {
-    SharedPtr<ServerSession> server_session(new ServerSession(kernel));
+ResultVal<SharedPtr<ServerSession>> ServerSession::Create(std::string name) {
+    SharedPtr<ServerSession> server_session(new ServerSession);
 
     server_session->name = std::move(name);
     server_session->parent = nullptr;
@@ -105,10 +104,11 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     // The ServerSession received a sync request, this means that there's new data available
     // from its ClientSession, so wake up any threads that may be waiting on a svcReplyAndReceive or
     // similar.
+
     Kernel::HLERequestContext context(this);
     u32* cmd_buf = (u32*)Memory::GetPointer(thread->GetTLSAddress());
     context.PopulateFromIncomingCommandBuffer(cmd_buf, *Core::CurrentProcess(),
-                                              kernel.HandleTable());
+                                              Kernel::g_handle_table);
 
     ResultCode result = RESULT_SUCCESS;
     // If the session has been converted to a domain, handle the domain request
@@ -160,11 +160,10 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
     return result;
 }
 
-ServerSession::SessionPair ServerSession::CreateSessionPair(KernelCore& kernel,
-                                                            const std::string& name,
+ServerSession::SessionPair ServerSession::CreateSessionPair(const std::string& name,
                                                             SharedPtr<ClientPort> port) {
-    auto server_session = ServerSession::Create(kernel, name + "_Server").Unwrap();
-    SharedPtr<ClientSession> client_session(new ClientSession(kernel));
+    auto server_session = ServerSession::Create(name + "_Server").Unwrap();
+    SharedPtr<ClientSession> client_session(new ClientSession);
     client_session->name = name + "_Client";
 
     std::shared_ptr<Session> parent(new Session);

src/core/hle/kernel/server_session.h

@@ -15,14 +15,13 @@
 
 namespace Kernel {
 
-class ClientPort;
 class ClientSession;
-class HLERequestContext;
-class KernelCore;
+class ClientPort;
 class ServerSession;
 class Session;
 class SessionRequestHandler;
 class Thread;
+class HLERequestContext;
 
 /**
  * Kernel object representing the server endpoint of an IPC session. Sessions are the basic CTR-OS
@@ -51,12 +50,11 @@ public:
 
     /**
      * Creates a pair of ServerSession and an associated ClientSession.
-     * @param kernel      The kernal instance to create the session pair under.
      * @param name        Optional name of the ports.
      * @param client_port Optional The ClientPort that spawned this session.
      * @return The created session tuple
      */
-    static SessionPair CreateSessionPair(KernelCore& kernel, const std::string& name = "Unknown",
+    static SessionPair CreateSessionPair(const std::string& name = "Unknown",
                                          SharedPtr<ClientPort> client_port = nullptr);
 
     /**
@@ -113,18 +111,16 @@ public:
     }
 
 private:
-    explicit ServerSession(KernelCore& kernel);
+    ServerSession();
     ~ServerSession() override;
 
     /**
      * Creates a server session. The server session can have an optional HLE handler,
      * which will be invoked to handle the IPC requests that this session receives.
-     * @param kernel The kernel instance to create this server session under.
      * @param name Optional name of the server session.
      * @return The created server session
      */
-    static ResultVal<SharedPtr<ServerSession>> Create(KernelCore& kernel,
-                                                      std::string name = "Unknown");
+    static ResultVal<SharedPtr<ServerSession>> Create(std::string name = "Unknown");
 
     /// Handles a SyncRequest to a domain, forwarding the request to the proper object or closing an
     /// object handle.

src/core/hle/kernel/shared_memory.cpp

@@ -13,14 +13,14 @@
 
 namespace Kernel {
 
-SharedMemory::SharedMemory(KernelCore& kernel) : Object{kernel} {}
-SharedMemory::~SharedMemory() = default;
+SharedMemory::SharedMemory() {}
+SharedMemory::~SharedMemory() {}
 
-SharedPtr<SharedMemory> SharedMemory::Create(KernelCore& kernel, SharedPtr<Process> owner_process,
-                                             u64 size, MemoryPermission permissions,
+SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u64 size,
+                                             MemoryPermission permissions,
                                              MemoryPermission other_permissions, VAddr address,
                                              MemoryRegion region, std::string name) {
-    SharedPtr<SharedMemory> shared_memory(new SharedMemory(kernel));
+    SharedPtr<SharedMemory> shared_memory(new SharedMemory);
 
     shared_memory->owner_process = std::move(owner_process);
     shared_memory->name = std::move(name);
@@ -59,10 +59,12 @@ SharedPtr<SharedMemory> SharedMemory::Create(KernelCore& kernel, SharedPtr<Proce
     return shared_memory;
 }
 
-SharedPtr<SharedMemory> SharedMemory::CreateForApplet(
-    KernelCore& kernel, std::shared_ptr<std::vector<u8>> heap_block, u32 offset, u32 size,
-    MemoryPermission permissions, MemoryPermission other_permissions, std::string name) {
-    SharedPtr<SharedMemory> shared_memory(new SharedMemory(kernel));
+SharedPtr<SharedMemory> SharedMemory::CreateForApplet(std::shared_ptr<std::vector<u8>> heap_block,
+                                                      u32 offset, u32 size,
+                                                      MemoryPermission permissions,
+                                                      MemoryPermission other_permissions,
+                                                      std::string name) {
+    SharedPtr<SharedMemory> shared_memory(new SharedMemory);
 
     shared_memory->owner_process = nullptr;
     shared_memory->name = std::move(name);

src/core/hle/kernel/shared_memory.h

@@ -15,8 +15,6 @@
 
 namespace Kernel {
 
-class KernelCore;
-
 /// Permissions for mapped shared memory blocks
 enum class MemoryPermission : u32 {
     None = 0,
@@ -34,7 +32,6 @@ class SharedMemory final : public Object {
 public:
     /**
      * Creates a shared memory object.
-     * @param kernel The kernel instance to create a shared memory instance under.
      * @param owner_process Process that created this shared memory object.
      * @param size Size of the memory block. Must be page-aligned.
      * @param permissions Permission restrictions applied to the process which created the block.
@@ -45,15 +42,14 @@ public:
      * linear heap.
      * @param name Optional object name, used for debugging purposes.
      */
-    static SharedPtr<SharedMemory> Create(KernelCore& kernel, SharedPtr<Process> owner_process,
-                                          u64 size, MemoryPermission permissions,
+    static SharedPtr<SharedMemory> Create(SharedPtr<Process> owner_process, u64 size,
+                                          MemoryPermission permissions,
                                           MemoryPermission other_permissions, VAddr address = 0,
                                           MemoryRegion region = MemoryRegion::BASE,
                                           std::string name = "Unknown");
 
     /**
      * Creates a shared memory object from a block of memory managed by an HLE applet.
-     * @param kernel The kernel instance to create a shared memory instance under.
      * @param heap_block Heap block of the HLE applet.
      * @param offset The offset into the heap block that the SharedMemory will map.
      * @param size Size of the memory block. Must be page-aligned.
@@ -62,8 +58,7 @@ public:
      * block.
      * @param name Optional object name, used for debugging purposes.
      */
-    static SharedPtr<SharedMemory> CreateForApplet(KernelCore& kernel,
-                                                   std::shared_ptr<std::vector<u8>> heap_block,
+    static SharedPtr<SharedMemory> CreateForApplet(std::shared_ptr<std::vector<u8>> heap_block,
                                                    u32 offset, u32 size,
                                                    MemoryPermission permissions,
                                                    MemoryPermission other_permissions,
@@ -130,7 +125,7 @@ public:
     std::string name;
 
 private:
-    explicit SharedMemory(KernelCore& kernel);
+    SharedMemory();
     ~SharedMemory() override;
 };
 

src/core/hle/kernel/svc.cpp

@@ -12,20 +12,16 @@
 #include "common/logging/log.h"
 #include "common/microprofile.h"
 #include "common/string_util.h"
-#include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/mutex.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/kernel/svc.h"
 #include "core/hle/kernel/svc_wrap.h"
@@ -91,15 +87,13 @@ static ResultCode ConnectToNamedPort(Handle* out_handle, VAddr port_name_address
     CASCADE_RESULT(client_session, client_port->Connect());
 
     // Return the client session
-    auto& kernel = Core::System::GetInstance().Kernel();
-    CASCADE_RESULT(*out_handle, kernel.HandleTable().Create(client_session));
+    CASCADE_RESULT(*out_handle, g_handle_table.Create(client_session));
     return RESULT_SUCCESS;
 }
 
 /// Makes a blocking IPC call to an OS service.
 static ResultCode SendSyncRequest(Handle handle) {
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<ClientSession> session = kernel.HandleTable().Get<ClientSession>(handle);
+    SharedPtr<ClientSession> session = g_handle_table.Get<ClientSession>(handle);
     if (!session) {
         LOG_ERROR(Kernel_SVC, "called with invalid handle=0x{:08X}", handle);
         return ERR_INVALID_HANDLE;
@@ -118,8 +112,7 @@ static ResultCode SendSyncRequest(Handle handle) {
 static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
     LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -132,8 +125,7 @@ static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
 static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
     LOG_TRACE(Kernel_SVC, "called process=0x{:08X}", process_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Process> process = kernel.HandleTable().Get<Process>(process_handle);
+    const SharedPtr<Process> process = g_handle_table.Get<Process>(process_handle);
     if (!process) {
         return ERR_INVALID_HANDLE;
     }
@@ -176,11 +168,10 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
 
     using ObjectPtr = SharedPtr<WaitObject>;
     std::vector<ObjectPtr> objects(handle_count);
-    auto& kernel = Core::System::GetInstance().Kernel();
 
     for (u64 i = 0; i < handle_count; ++i) {
         const Handle handle = Memory::Read32(handles_address + i * sizeof(Handle));
-        const auto object = kernel.HandleTable().Get<WaitObject>(handle);
+        const auto object = g_handle_table.Get<WaitObject>(handle);
 
         if (object == nullptr) {
             return ERR_INVALID_HANDLE;
@@ -228,8 +219,7 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
 static ResultCode CancelSynchronization(Handle thread_handle) {
     LOG_TRACE(Kernel_SVC, "called thread=0x{:X}", thread_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -249,9 +239,7 @@ static ResultCode ArbitrateLock(Handle holding_thread_handle, VAddr mutex_addr,
               "requesting_current_thread_handle=0x{:08X}",
               holding_thread_handle, mutex_addr, requesting_thread_handle);
 
-    auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
-    return Mutex::TryAcquire(handle_table, mutex_addr, holding_thread_handle,
-                             requesting_thread_handle);
+    return Mutex::TryAcquire(mutex_addr, holding_thread_handle, requesting_thread_handle);
 }
 
 /// Unlock a mutex
@@ -364,8 +352,7 @@ static ResultCode GetThreadContext(Handle handle, VAddr addr) {
 
 /// Gets the priority for the specified thread
 static ResultCode GetThreadPriority(u32* priority, Handle handle) {
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(handle);
     if (!thread)
         return ERR_INVALID_HANDLE;
 
@@ -379,8 +366,7 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
         return ERR_OUT_OF_RANGE;
     }
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(handle);
+    SharedPtr<Thread> thread = g_handle_table.Get<Thread>(handle);
     if (!thread)
         return ERR_INVALID_HANDLE;
 
@@ -409,8 +395,7 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
               "called, shared_memory_handle=0x{:X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
               shared_memory_handle, addr, size, permissions);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto shared_memory = kernel.HandleTable().Get<SharedMemory>(shared_memory_handle);
+    SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
     if (!shared_memory) {
         return ERR_INVALID_HANDLE;
     }
@@ -438,8 +423,7 @@ static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64
     LOG_WARNING(Kernel_SVC, "called, shared_memory_handle=0x{:08X}, addr=0x{:X}, size=0x{:X}",
                 shared_memory_handle, addr, size);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto shared_memory = kernel.HandleTable().Get<SharedMemory>(shared_memory_handle);
+    SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
 
     return shared_memory->Unmap(Core::CurrentProcess().get(), addr);
 }
@@ -447,9 +431,7 @@ static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64
 /// Query process memory
 static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_info*/,
                                      Handle process_handle, u64 addr) {
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Process> process = kernel.HandleTable().Get<Process>(process_handle);
+    SharedPtr<Process> process = g_handle_table.Get<Process>(process_handle);
     if (!process) {
         return ERR_INVALID_HANDLE;
     }
@@ -546,11 +528,10 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
         break;
     }
 
-    auto& kernel = Core::System::GetInstance().Kernel();
     CASCADE_RESULT(SharedPtr<Thread> thread,
-                   Thread::Create(kernel, name, entry_point, priority, arg, processor_id, stack_top,
+                   Thread::Create(name, entry_point, priority, arg, processor_id, stack_top,
                                   Core::CurrentProcess()));
-    CASCADE_RESULT(thread->guest_handle, kernel.HandleTable().Create(thread));
+    CASCADE_RESULT(thread->guest_handle, g_handle_table.Create(thread));
     *out_handle = thread->guest_handle;
 
     Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
@@ -567,8 +548,7 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
 static ResultCode StartThread(Handle thread_handle) {
     LOG_TRACE(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -615,8 +595,7 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
         "called mutex_addr={:X}, condition_variable_addr={:X}, thread_handle=0x{:08X}, timeout={}",
         mutex_addr, condition_variable_addr, thread_handle, nano_seconds);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     ASSERT(thread);
 
     CASCADE_CODE(Mutex::Release(mutex_addr));
@@ -725,9 +704,8 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
                                                mutex_val | Mutex::MutexHasWaitersFlag));
 
             // The mutex is already owned by some other thread, make this thread wait on it.
-            auto& kernel = Core::System::GetInstance().Kernel();
             Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
-            auto owner = kernel.HandleTable().Get<Thread>(owner_handle);
+            auto owner = g_handle_table.Get<Thread>(owner_handle);
             ASSERT(owner);
             ASSERT(thread->status == ThreadStatus::WaitMutex);
             thread->wakeup_callback = nullptr;
@@ -805,20 +783,14 @@ static u64 GetSystemTick() {
 /// Close a handle
 static ResultCode CloseHandle(Handle handle) {
     LOG_TRACE(Kernel_SVC, "Closing handle 0x{:08X}", handle);
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    return kernel.HandleTable().Close(handle);
+    return g_handle_table.Close(handle);
 }
 
 /// Reset an event
 static ResultCode ResetSignal(Handle handle) {
     LOG_WARNING(Kernel_SVC, "(STUBBED) called handle 0x{:08X}", handle);
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto event = kernel.HandleTable().Get<Event>(handle);
-
+    auto event = g_handle_table.Get<Event>(handle);
     ASSERT(event != nullptr);
-
     event->Clear();
     return RESULT_SUCCESS;
 }
@@ -834,8 +806,7 @@ static ResultCode CreateTransferMemory(Handle* handle, VAddr addr, u64 size, u32
 static ResultCode GetThreadCoreMask(Handle thread_handle, u32* core, u64* mask) {
     LOG_TRACE(Kernel_SVC, "called, handle=0x{:08X}", thread_handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -850,8 +821,7 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
     LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, mask=0x{:16X}, core=0x{:X}", thread_handle,
               mask, core);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    const SharedPtr<Thread> thread = kernel.HandleTable().Get<Thread>(thread_handle);
+    const SharedPtr<Thread> thread = g_handle_table.Get<Thread>(thread_handle);
     if (!thread) {
         return ERR_INVALID_HANDLE;
     }
@@ -891,23 +861,19 @@ static ResultCode CreateSharedMemory(Handle* handle, u64 size, u32 local_permiss
                                      u32 remote_permissions) {
     LOG_TRACE(Kernel_SVC, "called, size=0x{:X}, localPerms=0x{:08X}, remotePerms=0x{:08X}", size,
               local_permissions, remote_permissions);
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    auto& handle_table = kernel.HandleTable();
-    auto shared_mem_handle =
-        SharedMemory::Create(kernel, handle_table.Get<Process>(KernelHandle::CurrentProcess), size,
+    auto sharedMemHandle =
+        SharedMemory::Create(g_handle_table.Get<Process>(KernelHandle::CurrentProcess), size,
                              static_cast<MemoryPermission>(local_permissions),
                              static_cast<MemoryPermission>(remote_permissions));
 
-    CASCADE_RESULT(*handle, handle_table.Create(shared_mem_handle));
+    CASCADE_RESULT(*handle, g_handle_table.Create(sharedMemHandle));
     return RESULT_SUCCESS;
 }
 
 static ResultCode ClearEvent(Handle handle) {
     LOG_TRACE(Kernel_SVC, "called, event=0x{:08X}", handle);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<Event> evt = kernel.HandleTable().Get<Event>(handle);
+    SharedPtr<Event> evt = g_handle_table.Get<Event>(handle);
     if (evt == nullptr)
         return ERR_INVALID_HANDLE;
     evt->Clear();

src/core/hle/kernel/thread.cpp

@@ -16,21 +16,22 @@
 #include "common/thread_queue_list.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
+#include "core/hle/lock.h"
 #include "core/hle/result.h"
 #include "core/memory.h"
 
 namespace Kernel {
 
+/// Event type for the thread wake up event
+static CoreTiming::EventType* ThreadWakeupEventType = nullptr;
+
 bool Thread::ShouldWait(Thread* thread) const {
     return status != ThreadStatus::Dead;
 }
@@ -39,17 +40,32 @@ void Thread::Acquire(Thread* thread) {
     ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
 }
 
-Thread::Thread(KernelCore& kernel) : WaitObject{kernel} {}
-Thread::~Thread() = default;
+// TODO(yuriks): This can be removed if Thread objects are explicitly pooled in the future, allowing
+//               us to simply use a pool index or similar.
+static Kernel::HandleTable wakeup_callback_handle_table;
+
+// The first available thread id at startup
+static u32 next_thread_id;
+
+/**
+ * Creates a new thread ID
+ * @return The new thread ID
+ */
+inline static u32 const NewThreadId() {
+    return next_thread_id++;
+}
+
+Thread::Thread() {}
+Thread::~Thread() {}
 
 void Thread::Stop() {
     // Cancel any outstanding wakeup events for this thread
-    CoreTiming::UnscheduleEvent(kernel.ThreadWakeupCallbackEventType(), callback_handle);
-    kernel.ThreadWakeupCallbackHandleTable().Close(callback_handle);
+    CoreTiming::UnscheduleEvent(ThreadWakeupEventType, callback_handle);
+    wakeup_callback_handle_table.Close(callback_handle);
     callback_handle = 0;
 
     // Clean up thread from ready queue
-    // This is only needed when the thread is terminated forcefully (SVC TerminateProcess)
+    // This is only needed when the thread is termintated forcefully (SVC TerminateProcess)
     if (status == ThreadStatus::Ready) {
         scheduler->UnscheduleThread(this, current_priority);
     }
@@ -82,6 +98,63 @@ void ExitCurrentThread() {
     Core::System::GetInstance().CurrentScheduler().RemoveThread(thread);
 }
 
+/**
+ * Callback that will wake up the thread it was scheduled for
+ * @param thread_handle The handle of the thread that's been awoken
+ * @param cycles_late The number of CPU cycles that have passed since the desired wakeup time
+ */
+static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
+    const auto proper_handle = static_cast<Handle>(thread_handle);
+
+    // Lock the global kernel mutex when we enter the kernel HLE.
+    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
+
+    SharedPtr<Thread> thread = wakeup_callback_handle_table.Get<Thread>(proper_handle);
+    if (thread == nullptr) {
+        LOG_CRITICAL(Kernel, "Callback fired for invalid thread {:08X}", proper_handle);
+        return;
+    }
+
+    bool resume = true;
+
+    if (thread->status == ThreadStatus::WaitSynchAny ||
+        thread->status == ThreadStatus::WaitSynchAll ||
+        thread->status == ThreadStatus::WaitHLEEvent) {
+        // Remove the thread from each of its waiting objects' waitlists
+        for (auto& object : thread->wait_objects)
+            object->RemoveWaitingThread(thread.get());
+        thread->wait_objects.clear();
+
+        // Invoke the wakeup callback before clearing the wait objects
+        if (thread->wakeup_callback)
+            resume = thread->wakeup_callback(ThreadWakeupReason::Timeout, thread, nullptr, 0);
+    }
+
+    if (thread->mutex_wait_address != 0 || thread->condvar_wait_address != 0 ||
+        thread->wait_handle) {
+        ASSERT(thread->status == ThreadStatus::WaitMutex);
+        thread->mutex_wait_address = 0;
+        thread->condvar_wait_address = 0;
+        thread->wait_handle = 0;
+
+        auto lock_owner = thread->lock_owner;
+        // Threads waking up by timeout from WaitProcessWideKey do not perform priority inheritance
+        // and don't have a lock owner unless SignalProcessWideKey was called first and the thread
+        // wasn't awakened due to the mutex already being acquired.
+        if (lock_owner) {
+            lock_owner->RemoveMutexWaiter(thread);
+        }
+    }
+
+    if (thread->arb_wait_address != 0) {
+        ASSERT(thread->status == ThreadStatus::WaitArb);
+        thread->arb_wait_address = 0;
+    }
+
+    if (resume)
+        thread->ResumeFromWait();
+}
+
 void Thread::WakeAfterDelay(s64 nanoseconds) {
     // Don't schedule a wakeup if the thread wants to wait forever
     if (nanoseconds == -1)
@@ -89,12 +162,12 @@ void Thread::WakeAfterDelay(s64 nanoseconds) {
 
     // This function might be called from any thread so we have to be cautious and use the
     // thread-safe version of ScheduleEvent.
-    CoreTiming::ScheduleEventThreadsafe(CoreTiming::nsToCycles(nanoseconds),
-                                        kernel.ThreadWakeupCallbackEventType(), callback_handle);
+    CoreTiming::ScheduleEventThreadsafe(CoreTiming::nsToCycles(nanoseconds), ThreadWakeupEventType,
+                                        callback_handle);
 }
 
 void Thread::CancelWakeupTimer() {
-    CoreTiming::UnscheduleEventThreadsafe(kernel.ThreadWakeupCallbackEventType(), callback_handle);
+    CoreTiming::UnscheduleEventThreadsafe(ThreadWakeupEventType, callback_handle);
 }
 
 static boost::optional<s32> GetNextProcessorId(u64 mask) {
@@ -221,9 +294,9 @@ static void ResetThreadContext(Core::ARM_Interface::ThreadContext& context, VAdd
     context.fpscr = 0;
 }
 
-ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name, VAddr entry_point,
-                                            u32 priority, u64 arg, s32 processor_id,
-                                            VAddr stack_top, SharedPtr<Process> owner_process) {
+ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point, u32 priority,
+                                            u64 arg, s32 processor_id, VAddr stack_top,
+                                            SharedPtr<Process> owner_process) {
     // Check if priority is in ranged. Lowest priority -> highest priority id.
     if (priority > THREADPRIO_LOWEST) {
         LOG_ERROR(Kernel_SVC, "Invalid thread priority: {}", priority);
@@ -243,9 +316,9 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
         return ResultCode(-1);
     }
 
-    SharedPtr<Thread> thread(new Thread(kernel));
+    SharedPtr<Thread> thread(new Thread);
 
-    thread->thread_id = kernel.CreateNewThreadID();
+    thread->thread_id = NewThreadId();
     thread->status = ThreadStatus::Dormant;
     thread->entry_point = entry_point;
     thread->stack_top = stack_top;
@@ -260,7 +333,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
     thread->condvar_wait_address = 0;
     thread->wait_handle = 0;
     thread->name = std::move(name);
-    thread->callback_handle = kernel.ThreadWakeupCallbackHandleTable().Create(thread).Unwrap();
+    thread->callback_handle = wakeup_callback_handle_table.Create(thread).Unwrap();
     thread->owner_process = owner_process;
     thread->scheduler = Core::System::GetInstance().Scheduler(processor_id);
     thread->scheduler->AddThread(thread, priority);
@@ -310,19 +383,19 @@ void Thread::BoostPriority(u32 priority) {
     current_priority = priority;
 }
 
-SharedPtr<Thread> SetupMainThread(KernelCore& kernel, VAddr entry_point, u32 priority,
+SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
                                   SharedPtr<Process> owner_process) {
     // Setup page table so we can write to memory
     SetCurrentPageTable(&Core::CurrentProcess()->vm_manager.page_table);
 
     // Initialize new "main" thread
-    auto thread_res = Thread::Create(kernel, "main", entry_point, priority, 0, THREADPROCESSORID_0,
+    auto thread_res = Thread::Create("main", entry_point, priority, 0, THREADPROCESSORID_0,
                                      Memory::STACK_AREA_VADDR_END, std::move(owner_process));
 
     SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
 
     // Register 1 must be a handle to the main thread
-    thread->guest_handle = kernel.HandleTable().Create(thread).Unwrap();
+    thread->guest_handle = Kernel::g_handle_table.Create(thread).Unwrap();
 
     thread->context.cpu_registers[1] = thread->guest_handle;
 
@@ -455,4 +528,13 @@ Thread* GetCurrentThread() {
     return Core::System::GetInstance().CurrentScheduler().GetCurrentThread();
 }
 
+void ThreadingInit() {
+    ThreadWakeupEventType = CoreTiming::RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
+    next_thread_id = 1;
+}
+
+void ThreadingShutdown() {
+    Kernel::ClearProcessList();
+}
+
 } // namespace Kernel

src/core/hle/kernel/thread.h

@@ -56,7 +56,6 @@ enum class ThreadWakeupReason {
 
 namespace Kernel {
 
-class KernelCore;
 class Process;
 class Scheduler;
 
@@ -64,7 +63,6 @@ class Thread final : public WaitObject {
 public:
     /**
      * Creates and returns a new thread. The new thread is immediately scheduled
-     * @param kernel The kernel instance this thread will be created under.
      * @param name The friendly name desired for the thread
      * @param entry_point The address at which the thread should start execution
      * @param priority The thread's priority
@@ -74,9 +72,8 @@ public:
      * @param owner_process The parent process for the thread
      * @return A shared pointer to the newly created thread
      */
-    static ResultVal<SharedPtr<Thread>> Create(KernelCore& kernel, std::string name,
-                                               VAddr entry_point, u32 priority, u64 arg,
-                                               s32 processor_id, VAddr stack_top,
+    static ResultVal<SharedPtr<Thread>> Create(std::string name, VAddr entry_point, u32 priority,
+                                               u64 arg, s32 processor_id, VAddr stack_top,
                                                SharedPtr<Process> owner_process);
 
     std::string GetName() const override {
@@ -266,7 +263,7 @@ public:
     u64 affinity_mask{0x1};
 
 private:
-    explicit Thread(KernelCore& kernel);
+    Thread();
     ~Thread() override;
 
     std::shared_ptr<std::vector<u8>> tls_memory = std::make_shared<std::vector<u8>>();
@@ -274,13 +271,12 @@ private:
 
 /**
  * Sets up the primary application thread
- * @param kernel The kernel instance to create the main thread under.
  * @param entry_point The address at which the thread should start execution
  * @param priority The priority to give the main thread
  * @param owner_process The parent process for the main thread
  * @return A shared pointer to the main thread
  */
-SharedPtr<Thread> SetupMainThread(KernelCore& kernel, VAddr entry_point, u32 priority,
+SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
                                   SharedPtr<Process> owner_process);
 
 /**
@@ -298,4 +294,14 @@ void WaitCurrentThread_Sleep();
  */
 void ExitCurrentThread();
 
+/**
+ * Initialize threading
+ */
+void ThreadingInit();
+
+/**
+ * Shutdown threading
+ */
+void ThreadingShutdown();
+
 } // namespace Kernel

src/core/hle/kernel/timer.cpp

@@ -2,31 +2,36 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <cinttypes>
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/hle/kernel/handle_table.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
 
 namespace Kernel {
 
-Timer::Timer(KernelCore& kernel) : WaitObject{kernel} {}
-Timer::~Timer() = default;
+/// The event type of the generic timer callback event
+static CoreTiming::EventType* timer_callback_event_type = nullptr;
+// TODO(yuriks): This can be removed if Timer objects are explicitly pooled in the future, allowing
+//               us to simply use a pool index or similar.
+static Kernel::HandleTable timer_callback_handle_table;
 
-SharedPtr<Timer> Timer::Create(KernelCore& kernel, ResetType reset_type, std::string name) {
-    SharedPtr<Timer> timer(new Timer(kernel));
+Timer::Timer() {}
+Timer::~Timer() {}
+
+SharedPtr<Timer> Timer::Create(ResetType reset_type, std::string name) {
+    SharedPtr<Timer> timer(new Timer);
 
     timer->reset_type = reset_type;
     timer->signaled = false;
     timer->name = std::move(name);
     timer->initial_delay = 0;
     timer->interval_delay = 0;
-    timer->callback_handle = kernel.CreateTimerCallbackHandle(timer).Unwrap();
+    timer->callback_handle = timer_callback_handle_table.Create(timer).Unwrap();
 
     return timer;
 }
@@ -53,13 +58,13 @@ void Timer::Set(s64 initial, s64 interval) {
         // Immediately invoke the callback
         Signal(0);
     } else {
-        CoreTiming::ScheduleEvent(CoreTiming::nsToCycles(initial), kernel.TimerCallbackEventType(),
+        CoreTiming::ScheduleEvent(CoreTiming::nsToCycles(initial), timer_callback_event_type,
                                   callback_handle);
     }
 }
 
 void Timer::Cancel() {
-    CoreTiming::UnscheduleEvent(kernel.TimerCallbackEventType(), callback_handle);
+    CoreTiming::UnscheduleEvent(timer_callback_event_type, callback_handle);
 }
 
 void Timer::Clear() {
@@ -84,8 +89,28 @@ void Timer::Signal(int cycles_late) {
     if (interval_delay != 0) {
         // Reschedule the timer with the interval delay
         CoreTiming::ScheduleEvent(CoreTiming::nsToCycles(interval_delay) - cycles_late,
-                                  kernel.TimerCallbackEventType(), callback_handle);
+                                  timer_callback_event_type, callback_handle);
     }
 }
 
+/// The timer callback event, called when a timer is fired
+static void TimerCallback(u64 timer_handle, int cycles_late) {
+    SharedPtr<Timer> timer =
+        timer_callback_handle_table.Get<Timer>(static_cast<Handle>(timer_handle));
+
+    if (timer == nullptr) {
+        LOG_CRITICAL(Kernel, "Callback fired for invalid timer {:016X}", timer_handle);
+        return;
+    }
+
+    timer->Signal(cycles_late);
+}
+
+void TimersInit() {
+    timer_callback_handle_table.Clear();
+    timer_callback_event_type = CoreTiming::RegisterEvent("TimerCallback", TimerCallback);
+}
+
+void TimersShutdown() {}
+
 } // namespace Kernel

src/core/hle/kernel/timer.h

@@ -10,19 +10,15 @@
 
 namespace Kernel {
 
-class KernelCore;
-
 class Timer final : public WaitObject {
 public:
     /**
      * Creates a timer
-     * @param kernel The kernel instance to create the timer callback handle for.
      * @param reset_type ResetType describing how to create the timer
      * @param name Optional name of timer
      * @return The created Timer
      */
-    static SharedPtr<Timer> Create(KernelCore& kernel, ResetType reset_type,
-                                   std::string name = "Unknown");
+    static SharedPtr<Timer> Create(ResetType reset_type, std::string name = "Unknown");
 
     std::string GetTypeName() const override {
         return "Timer";
@@ -72,7 +68,7 @@ public:
     void Signal(int cycles_late);
 
 private:
-    explicit Timer(KernelCore& kernel);
+    Timer();
     ~Timer() override;
 
     ResetType reset_type; ///< The ResetType of this timer
@@ -87,4 +83,9 @@ private:
     Handle callback_handle;
 };
 
+/// Initializes the required variables for timers
+void TimersInit();
+/// Tears down the timer variables
+void TimersShutdown();
+
 } // namespace Kernel

src/core/hle/kernel/wait_object.cpp

@@ -12,9 +12,6 @@
 
 namespace Kernel {
 
-WaitObject::WaitObject(KernelCore& kernel) : Object{kernel} {}
-WaitObject::~WaitObject() = default;
-
 void WaitObject::AddWaitingThread(SharedPtr<Thread> thread) {
     auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread);
     if (itr == waiting_threads.end())

src/core/hle/kernel/wait_object.h

@@ -11,15 +11,11 @@
 
 namespace Kernel {
 
-class KernelCore;
 class Thread;
 
 /// Class that represents a Kernel object that a thread can be waiting on
 class WaitObject : public Object {
 public:
-    explicit WaitObject(KernelCore& kernel);
-    ~WaitObject() override;
-
     /**
      * Check if the specified thread should wait until the object is available
      * @param thread The thread about which we're deciding.

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

@@ -160,9 +160,8 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
     };
     RegisterHandlers(functions);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
     launchable_event =
-        Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "ISelfController:LaunchableEvent");
+        Kernel::Event::Create(Kernel::ResetType::Sticky, "ISelfController:LaunchableEvent");
 }
 
 void ISelfController::SetFocusHandlingMode(Kernel::HLERequestContext& ctx) {
@@ -333,8 +332,7 @@ ICommonStateGetter::ICommonStateGetter() : ServiceFramework("ICommonStateGetter"
     };
     RegisterHandlers(functions);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "ICommonStateGetter:Event");
+    event = Kernel::Event::Create(Kernel::ResetType::OneShot, "ICommonStateGetter:Event");
 }
 
 void ICommonStateGetter::GetBootMode(Kernel::HLERequestContext& ctx) {
@@ -507,8 +505,7 @@ public:
         };
         RegisterHandlers(functions);
 
-        auto& kernel = Core::System::GetInstance().Kernel();
-        state_changed_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
+        state_changed_event = Kernel::Event::Create(Kernel::ResetType::OneShot,
                                                     "ILibraryAppletAccessor:StateChangedEvent");
     }
 

src/core/hle/service/audio/audout_u.cpp

@@ -47,9 +47,7 @@ public:
         RegisterHandlers(functions);
 
         // This is the event handle used to check if the audio buffer was released
-        auto& kernel = Core::System::GetInstance().Kernel();
-        buffer_event =
-            Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "IAudioOutBufferReleased");
+        buffer_event = Kernel::Event::Create(Kernel::ResetType::Sticky, "IAudioOutBufferReleased");
 
         stream = audio_core.OpenStream(audio_params.sample_rate, audio_params.channel_count,
                                        "IAudioOut", [=]() { buffer_event->Signal(); });

src/core/hle/service/audio/audren_u.cpp

@@ -35,9 +35,8 @@ public:
         };
         RegisterHandlers(functions);
 
-        auto& kernel = Core::System::GetInstance().Kernel();
         system_event =
-            Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "IAudioRenderer:SystemEvent");
+            Kernel::Event::Create(Kernel::ResetType::Sticky, "IAudioRenderer:SystemEvent");
         renderer = std::make_unique<AudioCore::AudioRenderer>(audren_params, system_event);
     }
 
@@ -122,9 +121,8 @@ public:
         };
         RegisterHandlers(functions);
 
-        auto& kernel = Core::System::GetInstance().Kernel();
-        buffer_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
-                                             "IAudioOutBufferReleasedEvent");
+        buffer_event =
+            Kernel::Event::Create(Kernel::ResetType::OneShot, "IAudioOutBufferReleasedEvent");
     }
 
 private:

src/core/hle/service/filesystem/filesystem.h

@@ -7,7 +7,6 @@
 #include <memory>
 #include "common/common_types.h"
 #include "core/file_sys/directory.h"
-#include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
 
 namespace FileSys {

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -26,17 +26,6 @@
 
 namespace Service::FileSystem {
 
-enum class FileSystemType : u8 {
-    Invalid0 = 0,
-    Invalid1 = 1,
-    Logo = 2,
-    ContentControl = 3,
-    ContentManual = 4,
-    ContentMeta = 5,
-    ContentData = 6,
-    ApplicationPackage = 7,
-};
-
 class IStorage final : public ServiceFramework<IStorage> {
 public:
     explicit IStorage(FileSys::VirtualFile backend_)
@@ -431,7 +420,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {0, nullptr, "MountContent"},
         {1, &FSP_SRV::Initialize, "Initialize"},
         {2, nullptr, "OpenDataFileSystemByCurrentProcess"},
-        {7, &FSP_SRV::OpenFileSystemWithPatch, "OpenFileSystemWithPatch"},
+        {7, nullptr, "OpenFileSystemWithPatch"},
         {8, nullptr, "OpenFileSystemWithId"},
         {9, nullptr, "OpenDataFileSystemByApplicationId"},
         {11, nullptr, "OpenBisFileSystem"},
@@ -455,7 +444,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {34, nullptr, "GetCacheStorageSize"},
         {51, &FSP_SRV::MountSaveData, "MountSaveData"},
         {52, nullptr, "OpenSaveDataFileSystemBySystemSaveDataId"},
-        {53, &FSP_SRV::OpenReadOnlySaveDataFileSystem, "OpenReadOnlySaveDataFileSystem"},
+        {53, nullptr, "OpenReadOnlySaveDataFileSystem"},
         {57, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataSpaceId"},
         {58, nullptr, "ReadSaveDataFileSystemExtraData"},
         {59, nullptr, "WriteSaveDataFileSystemExtraData"},
@@ -527,16 +516,6 @@ void FSP_SRV::Initialize(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
-void FSP_SRV::OpenFileSystemWithPatch(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    const auto type = rp.PopRaw<FileSystemType>();
-    const auto title_id = rp.PopRaw<u64>();
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 0};
-    rb.Push(ResultCode(-1));
-}
-
 void FSP_SRV::MountSdCard(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_FS, "called");
 
@@ -584,11 +563,6 @@ void FSP_SRV::MountSaveData(Kernel::HLERequestContext& ctx) {
     rb.PushIpcInterface<IFileSystem>(std::move(filesystem));
 }
 
-void FSP_SRV::OpenReadOnlySaveDataFileSystem(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_FS, "(STUBBED) called, delegating to 51 OpenSaveDataFilesystem");
-    MountSaveData(ctx);
-}
-
 void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 

src/core/hle/service/filesystem/fsp_srv.h

@@ -20,11 +20,9 @@ public:
 
 private:
     void Initialize(Kernel::HLERequestContext& ctx);
-    void OpenFileSystemWithPatch(Kernel::HLERequestContext& ctx);
     void MountSdCard(Kernel::HLERequestContext& ctx);
     void CreateSaveData(Kernel::HLERequestContext& ctx);
     void MountSaveData(Kernel::HLERequestContext& ctx);
-    void OpenReadOnlySaveDataFileSystem(Kernel::HLERequestContext& ctx);
     void GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
     void OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
     void OpenDataStorageByDataId(Kernel::HLERequestContext& ctx);

src/core/hle/service/hid/hid.cpp

@@ -4,7 +4,6 @@
 
 #include <atomic>
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/frontend/emu_window.h"
@@ -36,10 +35,9 @@ public:
         };
         RegisterHandlers(functions);
 
-        auto& kernel = Core::System::GetInstance().Kernel();
         shared_mem = Kernel::SharedMemory::Create(
-            kernel, nullptr, 0x40000, Kernel::MemoryPermission::ReadWrite,
-            Kernel::MemoryPermission::Read, 0, Kernel::MemoryRegion::BASE, "HID:SharedMemory");
+            nullptr, 0x40000, Kernel::MemoryPermission::ReadWrite, Kernel::MemoryPermission::Read,
+            0, Kernel::MemoryRegion::BASE, "HID:SharedMemory");
 
         // Register update callbacks
         pad_update_event = CoreTiming::RegisterEvent(
@@ -404,8 +402,7 @@ public:
 
         RegisterHandlers(functions);
 
-        auto& kernel = Core::System::GetInstance().Kernel();
-        event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "hid:EventHandle");
+        event = Kernel::Event::Create(Kernel::ResetType::OneShot, "hid:EventHandle");
     }
     ~Hid() = default;
 

src/core/hle/service/nfp/nfp.cpp

@@ -46,13 +46,11 @@ public:
         };
         RegisterHandlers(functions);
 
-        auto& kernel = Core::System::GetInstance().Kernel();
-        activate_event =
-            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IUser:ActivateEvent");
+        activate_event = Kernel::Event::Create(Kernel::ResetType::OneShot, "IUser:ActivateEvent");
         deactivate_event =
-            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IUser:DeactivateEvent");
-        availability_change_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
-                                                          "IUser:AvailabilityChangeEvent");
+            Kernel::Event::Create(Kernel::ResetType::OneShot, "IUser:DeactivateEvent");
+        availability_change_event =
+            Kernel::Event::Create(Kernel::ResetType::OneShot, "IUser:AvailabilityChangeEvent");
     }
 
 private:

src/core/hle/service/nifm/nifm.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/service/nifm/nifm.h"
@@ -55,9 +54,8 @@ public:
         };
         RegisterHandlers(functions);
 
-        auto& kernel = Core::System::GetInstance().Kernel();
-        event1 = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IRequest:Event1");
-        event2 = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "IRequest:Event2");
+        event1 = Kernel::Event::Create(Kernel::ResetType::OneShot, "IRequest:Event1");
+        event2 = Kernel::Event::Create(Kernel::ResetType::OneShot, "IRequest:Event2");
     }
 
 private:

src/core/hle/service/ns/pl_u.cpp

@@ -266,9 +266,8 @@ void PL_U::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
         SHARED_FONT_MEM_VADDR, shared_font, 0, SHARED_FONT_MEM_SIZE, Kernel::MemoryState::Shared);
 
     // Create shared font memory object
-    auto& kernel = Core::System::GetInstance().Kernel();
     shared_font_mem = Kernel::SharedMemory::Create(
-        kernel, Core::CurrentProcess(), SHARED_FONT_MEM_SIZE, Kernel::MemoryPermission::ReadWrite,
+        Core::CurrentProcess(), SHARED_FONT_MEM_SIZE, Kernel::MemoryPermission::ReadWrite,
         Kernel::MemoryPermission::Read, SHARED_FONT_MEM_VADDR, Kernel::MemoryRegion::BASE,
         "PL_U:shared_font_mem");
 

src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -7,7 +7,6 @@
 #include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
-#include "core/perf_stats.h"
 #include "video_core/gpu.h"
 #include "video_core/renderer_base.h"
 
@@ -32,7 +31,7 @@ void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u3
         transform, crop_rect};
 
     auto& instance = Core::System::GetInstance();
-    instance.GetPerfStats().EndGameFrame();
+    instance.perf_stats.EndGameFrame();
     instance.Renderer().SwapBuffers(framebuffer);
 }
 

src/core/hle/service/nvdrv/devices/nvhost_gpu.h

@@ -10,7 +10,6 @@
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
-#include "video_core/memory_manager.h"
 
 namespace Service::Nvidia::Devices {
 

src/core/hle/service/nvdrv/interface.cpp

@@ -4,7 +4,6 @@
 
 #include <cinttypes>
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/service/nvdrv/interface.h"
@@ -108,8 +107,7 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
     };
     RegisterHandlers(functions);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    query_event = Kernel::Event::Create(kernel, Kernel::ResetType::OneShot, "NVDRV::query_event");
+    query_event = Kernel::Event::Create(Kernel::ResetType::OneShot, "NVDRV::query_event");
 }
 
 } // namespace Service::Nvidia

src/core/hle/service/nvflinger/buffer_queue.cpp

@@ -6,16 +6,14 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
 
 namespace Service {
 namespace NVFlinger {
 
 BufferQueue::BufferQueue(u32 id, u64 layer_id) : id(id), layer_id(layer_id) {
-    auto& kernel = Core::System::GetInstance().Kernel();
     buffer_wait_event =
-        Kernel::Event::Create(kernel, Kernel::ResetType::Sticky, "BufferQueue NativeHandle");
+        Kernel::Event::Create(Kernel::ResetType::Sticky, "BufferQueue NativeHandle");
 }
 
 void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer) {

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -17,7 +17,6 @@
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
-#include "core/perf_stats.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 
@@ -138,7 +137,7 @@ void NVFlinger::Compose() {
             auto& system_instance = Core::System::GetInstance();
 
             // There was no queued buffer to draw, render previous frame
-            system_instance.GetPerfStats().EndGameFrame();
+            system_instance.perf_stats.EndGameFrame();
             system_instance.Renderer().SwapBuffers({});
             continue;
         }
@@ -162,8 +161,7 @@ void NVFlinger::Compose() {
 Layer::Layer(u64 id, std::shared_ptr<BufferQueue> queue) : id(id), buffer_queue(std::move(queue)) {}
 
 Display::Display(u64 id, std::string name) : id(id), name(std::move(name)) {
-    auto& kernel = Core::System::GetInstance().Kernel();
-    vsync_event = Kernel::Event::Create(kernel, Kernel::ResetType::Pulse, "Display VSync Event");
+    vsync_event = Kernel::Event::Create(Kernel::ResetType::Pulse, "Display VSync Event");
 }
 
 } // namespace Service::NVFlinger

src/core/hle/service/service.cpp

@@ -107,24 +107,19 @@ void ServiceFrameworkBase::InstallAsService(SM::ServiceManager& service_manager)
 
 void ServiceFrameworkBase::InstallAsNamedPort() {
     ASSERT(port == nullptr);
-
-    auto& kernel = Core::System::GetInstance().Kernel();
     SharedPtr<ServerPort> server_port;
     SharedPtr<ClientPort> client_port;
-    std::tie(server_port, client_port) =
-        ServerPort::CreatePortPair(kernel, max_sessions, service_name);
+    std::tie(server_port, client_port) = ServerPort::CreatePortPair(max_sessions, service_name);
     server_port->SetHleHandler(shared_from_this());
     AddNamedPort(service_name, std::move(client_port));
 }
 
 Kernel::SharedPtr<Kernel::ClientPort> ServiceFrameworkBase::CreatePort() {
     ASSERT(port == nullptr);
-
-    auto& kernel = Core::System::GetInstance().Kernel();
     Kernel::SharedPtr<Kernel::ServerPort> server_port;
     Kernel::SharedPtr<Kernel::ClientPort> client_port;
     std::tie(server_port, client_port) =
-        Kernel::ServerPort::CreatePortPair(kernel, max_sessions, service_name);
+        Kernel::ServerPort::CreatePortPair(max_sessions, service_name);
     port = MakeResult<Kernel::SharedPtr<Kernel::ServerPort>>(std::move(server_port)).Unwrap();
     port->SetHleHandler(shared_from_this());
     return client_port;

src/core/hle/service/sm/sm.cpp

@@ -4,7 +4,6 @@
 
 #include <tuple>
 #include "common/assert.h"
-#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
@@ -48,11 +47,9 @@ ResultVal<Kernel::SharedPtr<Kernel::ServerPort>> ServiceManager::RegisterService
     if (registered_services.find(name) != registered_services.end())
         return ERR_ALREADY_REGISTERED;
 
-    auto& kernel = Core::System::GetInstance().Kernel();
     Kernel::SharedPtr<Kernel::ServerPort> server_port;
     Kernel::SharedPtr<Kernel::ClientPort> client_port;
-    std::tie(server_port, client_port) =
-        Kernel::ServerPort::CreatePortPair(kernel, max_sessions, name);
+    std::tie(server_port, client_port) = Kernel::ServerPort::CreatePortPair(max_sessions, name);
 
     registered_services.emplace(std::move(name), std::move(client_port));
     return MakeResult<Kernel::SharedPtr<Kernel::ServerPort>>(std::move(server_port));

src/core/loader/deconstructed_rom_directory.cpp

@@ -6,12 +6,10 @@
 #include "common/common_funcs.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/romfs_factory.h"
 #include "core/gdbstub/gdbstub.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/service/filesystem/filesystem.h"
@@ -119,11 +117,10 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
         }
     }
 
-    auto& kernel = Core::System::GetInstance().Kernel();
     process->program_id = metadata.GetTitleID();
     process->svc_access_mask.set();
     process->resource_limit =
-        kernel.ResourceLimitForCategory(Kernel::ResourceLimitCategory::APPLICATION);
+        Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
     process->Run(Memory::PROCESS_IMAGE_VADDR, metadata.GetMainThreadPriority(),
                  metadata.GetMainThreadStackSize());
 

src/core/loader/elf.cpp

@@ -9,8 +9,6 @@
 #include "common/common_types.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
-#include "core/core.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/loader/elf.h"
@@ -302,8 +300,7 @@ SharedPtr<CodeSet> ElfReader::LoadInto(u32 vaddr) {
     std::vector<u8> program_image(total_image_size);
     size_t current_image_position = 0;
 
-    auto& kernel = Core::System::GetInstance().Kernel();
-    SharedPtr<CodeSet> codeset = CodeSet::Create(kernel, "");
+    SharedPtr<CodeSet> codeset = CodeSet::Create("");
 
     for (unsigned int i = 0; i < header->e_phnum; ++i) {
         Elf32_Phdr* p = &segments[i];
@@ -403,9 +400,8 @@ ResultStatus AppLoader_ELF::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     process->svc_access_mask.set();
 
     // Attach the default resource limit (APPLICATION) to the process
-    auto& kernel = Core::System::GetInstance().Kernel();
     process->resource_limit =
-        kernel.ResourceLimitForCategory(Kernel::ResourceLimitCategory::APPLICATION);
+        Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
 
     process->Run(codeset->entrypoint, 48, Memory::DEFAULT_STACK_SIZE);
 

src/core/loader/nro.cpp

@@ -14,7 +14,6 @@
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/gdbstub/gdbstub.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/loader/nro.h"
@@ -137,8 +136,7 @@ bool AppLoader_NRO::LoadNro(FileSys::VirtualFile file, VAddr load_base) {
     }
 
     // Build program image
-    auto& kernel = Core::System::GetInstance().Kernel();
-    Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create(kernel, "");
+    Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("");
     std::vector<u8> program_image = file->ReadBytes(PageAlignSize(nro_header.file_size));
     if (program_image.size() != PageAlignSize(nro_header.file_size)) {
         return {};
@@ -187,10 +185,9 @@ ResultStatus AppLoader_NRO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
         return ResultStatus::ErrorLoadingNRO;
     }
 
-    auto& kernel = Core::System::GetInstance().Kernel();
     process->svc_access_mask.set();
     process->resource_limit =
-        kernel.ResourceLimitForCategory(Kernel::ResourceLimitCategory::APPLICATION);
+        Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
     process->Run(base_addr, THREADPRIO_DEFAULT, Memory::DEFAULT_STACK_SIZE);
 
     is_loaded = true;

src/core/loader/nso.cpp

@@ -11,7 +11,6 @@
 #include "common/swap.h"
 #include "core/core.h"
 #include "core/gdbstub/gdbstub.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/loader/nso.h"
@@ -101,8 +100,7 @@ VAddr AppLoader_NSO::LoadModule(FileSys::VirtualFile file, VAddr load_base) {
         return {};
 
     // Build program image
-    auto& kernel = Core::System::GetInstance().Kernel();
-    Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create(kernel, "");
+    Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("");
     std::vector<u8> program_image;
     for (std::size_t i = 0; i < nso_header.segments.size(); ++i) {
         const std::vector<u8> compressed_data =
@@ -153,10 +151,9 @@ ResultStatus AppLoader_NSO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     LoadModule(file, Memory::PROCESS_IMAGE_VADDR);
     LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", file->GetName(), Memory::PROCESS_IMAGE_VADDR);
 
-    auto& kernel = Core::System::GetInstance().Kernel();
     process->svc_access_mask.set();
     process->resource_limit =
-        kernel.ResourceLimitForCategory(Kernel::ResourceLimitCategory::APPLICATION);
+        Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
     process->Run(Memory::PROCESS_IMAGE_VADDR, THREADPRIO_DEFAULT, Memory::DEFAULT_STACK_SIZE);
 
     is_loaded = true;

src/core/memory.cpp

@@ -251,8 +251,8 @@ std::string ReadCString(VAddr vaddr, std::size_t max_length) {
     return string;
 }
 
-void RasterizerMarkRegionCached(VAddr vaddr, u64 size, bool cached) {
-    if (vaddr == 0) {
+void RasterizerMarkRegionCached(Tegra::GPUVAddr gpu_addr, u64 size, bool cached) {
+    if (gpu_addr == 0) {
         return;
     }
 
@@ -261,8 +261,19 @@ void RasterizerMarkRegionCached(VAddr vaddr, u64 size, bool cached) {
     // CPU pages, hence why we iterate on a CPU page basis (note: GPU page size is different). This
     // assumes the specified GPU address region is contiguous as well.
 
-    u64 num_pages = ((vaddr + size - 1) >> PAGE_BITS) - (vaddr >> PAGE_BITS) + 1;
-    for (unsigned i = 0; i < num_pages; ++i, vaddr += PAGE_SIZE) {
+    u64 num_pages = ((gpu_addr + size - 1) >> PAGE_BITS) - (gpu_addr >> PAGE_BITS) + 1;
+    for (unsigned i = 0; i < num_pages; ++i, gpu_addr += PAGE_SIZE) {
+        boost::optional<VAddr> maybe_vaddr =
+            Core::System::GetInstance().GPU().MemoryManager().GpuToCpuAddress(gpu_addr);
+        // The GPU <-> CPU virtual memory mapping is not 1:1
+        if (!maybe_vaddr) {
+            LOG_ERROR(HW_Memory,
+                      "Trying to flush a cached region to an invalid physical address {:016X}",
+                      gpu_addr);
+            continue;
+        }
+        VAddr vaddr = *maybe_vaddr;
+
         PageType& page_type = current_page_table->attributes[vaddr >> PAGE_BITS];
 
         if (cached) {
@@ -333,19 +344,29 @@ void RasterizerFlushVirtualRegion(VAddr start, u64 size, FlushMode mode) {
 
         const VAddr overlap_start = std::max(start, region_start);
         const VAddr overlap_end = std::min(end, region_end);
+
+        const std::vector<Tegra::GPUVAddr> gpu_addresses =
+            system_instance.GPU().MemoryManager().CpuToGpuAddress(overlap_start);
+
+        if (gpu_addresses.empty()) {
+            return;
+        }
+
         const u64 overlap_size = overlap_end - overlap_start;
 
-        auto& rasterizer = system_instance.Renderer().Rasterizer();
-        switch (mode) {
-        case FlushMode::Flush:
-            rasterizer.FlushRegion(overlap_start, overlap_size);
-            break;
-        case FlushMode::Invalidate:
-            rasterizer.InvalidateRegion(overlap_start, overlap_size);
-            break;
-        case FlushMode::FlushAndInvalidate:
-            rasterizer.FlushAndInvalidateRegion(overlap_start, overlap_size);
-            break;
+        for (const auto& gpu_address : gpu_addresses) {
+            auto& rasterizer = system_instance.Renderer().Rasterizer();
+            switch (mode) {
+            case FlushMode::Flush:
+                rasterizer.FlushRegion(gpu_address, overlap_size);
+                break;
+            case FlushMode::Invalidate:
+                rasterizer.InvalidateRegion(gpu_address, overlap_size);
+                break;
+            case FlushMode::FlushAndInvalidate:
+                rasterizer.FlushAndInvalidateRegion(gpu_address, overlap_size);
+                break;
+            }
         }
     };
 

src/core/memory.h

@@ -11,6 +11,7 @@
 #include <boost/icl/interval_map.hpp>
 #include "common/common_types.h"
 #include "core/memory_hook.h"
+#include "video_core/memory_manager.h"
 
 namespace Kernel {
 class Process;
@@ -178,7 +179,7 @@ enum class FlushMode {
 /**
  * Mark each page touching the region as cached.
  */
-void RasterizerMarkRegionCached(VAddr vaddr, u64 size, bool cached);
+void RasterizerMarkRegionCached(Tegra::GPUVAddr gpu_addr, u64 size, bool cached);
 
 /**
  * Flushes and invalidates any externally cached rasterizer resources touching the given virtual

src/core/perf_stats.cpp

@@ -40,7 +40,7 @@ void PerfStats::EndGameFrame() {
     game_frames += 1;
 }
 
-PerfStatsResults PerfStats::GetAndResetStats(microseconds current_system_time_us) {
+PerfStats::Results PerfStats::GetAndResetStats(microseconds current_system_time_us) {
     std::lock_guard<std::mutex> lock(object_mutex);
 
     const auto now = Clock::now();
@@ -49,7 +49,7 @@ PerfStatsResults PerfStats::GetAndResetStats(microseconds current_system_time_us
 
     const auto system_us_per_second = (current_system_time_us - reset_point_system_us) / interval;
 
-    PerfStatsResults results{};
+    Results results{};
     results.system_fps = static_cast<double>(system_frames) / interval;
     results.game_fps = static_cast<double>(game_frames) / interval;
     results.frametime = duration_cast<DoubleSecs>(accumulated_frametime).count() /

src/core/perf_stats.h

@@ -10,17 +10,6 @@
 
 namespace Core {
 
-struct PerfStatsResults {
-    /// System FPS (LCD VBlanks) in Hz
-    double system_fps;
-    /// Game FPS (GSP frame submissions) in Hz
-    double game_fps;
-    /// Walltime per system frame, in seconds, excluding any waits
-    double frametime;
-    /// Ratio of walltime / emulated time elapsed
-    double emulation_speed;
-};
-
 /**
  * Class to manage and query performance/timing statistics. All public functions of this class are
  * thread-safe unless stated otherwise.
@@ -29,11 +18,22 @@ class PerfStats {
 public:
     using Clock = std::chrono::high_resolution_clock;
 
+    struct Results {
+        /// System FPS (LCD VBlanks) in Hz
+        double system_fps;
+        /// Game FPS (GSP frame submissions) in Hz
+        double game_fps;
+        /// Walltime per system frame, in seconds, excluding any waits
+        double frametime;
+        /// Ratio of walltime / emulated time elapsed
+        double emulation_speed;
+    };
+
     void BeginSystemFrame();
     void EndSystemFrame();
     void EndGameFrame();
 
-    PerfStatsResults GetAndResetStats(std::chrono::microseconds current_system_time_us);
+    Results GetAndResetStats(std::chrono::microseconds current_system_time_us);
 
     /**
      * Gets the ratio between walltime and the emulated time of the previous system frame. This is

src/core/telemetry_session.cpp

@@ -7,7 +7,6 @@
 #include "common/file_util.h"
 
 #include "core/core.h"
-#include "core/loader/loader.h"
 #include "core/settings.h"
 #include "core/telemetry_session.h"
 

src/tests/core/arm/arm_test_common.cpp

@@ -13,7 +13,7 @@ namespace ArmTests {
 TestEnvironment::TestEnvironment(bool mutable_memory_)
     : mutable_memory(mutable_memory_), test_memory(std::make_shared<TestMemory>(this)) {
 
-    Core::CurrentProcess() = Kernel::Process::Create(kernel, "");
+    Core::CurrentProcess() = Kernel::Process::Create("");
     page_table = &Core::CurrentProcess()->vm_manager.page_table;
 
     page_table->pointers.fill(nullptr);

src/tests/core/arm/arm_test_common.h

@@ -9,7 +9,6 @@
 #include <vector>
 
 #include "common/common_types.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/memory_hook.h"
 
 namespace Memory {
@@ -87,7 +86,6 @@ private:
     std::shared_ptr<TestMemory> test_memory;
     std::vector<WriteRecord> write_records;
     Memory::PageTable* page_table = nullptr;
-    Kernel::KernelCore kernel;
 };
 
 } // namespace ArmTests

src/video_core/engines/maxwell_3d.cpp

@@ -5,13 +5,13 @@
 #include <cinttypes>
 #include "common/assert.h"
 #include "core/core.h"
-#include "core/core_timing.h"
-#include "core/memory.h"
 #include "video_core/debug_utils/debug_utils.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_base.h"
+#include "video_core/textures/decoders.h"
 #include "video_core/textures/texture.h"
+#include "video_core/video_core.h"
 
 namespace Tegra {
 namespace Engines {
@@ -195,8 +195,8 @@ void Maxwell3D::ProcessQueryGet() {
             // wait queues.
             LongQueryResult query_result{};
             query_result.value = result;
-            // TODO(Subv): Generate a real GPU timestamp and write it here instead of CoreTiming
-            query_result.timestamp = CoreTiming::GetTicks();
+            // TODO(Subv): Generate a real GPU timestamp and write it here instead of 0
+            query_result.timestamp = 0;
             Memory::WriteBlock(*address, &query_result, sizeof(query_result));
         }
         break;

src/video_core/engines/shader_bytecode.h

@@ -147,7 +147,6 @@ enum class PredCondition : u64 {
     LessThanWithNan = 9,
     GreaterThanWithNan = 12,
     NotEqualWithNan = 13,
-    GreaterEqualWithNan = 14,
     // TODO(Subv): Other condition types
 };
 
@@ -214,18 +213,6 @@ enum class XmadMode : u64 {
     CBcc = 4,
 };
 
-enum class IAdd3Mode : u64 {
-    None = 0,
-    RightShift = 1,
-    LeftShift = 2,
-};
-
-enum class IAdd3Height : u64 {
-    None = 0,
-    LowerHalfWord = 1,
-    UpperHalfWord = 2,
-};
-
 enum class FlowCondition : u64 {
     Always = 0xF,
     Fcsm_Tr = 0x1C, // TODO(bunnei): What is this used for?
@@ -243,8 +230,6 @@ enum class TextureType : u64 {
     TextureCube = 3,
 };
 
-enum class IpaMode : u64 { Pass = 0, None = 1, Constant = 2, Sc = 3 };
-
 union Instruction {
     Instruction& operator=(const Instruction& instr) {
         value = instr.value;
@@ -327,10 +312,6 @@ union Instruction {
         }
     } alu;
 
-    union {
-        BitField<54, 3, IpaMode> mode;
-    } ipa;
-
     union {
         BitField<48, 1, u64> negate_b;
     } fmul;
@@ -361,16 +342,6 @@ union Instruction {
         BitField<48, 1, u64> is_signed;
     } imnmx;
 
-    union {
-        BitField<31, 2, IAdd3Height> height_c;
-        BitField<33, 2, IAdd3Height> height_b;
-        BitField<35, 2, IAdd3Height> height_a;
-        BitField<37, 2, IAdd3Mode> mode;
-        BitField<49, 1, u64> neg_c;
-        BitField<50, 1, u64> neg_b;
-        BitField<51, 1, u64> neg_a;
-    } iadd3;
-
     union {
         BitField<54, 1, u64> saturate;
         BitField<56, 1, u64> negate_a;
@@ -669,7 +640,7 @@ public:
         IADD_C,
         IADD_R,
         IADD_IMM,
-        IADD3_C, // Add 3 Integers
+        IADD3_C,
         IADD3_R,
         IADD3_IMM,
         IADD32I,

src/video_core/rasterizer_cache.h

@@ -4,86 +4,113 @@
 
 #pragma once
 
-#include <set>
-
+#include <unordered_map>
 #include <boost/icl/interval_map.hpp>
-#include <boost/range/iterator_range_core.hpp>
+#include <boost/range/iterator_range.hpp>
 
 #include "common/common_types.h"
-#include "core/core.h"
-#include "video_core/rasterizer_interface.h"
-#include "video_core/renderer_base.h"
+#include "core/memory.h"
+#include "video_core/memory_manager.h"
 
 template <class T>
 class RasterizerCache : NonCopyable {
 public:
     /// Mark the specified region as being invalidated
-    void InvalidateRegion(VAddr addr, u64 size) {
-        if (size == 0)
-            return;
+    void InvalidateRegion(Tegra::GPUVAddr region_addr, size_t region_size) {
+        for (auto iter = cached_objects.cbegin(); iter != cached_objects.cend();) {
+            const auto& object{iter->second};
 
-        const ObjectInterval interval{addr, addr + size};
-        for (auto& pair : boost::make_iterator_range(object_cache.equal_range(interval))) {
-            for (auto& cached_object : pair.second) {
-                if (!cached_object)
-                    continue;
+            ++iter;
 
-                remove_objects.emplace(cached_object);
+            if (object->GetAddr() <= (region_addr + region_size) &&
+                region_addr <= (object->GetAddr() + object->GetSizeInBytes())) {
+                // Regions overlap, so invalidate
+                Unregister(object);
             }
         }
-
-        for (auto& remove_object : remove_objects) {
-            Unregister(remove_object);
-        }
-
-        remove_objects.clear();
-    }
-
-    /// Invalidates everything in the cache
-    void InvalidateAll() {
-        while (object_cache.begin() != object_cache.end()) {
-            Unregister(*object_cache.begin()->second.begin());
-        }
     }
 
 protected:
     /// Tries to get an object from the cache with the specified address
-    T TryGet(VAddr addr) const {
-        const ObjectInterval interval{addr};
-        for (auto& pair : boost::make_iterator_range(object_cache.equal_range(interval))) {
-            for (auto& cached_object : pair.second) {
-                if (cached_object->GetAddr() == addr) {
-                    return cached_object;
-                }
-            }
+    T TryGet(Tegra::GPUVAddr addr) const {
+        const auto& search{cached_objects.find(addr)};
+        if (search != cached_objects.end()) {
+            return search->second;
         }
+
         return nullptr;
     }
 
+    /// Gets a reference to the cache
+    const std::unordered_map<Tegra::GPUVAddr, T>& GetCache() const {
+        return cached_objects;
+    }
+
     /// Register an object into the cache
     void Register(const T& object) {
-        object_cache.add({GetInterval(object), ObjectSet{object}});
-        auto& rasterizer = Core::System::GetInstance().Renderer().Rasterizer();
-        rasterizer.UpdatePagesCachedCount(object->GetAddr(), object->GetSizeInBytes(), 1);
+        const auto& search{cached_objects.find(object->GetAddr())};
+        if (search != cached_objects.end()) {
+            // Registered already
+            return;
+        }
+
+        cached_objects[object->GetAddr()] = object;
+        UpdatePagesCachedCount(object->GetAddr(), object->GetSizeInBytes(), 1);
     }
 
     /// Unregisters an object from the cache
     void Unregister(const T& object) {
-        auto& rasterizer = Core::System::GetInstance().Renderer().Rasterizer();
-        rasterizer.UpdatePagesCachedCount(object->GetAddr(), object->GetSizeInBytes(), -1);
-        object_cache.subtract({GetInterval(object), ObjectSet{object}});
+        const auto& search{cached_objects.find(object->GetAddr())};
+        if (search == cached_objects.end()) {
+            // Unregistered already
+            return;
+        }
+
+        UpdatePagesCachedCount(object->GetAddr(), object->GetSizeInBytes(), -1);
+        cached_objects.erase(search);
     }
 
 private:
-    using ObjectSet = std::set<T>;
-    using ObjectCache = boost::icl::interval_map<VAddr, ObjectSet>;
-    using ObjectInterval = typename ObjectCache::interval_type;
+    using PageMap = boost::icl::interval_map<u64, int>;
 
-    static auto GetInterval(const T& object) {
-        return ObjectInterval::right_open(object->GetAddr(),
-                                          object->GetAddr() + object->GetSizeInBytes());
+    template <typename Map, typename Interval>
+    constexpr auto RangeFromInterval(Map& map, const Interval& interval) {
+        return boost::make_iterator_range(map.equal_range(interval));
     }
 
-    ObjectCache object_cache;
-    ObjectSet remove_objects;
+    /// Increase/decrease the number of object in pages touching the specified region
+    void UpdatePagesCachedCount(Tegra::GPUVAddr addr, u64 size, int delta) {
+        const u64 page_start{addr >> Tegra::MemoryManager::PAGE_BITS};
+        const u64 page_end{(addr + size) >> Tegra::MemoryManager::PAGE_BITS};
+
+        // Interval maps will erase segments if count reaches 0, so if delta is negative we have to
+        // subtract after iterating
+        const auto pages_interval = PageMap::interval_type::right_open(page_start, page_end);
+        if (delta > 0)
+            cached_pages.add({pages_interval, delta});
+
+        for (const auto& pair : RangeFromInterval(cached_pages, pages_interval)) {
+            const auto interval = pair.first & pages_interval;
+            const int count = pair.second;
+
+            const Tegra::GPUVAddr interval_start_addr = boost::icl::first(interval)
+                                                        << Tegra::MemoryManager::PAGE_BITS;
+            const Tegra::GPUVAddr interval_end_addr = boost::icl::last_next(interval)
+                                                      << Tegra::MemoryManager::PAGE_BITS;
+            const u64 interval_size = interval_end_addr - interval_start_addr;
+
+            if (delta > 0 && count == delta)
+                Memory::RasterizerMarkRegionCached(interval_start_addr, interval_size, true);
+            else if (delta < 0 && count == -delta)
+                Memory::RasterizerMarkRegionCached(interval_start_addr, interval_size, false);
+            else
+                ASSERT(count >= 0);
+        }
+
+        if (delta < 0)
+            cached_pages.add({pages_interval, delta});
+    }
+
+    std::unordered_map<Tegra::GPUVAddr, T> cached_objects;
+    PageMap cached_pages;
 };

src/video_core/rasterizer_interface.h

@@ -27,14 +27,14 @@ public:
     virtual void FlushAll() = 0;
 
     /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
-    virtual void FlushRegion(VAddr addr, u64 size) = 0;
+    virtual void FlushRegion(Tegra::GPUVAddr addr, u64 size) = 0;
 
     /// Notify rasterizer that any caches of the specified region should be invalidated
-    virtual void InvalidateRegion(VAddr addr, u64 size) = 0;
+    virtual void InvalidateRegion(Tegra::GPUVAddr addr, u64 size) = 0;
 
     /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
     /// and invalidated
-    virtual void FlushAndInvalidateRegion(VAddr addr, u64 size) = 0;
+    virtual void FlushAndInvalidateRegion(Tegra::GPUVAddr addr, u64 size) = 0;
 
     /// Attempt to use a faster method to perform a display transfer with is_texture_copy = 0
     virtual bool AccelerateDisplayTransfer(const void* config) {
@@ -60,8 +60,5 @@ public:
     virtual bool AccelerateDrawBatch(bool is_indexed) {
         return false;
     }
-
-    /// Increase/decrease the number of object in pages touching the specified region
-    virtual void UpdatePagesCachedCount(Tegra::GPUVAddr addr, u64 size, int delta) {}
 };
 } // namespace VideoCore

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -274,41 +274,6 @@ bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) {
     return true;
 }
 
-template <typename Map, typename Interval>
-static constexpr auto RangeFromInterval(Map& map, const Interval& interval) {
-    return boost::make_iterator_range(map.equal_range(interval));
-}
-
-void RasterizerOpenGL::UpdatePagesCachedCount(VAddr addr, u64 size, int delta) {
-    const u64 page_start{addr >> Memory::PAGE_BITS};
-    const u64 page_end{(addr + size + Memory::PAGE_SIZE - 1) >> Memory::PAGE_BITS};
-
-    // Interval maps will erase segments if count reaches 0, so if delta is negative we have to
-    // subtract after iterating
-    const auto pages_interval = CachedPageMap::interval_type::right_open(page_start, page_end);
-    if (delta > 0)
-        cached_pages.add({pages_interval, delta});
-
-    for (const auto& pair : RangeFromInterval(cached_pages, pages_interval)) {
-        const auto interval = pair.first & pages_interval;
-        const int count = pair.second;
-
-        const VAddr interval_start_addr = boost::icl::first(interval) << Memory::PAGE_BITS;
-        const VAddr interval_end_addr = boost::icl::last_next(interval) << Memory::PAGE_BITS;
-        const u64 interval_size = interval_end_addr - interval_start_addr;
-
-        if (delta > 0 && count == delta)
-            Memory::RasterizerMarkRegionCached(interval_start_addr, interval_size, true);
-        else if (delta < 0 && count == -delta)
-            Memory::RasterizerMarkRegionCached(interval_start_addr, interval_size, false);
-        else
-            ASSERT(count >= 0);
-    }
-
-    if (delta < 0)
-        cached_pages.add({pages_interval, delta});
-}
-
 std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb,
                                                                     bool using_depth_fb,
                                                                     bool preserve_contents) {
@@ -432,6 +397,16 @@ void RasterizerOpenGL::Clear() {
     glClearStencil(regs.clear_stencil);
 
     glClear(clear_mask);
+
+    // Mark framebuffer surfaces as dirty
+    if (Settings::values.use_accurate_framebuffers) {
+        if (dirty_color_surface != nullptr) {
+            res_cache.FlushSurface(dirty_color_surface);
+        }
+        if (dirty_depth_surface != nullptr) {
+            res_cache.FlushSurface(dirty_depth_surface);
+        }
+    }
 }
 
 std::pair<u8*, GLintptr> RasterizerOpenGL::AlignBuffer(u8* buffer_ptr, GLintptr buffer_offset,
@@ -547,6 +522,16 @@ void RasterizerOpenGL::DrawArrays() {
         texture_unit.Unbind();
     }
     state.Apply();
+
+    // Mark framebuffer surfaces as dirty
+    if (Settings::values.use_accurate_framebuffers) {
+        if (dirty_color_surface != nullptr) {
+            res_cache.FlushSurface(dirty_color_surface);
+        }
+        if (dirty_depth_surface != nullptr) {
+            res_cache.FlushSurface(dirty_depth_surface);
+        }
+    }
 }
 
 void RasterizerOpenGL::NotifyMaxwellRegisterChanged(u32 method) {}
@@ -555,17 +540,17 @@ void RasterizerOpenGL::FlushAll() {
     MICROPROFILE_SCOPE(OpenGL_CacheManagement);
 }
 
-void RasterizerOpenGL::FlushRegion(VAddr addr, u64 size) {
+void RasterizerOpenGL::FlushRegion(Tegra::GPUVAddr addr, u64 size) {
     MICROPROFILE_SCOPE(OpenGL_CacheManagement);
 }
 
-void RasterizerOpenGL::InvalidateRegion(VAddr addr, u64 size) {
+void RasterizerOpenGL::InvalidateRegion(Tegra::GPUVAddr addr, u64 size) {
     MICROPROFILE_SCOPE(OpenGL_CacheManagement);
     res_cache.InvalidateRegion(addr, size);
     shader_cache.InvalidateRegion(addr, size);
 }
 
-void RasterizerOpenGL::FlushAndInvalidateRegion(VAddr addr, u64 size) {
+void RasterizerOpenGL::FlushAndInvalidateRegion(Tegra::GPUVAddr addr, u64 size) {
     MICROPROFILE_SCOPE(OpenGL_CacheManagement);
     InvalidateRegion(addr, size);
 }

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -10,11 +10,7 @@
 #include <tuple>
 #include <utility>
 #include <vector>
-
-#include <boost/icl/interval_map.hpp>
-#include <boost/range/iterator_range.hpp>
 #include <glad/glad.h>
-
 #include "common/common_types.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/memory_manager.h"
@@ -44,16 +40,15 @@ public:
     void Clear() override;
     void NotifyMaxwellRegisterChanged(u32 method) override;
     void FlushAll() override;
-    void FlushRegion(VAddr addr, u64 size) override;
-    void InvalidateRegion(VAddr addr, u64 size) override;
-    void FlushAndInvalidateRegion(VAddr addr, u64 size) override;
+    void FlushRegion(Tegra::GPUVAddr addr, u64 size) override;
+    void InvalidateRegion(Tegra::GPUVAddr addr, u64 size) override;
+    void FlushAndInvalidateRegion(Tegra::GPUVAddr addr, u64 size) override;
     bool AccelerateDisplayTransfer(const void* config) override;
     bool AccelerateTextureCopy(const void* config) override;
     bool AccelerateFill(const void* config) override;
     bool AccelerateDisplay(const Tegra::FramebufferConfig& config, VAddr framebuffer_addr,
                            u32 pixel_stride) override;
     bool AccelerateDrawBatch(bool is_indexed) override;
-    void UpdatePagesCachedCount(Tegra::GPUVAddr addr, u64 size, int delta) override;
 
     /// OpenGL shader generated for a given Maxwell register state
     struct MaxwellShader {
@@ -192,9 +187,6 @@ private:
 
     enum class AccelDraw { Disabled, Arrays, Indexed };
     AccelDraw accelerate_draw = AccelDraw::Disabled;
-
-    using CachedPageMap = boost::icl::interval_map<u64, int>;
-    CachedPageMap cached_pages;
 };
 
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -33,16 +33,11 @@ struct FormatTuple {
     bool compressed;
 };
 
-static VAddr TryGetCpuAddr(Tegra::GPUVAddr gpu_addr) {
-    auto& gpu{Core::System::GetInstance().GPU()};
-    const auto cpu_addr{gpu.MemoryManager().GpuToCpuAddress(gpu_addr)};
-    return cpu_addr ? *cpu_addr : 0;
-}
-
 /*static*/ SurfaceParams SurfaceParams::CreateForTexture(
     const Tegra::Texture::FullTextureInfo& config) {
+
     SurfaceParams params{};
-    params.addr = TryGetCpuAddr(config.tic.Address());
+    params.addr = config.tic.Address();
     params.is_tiled = config.tic.IsTiled();
     params.block_height = params.is_tiled ? config.tic.BlockHeight() : 0,
     params.pixel_format =
@@ -60,8 +55,9 @@ static VAddr TryGetCpuAddr(Tegra::GPUVAddr gpu_addr) {
 
 /*static*/ SurfaceParams SurfaceParams::CreateForFramebuffer(
     const Tegra::Engines::Maxwell3D::Regs::RenderTargetConfig& config) {
+
     SurfaceParams params{};
-    params.addr = TryGetCpuAddr(config.Address());
+    params.addr = config.Address();
     params.is_tiled = true;
     params.block_height = Tegra::Texture::TICEntry::DefaultBlockHeight;
     params.pixel_format = PixelFormatFromRenderTargetFormat(config.format);
@@ -79,8 +75,9 @@ static VAddr TryGetCpuAddr(Tegra::GPUVAddr gpu_addr) {
 /*static*/ SurfaceParams SurfaceParams::CreateForDepthBuffer(u32 zeta_width, u32 zeta_height,
                                                              Tegra::GPUVAddr zeta_address,
                                                              Tegra::DepthFormat format) {
+
     SurfaceParams params{};
-    params.addr = TryGetCpuAddr(zeta_address);
+    params.addr = zeta_address;
     params.is_tiled = true;
     params.block_height = Tegra::Texture::TICEntry::DefaultBlockHeight;
     params.pixel_format = PixelFormatFromDepthFormat(format);
@@ -123,11 +120,7 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
      true},                                                                     // DXN2UNORM
     {GL_COMPRESSED_SIGNED_RG_RGTC2, GL_RG, GL_INT, ComponentType::SNorm, true}, // DXN2SNORM
     {GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
-     true}, // BC7U
-    {GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8,
-     ComponentType::UNorm, true}, // BC6H_UF16
-    {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
-     true},                                                                    // BC6H_SF16
+     true},                                                                    // BC7U
     {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_4X4
     {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},            // G8R8U
     {GL_RG8, GL_RG, GL_BYTE, ComponentType::SNorm, false},                     // G8R8S
@@ -174,6 +167,11 @@ static const FormatTuple& GetFormatTuple(PixelFormat pixel_format, ComponentType
     return format;
 }
 
+VAddr SurfaceParams::GetCpuAddr() const {
+    auto& gpu = Core::System::GetInstance().GPU();
+    return *gpu.MemoryManager().GpuToCpuAddress(addr);
+}
+
 static bool IsPixelFormatASTC(PixelFormat format) {
     switch (format) {
     case PixelFormat::ASTC_2D_4X4:
@@ -212,36 +210,39 @@ static bool IsFormatBCn(PixelFormat format) {
     case PixelFormat::DXN2SNORM:
     case PixelFormat::DXN2UNORM:
     case PixelFormat::BC7U:
-    case PixelFormat::BC6H_UF16:
-    case PixelFormat::BC6H_SF16:
         return true;
     }
     return false;
 }
 
 template <bool morton_to_gl, PixelFormat format>
-void MortonCopy(u32 stride, u32 block_height, u32 height, std::vector<u8>& gl_buffer, VAddr addr) {
+void MortonCopy(u32 stride, u32 block_height, u32 height, std::vector<u8>& gl_buffer,
+                Tegra::GPUVAddr addr) {
     constexpr u32 bytes_per_pixel = SurfaceParams::GetFormatBpp(format) / CHAR_BIT;
     constexpr u32 gl_bytes_per_pixel = CachedSurface::GetGLBytesPerPixel(format);
+    auto& gpu = Core::System::GetInstance().GPU();
 
     if (morton_to_gl) {
         // With the BCn formats (DXT and DXN), each 4x4 tile is swizzled instead of just individual
         // pixel values.
         const u32 tile_size{IsFormatBCn(format) ? 4U : 1U};
-        const std::vector<u8> data = Tegra::Texture::UnswizzleTexture(
-            addr, tile_size, bytes_per_pixel, stride, height, block_height);
+        const std::vector<u8> data =
+            Tegra::Texture::UnswizzleTexture(*gpu.MemoryManager().GpuToCpuAddress(addr), tile_size,
+                                             bytes_per_pixel, stride, height, block_height);
         const size_t size_to_copy{std::min(gl_buffer.size(), data.size())};
         gl_buffer.assign(data.begin(), data.begin() + size_to_copy);
     } else {
         // TODO(bunnei): Assumes the default rendering GOB size of 16 (128 lines). We should
         // check the configuration for this and perform more generic un/swizzle
         LOG_WARNING(Render_OpenGL, "need to use correct swizzle/GOB parameters!");
-        VideoCore::MortonCopyPixels128(stride, height, bytes_per_pixel, gl_bytes_per_pixel,
-                                       Memory::GetPointer(addr), gl_buffer.data(), morton_to_gl);
+        VideoCore::MortonCopyPixels128(
+            stride, height, bytes_per_pixel, gl_bytes_per_pixel,
+            Memory::GetPointer(*gpu.MemoryManager().GpuToCpuAddress(addr)), gl_buffer.data(),
+            morton_to_gl);
     }
 }
 
-static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, VAddr),
+static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPUVAddr),
                             SurfaceParams::MaxPixelFormat>
     morton_to_gl_fns = {
         // clang-format off
@@ -265,8 +266,6 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, VAddr),
         MortonCopy<true, PixelFormat::DXN2UNORM>,
         MortonCopy<true, PixelFormat::DXN2SNORM>,
         MortonCopy<true, PixelFormat::BC7U>,
-        MortonCopy<true, PixelFormat::BC6H_UF16>,
-        MortonCopy<true, PixelFormat::BC6H_SF16>,
         MortonCopy<true, PixelFormat::ASTC_2D_4X4>,
         MortonCopy<true, PixelFormat::G8R8U>,
         MortonCopy<true, PixelFormat::G8R8S>,
@@ -298,7 +297,7 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, VAddr),
         // clang-format on
 };
 
-static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, VAddr),
+static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPUVAddr),
                             SurfaceParams::MaxPixelFormat>
     gl_to_morton_fns = {
         // clang-format off
@@ -315,10 +314,8 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, VAddr),
         MortonCopy<false, PixelFormat::RGBA16UI>,
         MortonCopy<false, PixelFormat::R11FG11FB10F>,
         MortonCopy<false, PixelFormat::RGBA32UI>,
-        // TODO(Subv): Swizzling DXT1/DXT23/DXT45/DXN1/DXN2/BC7U/BC6H_UF16/BC6H_SF16/ASTC_2D_4X4
-        // formats are not supported
-        nullptr,
-        nullptr,
+        // TODO(Subv): Swizzling DXT1/DXT23/DXT45/DXN1/DXN2/BC7U/ASTC_2D_4X4 formats is not
+        // supported
         nullptr,
         nullptr,
         nullptr,
@@ -535,7 +532,7 @@ MICROPROFILE_DEFINE(OpenGL_SurfaceLoad, "OpenGL", "Surface Load", MP_RGB(128, 64
 void CachedSurface::LoadGLBuffer() {
     ASSERT(params.type != SurfaceType::Fill);
 
-    const u8* const texture_src_data = Memory::GetPointer(params.addr);
+    const u8* const texture_src_data = Memory::GetPointer(params.GetCpuAddr());
 
     ASSERT(texture_src_data);
 
@@ -560,7 +557,7 @@ void CachedSurface::LoadGLBuffer() {
 
 MICROPROFILE_DEFINE(OpenGL_SurfaceFlush, "OpenGL", "Surface Flush", MP_RGB(128, 192, 64));
 void CachedSurface::FlushGLBuffer() {
-    u8* const dst_buffer = Memory::GetPointer(params.addr);
+    u8* const dst_buffer = Memory::GetPointer(params.GetCpuAddr());
 
     ASSERT(dst_buffer);
     ASSERT(gl_buffer.size() ==
@@ -757,10 +754,19 @@ Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, bool pres
         return {};
     }
 
+    auto& gpu = Core::System::GetInstance().GPU();
+    // Don't try to create any entries in the cache if the address of the texture is invalid.
+    if (gpu.MemoryManager().GpuToCpuAddress(params.addr) == boost::none)
+        return {};
+
     // Look up surface in the cache based on address
     Surface surface{TryGet(params.addr)};
     if (surface) {
-        if (surface->GetSurfaceParams().IsCompatibleSurface(params)) {
+        if (Settings::values.use_accurate_framebuffers) {
+            // If use_accurate_framebuffers is enabled, always load from memory
+            FlushSurface(surface);
+            Unregister(surface);
+        } else if (surface->GetSurfaceParams().IsCompatibleSurface(params)) {
             // Use the cached surface as-is
             return surface;
         } else if (preserve_contents) {
@@ -776,9 +782,15 @@ Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, bool pres
         }
     }
 
-    // No cached surface found - get a new one
-    surface = GetUncachedSurface(params);
-    Register(surface);
+    // Try to get a previously reserved surface
+    surface = TryGetReservedSurface(params);
+
+    // No surface found - create a new one
+    if (!surface) {
+        surface = std::make_shared<CachedSurface>(params);
+        ReserveSurface(surface);
+        Register(surface);
+    }
 
     // Only load surface from memory if we care about the contents
     if (preserve_contents) {
@@ -788,23 +800,13 @@ Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, bool pres
     return surface;
 }
 
-Surface RasterizerCacheOpenGL::GetUncachedSurface(const SurfaceParams& params) {
-    Surface surface{TryGetReservedSurface(params)};
-    if (!surface) {
-        // No reserved surface available, create a new one and reserve it
-        surface = std::make_shared<CachedSurface>(params);
-        ReserveSurface(surface);
-    }
-    return surface;
-}
-
 Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& surface,
                                                const SurfaceParams& new_params) {
     // Verify surface is compatible for blitting
     const auto& params{surface->GetSurfaceParams()};
 
-    // Get a new surface with the new parameters, and blit the previous surface to it
-    Surface new_surface{GetUncachedSurface(new_params)};
+    // Create a new surface with the new parameters, and blit the previous surface to it
+    Surface new_surface{std::make_shared<CachedSurface>(new_params)};
 
     // If format is unchanged, we can do a faster blit without reinterpreting pixel data
     if (params.pixel_format == new_params.pixel_format) {
@@ -814,73 +816,92 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& surface,
         return new_surface;
     }
 
-    // When using accurate framebuffers, always copy old data to new surface, regardless of format
-    if (Settings::values.use_accurate_framebuffers) {
-        auto source_format = GetFormatTuple(params.pixel_format, params.component_type);
-        auto dest_format = GetFormatTuple(new_params.pixel_format, new_params.component_type);
+    auto source_format = GetFormatTuple(params.pixel_format, params.component_type);
+    auto dest_format = GetFormatTuple(new_params.pixel_format, new_params.component_type);
 
-        size_t buffer_size = std::max(params.SizeInBytes(), new_params.SizeInBytes());
+    size_t buffer_size = std::max(params.SizeInBytes(), new_params.SizeInBytes());
 
-        // Use a Pixel Buffer Object to download the previous texture and then upload it to the new
-        // one using the new format.
-        OGLBuffer pbo;
-        pbo.Create();
+    // Use a Pixel Buffer Object to download the previous texture and then upload it to the new one
+    // using the new format.
+    OGLBuffer pbo;
+    pbo.Create();
 
-        glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo.handle);
-        glBufferData(GL_PIXEL_PACK_BUFFER, buffer_size, nullptr, GL_STREAM_DRAW_ARB);
-        if (source_format.compressed) {
-            glGetCompressedTextureImage(surface->Texture().handle, 0,
-                                        static_cast<GLsizei>(params.SizeInBytes()), nullptr);
-        } else {
-            glGetTextureImage(surface->Texture().handle, 0, source_format.format,
-                              source_format.type, static_cast<GLsizei>(params.SizeInBytes()),
-                              nullptr);
-        }
-        // If the new texture is bigger than the previous one, we need to fill in the rest with data
-        // from the CPU.
-        if (params.SizeInBytes() < new_params.SizeInBytes()) {
-            // Upload the rest of the memory.
-            if (new_params.is_tiled) {
-                // TODO(Subv): We might have to de-tile the subtexture and re-tile it with the rest
-                // of the data in this case. Games like Super Mario Odyssey seem to hit this case
-                // when drawing, it re-uses the memory of a previous texture as a bigger framebuffer
-                // but it doesn't clear it beforehand, the texture is already full of zeros.
-                LOG_CRITICAL(HW_GPU, "Trying to upload extra texture data from the CPU during "
-                                     "reinterpretation but the texture is tiled.");
-            }
-            size_t remaining_size = new_params.SizeInBytes() - params.SizeInBytes();
-            std::vector<u8> data(remaining_size);
-            Memory::ReadBlock(new_params.addr + params.SizeInBytes(), data.data(), data.size());
-            glBufferSubData(GL_PIXEL_PACK_BUFFER, params.SizeInBytes(), remaining_size,
-                            data.data());
-        }
-
-        glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
-
-        const auto& dest_rect{new_params.GetRect()};
-
-        glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo.handle);
-        if (dest_format.compressed) {
-            glCompressedTexSubImage2D(
-                GL_TEXTURE_2D, 0, 0, 0, static_cast<GLsizei>(dest_rect.GetWidth()),
-                static_cast<GLsizei>(dest_rect.GetHeight()), dest_format.format,
-                static_cast<GLsizei>(new_params.SizeInBytes()), nullptr);
-        } else {
-            glTextureSubImage2D(new_surface->Texture().handle, 0, 0, 0,
-                                static_cast<GLsizei>(dest_rect.GetWidth()),
-                                static_cast<GLsizei>(dest_rect.GetHeight()), dest_format.format,
-                                dest_format.type, nullptr);
-        }
-        glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
-
-        pbo.Release();
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo.handle);
+    glBufferData(GL_PIXEL_PACK_BUFFER, buffer_size, nullptr, GL_STREAM_DRAW_ARB);
+    if (source_format.compressed) {
+        glGetCompressedTextureImage(surface->Texture().handle, 0,
+                                    static_cast<GLsizei>(params.SizeInBytes()), nullptr);
+    } else {
+        glGetTextureImage(surface->Texture().handle, 0, source_format.format, source_format.type,
+                          static_cast<GLsizei>(params.SizeInBytes()), nullptr);
     }
+    // If the new texture is bigger than the previous one, we need to fill in the rest with data
+    // from the CPU.
+    if (params.SizeInBytes() < new_params.SizeInBytes()) {
+        // Upload the rest of the memory.
+        if (new_params.is_tiled) {
+            // TODO(Subv): We might have to de-tile the subtexture and re-tile it with the rest of
+            // the data in this case. Games like Super Mario Odyssey seem to hit this case when
+            // drawing, it re-uses the memory of a previous texture as a bigger framebuffer but it
+            // doesn't clear it beforehand, the texture is already full of zeros.
+            LOG_CRITICAL(HW_GPU, "Trying to upload extra texture data from the CPU during "
+                                 "reinterpretation but the texture is tiled.");
+        }
+        size_t remaining_size = new_params.SizeInBytes() - params.SizeInBytes();
+        auto address = Core::System::GetInstance().GPU().MemoryManager().GpuToCpuAddress(
+            new_params.addr + params.SizeInBytes());
+        std::vector<u8> data(remaining_size);
+        Memory::ReadBlock(*address, data.data(), data.size());
+        glBufferSubData(GL_PIXEL_PACK_BUFFER, params.SizeInBytes(), remaining_size, data.data());
+    }
+
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+
+    const auto& dest_rect{new_params.GetRect()};
+
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo.handle);
+    if (dest_format.compressed) {
+        glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
+                                  static_cast<GLsizei>(dest_rect.GetWidth()),
+                                  static_cast<GLsizei>(dest_rect.GetHeight()), dest_format.format,
+                                  static_cast<GLsizei>(new_params.SizeInBytes()), nullptr);
+    } else {
+        glTextureSubImage2D(new_surface->Texture().handle, 0, 0, 0,
+                            static_cast<GLsizei>(dest_rect.GetWidth()),
+                            static_cast<GLsizei>(dest_rect.GetHeight()), dest_format.format,
+                            dest_format.type, nullptr);
+    }
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+
+    pbo.Release();
 
     return new_surface;
 }
 
-Surface RasterizerCacheOpenGL::TryFindFramebufferSurface(VAddr addr) const {
-    return TryGet(addr);
+Surface RasterizerCacheOpenGL::TryFindFramebufferSurface(VAddr cpu_addr) const {
+    // Tries to find the GPU address of a framebuffer based on the CPU address. This is because
+    // final output framebuffers are specified by CPU address, but internally our GPU cache uses
+    // GPU addresses. We iterate through all cached framebuffers, and compare their starting CPU
+    // address to the one provided. This is obviously not great, and won't work if the
+    // framebuffer overlaps surfaces.
+
+    std::vector<Surface> surfaces;
+    for (const auto& surface : GetCache()) {
+        const auto& params = surface.second->GetSurfaceParams();
+        const VAddr surface_cpu_addr = params.GetCpuAddr();
+        if (cpu_addr >= surface_cpu_addr && cpu_addr < (surface_cpu_addr + params.size_in_bytes)) {
+            ASSERT_MSG(cpu_addr == surface_cpu_addr, "overlapping surfaces are unsupported");
+            surfaces.push_back(surface.second);
+        }
+    }
+
+    if (surfaces.empty()) {
+        return {};
+    }
+
+    ASSERT_MSG(surfaces.size() == 1, ">1 surface is unsupported");
+
+    return surfaces[0];
 }
 
 void RasterizerCacheOpenGL::ReserveSurface(const Surface& surface) {
@@ -892,6 +913,7 @@ Surface RasterizerCacheOpenGL::TryGetReservedSurface(const SurfaceParams& params
     const auto& surface_reserve_key{SurfaceReserveKey::Create(params)};
     auto search{surface_reserve.find(surface_reserve_key)};
     if (search != surface_reserve.end()) {
+        Register(search->second);
         return search->second;
     }
     return {};

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -45,44 +45,42 @@ struct SurfaceParams {
         DXN2UNORM = 17,
         DXN2SNORM = 18,
         BC7U = 19,
-        BC6H_UF16 = 20,
-        BC6H_SF16 = 21,
-        ASTC_2D_4X4 = 22,
-        G8R8U = 23,
-        G8R8S = 24,
-        BGRA8 = 25,
-        RGBA32F = 26,
-        RG32F = 27,
-        R32F = 28,
-        R16F = 29,
-        R16U = 30,
-        R16S = 31,
-        R16UI = 32,
-        R16I = 33,
-        RG16 = 34,
-        RG16F = 35,
-        RG16UI = 36,
-        RG16I = 37,
-        RG16S = 38,
-        RGB32F = 39,
-        SRGBA8 = 40,
-        RG8U = 41,
-        RG8S = 42,
-        RG32UI = 43,
-        R32UI = 44,
+        ASTC_2D_4X4 = 20,
+        G8R8U = 21,
+        G8R8S = 22,
+        BGRA8 = 23,
+        RGBA32F = 24,
+        RG32F = 25,
+        R32F = 26,
+        R16F = 27,
+        R16U = 28,
+        R16S = 29,
+        R16UI = 30,
+        R16I = 31,
+        RG16 = 32,
+        RG16F = 33,
+        RG16UI = 34,
+        RG16I = 35,
+        RG16S = 36,
+        RGB32F = 37,
+        SRGBA8 = 38,
+        RG8U = 39,
+        RG8S = 40,
+        RG32UI = 41,
+        R32UI = 42,
 
         MaxColorFormat,
 
         // Depth formats
-        Z32F = 45,
-        Z16 = 46,
+        Z32F = 43,
+        Z16 = 44,
 
         MaxDepthFormat,
 
         // DepthStencil formats
-        Z24S8 = 47,
-        S8Z24 = 48,
-        Z32FS8 = 49,
+        Z24S8 = 45,
+        S8Z24 = 46,
+        Z32FS8 = 47,
 
         MaxDepthStencilFormat,
 
@@ -140,8 +138,6 @@ struct SurfaceParams {
             4, // DXN2UNORM
             4, // DXN2SNORM
             4, // BC7U
-            4, // BC6H_UF16
-            4, // BC6H_SF16
             4, // ASTC_2D_4X4
             1, // G8R8U
             1, // G8R8S
@@ -201,8 +197,6 @@ struct SurfaceParams {
             128, // DXN2UNORM
             128, // DXN2SNORM
             128, // BC7U
-            128, // BC6H_UF16
-            128, // BC6H_SF16
             32,  // ASTC_2D_4X4
             16,  // G8R8U
             16,  // G8R8S
@@ -488,10 +482,6 @@ struct SurfaceParams {
             UNREACHABLE();
         case Tegra::Texture::TextureFormat::BC7U:
             return PixelFormat::BC7U;
-        case Tegra::Texture::TextureFormat::BC6H_UF16:
-            return PixelFormat::BC6H_UF16;
-        case Tegra::Texture::TextureFormat::BC6H_SF16:
-            return PixelFormat::BC6H_SF16;
         case Tegra::Texture::TextureFormat::ASTC_2D_4X4:
             return PixelFormat::ASTC_2D_4X4;
         case Tegra::Texture::TextureFormat::R16_G16:
@@ -638,6 +628,9 @@ struct SurfaceParams {
                GetFormatBpp(pixel_format) / CHAR_BIT;
     }
 
+    /// Returns the CPU virtual address for this surface
+    VAddr GetCpuAddr() const;
+
     /// Creates SurfaceParams from a texture configuration
     static SurfaceParams CreateForTexture(const Tegra::Texture::FullTextureInfo& config);
 
@@ -650,13 +643,25 @@ struct SurfaceParams {
                                               Tegra::GPUVAddr zeta_address,
                                               Tegra::DepthFormat format);
 
+    bool operator==(const SurfaceParams& other) const {
+        return std::tie(addr, is_tiled, block_height, pixel_format, component_type, type, width,
+                        height, unaligned_height, size_in_bytes) ==
+               std::tie(other.addr, other.is_tiled, other.block_height, other.pixel_format,
+                        other.component_type, other.type, other.width, other.height,
+                        other.unaligned_height, other.size_in_bytes);
+    }
+
+    bool operator!=(const SurfaceParams& other) const {
+        return !operator==(other);
+    }
+
     /// Checks if surfaces are compatible for caching
     bool IsCompatibleSurface(const SurfaceParams& other) const {
         return std::tie(pixel_format, type, cache_width, cache_height) ==
                std::tie(other.pixel_format, other.type, other.cache_width, other.cache_height);
     }
 
-    VAddr addr;
+    Tegra::GPUVAddr addr;
     bool is_tiled;
     u32 block_height;
     PixelFormat pixel_format;
@@ -697,7 +702,7 @@ class CachedSurface final {
 public:
     CachedSurface(const SurfaceParams& params);
 
-    VAddr GetAddr() const {
+    Tegra::GPUVAddr GetAddr() const {
         return params.addr;
     }
 
@@ -748,16 +753,13 @@ public:
     /// Flushes the surface to Switch memory
     void FlushSurface(const Surface& surface);
 
-    /// Tries to find a framebuffer using on the provided CPU address
-    Surface TryFindFramebufferSurface(VAddr addr) const;
+    /// Tries to find a framebuffer GPU address based on the provided CPU address
+    Surface TryFindFramebufferSurface(VAddr cpu_addr) const;
 
 private:
     void LoadSurface(const Surface& surface);
     Surface GetSurface(const SurfaceParams& params, bool preserve_contents = true);
 
-    /// Gets an uncached surface, creating it if need be
-    Surface GetUncachedSurface(const SurfaceParams& params);
-
     /// Recreates a surface with new parameters
     Surface RecreateSurface(const Surface& surface, const SurfaceParams& new_params);
 

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -12,17 +12,21 @@
 namespace OpenGL {
 
 /// Gets the address for the specified shader stage program
-static VAddr GetShaderAddress(Maxwell::ShaderProgram program) {
+static Tegra::GPUVAddr GetShaderAddress(Maxwell::ShaderProgram program) {
     auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
     auto& shader_config = gpu.regs.shader_config[static_cast<size_t>(program)];
-    return *gpu.memory_manager.GpuToCpuAddress(gpu.regs.code_address.CodeAddress() +
-                                               shader_config.offset);
+
+    return gpu.regs.code_address.CodeAddress() + shader_config.offset;
 }
 
 /// Gets the shader program code from memory for the specified address
-static GLShader::ProgramCode GetShaderCode(VAddr addr) {
+static GLShader::ProgramCode GetShaderCode(Tegra::GPUVAddr addr) {
+    auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
+
     GLShader::ProgramCode program_code(GLShader::MAX_PROGRAM_CODE_LENGTH);
-    Memory::ReadBlock(addr, program_code.data(), program_code.size() * sizeof(u64));
+    const boost::optional<VAddr> cpu_address{gpu.memory_manager.GpuToCpuAddress(addr)};
+    Memory::ReadBlock(*cpu_address, program_code.data(), program_code.size() * sizeof(u64));
+
     return program_code;
 }
 
@@ -51,7 +55,7 @@ static void SetShaderUniformBlockBindings(GLuint shader) {
                                  sizeof(GLShader::MaxwellUniformData));
 }
 
-CachedShader::CachedShader(VAddr addr, Maxwell::ShaderProgram program_type)
+CachedShader::CachedShader(Tegra::GPUVAddr addr, Maxwell::ShaderProgram program_type)
     : addr{addr}, program_type{program_type}, setup{GetShaderCode(addr)} {
 
     GLShader::ProgramResult program_result;
@@ -109,7 +113,7 @@ GLint CachedShader::GetUniformLocation(const std::string& name) {
 }
 
 Shader ShaderCacheOpenGL::GetStageProgram(Maxwell::ShaderProgram program) {
-    const VAddr program_addr{GetShaderAddress(program)};
+    const Tegra::GPUVAddr program_addr{GetShaderAddress(program)};
 
     // Look up shader in the cache based on address
     Shader shader{TryGet(program_addr)};

src/video_core/renderer_opengl/gl_shader_cache.h

@@ -8,6 +8,7 @@
 #include <unordered_map>
 
 #include "common/common_types.h"
+#include "video_core/memory_manager.h"
 #include "video_core/rasterizer_cache.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"
@@ -20,16 +21,16 @@ using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 
 class CachedShader final {
 public:
-    CachedShader(VAddr addr, Maxwell::ShaderProgram program_type);
+    CachedShader(Tegra::GPUVAddr addr, Maxwell::ShaderProgram program_type);
 
     /// Gets the address of the shader in guest memory, required for cache management
-    VAddr GetAddr() const {
+    Tegra::GPUVAddr GetAddr() const {
         return addr;
     }
 
     /// Gets the size of the shader in guest memory, required for cache management
     size_t GetSizeInBytes() const {
-        return GLShader::MAX_PROGRAM_CODE_LENGTH * sizeof(u64);
+        return sizeof(GLShader::ProgramCode);
     }
 
     /// Gets the shader entries for the shader
@@ -49,7 +50,7 @@ public:
     GLint GetUniformLocation(const std::string& name);
 
 private:
-    VAddr addr;
+    Tegra::GPUVAddr addr;
     Maxwell::ShaderProgram program_type;
     GLShader::ShaderSetup setup;
     GLShader::ShaderEntries entries;

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -729,7 +729,8 @@ private:
             {PredCondition::LessEqual, "<="},         {PredCondition::GreaterThan, ">"},
             {PredCondition::NotEqual, "!="},          {PredCondition::GreaterEqual, ">="},
             {PredCondition::LessThanWithNan, "<"},    {PredCondition::NotEqualWithNan, "!="},
-            {PredCondition::GreaterThanWithNan, ">"}, {PredCondition::GreaterEqualWithNan, ">="}};
+            {PredCondition::GreaterThanWithNan, ">"},
+        };
 
         const auto& comparison{PredicateComparisonStrings.find(condition)};
         ASSERT_MSG(comparison != PredicateComparisonStrings.end(),
@@ -738,8 +739,7 @@ private:
         std::string predicate{'(' + op_a + ") " + comparison->second + " (" + op_b + ')'};
         if (condition == PredCondition::LessThanWithNan ||
             condition == PredCondition::NotEqualWithNan ||
-            condition == PredCondition::GreaterThanWithNan ||
-            condition == PredCondition::GreaterEqualWithNan) {
+            condition == PredCondition::GreaterThanWithNan) {
             predicate += " || isnan(" + op_a + ") || isnan(" + op_b + ')';
         }
 
@@ -1287,67 +1287,6 @@ private:
                                           instr.alu.saturate_d);
                 break;
             }
-            case OpCode::Id::IADD3_C:
-            case OpCode::Id::IADD3_R:
-            case OpCode::Id::IADD3_IMM: {
-                std::string op_c = regs.GetRegisterAsInteger(instr.gpr39);
-
-                auto apply_height = [](auto height, auto& oprand) {
-                    switch (height) {
-                    case Tegra::Shader::IAdd3Height::None:
-                        break;
-                    case Tegra::Shader::IAdd3Height::LowerHalfWord:
-                        oprand = "((" + oprand + ") & 0xFFFF)";
-                        break;
-                    case Tegra::Shader::IAdd3Height::UpperHalfWord:
-                        oprand = "((" + oprand + ") >> 16)";
-                        break;
-                    default:
-                        LOG_CRITICAL(HW_GPU, "Unhandled IADD3 height: {}",
-                                     static_cast<u32>(height.Value()));
-                        UNREACHABLE();
-                    }
-                };
-
-                if (opcode->GetId() == OpCode::Id::IADD3_R) {
-                    apply_height(instr.iadd3.height_a, op_a);
-                    apply_height(instr.iadd3.height_b, op_b);
-                    apply_height(instr.iadd3.height_c, op_c);
-                }
-
-                if (instr.iadd3.neg_a)
-                    op_a = "-(" + op_a + ')';
-
-                if (instr.iadd3.neg_b)
-                    op_b = "-(" + op_b + ')';
-
-                if (instr.iadd3.neg_c)
-                    op_c = "-(" + op_c + ')';
-
-                std::string result;
-                if (opcode->GetId() == OpCode::Id::IADD3_R) {
-                    switch (instr.iadd3.mode) {
-                    case Tegra::Shader::IAdd3Mode::RightShift:
-                        // TODO(tech4me): According to
-                        // https://envytools.readthedocs.io/en/latest/hw/graph/maxwell/cuda/int.html?highlight=iadd3
-                        // The addition between op_a and op_b should be done in uint33, more
-                        // investigation required
-                        result = "(((" + op_a + " + " + op_b + ") >> 16) + " + op_c + ')';
-                        break;
-                    case Tegra::Shader::IAdd3Mode::LeftShift:
-                        result = "(((" + op_a + " + " + op_b + ") << 16) + " + op_c + ')';
-                        break;
-                    default:
-                        result = '(' + op_a + " + " + op_b + " + " + op_c + ')';
-                        break;
-                    }
-                } else {
-                    result = '(' + op_a + " + " + op_b + " + " + op_c + ')';
-                }
-
-                regs.SetRegisterToInteger(instr.gpr0, true, 0, result, 1, 1);
-                break;
-            }
             case OpCode::Id::ISCADD_C:
             case OpCode::Id::ISCADD_R:
             case OpCode::Id::ISCADD_IMM: {
@@ -2109,39 +2048,7 @@ private:
             }
             case OpCode::Id::IPA: {
                 const auto& attribute = instr.attribute.fmt28;
-                const auto& reg = instr.gpr0;
-                switch (instr.ipa.mode) {
-                case Tegra::Shader::IpaMode::Pass:
-                    if (stage == Maxwell3D::Regs::ShaderStage::Fragment &&
-                        attribute.index == Attribute::Index::Position) {
-                        switch (attribute.element) {
-                        case 0:
-                            shader.AddLine(regs.GetRegisterAsFloat(reg) + " = gl_FragCoord.x;");
-                            break;
-                        case 1:
-                            shader.AddLine(regs.GetRegisterAsFloat(reg) + " = gl_FragCoord.y;");
-                            break;
-                        case 2:
-                            shader.AddLine(regs.GetRegisterAsFloat(reg) + " = gl_FragCoord.z;");
-                            break;
-                        case 3:
-                            shader.AddLine(regs.GetRegisterAsFloat(reg) + " = 1.0;");
-                            break;
-                        }
-                    } else {
-                        regs.SetRegisterToInputAttibute(reg, attribute.element, attribute.index);
-                    }
-                    break;
-                case Tegra::Shader::IpaMode::None:
-                    regs.SetRegisterToInputAttibute(reg, attribute.element, attribute.index);
-                    break;
-                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled IPA mode: {}",
-                                 static_cast<u32>(instr.ipa.mode.Value()));
-                    UNREACHABLE();
-                    regs.SetRegisterToInputAttibute(reg, attribute.element, attribute.index);
-                }
-
+                regs.SetRegisterToInputAttibute(instr.gpr0, attribute.element, attribute.index);
                 break;
             }
             case OpCode::Id::SSY: {

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -10,14 +10,11 @@
 #include <glad/glad.h>
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "common/telemetry.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/frontend/emu_window.h"
 #include "core/memory.h"
-#include "core/perf_stats.h"
 #include "core/settings.h"
-#include "core/telemetry_session.h"
 #include "core/tracer/recorder.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/renderer_opengl.h"
@@ -118,7 +115,7 @@ RendererOpenGL::~RendererOpenGL() = default;
 void RendererOpenGL::SwapBuffers(boost::optional<const Tegra::FramebufferConfig&> framebuffer) {
     ScopeAcquireGLContext acquire_context{render_window};
 
-    Core::System::GetInstance().GetPerfStats().EndSystemFrame();
+    Core::System::GetInstance().perf_stats.EndSystemFrame();
 
     // Maintain the rasterizer's state as a priority
     OpenGLState prev_state = OpenGLState::GetCurState();
@@ -143,8 +140,8 @@ void RendererOpenGL::SwapBuffers(boost::optional<const Tegra::FramebufferConfig&
 
     render_window.PollEvents();
 
-    Core::System::GetInstance().FrameLimiter().DoFrameLimiting(CoreTiming::GetGlobalTimeUs());
-    Core::System::GetInstance().GetPerfStats().BeginSystemFrame();
+    Core::System::GetInstance().frame_limiter.DoFrameLimiting(CoreTiming::GetGlobalTimeUs());
+    Core::System::GetInstance().perf_stats.BeginSystemFrame();
 
     // Restore the rasterizer state
     prev_state.Apply();

src/video_core/textures/decoders.cpp

@@ -56,8 +56,6 @@ u32 BytesPerPixel(TextureFormat format) {
     case TextureFormat::DXT45:
     case TextureFormat::DXN2:
     case TextureFormat::BC7U:
-    case TextureFormat::BC6H_UF16:
-    case TextureFormat::BC6H_SF16:
         // In this case a 'pixel' actually refers to a 4x4 tile.
         return 16;
     case TextureFormat::R32_G32_B32:
@@ -108,8 +106,6 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
     case TextureFormat::DXN1:
     case TextureFormat::DXN2:
     case TextureFormat::BC7U:
-    case TextureFormat::BC6H_UF16:
-    case TextureFormat::BC6H_SF16:
     case TextureFormat::ASTC_2D_4X4:
     case TextureFormat::A8R8G8B8:
     case TextureFormat::A2B10G10R10:

src/yuzu/CMakeLists.txt

@@ -70,9 +70,6 @@ set(UIS
     main.ui
 )
 
-file(GLOB COMPAT_LIST
-     ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
-     ${CMAKE_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
 file(GLOB_RECURSE ICONS ${CMAKE_SOURCE_DIR}/dist/icons/*)
 file(GLOB_RECURSE THEMES ${CMAKE_SOURCE_DIR}/dist/qt_themes/*)
 
@@ -80,7 +77,6 @@ qt5_wrap_ui(UI_HDRS ${UIS})
 
 target_sources(yuzu
     PRIVATE
-        ${COMPAT_LIST}
         ${ICONS}
         ${THEMES}
         ${UI_HDRS}

src/yuzu/debugger/wait_tree.cpp

@@ -9,14 +9,11 @@
 #include "core/core.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/mutex.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
 #include "core/hle/kernel/wait_object.h"
 
-WaitTreeItem::WaitTreeItem() = default;
 WaitTreeItem::~WaitTreeItem() = default;
 
 QColor WaitTreeItem::GetColor() const {
@@ -74,22 +71,17 @@ std::vector<std::unique_ptr<WaitTreeThread>> WaitTreeItem::MakeThreadItemList()
 }
 
 WaitTreeText::WaitTreeText(const QString& t) : text(t) {}
-WaitTreeText::~WaitTreeText() = default;
 
 QString WaitTreeText::GetText() const {
     return text;
 }
 
 WaitTreeMutexInfo::WaitTreeMutexInfo(VAddr mutex_address) : mutex_address(mutex_address) {
-    auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
-
     mutex_value = Memory::Read32(mutex_address);
     owner_handle = static_cast<Kernel::Handle>(mutex_value & Kernel::Mutex::MutexOwnerMask);
-    owner = handle_table.Get<Kernel::Thread>(owner_handle);
+    owner = Kernel::g_handle_table.Get<Kernel::Thread>(owner_handle);
 }
 
-WaitTreeMutexInfo::~WaitTreeMutexInfo() = default;
-
 QString WaitTreeMutexInfo::GetText() const {
     return tr("waiting for mutex 0x%1").arg(mutex_address, 16, 16, QLatin1Char('0'));
 }
@@ -108,7 +100,6 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeMutexInfo::GetChildren() cons
 }
 
 WaitTreeCallstack::WaitTreeCallstack(const Kernel::Thread& thread) : thread(thread) {}
-WaitTreeCallstack::~WaitTreeCallstack() = default;
 
 QString WaitTreeCallstack::GetText() const {
     return tr("Call stack");
@@ -133,10 +124,6 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeCallstack::GetChildren() cons
 }
 
 WaitTreeWaitObject::WaitTreeWaitObject(const Kernel::WaitObject& o) : object(o) {}
-WaitTreeWaitObject::~WaitTreeWaitObject() = default;
-
-WaitTreeExpandableItem::WaitTreeExpandableItem() = default;
-WaitTreeExpandableItem::~WaitTreeExpandableItem() = default;
 
 bool WaitTreeExpandableItem::IsExpandable() const {
     return true;
@@ -191,8 +178,6 @@ WaitTreeObjectList::WaitTreeObjectList(
     const std::vector<Kernel::SharedPtr<Kernel::WaitObject>>& list, bool w_all)
     : object_list(list), wait_all(w_all) {}
 
-WaitTreeObjectList::~WaitTreeObjectList() = default;
-
 QString WaitTreeObjectList::GetText() const {
     if (wait_all)
         return tr("waiting for all objects");
@@ -207,7 +192,6 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeObjectList::GetChildren() con
 }
 
 WaitTreeThread::WaitTreeThread(const Kernel::Thread& thread) : WaitTreeWaitObject(thread) {}
-WaitTreeThread::~WaitTreeThread() = default;
 
 QString WaitTreeThread::GetText() const {
     const auto& thread = static_cast<const Kernel::Thread&>(object);
@@ -326,7 +310,6 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
 }
 
 WaitTreeEvent::WaitTreeEvent(const Kernel::Event& object) : WaitTreeWaitObject(object) {}
-WaitTreeEvent::~WaitTreeEvent() = default;
 
 std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeEvent::GetChildren() const {
     std::vector<std::unique_ptr<WaitTreeItem>> list(WaitTreeWaitObject::GetChildren());
@@ -338,7 +321,6 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeEvent::GetChildren() const {
 }
 
 WaitTreeTimer::WaitTreeTimer(const Kernel::Timer& object) : WaitTreeWaitObject(object) {}
-WaitTreeTimer::~WaitTreeTimer() = default;
 
 std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeTimer::GetChildren() const {
     std::vector<std::unique_ptr<WaitTreeItem>> list(WaitTreeWaitObject::GetChildren());
@@ -356,7 +338,6 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeTimer::GetChildren() const {
 
 WaitTreeThreadList::WaitTreeThreadList(const std::vector<Kernel::SharedPtr<Kernel::Thread>>& list)
     : thread_list(list) {}
-WaitTreeThreadList::~WaitTreeThreadList() = default;
 
 QString WaitTreeThreadList::GetText() const {
     return tr("waited by thread");
@@ -370,7 +351,6 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThreadList::GetChildren() con
 }
 
 WaitTreeModel::WaitTreeModel(QObject* parent) : QAbstractItemModel(parent) {}
-WaitTreeModel::~WaitTreeModel() = default;
 
 QModelIndex WaitTreeModel::index(int row, int column, const QModelIndex& parent) const {
     if (!hasIndex(row, column, parent))
@@ -439,8 +419,6 @@ WaitTreeWidget::WaitTreeWidget(QWidget* parent) : QDockWidget(tr("Wait Tree"), p
     setEnabled(false);
 }
 
-WaitTreeWidget::~WaitTreeWidget() = default;
-
 void WaitTreeWidget::OnDebugModeEntered() {
     if (!Core::System::GetInstance().IsPoweredOn())
         return;

src/yuzu/debugger/wait_tree.h

@@ -4,15 +4,11 @@
 
 #pragma once
 
-#include <cstddef>
-#include <memory>
-#include <vector>
-
 #include <QAbstractItemModel>
 #include <QDockWidget>
 #include <QTreeView>
 #include <boost/container/flat_set.hpp>
-#include "common/common_types.h"
+#include "core/core.h"
 #include "core/hle/kernel/object.h"
 
 class EmuThread;
@@ -29,7 +25,6 @@ class WaitTreeThread;
 class WaitTreeItem : public QObject {
     Q_OBJECT
 public:
-    WaitTreeItem();
     ~WaitTreeItem() override;
 
     virtual bool IsExpandable() const;
@@ -54,8 +49,6 @@ class WaitTreeText : public WaitTreeItem {
     Q_OBJECT
 public:
     explicit WaitTreeText(const QString& text);
-    ~WaitTreeText() override;
-
     QString GetText() const override;
 
 private:
@@ -65,9 +58,6 @@ private:
 class WaitTreeExpandableItem : public WaitTreeItem {
     Q_OBJECT
 public:
-    WaitTreeExpandableItem();
-    ~WaitTreeExpandableItem() override;
-
     bool IsExpandable() const override;
 };
 
@@ -75,8 +65,6 @@ class WaitTreeMutexInfo : public WaitTreeExpandableItem {
     Q_OBJECT
 public:
     explicit WaitTreeMutexInfo(VAddr mutex_address);
-    ~WaitTreeMutexInfo() override;
-
     QString GetText() const override;
     std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
 
@@ -91,8 +79,6 @@ class WaitTreeCallstack : public WaitTreeExpandableItem {
     Q_OBJECT
 public:
     explicit WaitTreeCallstack(const Kernel::Thread& thread);
-    ~WaitTreeCallstack() override;
-
     QString GetText() const override;
     std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
 
@@ -104,8 +90,6 @@ class WaitTreeWaitObject : public WaitTreeExpandableItem {
     Q_OBJECT
 public:
     explicit WaitTreeWaitObject(const Kernel::WaitObject& object);
-    ~WaitTreeWaitObject() override;
-
     static std::unique_ptr<WaitTreeWaitObject> make(const Kernel::WaitObject& object);
     QString GetText() const override;
     std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
@@ -121,8 +105,6 @@ class WaitTreeObjectList : public WaitTreeExpandableItem {
 public:
     WaitTreeObjectList(const std::vector<Kernel::SharedPtr<Kernel::WaitObject>>& list,
                        bool wait_all);
-    ~WaitTreeObjectList() override;
-
     QString GetText() const override;
     std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
 
@@ -135,8 +117,6 @@ class WaitTreeThread : public WaitTreeWaitObject {
     Q_OBJECT
 public:
     explicit WaitTreeThread(const Kernel::Thread& thread);
-    ~WaitTreeThread() override;
-
     QString GetText() const override;
     QColor GetColor() const override;
     std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
@@ -146,8 +126,6 @@ class WaitTreeEvent : public WaitTreeWaitObject {
     Q_OBJECT
 public:
     explicit WaitTreeEvent(const Kernel::Event& object);
-    ~WaitTreeEvent() override;
-
     std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
 };
 
@@ -155,8 +133,6 @@ class WaitTreeTimer : public WaitTreeWaitObject {
     Q_OBJECT
 public:
     explicit WaitTreeTimer(const Kernel::Timer& object);
-    ~WaitTreeTimer() override;
-
     std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
 };
 
@@ -164,8 +140,6 @@ class WaitTreeThreadList : public WaitTreeExpandableItem {
     Q_OBJECT
 public:
     explicit WaitTreeThreadList(const std::vector<Kernel::SharedPtr<Kernel::Thread>>& list);
-    ~WaitTreeThreadList() override;
-
     QString GetText() const override;
     std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
 
@@ -178,7 +152,6 @@ class WaitTreeModel : public QAbstractItemModel {
 
 public:
     explicit WaitTreeModel(QObject* parent = nullptr);
-    ~WaitTreeModel() override;
 
     QVariant data(const QModelIndex& index, int role) const override;
     QModelIndex index(int row, int column, const QModelIndex& parent) const override;
@@ -198,7 +171,6 @@ class WaitTreeWidget : public QDockWidget {
 
 public:
     explicit WaitTreeWidget(QWidget* parent = nullptr);
-    ~WaitTreeWidget() override;
 
 public slots:
     void OnDebugModeEntered();

src/yuzu/game_list.cpp

@@ -7,14 +7,10 @@
 #include <QDir>
 #include <QFileInfo>
 #include <QHeaderView>
-#include <QJsonArray>
-#include <QJsonDocument>
-#include <QJsonObject>
 #include <QKeyEvent>
 #include <QMenu>
 #include <QThreadPool>
 #include <boost/container/flat_map.hpp>
-#include <fmt/format.h>
 #include "common/common_paths.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
@@ -23,12 +19,10 @@
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs.h"
 #include "core/file_sys/vfs_real.h"
-#include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
-#include "yuzu/game_list.h"
-#include "yuzu/game_list_p.h"
-#include "yuzu/main.h"
-#include "yuzu/ui_settings.h"
+#include "game_list.h"
+#include "game_list_p.h"
+#include "ui_settings.h"
 
 GameList::SearchField::KeyReleaseEater::KeyReleaseEater(GameList* gamelist) : gamelist{gamelist} {}
 
@@ -230,7 +224,6 @@ GameList::GameList(FileSys::VirtualFilesystem vfs, GMainWindow* parent)
 
     item_model->insertColumns(0, COLUMN_COUNT);
     item_model->setHeaderData(COLUMN_NAME, Qt::Horizontal, "Name");
-    item_model->setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, "Compatibility");
     item_model->setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, "File type");
     item_model->setHeaderData(COLUMN_SIZE, Qt::Horizontal, "Size");
 
@@ -332,62 +325,12 @@ void GameList::PopupContextMenu(const QPoint& menu_location) {
 
     QMenu context_menu;
     QAction* open_save_location = context_menu.addAction(tr("Open Save Data Location"));
-    QAction* navigate_to_gamedb_entry = context_menu.addAction(tr("Navigate to GameDB entry"));
-
     open_save_location->setEnabled(program_id != 0);
-    auto it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
-    navigate_to_gamedb_entry->setVisible(it != compatibility_list.end() && program_id != 0);
-
     connect(open_save_location, &QAction::triggered,
             [&]() { emit OpenFolderRequested(program_id, GameListOpenTarget::SaveData); });
-    connect(navigate_to_gamedb_entry, &QAction::triggered,
-            [&]() { emit NavigateToGamedbEntryRequested(program_id, compatibility_list); });
-
     context_menu.exec(tree_view->viewport()->mapToGlobal(menu_location));
 }
 
-void GameList::LoadCompatibilityList() {
-    QFile compat_list{":compatibility_list/compatibility_list.json"};
-
-    if (!compat_list.open(QFile::ReadOnly | QFile::Text)) {
-        LOG_ERROR(Frontend, "Unable to open game compatibility list");
-        return;
-    }
-
-    if (compat_list.size() == 0) {
-        LOG_WARNING(Frontend, "Game compatibility list is empty");
-        return;
-    }
-
-    const QByteArray content = compat_list.readAll();
-    if (content.isEmpty()) {
-        LOG_ERROR(Frontend, "Unable to completely read game compatibility list");
-        return;
-    }
-
-    const QString string_content = content;
-    QJsonDocument json = QJsonDocument::fromJson(string_content.toUtf8());
-    QJsonArray arr = json.array();
-
-    for (const QJsonValue& value : arr) {
-        QJsonObject game = value.toObject();
-
-        if (game.contains("compatibility") && game["compatibility"].isDouble()) {
-            int compatibility = game["compatibility"].toInt();
-            QString directory = game["directory"].toString();
-            QJsonArray ids = game["releases"].toArray();
-
-            for (const QJsonValue& value : ids) {
-                QJsonObject object = value.toObject();
-                QString id = object["id"].toString();
-                compatibility_list.emplace(
-                    id.toUpper().toStdString(),
-                    std::make_pair(QString::number(compatibility), directory));
-            }
-        }
-    }
-}
-
 void GameList::PopulateAsync(const QString& dir_path, bool deep_scan) {
     if (!FileUtil::Exists(dir_path.toStdString()) ||
         !FileUtil::IsDirectory(dir_path.toStdString())) {
@@ -402,7 +345,7 @@ void GameList::PopulateAsync(const QString& dir_path, bool deep_scan) {
 
     emit ShouldCancelWorker();
 
-    GameListWorker* worker = new GameListWorker(vfs, dir_path, deep_scan, compatibility_list);
+    GameListWorker* worker = new GameListWorker(vfs, dir_path, deep_scan);
 
     connect(worker, &GameListWorker::EntryReady, this, &GameList::AddEntry, Qt::QueuedConnection);
     connect(worker, &GameListWorker::Finished, this, &GameList::DonePopulating,
@@ -483,14 +426,6 @@ static void GetMetadataFromControlNCA(const std::shared_ptr<FileSys::NCA>& nca,
     }
 }
 
-GameListWorker::GameListWorker(
-    FileSys::VirtualFilesystem vfs, QString dir_path, bool deep_scan,
-    const std::unordered_map<std::string, std::pair<QString, QString>>& compatibility_list)
-    : vfs(std::move(vfs)), dir_path(std::move(dir_path)), deep_scan(deep_scan),
-      compatibility_list(compatibility_list) {}
-
-GameListWorker::~GameListWorker() = default;
-
 void GameListWorker::AddInstalledTitlesToGameList(std::shared_ptr<FileSys::RegisteredCache> cache) {
     const auto installed_games = cache->ListEntriesFilter(FileSys::TitleType::Application,
                                                           FileSys::ContentRecordType::Program);
@@ -588,19 +523,11 @@ void GameListWorker::AddFstEntriesToGameList(const std::string& dir_path, unsign
                 }
             }
 
-            auto it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
-
-            // The game list uses this as compatibility number for untested games
-            QString compatibility("99");
-            if (it != compatibility_list.end())
-                compatibility = it->second.first;
-
             emit EntryReady({
                 new GameListItemPath(
                     FormatGameName(physical_name), icon, QString::fromStdString(name),
                     QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType())),
                     program_id),
-                new GameListItemCompat(compatibility),
                 new GameListItem(
                     QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType()))),
                 new GameListItemSize(FileUtil::GetSize(physical_name)),

src/yuzu/game_list.h

@@ -4,8 +4,6 @@
 
 #pragma once
 
-#include <unordered_map>
-
 #include <QFileSystemWatcher>
 #include <QHBoxLayout>
 #include <QLabel>
@@ -19,13 +17,9 @@
 #include <QTreeView>
 #include <QVBoxLayout>
 #include <QWidget>
+#include "main.h"
 
 class GameListWorker;
-class GMainWindow;
-
-namespace FileSys {
-class VfsFilesystem;
-}
 
 enum class GameListOpenTarget { SaveData };
 
@@ -35,7 +29,6 @@ class GameList : public QWidget {
 public:
     enum {
         COLUMN_NAME,
-        COLUMN_COMPATIBILITY,
         COLUMN_FILE_TYPE,
         COLUMN_SIZE,
         COLUMN_COUNT, // Number of columns
@@ -68,14 +61,13 @@ public:
         QToolButton* button_filter_close = nullptr;
     };
 
-    explicit GameList(std::shared_ptr<FileSys::VfsFilesystem> vfs, GMainWindow* parent = nullptr);
+    explicit GameList(FileSys::VirtualFilesystem vfs, GMainWindow* parent = nullptr);
     ~GameList() override;
 
     void clearFilter();
     void setFilterFocus();
     void setFilterVisible(bool visibility);
 
-    void LoadCompatibilityList();
     void PopulateAsync(const QString& dir_path, bool deep_scan);
 
     void SaveInterfaceLayout();
@@ -87,9 +79,6 @@ signals:
     void GameChosen(QString game_path);
     void ShouldCancelWorker();
     void OpenFolderRequested(u64 program_id, GameListOpenTarget target);
-    void NavigateToGamedbEntryRequested(
-        u64 program_id,
-        std::unordered_map<std::string, std::pair<QString, QString>>& compatibility_list);
 
 private slots:
     void onTextChanged(const QString& newText);
@@ -103,7 +92,7 @@ private:
     void PopupContextMenu(const QPoint& menu_location);
     void RefreshGameDirectory();
 
-    std::shared_ptr<FileSys::VfsFilesystem> vfs;
+    FileSys::VirtualFilesystem vfs;
     SearchField* search_field;
     GMainWindow* main_window = nullptr;
     QVBoxLayout* layout = nullptr;
@@ -111,7 +100,6 @@ private:
     QStandardItemModel* item_model = nullptr;
     GameListWorker* current_worker = nullptr;
     QFileSystemWatcher* watcher = nullptr;
-    std::unordered_map<std::string, std::pair<QString, QString>> compatibility_list;
 };
 
 Q_DECLARE_METATYPE(GameListOpenTarget);

src/yuzu/game_list_p.h

@@ -8,25 +8,16 @@
 #include <atomic>
 #include <map>
 #include <memory>
-#include <unordered_map>
 #include <utility>
-#include <QCoreApplication>
 #include <QImage>
-#include <QObject>
 #include <QRunnable>
 #include <QStandardItem>
 #include <QString>
-#include "common/logging/log.h"
 #include "common/string_util.h"
-#include "yuzu/ui_settings.h"
+#include "core/file_sys/content_archive.h"
+#include "ui_settings.h"
 #include "yuzu/util/util.h"
 
-namespace FileSys {
-class NCA;
-class RegisteredCache;
-class VfsFilesystem;
-} // namespace FileSys
-
 /**
  * Gets the default icon (for games without valid SMDH)
  * @param large If true, returns large icon (48x48), otherwise returns small icon (24x24)
@@ -38,17 +29,6 @@ static QPixmap GetDefaultIcon(u32 size) {
     return icon;
 }
 
-static auto FindMatchingCompatibilityEntry(
-    const std::unordered_map<std::string, std::pair<QString, QString>>& compatibility_list,
-    u64 program_id) {
-    return std::find_if(
-        compatibility_list.begin(), compatibility_list.end(),
-        [program_id](const std::pair<std::string, std::pair<QString, QString>>& element) {
-            std::string pid = fmt::format("{:016X}", program_id);
-            return element.first == pid;
-        });
-}
-
 class GameListItem : public QStandardItem {
 
 public:
@@ -116,45 +96,6 @@ public:
     }
 };
 
-class GameListItemCompat : public GameListItem {
-    Q_DECLARE_TR_FUNCTIONS(GameListItemCompat)
-public:
-    static const int CompatNumberRole = Qt::UserRole + 1;
-    GameListItemCompat() = default;
-    explicit GameListItemCompat(const QString& compatiblity) {
-        struct CompatStatus {
-            QString color;
-            const char* text;
-            const char* tooltip;
-        };
-        // clang-format off
-        static const std::map<QString, CompatStatus> status_data = {
-        {"0",  {"#5c93ed", QT_TR_NOOP("Perfect"),    QT_TR_NOOP("Game functions flawless with no audio or graphical glitches, all tested functionality works as intended without\nany workarounds needed.")}},
-        {"1",  {"#47d35c", QT_TR_NOOP("Great"),      QT_TR_NOOP("Game functions with minor graphical or audio glitches and is playable from start to finish. May require some\nworkarounds.")}},
-        {"2",  {"#94b242", QT_TR_NOOP("Okay"),       QT_TR_NOOP("Game functions with major graphical or audio glitches, but game is playable from start to finish with\nworkarounds.")}},
-        {"3",  {"#f2d624", QT_TR_NOOP("Bad"),        QT_TR_NOOP("Game functions, but with major graphical or audio glitches. Unable to progress in specific areas due to glitches\neven with workarounds.")}},
-        {"4",  {"#FF0000", QT_TR_NOOP("Intro/Menu"), QT_TR_NOOP("Game is completely unplayable due to major graphical or audio glitches. Unable to progress past the Start\nScreen.")}},
-        {"5",  {"#828282", QT_TR_NOOP("Won't Boot"), QT_TR_NOOP("The game crashes when attempting to startup.")}},
-        {"99", {"#000000", QT_TR_NOOP("Not Tested"), QT_TR_NOOP("The game has not yet been tested.")}}};
-        // clang-format on
-
-        auto iterator = status_data.find(compatiblity);
-        if (iterator == status_data.end()) {
-            LOG_WARNING(Frontend, "Invalid compatibility number {}", compatiblity.toStdString());
-            return;
-        }
-        CompatStatus status = iterator->second;
-        setData(compatiblity, CompatNumberRole);
-        setText(QObject::tr(status.text));
-        setToolTip(QObject::tr(status.tooltip));
-        setData(CreateCirclePixmapFromColor(status.color), Qt::DecorationRole);
-    }
-
-    bool operator<(const QStandardItem& other) const override {
-        return data(CompatNumberRole) < other.data(CompatNumberRole);
-    }
-};
-
 /**
  * A specialization of GameListItem for size values.
  * This class ensures that for every numerical size value it holds (in bytes), a correct
@@ -200,10 +141,8 @@ class GameListWorker : public QObject, public QRunnable {
     Q_OBJECT
 
 public:
-    GameListWorker(
-        std::shared_ptr<FileSys::VfsFilesystem> vfs, QString dir_path, bool deep_scan,
-        const std::unordered_map<std::string, std::pair<QString, QString>>& compatibility_list);
-    ~GameListWorker() override;
+    GameListWorker(FileSys::VirtualFilesystem vfs, QString dir_path, bool deep_scan)
+        : vfs(std::move(vfs)), dir_path(std::move(dir_path)), deep_scan(deep_scan) {}
 
 public slots:
     /// Starts the processing of directory tree information.
@@ -226,12 +165,11 @@ signals:
     void Finished(QStringList watch_list);
 
 private:
-    std::shared_ptr<FileSys::VfsFilesystem> vfs;
+    FileSys::VirtualFilesystem vfs;
     std::map<u64, std::shared_ptr<FileSys::NCA>> nca_control_map;
     QStringList watch_list;
     QString dir_path;
     bool deep_scan;
-    const std::unordered_map<std::string, std::pair<QString, QString>>& compatibility_list;
     std::atomic_bool stop_processing;
 
     void AddInstalledTitlesToGameList(std::shared_ptr<FileSys::RegisteredCache> cache);

src/yuzu/main.cpp

@@ -16,27 +16,25 @@
 #include <QMessageBox>
 #include <QtGui>
 #include <QtWidgets>
-#include <fmt/format.h>
 #include "common/common_paths.h"
 #include "common/logging/backend.h"
 #include "common/logging/filter.h"
 #include "common/logging/log.h"
+#include "common/logging/text_formatter.h"
 #include "common/microprofile.h"
 #include "common/scm_rev.h"
 #include "common/scope_exit.h"
 #include "common/string_util.h"
-#include "common/telemetry.h"
 #include "core/core.h"
 #include "core/crypto/key_manager.h"
+#include "core/file_sys/bis_factory.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs_real.h"
-#include "core/hle/service/filesystem/filesystem.h"
+#include "core/gdbstub/gdbstub.h"
 #include "core/loader/loader.h"
-#include "core/perf_stats.h"
 #include "core/settings.h"
-#include "core/telemetry_session.h"
 #include "video_core/debug_utils/debug_utils.h"
 #include "yuzu/about_dialog.h"
 #include "yuzu/bootmanager.h"
@@ -48,7 +46,6 @@
 #include "yuzu/debugger/profiler.h"
 #include "yuzu/debugger/wait_tree.h"
 #include "yuzu/game_list.h"
-#include "yuzu/game_list_p.h"
 #include "yuzu/hotkeys.h"
 #include "yuzu/main.h"
 #include "yuzu/ui_settings.h"
@@ -137,7 +134,6 @@ GMainWindow::GMainWindow()
 
     // Necessary to load titles from nand in gamelist.
     Service::FileSystem::CreateFactories(vfs);
-    game_list->LoadCompatibilityList();
     game_list->PopulateAsync(UISettings::values.gamedir, UISettings::values.gamedir_deepscan);
 
     // Show one-time "callout" messages to the user
@@ -353,8 +349,6 @@ void GMainWindow::RestoreUIState() {
 void GMainWindow::ConnectWidgetEvents() {
     connect(game_list, &GameList::GameChosen, this, &GMainWindow::OnGameListLoadFile);
     connect(game_list, &GameList::OpenFolderRequested, this, &GMainWindow::OnGameListOpenFolder);
-    connect(game_list, &GameList::NavigateToGamedbEntryRequested, this,
-            &GMainWindow::OnGameListNavigateToGamedbEntry);
 
     connect(this, &GMainWindow::EmulationStarting, render_window,
             &GRenderWindow::OnEmulationStarting);
@@ -684,20 +678,6 @@ void GMainWindow::OnGameListOpenFolder(u64 program_id, GameListOpenTarget target
     QDesktopServices::openUrl(QUrl::fromLocalFile(qpath));
 }
 
-void GMainWindow::OnGameListNavigateToGamedbEntry(
-    u64 program_id,
-    std::unordered_map<std::string, std::pair<QString, QString>>& compatibility_list) {
-
-    auto it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
-
-    QString directory;
-
-    if (it != compatibility_list.end())
-        directory = it->second.second;
-
-    QDesktopServices::openUrl(QUrl("https://yuzu-emu.org/game/" + directory));
-}
-
 void GMainWindow::OnMenuLoadFile() {
     QString extensions;
     for (const auto& piece : game_list->supported_file_extensions)

src/yuzu/main.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <memory>
-#include <unordered_map>
 #include <QMainWindow>
 #include <QTimer>
 #include "core/core.h"
@@ -24,10 +23,6 @@ class ProfilerWidget;
 class WaitTreeWidget;
 enum class GameListOpenTarget;
 
-namespace FileSys {
-class VfsFilesystem;
-}
-
 namespace Tegra {
 class DebugContext;
 }
@@ -129,9 +124,6 @@ private slots:
     /// Called whenever a user selects a game in the game list widget.
     void OnGameListLoadFile(QString game_path);
     void OnGameListOpenFolder(u64 program_id, GameListOpenTarget target);
-    void OnGameListNavigateToGamedbEntry(
-        u64 program_id,
-        std::unordered_map<std::string, std::pair<QString, QString>>& compatibility_list);
     void OnMenuLoadFile();
     void OnMenuLoadFolder();
     void OnMenuInstallToNAND();
@@ -174,7 +166,7 @@ private:
     QString game_path;
 
     // FS
-    std::shared_ptr<FileSys::VfsFilesystem> vfs;
+    FileSys::VirtualFilesystem vfs;
 
     // Debugger panes
     ProfilerWidget* profilerWidget;

src/yuzu/util/util.cpp

@@ -4,7 +4,6 @@
 
 #include <array>
 #include <cmath>
-#include <QPainter>
 #include "yuzu/util/util.h"
 
 QFont GetMonospaceFont() {
@@ -25,13 +24,3 @@ QString ReadableByteSize(qulonglong size) {
         .arg(size / std::pow(1024, digit_groups), 0, 'f', 1)
         .arg(units[digit_groups]);
 }
-
-QPixmap CreateCirclePixmapFromColor(const QColor& color) {
-    QPixmap circle_pixmap(16, 16);
-    circle_pixmap.fill(Qt::transparent);
-    QPainter painter(&circle_pixmap);
-    painter.setPen(color);
-    painter.setBrush(color);
-    painter.drawEllipse(0, 0, 15, 15);
-    return circle_pixmap;
-}

src/yuzu/util/util.h

@@ -12,10 +12,3 @@ QFont GetMonospaceFont();
 
 /// Convert a size in bytes into a readable format (KiB, MiB, etc.)
 QString ReadableByteSize(qulonglong size);
-
-/**
- * Creates a circle pixmap from a specified color
- * @param color The color the pixmap shall have
- * @return QPixmap circle pixmap
- */
-QPixmap CreateCirclePixmapFromColor(const QColor& color);

src/yuzu_cmd/yuzu.cpp

@@ -17,13 +17,10 @@
 #include "common/scm_rev.h"
 #include "common/scope_exit.h"
 #include "common/string_util.h"
-#include "common/telemetry.h"
 #include "core/core.h"
-#include "core/file_sys/vfs_real.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/loader/loader.h"
 #include "core/settings.h"
-#include "core/telemetry_session.h"
 #include "yuzu_cmd/config.h"
 #include "yuzu_cmd/emu_window/emu_window_sdl2.h"