qt: Add message about not moving contents on dir change

externals: Update dynarmic to 0435ac2

.travis.yml

@@ -20,6 +20,7 @@ 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
@@ -27,6 +28,7 @@ matrix:
       install: "./.travis/macos/deps.sh"
       script: "./.travis/macos/build.sh"
       after_success: "./.travis/macos/upload.sh"
+      cache: ccache
 
 deploy:
   provider: releases
@@ -42,7 +44,3 @@ notifications:
   webhooks:
     urls:
       - https://api.yuzu-emu.org/code/travis/notify
-
-cache:
-  directories:
-    - $HOME/.ccache

.travis/linux/build.sh

@@ -1,3 +1,4 @@
 #!/bin/bash -ex
 
-docker run -e CCACHE_DIR=/ccache -v $HOME/.ccache:/ccache --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu ubuntu:18.04 /bin/bash /yuzu/.travis/linux/docker.sh
+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

.travis/linux/docker.sh

@@ -5,14 +5,8 @@ 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
-ccache --show-stats > ccache_before
-cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -G Ninja
+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
 ninja
-ccache --show-stats > ccache_after
-diff -U100 ccache_before ccache_after || true
 
 ctest -VV -C Release

.travis/macos/build.sh

@@ -5,14 +5,11 @@ 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
+cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON
 make -j4
-ccache --show-stats > ccache_after
-diff -U100 ccache_before ccache_after || true
 
 ctest -VV -C Release

CMakeLists.txt

@@ -41,6 +41,19 @@ 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 .. 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 -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON .. 2>&1 && exit 0'
         } else {
-          C:\msys64\usr\bin\bash.exe -lc "cmake -G 'MSYS Makefiles' -DYUZU_BUILD_UNICORN=1 -DCMAKE_BUILD_TYPE=Release .. 2>&1"
+          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"
         }
   - cd ..
 
@@ -162,10 +162,6 @@ artifacts:
   - path: $(BUILD_ZIP)
     name: build
     type: zip
-  - path: $(BUILD_SYMBOLS)
-    name: debugsymbols
-  - path: $(BUILD_UPDATE)
-    name: update
 
 deploy:
   provider: GitHub

dist/compatibility_list/compatibility_list.qrc

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

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -9,6 +9,7 @@
 #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,24 +2,35 @@
 // 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"
 
@@ -27,71 +38,9 @@ namespace Core {
 
 /*static*/ System System::s_instance;
 
-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) {
+namespace {
+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;
@@ -121,173 +70,402 @@ static FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem
     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) {
-    app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
+    return impl->Load(emu_window, 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));
-        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;
+bool System::IsPoweredOn() const {
+    return impl->cpu_barrier && impl->cpu_barrier->IsAlive();
 }
 
 void System::PrepareReschedule() {
     CurrentCpuCore().PrepareReschedule();
 }
 
-PerfStats::Results System::GetAndResetPerfStats() {
-    return perf_stats.GetAndResetStats(CoreTiming::GetGlobalTimeUs());
+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();
 }
 
 const std::shared_ptr<Kernel::Scheduler>& System::Scheduler(size_t core_index) {
     ASSERT(core_index < NUM_CPU_CORES);
-    return cpu_cores[core_index]->Scheduler();
+    return impl->cpu_cores[core_index]->Scheduler();
 }
 
-Kernel::KernelCore& System::Kernel() {
-    return kernel;
-}
-
-const Kernel::KernelCore& System::Kernel() const {
-    return kernel;
+Kernel::SharedPtr<Kernel::Process>& System::CurrentProcess() {
+    return impl->current_process;
 }
 
 ARM_Interface& System::ArmInterface(size_t core_index) {
     ASSERT(core_index < NUM_CPU_CORES);
-    return cpu_cores[core_index]->ArmInterface();
+    return impl->cpu_cores[core_index]->ArmInterface();
 }
 
 Cpu& System::CpuCore(size_t core_index) {
     ASSERT(core_index < NUM_CPU_CORES);
-    return *cpu_cores[core_index];
+    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;
 }
 
 System::ResultStatus System::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;
+    return impl->Init(emu_window);
 }
 
 void System::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");
+    impl->Shutdown();
 }
 
 Service::SM::ServiceManager& System::ServiceManager() {
-    return *service_manager;
+    return *impl->service_manager;
 }
 
 const Service::SM::ServiceManager& System::ServiceManager() const {
-    return *service_manager;
+    return *impl->service_manager;
 }
 
 } // namespace Core

src/core/core.h

@@ -4,41 +4,55 @@
 
 #pragma once
 
-#include <array>
-#include <map>
+#include <cstddef>
 #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/kernel.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:
@@ -94,11 +108,7 @@ public:
      * This function should only be used by GDB Stub to support breakpoints, memory updates and
      * step/continue commands.
      */
-    void InvalidateCpuInstructionCaches() {
-        for (auto& cpu : cpu_cores) {
-            cpu->ArmInterface().ClearInstructionCache();
-        }
-    }
+    void InvalidateCpuInstructionCaches();
 
     /// Shutdown the emulated system.
     void Shutdown();
@@ -117,33 +127,28 @@ public:
      * application).
      * @returns True if the emulated system is powered on, otherwise false.
      */
-    bool IsPoweredOn() const {
-        return cpu_barrier && cpu_barrier->IsAlive();
-    }
+    bool IsPoweredOn() const;
 
     /**
      * Returns a reference to the telemetry session for this emulation session.
      * @returns Reference to the telemetry session.
      */
-    Core::TelemetrySession& TelemetrySession() const {
-        return *telemetry_session;
-    }
+    Core::TelemetrySession& TelemetrySession() const;
 
     /// Prepare the core emulation for a reschedule
     void PrepareReschedule();
 
     /// Gets and resets core performance statistics
-    PerfStats::Results GetAndResetPerfStats();
+    PerfStatsResults GetAndResetPerfStats();
 
     /// Gets an ARM interface to the CPU core that is currently running
-    ARM_Interface& CurrentArmInterface() {
-        return CurrentCpuCore().ArmInterface();
-    }
+    ARM_Interface& CurrentArmInterface();
 
     /// Gets the index of the currently running CPU core
-    size_t CurrentCoreIndex() {
-        return CurrentCpuCore().CoreIndex();
-    }
+    size_t CurrentCoreIndex();
+
+    /// Gets the scheduler for the CPU core that is currently running
+    Kernel::Scheduler& CurrentScheduler();
 
     /// Gets an ARM interface to the CPU core with the specified index
     ARM_Interface& ArmInterface(size_t core_index);
@@ -151,43 +156,26 @@ 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() {
-        return *gpu_core;
-    }
+    Tegra::GPU& GPU();
 
     /// Gets an immutable reference to the GPU interface.
-    const Tegra::GPU& GPU() const {
-        return *gpu_core;
-    }
+    const Tegra::GPU& GPU() const;
 
     /// Gets a mutable reference to the renderer.
-    VideoCore::RendererBase& Renderer() {
-        return *renderer;
-    }
+    VideoCore::RendererBase& Renderer();
 
     /// Gets an immutable reference to the renderer.
-    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;
-    }
+    const VideoCore::RendererBase& Renderer() const;
 
     /// 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() {
-        return current_process;
-    }
+    Kernel::SharedPtr<Kernel::Process>& CurrentProcess();
 
     /// Provides a reference to the kernel instance.
     Kernel::KernelCore& Kernel();
@@ -195,49 +183,37 @@ public:
     /// 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;
+
     /// Gets the name of the current game
-    Loader::ResultStatus GetGameName(std::string& out) const {
-        if (app_loader == nullptr)
-            return Loader::ResultStatus::ErrorNotInitialized;
-        return app_loader->ReadTitle(out);
-    }
+    Loader::ResultStatus GetGameName(std::string& out) const;
 
-    PerfStats perf_stats;
-    FrameLimiter frame_limiter;
+    void SetStatus(ResultStatus new_status, const char* details);
 
-    void SetStatus(ResultStatus new_status, const char* details = nullptr) {
-        status = new_status;
-        if (details) {
-            status_details = details;
-        }
-    }
+    const std::string& GetStatusDetails() const;
 
-    const std::string& GetStatusDetails() const {
-        return status_details;
-    }
-
-    Loader::AppLoader& GetAppLoader() const {
-        return *app_loader;
-    }
+    Loader::AppLoader& GetAppLoader() const;
 
     Service::SM::ServiceManager& ServiceManager();
     const Service::SM::ServiceManager& ServiceManager() const;
 
-    void SetGPUDebugContext(std::shared_ptr<Tegra::DebugContext> context) {
-        debug_context = std::move(context);
-    }
+    void SetGPUDebugContext(std::shared_ptr<Tegra::DebugContext> context);
 
-    std::shared_ptr<Tegra::DebugContext> GetGPUDebugContext() const {
-        return debug_context;
-    }
+    std::shared_ptr<Tegra::DebugContext> GetGPUDebugContext() const;
 
-    void SetFilesystem(FileSys::VirtualFilesystem vfs) {
-        virtual_filesystem = std::move(vfs);
-    }
+    void SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs);
 
-    FileSys::VirtualFilesystem GetFilesystem() const {
-        return virtual_filesystem;
-    }
+    std::shared_ptr<FileSys::VfsFilesystem> GetFilesystem() const;
 
 private:
     System();
@@ -253,34 +229,10 @@ private:
      */
     ResultStatus Init(Frontend::EmuWindow& emu_window);
 
-    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;
+    struct Impl;
+    std::unique_ptr<Impl> impl;
 
     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,6 +7,7 @@
 #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,6 +8,7 @@
 #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/kernel/address_arbiter.cpp

@@ -8,9 +8,11 @@
 #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/hle_ipc.cpp

@@ -18,6 +18,7 @@
 #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"

src/core/hle/kernel/server_session.cpp

@@ -13,6 +13,7 @@
 #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"
@@ -104,11 +105,10 @@ 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.
-
-    auto& handle_table = Core::System::GetInstance().Kernel().HandleTable();
     Kernel::HLERequestContext context(this);
     u32* cmd_buf = (u32*)Memory::GetPointer(thread->GetTLSAddress());
-    context.PopulateFromIncomingCommandBuffer(cmd_buf, *Core::CurrentProcess(), handle_table);
+    context.PopulateFromIncomingCommandBuffer(cmd_buf, *Core::CurrentProcess(),
+                                              kernel.HandleTable());
 
     ResultCode result = RESULT_SUCCESS;
     // If the session has been converted to a domain, handle the domain request

src/core/hle/kernel/svc.cpp

@@ -12,16 +12,20 @@
 #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"

src/core/hle/kernel/thread.cpp

@@ -16,6 +16,7 @@
 #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"
@@ -23,8 +24,8 @@
 #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"
 

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

@@ -60,17 +60,20 @@ ResultCode VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64
 
 ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) const {
     std::string path(FileUtil::SanitizePath(path_));
-    auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
     if (path.empty()) {
         // TODO(DarkLordZach): Why do games call this and what should it do? Works as is but...
         return RESULT_SUCCESS;
     }
-    if (dir->GetFile(FileUtil::GetFilename(path)) == nullptr)
+
+    auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
+    if (dir->GetFile(FileUtil::GetFilename(path)) == nullptr) {
         return FileSys::ERROR_PATH_NOT_FOUND;
+    }
     if (!dir->DeleteFile(FileUtil::GetFilename(path))) {
         // TODO(DarkLordZach): Find a better error code for this
         return ResultCode(-1);
     }
+
     return RESULT_SUCCESS;
 }
 

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

@@ -7,6 +7,7 @@
 #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,6 +26,17 @@
 
 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_)
@@ -420,7 +431,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {0, nullptr, "MountContent"},
         {1, &FSP_SRV::Initialize, "Initialize"},
         {2, nullptr, "OpenDataFileSystemByCurrentProcess"},
-        {7, nullptr, "OpenFileSystemWithPatch"},
+        {7, &FSP_SRV::OpenFileSystemWithPatch, "OpenFileSystemWithPatch"},
         {8, nullptr, "OpenFileSystemWithId"},
         {9, nullptr, "OpenDataFileSystemByApplicationId"},
         {11, nullptr, "OpenBisFileSystem"},
@@ -444,7 +455,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {34, nullptr, "GetCacheStorageSize"},
         {51, &FSP_SRV::MountSaveData, "MountSaveData"},
         {52, nullptr, "OpenSaveDataFileSystemBySystemSaveDataId"},
-        {53, nullptr, "OpenReadOnlySaveDataFileSystem"},
+        {53, &FSP_SRV::OpenReadOnlySaveDataFileSystem, "OpenReadOnlySaveDataFileSystem"},
         {57, nullptr, "ReadSaveDataFileSystemExtraDataBySaveDataSpaceId"},
         {58, nullptr, "ReadSaveDataFileSystemExtraData"},
         {59, nullptr, "WriteSaveDataFileSystemExtraData"},
@@ -516,6 +527,16 @@ 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");
 
@@ -563,6 +584,11 @@ 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,9 +20,11 @@ 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/nvdrv/devices/nvdisp_disp0.cpp

@@ -7,6 +7,7 @@
 #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"
 
@@ -31,7 +32,7 @@ void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u3
         transform, crop_rect};
 
     auto& instance = Core::System::GetInstance();
-    instance.perf_stats.EndGameFrame();
+    instance.GetPerfStats().EndGameFrame();
     instance.Renderer().SwapBuffers(framebuffer);
 }
 

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

@@ -17,6 +17,7 @@
 #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"
 
@@ -137,7 +138,7 @@ void NVFlinger::Compose() {
             auto& system_instance = Core::System::GetInstance();
 
             // There was no queued buffer to draw, render previous frame
-            system_instance.perf_stats.EndGameFrame();
+            system_instance.GetPerfStats().EndGameFrame();
             system_instance.Renderer().SwapBuffers({});
             continue;
         }

src/core/loader/deconstructed_rom_directory.cpp

@@ -11,6 +11,7 @@
 #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"

src/core/loader/elf.cpp

@@ -10,6 +10,7 @@
 #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"

src/core/loader/nro.cpp

@@ -14,6 +14,7 @@
 #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"

src/core/loader/nso.cpp

@@ -11,6 +11,7 @@
 #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"

src/core/perf_stats.cpp

@@ -40,7 +40,7 @@ void PerfStats::EndGameFrame() {
     game_frames += 1;
 }
 
-PerfStats::Results PerfStats::GetAndResetStats(microseconds current_system_time_us) {
+PerfStatsResults PerfStats::GetAndResetStats(microseconds current_system_time_us) {
     std::lock_guard<std::mutex> lock(object_mutex);
 
     const auto now = Clock::now();
@@ -49,7 +49,7 @@ PerfStats::Results PerfStats::GetAndResetStats(microseconds current_system_time_
 
     const auto system_us_per_second = (current_system_time_us - reset_point_system_us) / interval;
 
-    Results results{};
+    PerfStatsResults 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,6 +10,17 @@
 
 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.
@@ -18,22 +29,11 @@ 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();
 
-    Results GetAndResetStats(std::chrono::microseconds current_system_time_us);
+    PerfStatsResults 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/settings.h

@@ -127,6 +127,8 @@ struct Values {
 
     // Data Storage
     bool use_virtual_sd;
+    std::string nand_dir;
+    std::string sdmc_dir;
 
     // Renderer
     float resolution_factor;

src/core/telemetry_session.cpp

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

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 0
-            query_result.timestamp = 0;
+            // TODO(Subv): Generate a real GPU timestamp and write it here instead of CoreTiming
+            query_result.timestamp = CoreTiming::GetTicks();
             Memory::WriteBlock(*address, &query_result, sizeof(query_result));
         }
         break;

src/video_core/engines/shader_bytecode.h

@@ -147,6 +147,7 @@ enum class PredCondition : u64 {
     LessThanWithNan = 9,
     GreaterThanWithNan = 12,
     NotEqualWithNan = 13,
+    GreaterEqualWithNan = 14,
     // TODO(Subv): Other condition types
 };
 
@@ -242,7 +243,8 @@ enum class TextureType : u64 {
     TextureCube = 3,
 };
 
-enum class IpaMode : u64 { Pass = 0, None = 1, Constant = 2, Sc = 3 };
+enum class IpaInterpMode : u64 { Linear = 0, Perspective = 1, Flat = 2, Sc = 3 };
+enum class IpaSampleMode : u64 { Default = 0, Centroid = 1, Offset = 2 };
 
 union Instruction {
     Instruction& operator=(const Instruction& instr) {
@@ -327,10 +329,16 @@ union Instruction {
     } alu;
 
     union {
-        BitField<54, 3, IpaMode> mode;
+        BitField<51, 1, u64> saturate;
+        BitField<52, 2, IpaSampleMode> sample_mode;
+        BitField<54, 2, IpaInterpMode> interp_mode;
     } ipa;
 
     union {
+        BitField<39, 2, u64> tab5cb8_2;
+        BitField<41, 3, u64> tab5c68_1;
+        BitField<44, 2, u64> tab5c68_0;
+        BitField<47, 1, u64> cc;
         BitField<48, 1, u64> negate_b;
     } fmul;
 
@@ -344,6 +352,10 @@ union Instruction {
         BitField<49, 1, u64> negate_a;
     } alu_integer;
 
+    union {
+        BitField<40, 1, u64> invert;
+    } popc;
+
     union {
         BitField<39, 3, u64> pred;
         BitField<42, 1, u64> neg_pred;
@@ -394,8 +406,11 @@ union Instruction {
     } flow;
 
     union {
+        BitField<47, 1, u64> cc;
         BitField<48, 1, u64> negate_b;
         BitField<49, 1, u64> negate_c;
+        BitField<51, 2, u64> tab5980_1;
+        BitField<53, 2, u64> tab5980_0;
     } ffma;
 
     union {
@@ -504,6 +519,7 @@ union Instruction {
     union {
         BitField<0, 8, Register> gpr0;
         BitField<28, 8, Register> gpr28;
+        BitField<49, 1, u64> nodep;
         BitField<50, 3, u64> component_mask_selector;
         BitField<53, 4, u64> texture_info;
 
@@ -671,6 +687,9 @@ public:
         ISCADD_C, // Scale and Add
         ISCADD_R,
         ISCADD_IMM,
+        POPC_C,
+        POPC_R,
+        POPC_IMM,
         SEL_C,
         SEL_R,
         SEL_IMM,
@@ -892,6 +911,9 @@ private:
             INST("0100110000011---", Id::ISCADD_C, Type::ArithmeticInteger, "ISCADD_C"),
             INST("0101110000011---", Id::ISCADD_R, Type::ArithmeticInteger, "ISCADD_R"),
             INST("0011100-00011---", Id::ISCADD_IMM, Type::ArithmeticInteger, "ISCADD_IMM"),
+            INST("0100110000001---", Id::POPC_C, Type::ArithmeticInteger, "POPC_C"),
+            INST("0101110000001---", Id::POPC_R, Type::ArithmeticInteger, "POPC_R"),
+            INST("0011100-00001---", Id::POPC_IMM, Type::ArithmeticInteger, "POPC_IMM"),
             INST("0100110010100---", Id::SEL_C, Type::ArithmeticInteger, "SEL_C"),
             INST("0101110010100---", Id::SEL_R, Type::ArithmeticInteger, "SEL_R"),
             INST("0011100-10100---", Id::SEL_IMM, Type::ArithmeticInteger, "SEL_IMM"),

src/video_core/rasterizer_cache.h

@@ -4,100 +4,86 @@
 
 #pragma once
 
-#include <unordered_map>
-#include <vector>
+#include <set>
+
+#include <boost/icl/interval_map.hpp>
+#include <boost/range/iterator_range_core.hpp>
 
 #include "common/common_types.h"
 #include "core/core.h"
-#include "core/memory.h"
-#include "video_core/memory_manager.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_base.h"
 
 template <class T>
 class RasterizerCache : NonCopyable {
 public:
-    /// Mark the specified page as being invalidated
-    void InvalidatePage(u64 page) {
-        const auto& search_by_page{cached_pages.find(page)};
-        if (search_by_page == cached_pages.end()) {
+    /// Mark the specified region as being invalidated
+    void InvalidateRegion(VAddr addr, u64 size) {
+        if (size == 0)
             return;
+
+        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;
+
+                remove_objects.emplace(cached_object);
+            }
         }
 
-        for (const auto& object : search_by_page->second) {
-            Unregister(object.second, false);
+        for (auto& remove_object : remove_objects) {
+            Unregister(remove_object);
         }
 
-        cached_pages.erase(search_by_page);
+        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 u64 page{addr >> Memory::PAGE_BITS};
-        const auto& search_by_page{cached_pages.find(page)};
-        if (search_by_page == cached_pages.end()) {
-            return nullptr;
+        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;
+                }
+            }
         }
-
-        const auto& search_by_addr{search_by_page->second.find(addr)};
-        if (search_by_addr == search_by_page->second.end()) {
-            return nullptr;
-        }
-
-        return search_by_addr->second;
+        return nullptr;
     }
 
     /// Register an object into the cache
     void Register(const T& object) {
-        const u64 page{object->GetAddr() >> Memory::PAGE_BITS};
-        const auto& search_by_page{cached_pages.find(page)};
-        if (search_by_page != cached_pages.end()) {
-            search_by_page->second[object->GetAddr()] = object;
-        } else {
-            CacheMap new_cache_map;
-            new_cache_map[object->GetAddr()] = object;
-            cached_pages[page] = std::move(new_cache_map);
-        }
-
+        object_cache.add({GetInterval(object), ObjectSet{object}});
         auto& rasterizer = Core::System::GetInstance().Renderer().Rasterizer();
         rasterizer.UpdatePagesCachedCount(object->GetAddr(), object->GetSizeInBytes(), 1);
     }
 
     /// Unregisters an object from the cache
-    void Unregister(const T& object, bool remove_from_cache = true) {
-        const u64 page{object->GetAddr() >> Memory::PAGE_BITS};
-        const auto& search_by_page{cached_pages.find(page)};
-        if (search_by_page == cached_pages.end()) {
-            // Unregistered already
-            return;
-        }
-
-        const auto& search_by_addr{search_by_page->second.find(object->GetAddr())};
-        if (search_by_addr == search_by_page->second.end()) {
-            // Unregistered already
-            return;
-        }
-
+    void Unregister(const T& object) {
         auto& rasterizer = Core::System::GetInstance().Renderer().Rasterizer();
         rasterizer.UpdatePagesCachedCount(object->GetAddr(), object->GetSizeInBytes(), -1);
-
-        // Remove from the cache if specified
-        if (remove_from_cache) {
-            if (search_by_page->second.size() == 1) {
-                // Only one item at the page, remove the cached page
-                cached_pages.erase(search_by_page);
-            } else {
-                // Remove just the item at the cached page
-                search_by_page->second.erase(search_by_addr);
-            }
-        }
+        object_cache.subtract({GetInterval(object), ObjectSet{object}});
     }
 
 private:
-    using CacheMap = std::unordered_map<VAddr, T>;
+    using ObjectSet = std::set<T>;
+    using ObjectCache = boost::icl::interval_map<VAddr, ObjectSet>;
+    using ObjectInterval = typename ObjectCache::interval_type;
 
-    /// Two-level cache of objects, where first level is keyed on starting CPU address page, and
-    /// second level is keyed on exact CPU address
-    std::unordered_map<u64, CacheMap> cached_pages;
+    static auto GetInterval(const T& object) {
+        return ObjectInterval::right_open(object->GetAddr(),
+                                          object->GetAddr() + object->GetSizeInBytes());
+    }
+
+    ObjectCache object_cache;
+    ObjectSet remove_objects;
 };

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -432,16 +432,6 @@ 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,
@@ -557,16 +547,6 @@ 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) {}
@@ -581,11 +561,8 @@ void RasterizerOpenGL::FlushRegion(VAddr addr, u64 size) {
 
 void RasterizerOpenGL::InvalidateRegion(VAddr addr, u64 size) {
     MICROPROFILE_SCOPE(OpenGL_CacheManagement);
-    const u64 page_end{(addr + size + Memory::PAGE_SIZE - 1) >> Memory::PAGE_BITS};
-    for (u64 page{addr >> Memory::PAGE_BITS}; page <= page_end; ++page) {
-        res_cache.InvalidatePage(page);
-        shader_cache.InvalidatePage(page);
-    }
+    res_cache.InvalidateRegion(addr, size);
+    shader_cache.InvalidateRegion(addr, size);
 }
 
 void RasterizerOpenGL::FlushAndInvalidateRegion(VAddr addr, u64 size) {

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -123,7 +123,11 @@ 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
+     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
     {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
@@ -208,6 +212,8 @@ 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;
@@ -259,6 +265,8 @@ 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>,
@@ -307,8 +315,10 @@ 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/ASTC_2D_4X4 formats is not
-        // supported
+        // TODO(Subv): Swizzling DXT1/DXT23/DXT45/DXN1/DXN2/BC7U/BC6H_UF16/BC6H_SF16/ASTC_2D_4X4
+        // formats are not supported
+        nullptr,
+        nullptr,
         nullptr,
         nullptr,
         nullptr,
@@ -750,11 +760,7 @@ Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, bool pres
     // Look up surface in the cache based on address
     Surface surface{TryGet(params.addr)};
     if (surface) {
-        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)) {
+        if (surface->GetSurfaceParams().IsCompatibleSurface(params)) {
             // Use the cached surface as-is
             return surface;
         } else if (preserve_contents) {
@@ -770,15 +776,9 @@ Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, bool pres
         }
     }
 
-    // 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);
-    }
+    // No cached surface found - get a new one
+    surface = GetUncachedSurface(params);
+    Register(surface);
 
     // Only load surface from memory if we care about the contents
     if (preserve_contents) {
@@ -788,13 +788,23 @@ 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()};
 
-    // Create a new surface with the new parameters, and blit the previous surface to it
-    Surface new_surface{std::make_shared<CachedSurface>(new_params)};
+    // Get a new surface with the new parameters, and blit the previous surface to it
+    Surface new_surface{GetUncachedSurface(new_params)};
 
     // If format is unchanged, we can do a faster blit without reinterpreting pixel data
     if (params.pixel_format == new_params.pixel_format) {
@@ -804,63 +814,68 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& surface,
         return new_surface;
     }
 
-    auto source_format = GetFormatTuple(params.pixel_format, params.component_type);
-    auto dest_format = GetFormatTuple(new_params.pixel_format, new_params.component_type);
+    // 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);
 
-    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.");
+        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);
         }
-        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());
+        // 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, 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;
 }
 
@@ -877,7 +892,6 @@ 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,42 +45,44 @@ struct SurfaceParams {
         DXN2UNORM = 17,
         DXN2SNORM = 18,
         BC7U = 19,
-        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,
+        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,
 
         MaxColorFormat,
 
         // Depth formats
-        Z32F = 43,
-        Z16 = 44,
+        Z32F = 45,
+        Z16 = 46,
 
         MaxDepthFormat,
 
         // DepthStencil formats
-        Z24S8 = 45,
-        S8Z24 = 46,
-        Z32FS8 = 47,
+        Z24S8 = 47,
+        S8Z24 = 48,
+        Z32FS8 = 49,
 
         MaxDepthStencilFormat,
 
@@ -138,6 +140,8 @@ struct SurfaceParams {
             4, // DXN2UNORM
             4, // DXN2SNORM
             4, // BC7U
+            4, // BC6H_UF16
+            4, // BC6H_SF16
             4, // ASTC_2D_4X4
             1, // G8R8U
             1, // G8R8S
@@ -197,6 +201,8 @@ struct SurfaceParams {
             128, // DXN2UNORM
             128, // DXN2SNORM
             128, // BC7U
+            128, // BC6H_UF16
+            128, // BC6H_SF16
             32,  // ASTC_2D_4X4
             16,  // G8R8U
             16,  // G8R8S
@@ -482,6 +488,10 @@ 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:
@@ -640,18 +650,6 @@ 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) ==
@@ -757,6 +755,9 @@ 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.h

@@ -29,7 +29,7 @@ public:
 
     /// Gets the size of the shader in guest memory, required for cache management
     size_t GetSizeInBytes() const {
-        return sizeof(GLShader::ProgramCode);
+        return GLShader::MAX_PROGRAM_CODE_LENGTH * sizeof(u64);
     }
 
     /// Gets the shader entries for the shader

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -729,8 +729,7 @@ private:
             {PredCondition::LessEqual, "<="},         {PredCondition::GreaterThan, ">"},
             {PredCondition::NotEqual, "!="},          {PredCondition::GreaterEqual, ">="},
             {PredCondition::LessThanWithNan, "<"},    {PredCondition::NotEqualWithNan, "!="},
-            {PredCondition::GreaterThanWithNan, ">"},
-        };
+            {PredCondition::GreaterThanWithNan, ">"}, {PredCondition::GreaterEqualWithNan, ">="}};
 
         const auto& comparison{PredicateComparisonStrings.find(condition)};
         ASSERT_MSG(comparison != PredicateComparisonStrings.end(),
@@ -739,7 +738,8 @@ private:
         std::string predicate{'(' + op_a + ") " + comparison->second + " (" + op_b + ')'};
         if (condition == PredCondition::LessThanWithNan ||
             condition == PredCondition::NotEqualWithNan ||
-            condition == PredCondition::GreaterThanWithNan) {
+            condition == PredCondition::GreaterThanWithNan ||
+            condition == PredCondition::GreaterEqualWithNan) {
             predicate += " || isnan(" + op_a + ") || isnan(" + op_b + ')';
         }
 
@@ -887,6 +887,8 @@ private:
         // TEXS has two destination registers and a swizzle. The first two elements in the swizzle
         // go into gpr0+0 and gpr0+1, and the rest goes into gpr28+0 and gpr28+1
 
+        ASSERT_MSG(instr.texs.nodep == 0, "TEXS nodep not implemented");
+
         size_t written_components = 0;
         for (u32 component = 0; component < 4; ++component) {
             if (!instr.texs.IsComponentEnabled(component)) {
@@ -1038,6 +1040,15 @@ private:
             case OpCode::Id::FMUL_R:
             case OpCode::Id::FMUL_IMM: {
                 // FMUL does not have 'abs' bits and only the second operand has a 'neg' bit.
+                ASSERT_MSG(instr.fmul.tab5cb8_2 == 0, "FMUL tab5cb8_2({}) is not implemented",
+                           instr.fmul.tab5cb8_2.Value());
+                ASSERT_MSG(instr.fmul.tab5c68_1 == 0, "FMUL tab5cb8_1({}) is not implemented",
+                           instr.fmul.tab5c68_1.Value());
+                ASSERT_MSG(instr.fmul.tab5c68_0 == 1, "FMUL tab5cb8_0({}) is not implemented",
+                           instr.fmul.tab5c68_0
+                               .Value()); // SMO typical sends 1 here which seems to be the default
+                ASSERT_MSG(instr.fmul.cc == 0, "FMUL cc is not implemented");
+
                 op_b = GetOperandAbsNeg(op_b, false, instr.fmul.negate_b);
                 regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " * " + op_b, 1, 1,
                                         instr.alu.saturate_d);
@@ -1363,6 +1374,15 @@ private:
                                           "((" + op_a + " << " + shift + ") + " + op_b + ')', 1, 1);
                 break;
             }
+            case OpCode::Id::POPC_C:
+            case OpCode::Id::POPC_R:
+            case OpCode::Id::POPC_IMM: {
+                if (instr.popc.invert) {
+                    op_b = "~(" + op_b + ')';
+                }
+                regs.SetRegisterToInteger(instr.gpr0, true, 0, "bitCount(" + op_b + ')', 1, 1);
+                break;
+            }
             case OpCode::Id::SEL_C:
             case OpCode::Id::SEL_R:
             case OpCode::Id::SEL_IMM: {
@@ -1427,6 +1447,12 @@ private:
             std::string op_b = instr.ffma.negate_b ? "-" : "";
             std::string op_c = instr.ffma.negate_c ? "-" : "";
 
+            ASSERT_MSG(instr.ffma.cc == 0, "FFMA cc not implemented");
+            ASSERT_MSG(instr.ffma.tab5980_0 == 1, "FFMA tab5980_0({}) not implemented",
+                       instr.ffma.tab5980_0.Value()); // Seems to be 1 by default based on SMO
+            ASSERT_MSG(instr.ffma.tab5980_1 == 0, "FFMA tab5980_1({}) not implemented",
+                       instr.ffma.tab5980_1.Value());
+
             switch (opcode->GetId()) {
             case OpCode::Id::FFMA_CR: {
                 op_b += regs.GetUniform(instr.cbuf34.index, instr.cbuf34.offset,
@@ -2101,8 +2127,12 @@ 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:
+                ASSERT_MSG(instr.ipa.sample_mode == Tegra::Shader::IpaSampleMode::Default,
+                           "Unhandled IPA sample mode: {}",
+                           static_cast<u32>(instr.ipa.sample_mode.Value()));
+                ASSERT_MSG(instr.ipa.saturate == 0, "IPA saturate not implemented");
+                switch (instr.ipa.interp_mode) {
+                case Tegra::Shader::IpaInterpMode::Linear:
                     if (stage == Maxwell3D::Regs::ShaderStage::Fragment &&
                         attribute.index == Attribute::Index::Position) {
                         switch (attribute.element) {
@@ -2123,12 +2153,12 @@ private:
                         regs.SetRegisterToInputAttibute(reg, attribute.element, attribute.index);
                     }
                     break;
-                case Tegra::Shader::IpaMode::None:
+                case Tegra::Shader::IpaInterpMode::Perspective:
                     regs.SetRegisterToInputAttibute(reg, attribute.element, attribute.index);
                     break;
                 default:
                     LOG_CRITICAL(HW_GPU, "Unhandled IPA mode: {}",
-                                 static_cast<u32>(instr.ipa.mode.Value()));
+                                 static_cast<u32>(instr.ipa.interp_mode.Value()));
                     UNREACHABLE();
                     regs.SetRegisterToInputAttibute(reg, attribute.element, attribute.index);
                 }

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -10,11 +10,14 @@
 #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"
@@ -115,7 +118,7 @@ RendererOpenGL::~RendererOpenGL() = default;
 void RendererOpenGL::SwapBuffers(boost::optional<const Tegra::FramebufferConfig&> framebuffer) {
     ScopeAcquireGLContext acquire_context{render_window};
 
-    Core::System::GetInstance().perf_stats.EndSystemFrame();
+    Core::System::GetInstance().GetPerfStats().EndSystemFrame();
 
     // Maintain the rasterizer's state as a priority
     OpenGLState prev_state = OpenGLState::GetCurState();
@@ -140,8 +143,8 @@ void RendererOpenGL::SwapBuffers(boost::optional<const Tegra::FramebufferConfig&
 
     render_window.PollEvents();
 
-    Core::System::GetInstance().frame_limiter.DoFrameLimiting(CoreTiming::GetGlobalTimeUs());
-    Core::System::GetInstance().perf_stats.BeginSystemFrame();
+    Core::System::GetInstance().FrameLimiter().DoFrameLimiting(CoreTiming::GetGlobalTimeUs());
+    Core::System::GetInstance().GetPerfStats().BeginSystemFrame();
 
     // Restore the rasterizer state
     prev_state.Apply();

src/video_core/textures/decoders.cpp

@@ -56,6 +56,8 @@ 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:
@@ -106,6 +108,8 @@ 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,6 +70,9 @@ 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/*)
 
@@ -77,6 +80,7 @@ qt5_wrap_ui(UI_HDRS ${UIS})
 
 target_sources(yuzu
     PRIVATE
+        ${COMPAT_LIST}
         ${ICONS}
         ${THEMES}
         ${UI_HDRS}

src/yuzu/configuration/config.cpp

@@ -102,6 +102,20 @@ void Config::ReadValues() {
 
     qt_config->beginGroup("Data Storage");
     Settings::values.use_virtual_sd = qt_config->value("use_virtual_sd", true).toBool();
+    FileUtil::GetUserPath(
+        FileUtil::UserPath::NANDDir,
+        qt_config
+            ->value("nand_directory",
+                    QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)))
+            .toString()
+            .toStdString());
+    FileUtil::GetUserPath(
+        FileUtil::UserPath::SDMCDir,
+        qt_config
+            ->value("sdmc_directory",
+                    QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)))
+            .toString()
+            .toStdString());
     qt_config->endGroup();
 
     qt_config->beginGroup("System");
@@ -222,6 +236,10 @@ void Config::SaveValues() {
 
     qt_config->beginGroup("Data Storage");
     qt_config->setValue("use_virtual_sd", Settings::values.use_virtual_sd);
+    qt_config->setValue("nand_directory",
+                        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)));
+    qt_config->setValue("sdmc_directory",
+                        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)));
     qt_config->endGroup();
 
     qt_config->beginGroup("System");

src/yuzu/debugger/wait_tree.cpp

@@ -9,11 +9,14 @@
 #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 {
@@ -71,6 +74,7 @@ std::vector<std::unique_ptr<WaitTreeThread>> WaitTreeItem::MakeThreadItemList()
 }
 
 WaitTreeText::WaitTreeText(const QString& t) : text(t) {}
+WaitTreeText::~WaitTreeText() = default;
 
 QString WaitTreeText::GetText() const {
     return text;
@@ -84,6 +88,8 @@ WaitTreeMutexInfo::WaitTreeMutexInfo(VAddr mutex_address) : mutex_address(mutex_
     owner = 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'));
 }
@@ -102,6 +108,7 @@ 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");
@@ -126,6 +133,10 @@ 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;
@@ -180,6 +191,8 @@ 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");
@@ -194,6 +207,7 @@ 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);
@@ -312,6 +326,7 @@ 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());
@@ -323,6 +338,7 @@ 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());
@@ -340,6 +356,7 @@ 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");
@@ -353,6 +370,7 @@ 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))
@@ -421,6 +439,8 @@ 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,11 +4,15 @@
 
 #pragma once
 
+#include <cstddef>
+#include <memory>
+#include <vector>
+
 #include <QAbstractItemModel>
 #include <QDockWidget>
 #include <QTreeView>
 #include <boost/container/flat_set.hpp>
-#include "core/core.h"
+#include "common/common_types.h"
 #include "core/hle/kernel/object.h"
 
 class EmuThread;
@@ -25,6 +29,7 @@ class WaitTreeThread;
 class WaitTreeItem : public QObject {
     Q_OBJECT
 public:
+    WaitTreeItem();
     ~WaitTreeItem() override;
 
     virtual bool IsExpandable() const;
@@ -49,6 +54,8 @@ class WaitTreeText : public WaitTreeItem {
     Q_OBJECT
 public:
     explicit WaitTreeText(const QString& text);
+    ~WaitTreeText() override;
+
     QString GetText() const override;
 
 private:
@@ -58,6 +65,9 @@ private:
 class WaitTreeExpandableItem : public WaitTreeItem {
     Q_OBJECT
 public:
+    WaitTreeExpandableItem();
+    ~WaitTreeExpandableItem() override;
+
     bool IsExpandable() const override;
 };
 
@@ -65,6 +75,8 @@ 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;
 
@@ -79,6 +91,8 @@ 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;
 
@@ -90,6 +104,8 @@ 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;
@@ -105,6 +121,8 @@ 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;
 
@@ -117,6 +135,8 @@ 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;
@@ -126,6 +146,8 @@ class WaitTreeEvent : public WaitTreeWaitObject {
     Q_OBJECT
 public:
     explicit WaitTreeEvent(const Kernel::Event& object);
+    ~WaitTreeEvent() override;
+
     std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
 };
 
@@ -133,6 +155,8 @@ class WaitTreeTimer : public WaitTreeWaitObject {
     Q_OBJECT
 public:
     explicit WaitTreeTimer(const Kernel::Timer& object);
+    ~WaitTreeTimer() override;
+
     std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
 };
 
@@ -140,6 +164,8 @@ 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;
 
@@ -152,6 +178,7 @@ 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;
@@ -171,6 +198,7 @@ class WaitTreeWidget : public QDockWidget {
 
 public:
     explicit WaitTreeWidget(QWidget* parent = nullptr);
+    ~WaitTreeWidget() override;
 
 public slots:
     void OnDebugModeEntered();

src/yuzu/game_list.cpp

@@ -7,10 +7,14 @@
 #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"
@@ -19,10 +23,12 @@
 #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 "game_list.h"
-#include "game_list_p.h"
-#include "ui_settings.h"
+#include "yuzu/game_list.h"
+#include "yuzu/game_list_p.h"
+#include "yuzu/main.h"
+#include "yuzu/ui_settings.h"
 
 GameList::SearchField::KeyReleaseEater::KeyReleaseEater(GameList* gamelist) : gamelist{gamelist} {}
 
@@ -224,6 +230,7 @@ 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");
 
@@ -325,12 +332,62 @@ 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())) {
@@ -345,7 +402,7 @@ void GameList::PopulateAsync(const QString& dir_path, bool deep_scan) {
 
     emit ShouldCancelWorker();
 
-    GameListWorker* worker = new GameListWorker(vfs, dir_path, deep_scan);
+    GameListWorker* worker = new GameListWorker(vfs, dir_path, deep_scan, compatibility_list);
 
     connect(worker, &GameListWorker::EntryReady, this, &GameList::AddEntry, Qt::QueuedConnection);
     connect(worker, &GameListWorker::Finished, this, &GameList::DonePopulating,
@@ -426,6 +483,14 @@ 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);
@@ -523,11 +588,19 @@ 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,6 +4,8 @@
 
 #pragma once
 
+#include <unordered_map>
+
 #include <QFileSystemWatcher>
 #include <QHBoxLayout>
 #include <QLabel>
@@ -17,9 +19,13 @@
 #include <QTreeView>
 #include <QVBoxLayout>
 #include <QWidget>
-#include "main.h"
 
 class GameListWorker;
+class GMainWindow;
+
+namespace FileSys {
+class VfsFilesystem;
+}
 
 enum class GameListOpenTarget { SaveData };
 
@@ -29,6 +35,7 @@ class GameList : public QWidget {
 public:
     enum {
         COLUMN_NAME,
+        COLUMN_COMPATIBILITY,
         COLUMN_FILE_TYPE,
         COLUMN_SIZE,
         COLUMN_COUNT, // Number of columns
@@ -61,13 +68,14 @@ public:
         QToolButton* button_filter_close = nullptr;
     };
 
-    explicit GameList(FileSys::VirtualFilesystem vfs, GMainWindow* parent = nullptr);
+    explicit GameList(std::shared_ptr<FileSys::VfsFilesystem> 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();
@@ -79,6 +87,9 @@ 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);
@@ -92,7 +103,7 @@ private:
     void PopupContextMenu(const QPoint& menu_location);
     void RefreshGameDirectory();
 
-    FileSys::VirtualFilesystem vfs;
+    std::shared_ptr<FileSys::VfsFilesystem> vfs;
     SearchField* search_field;
     GMainWindow* main_window = nullptr;
     QVBoxLayout* layout = nullptr;
@@ -100,6 +111,7 @@ 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,16 +8,25 @@
 #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 "core/file_sys/content_archive.h"
-#include "ui_settings.h"
+#include "yuzu/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)
@@ -29,6 +38,17 @@ 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:
@@ -96,6 +116,45 @@ 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
@@ -141,8 +200,10 @@ class GameListWorker : public QObject, public QRunnable {
     Q_OBJECT
 
 public:
-    GameListWorker(FileSys::VirtualFilesystem vfs, QString dir_path, bool deep_scan)
-        : vfs(std::move(vfs)), dir_path(std::move(dir_path)), deep_scan(deep_scan) {}
+    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;
 
 public slots:
     /// Starts the processing of directory tree information.
@@ -165,11 +226,12 @@ signals:
     void Finished(QStringList watch_list);
 
 private:
-    FileSys::VirtualFilesystem vfs;
+    std::shared_ptr<FileSys::VfsFilesystem> 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

@@ -12,29 +12,32 @@
 
 #define QT_NO_OPENGL
 #include <QDesktopWidget>
+#include <QDialogButtonBox>
 #include <QFileDialog>
 #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/gdbstub/gdbstub.h"
+#include "core/hle/service/filesystem/filesystem.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"
@@ -46,6 +49,7 @@
 #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"
@@ -134,6 +138,7 @@ 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
@@ -349,6 +354,8 @@ 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);
@@ -366,6 +373,10 @@ void GMainWindow::ConnectMenuEvents() {
             &GMainWindow::OnMenuInstallToNAND);
     connect(ui.action_Select_Game_List_Root, &QAction::triggered, this,
             &GMainWindow::OnMenuSelectGameListRoot);
+    connect(ui.action_Select_NAND_Directory, &QAction::triggered, this,
+            [this] { OnMenuSelectEmulatedDirectory(EmulatedDirectoryTarget::NAND); });
+    connect(ui.action_Select_SDMC_Directory, &QAction::triggered, this,
+            [this] { OnMenuSelectEmulatedDirectory(EmulatedDirectoryTarget::SDMC); });
     connect(ui.action_Exit, &QAction::triggered, this, &QMainWindow::close);
 
     // Emulation
@@ -413,7 +424,7 @@ void GMainWindow::OnDisplayTitleBars(bool show) {
     }
 }
 
-bool GMainWindow::SupportsRequiredGLExtensions() {
+QStringList GMainWindow::GetUnsupportedGLExtensions() {
     QStringList unsupported_ext;
 
     if (!GLAD_GL_ARB_program_interface_query)
@@ -440,7 +451,7 @@ bool GMainWindow::SupportsRequiredGLExtensions() {
     for (const QString& ext : unsupported_ext)
         LOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext.toStdString());
 
-    return unsupported_ext.empty();
+    return unsupported_ext;
 }
 
 bool GMainWindow::LoadROM(const QString& filename) {
@@ -458,11 +469,13 @@ bool GMainWindow::LoadROM(const QString& filename) {
         return false;
     }
 
-    if (!SupportsRequiredGLExtensions()) {
-        QMessageBox::critical(
-            this, tr("Error while initializing OpenGL Core!"),
-            tr("Your GPU may not support one or more required OpenGL extensions. Please "
-               "ensure you have the latest graphics driver. See the log for more details."));
+    QStringList unsupported_gl_extensions = GetUnsupportedGLExtensions();
+    if (!unsupported_gl_extensions.empty()) {
+        QMessageBox::critical(this, tr("Error while initializing OpenGL Core!"),
+                              tr("Your GPU may not support one or more required OpenGL"
+                                 "extensions. Please ensure you have the latest graphics "
+                                 "driver.<br><br>Unsupported extensions:<br>") +
+                                  unsupported_gl_extensions.join("<br>"));
         return false;
     }
 
@@ -678,6 +691,20 @@ 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)
@@ -865,6 +892,28 @@ void GMainWindow::OnMenuSelectGameListRoot() {
     }
 }
 
+void GMainWindow::OnMenuSelectEmulatedDirectory(EmulatedDirectoryTarget target) {
+    const auto res = QMessageBox::information(
+        this, tr("Changing Emulated Directory"),
+        tr("You are about to change the emulated %1 directory of the system. Please note "
+           "that this does not also move the contents of the previous directory to the "
+           "new one and you will have to do that yourself.")
+            .arg(target == EmulatedDirectoryTarget::SDMC ? tr("SD card") : tr("NAND")),
+        QMessageBox::StandardButtons{QMessageBox::Ok, QMessageBox::Cancel});
+
+    if (res == QMessageBox::Cancel)
+        return;
+
+    QString dir_path = QFileDialog::getExistingDirectory(this, tr("Select Directory"));
+    if (!dir_path.isEmpty()) {
+        FileUtil::GetUserPath(target == EmulatedDirectoryTarget::SDMC ? FileUtil::UserPath::SDMCDir
+                                                                      : FileUtil::UserPath::NANDDir,
+                              dir_path.toStdString());
+        Service::FileSystem::CreateFactories(vfs);
+        game_list->PopulateAsync(UISettings::values.gamedir, UISettings::values.gamedir_deepscan);
+    }
+}
+
 void GMainWindow::OnMenuRecentFile() {
     QAction* action = qobject_cast<QAction*>(sender());
     assert(action);

src/yuzu/main.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <memory>
+#include <unordered_map>
 #include <QMainWindow>
 #include <QTimer>
 #include "core/core.h"
@@ -23,10 +24,19 @@ class ProfilerWidget;
 class WaitTreeWidget;
 enum class GameListOpenTarget;
 
+namespace FileSys {
+class VfsFilesystem;
+}
+
 namespace Tegra {
 class DebugContext;
 }
 
+enum class EmulatedDirectoryTarget {
+    NAND,
+    SDMC,
+};
+
 class GMainWindow : public QMainWindow {
     Q_OBJECT
 
@@ -80,7 +90,7 @@ private:
     void ConnectWidgetEvents();
     void ConnectMenuEvents();
 
-    bool SupportsRequiredGLExtensions();
+    QStringList GetUnsupportedGLExtensions();
     bool LoadROM(const QString& filename);
     void BootGame(const QString& filename);
     void ShutdownGame();
@@ -124,11 +134,16 @@ 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();
     /// Called whenever a user selects the "File->Select Game List Root" menu item
     void OnMenuSelectGameListRoot();
+    /// Called whenever a user select the "File->Select -- Directory" where -- is NAND or SD Card
+    void OnMenuSelectEmulatedDirectory(EmulatedDirectoryTarget target);
     void OnMenuRecentFile();
     void OnConfigure();
     void OnAbout();
@@ -166,7 +181,7 @@ private:
     QString game_path;
 
     // FS
-    FileSys::VirtualFilesystem vfs;
+    std::shared_ptr<FileSys::VfsFilesystem> vfs;
 
     // Debugger panes
     ProfilerWidget* profilerWidget;

src/yuzu/main.ui

@@ -65,6 +65,9 @@
     <addaction name="action_Select_Game_List_Root"/>
     <addaction name="menu_recent_files"/>
     <addaction name="separator"/>
+    <addaction name="action_Select_NAND_Directory"/>
+    <addaction name="action_Select_SDMC_Directory"/>
+    <addaction name="separator"/>
     <addaction name="action_Exit"/>
    </widget>
    <widget class="QMenu" name="menu_Emulation">
@@ -204,6 +207,22 @@
     <string>Selects a folder to display in the game list</string>
    </property>
   </action>
+  <action name="action_Select_NAND_Directory">
+   <property name="text">
+    <string>Select NAND Directory...</string>
+   </property>
+   <property name="toolTip">
+    <string>Selects a folder to use as the root of the emulated NAND</string>
+   </property>
+  </action>
+  <action name="action_Select_SDMC_Directory">
+   <property name="text">
+    <string>Select SD Card Directory...</string>
+   </property>
+   <property name="toolTip">
+    <string>Selects a folder to use as the root of the emulated SD card</string>
+   </property>
+  </action>
   <action name="action_Fullscreen">
    <property name="checkable">
     <bool>true</bool>

src/yuzu/util/util.cpp

@@ -4,6 +4,7 @@
 
 #include <array>
 #include <cmath>
+#include <QPainter>
 #include "yuzu/util/util.h"
 
 QFont GetMonospaceFont() {
@@ -24,3 +25,13 @@ 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,3 +12,10 @@ 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/config.cpp

@@ -114,6 +114,12 @@ void Config::ReadValues() {
     // Data Storage
     Settings::values.use_virtual_sd =
         sdl2_config->GetBoolean("Data Storage", "use_virtual_sd", true);
+    FileUtil::GetUserPath(FileUtil::UserPath::NANDDir,
+                          sdl2_config->Get("Data Storage", "nand_directory",
+                                           FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)));
+    FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir,
+                          sdl2_config->Get("Data Storage", "nand_directory",
+                                           FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)));
 
     // System
     Settings::values.use_docked_mode = sdl2_config->GetBoolean("System", "use_docked_mode", false);

src/yuzu_cmd/yuzu.cpp

@@ -17,10 +17,13 @@
 #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"