Merge branch 'master' into BC6H_UF16-BC6H_SF16

Require by ARMS

.gitmodules

@@ -31,6 +31,3 @@
 [submodule "opus"]
     path = externals/opus
     url = https://github.com/ogniK5377/opus.git
-[submodule "soundtouch"]
-	path = externals/soundtouch
-	url = https://github.com/citra-emu/ext-soundtouch.git

.travis.yml

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

.travis/linux/build.sh

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

.travis/linux/docker.sh

@@ -5,8 +5,14 @@ apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev
 
 cd /yuzu
 
+export PATH=/usr/lib/ccache:$PATH
+ln -sf /usr/bin/ccache /usr/lib/ccache/cc
+ln -sf /usr/bin/ccache /usr/lib/ccache/c++
 mkdir build && cd build
-cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -G Ninja
+ccache --show-stats > ccache_before
+cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -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,11 +5,14 @@ set -o pipefail
 export MACOSX_DEPLOYMENT_TARGET=10.12
 export Qt5_DIR=$(brew --prefix)/opt/qt5
 export UNICORNDIR=$(pwd)/externals/unicorn
-export PATH="/usr/local/opt/ccache/libexec:$PATH"
 
 mkdir build && cd build
+export PATH=/usr/local/opt/ccache/libexec:$PATH
+ccache --show-stats > ccache_before
 cmake --version
 cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON
 make -j4
+ccache --show-stats > ccache_after
+diff -U100 ccache_before ccache_after || true
 
 ctest -VV -C Release

CMakeLists.txt

@@ -431,9 +431,6 @@ enable_testing()
 add_subdirectory(externals)
 add_subdirectory(src)
 
-# Set yuzu project as default StartUp Project in Visual Studio
-set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT yuzu)
-
 
 # Installation instructions
 # =========================

appveyor.yml

@@ -162,6 +162,10 @@ artifacts:
   - path: $(BUILD_ZIP)
     name: build
     type: zip
+  - path: $(BUILD_SYMBOLS)
+    name: debugsymbols
+  - path: $(BUILD_UPDATE)
+    name: update
 
 deploy:
   provider: GitHub

externals/CMakeLists.txt

@@ -43,16 +43,10 @@ target_include_directories(mbedtls PUBLIC ./mbedtls/include)
 add_library(microprofile INTERFACE)
 target_include_directories(microprofile INTERFACE ./microprofile)
 
-# Open Source Archives
-add_subdirectory(open_source_archives EXCLUDE_FROM_ALL)
-
 # Unicorn
 add_library(unicorn-headers INTERFACE)
 target_include_directories(unicorn-headers INTERFACE ./unicorn/include)
 
-# SoundTouch
-add_subdirectory(soundtouch)
-
 # Xbyak
 if (ARCHITECTURE_x86_64)
     # Defined before "dynarmic" above

externals/open_source_archives/CMakeLists.txt

@@ -1,16 +0,0 @@
-add_library(open_source_archives
-    src/FontChineseSimplified.cpp
-    src/FontChineseTraditional.cpp
-    src/FontExtendedChineseSimplified.cpp
-    src/FontKorean.cpp
-    src/FontNintendoExtended.cpp
-    src/FontStandard.cpp
-    include/FontChineseSimplified.h
-    include/FontChineseTraditional.h
-    include/FontExtendedChineseSimplified.h
-    include/FontKorean.h
-    include/FontNintendoExtended.h
-    include/FontStandard.h
-)
-
-target_include_directories(open_source_archives PUBLIC include)

externals/open_source_archives/Readme.md

@@ -1,4 +0,0 @@
-These files were generated by https://github.com/FearlessTobi/yuzu_system_archives at git commit 0a24b0c9f38d71fb2c4bba5645a39029e539a5ec. To generate the files use the run.sh inside that repository.  
-
-The follwing system archives are currently included:
- - JPN/EUR/USA System Font

externals/open_source_archives/include/FontChineseSimplified.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <array>
-
-extern const std::array<unsigned char, 217276> FontChineseSimplified;
-

externals/open_source_archives/include/FontChineseTraditional.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <array>
-
-extern const std::array<unsigned char, 222236> FontChineseTraditional;
-

externals/open_source_archives/include/FontExtendedChineseSimplified.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <array>
-
-extern const std::array<unsigned char, 293516> FontExtendedChineseSimplified;
-

externals/open_source_archives/include/FontKorean.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <array>
-
-extern const std::array<unsigned char, 217276> FontKorean;
-

externals/open_source_archives/include/FontNintendoExtended.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <array>
-
-extern const std::array<unsigned char, 172064> FontNintendoExtended;
-

externals/open_source_archives/include/FontStandard.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <array>
-
-extern const std::array<unsigned char, 217276> FontStandard;
-

src/audio_core/CMakeLists.txt

@@ -17,8 +17,6 @@ add_library(audio_core STATIC
     sink_stream.h
     stream.cpp
     stream.h
-    time_stretch.cpp
-    time_stretch.h
 
     $<$<BOOL:${ENABLE_CUBEB}>:cubeb_sink.cpp cubeb_sink.h>
 )
@@ -26,7 +24,6 @@ add_library(audio_core STATIC
 create_target_directory_groups(audio_core)
 
 target_link_libraries(audio_core PUBLIC common core)
-target_link_libraries(audio_core PRIVATE SoundTouch)
 
 if(ENABLE_CUBEB)
     target_link_libraries(audio_core PRIVATE cubeb)

src/audio_core/algorithm/filter.cpp

@@ -35,12 +35,12 @@ Filter::Filter(double a0, double a1, double a2, double b0, double b1, double b2)
     : a1(a1 / a0), a2(a2 / a0), b0(b0 / a0), b1(b1 / a0), b2(b2 / a0) {}
 
 void Filter::Process(std::vector<s16>& signal) {
-    const std::size_t num_frames = signal.size() / 2;
-    for (std::size_t i = 0; i < num_frames; i++) {
+    const size_t num_frames = signal.size() / 2;
+    for (size_t i = 0; i < num_frames; i++) {
         std::rotate(in.begin(), in.end() - 1, in.end());
         std::rotate(out.begin(), out.end() - 1, out.end());
 
-        for (std::size_t ch = 0; ch < channel_count; ch++) {
+        for (size_t ch = 0; ch < channel_count; ch++) {
             in[0][ch] = signal[i * channel_count + ch];
 
             out[0][ch] = b0 * in[0][ch] + b1 * in[1][ch] + b2 * in[2][ch] - a1 * out[1][ch] -
@@ -54,14 +54,14 @@ void Filter::Process(std::vector<s16>& signal) {
 /// Calculates the appropriate Q for each biquad in a cascading filter.
 /// @param total_count The total number of biquads to be cascaded.
 /// @param index 0-index of the biquad to calculate the Q value for.
-static double CascadingBiquadQ(std::size_t total_count, std::size_t index) {
+static double CascadingBiquadQ(size_t total_count, size_t index) {
     const double pole = M_PI * (2 * index + 1) / (4.0 * total_count);
     return 1.0 / (2.0 * std::cos(pole));
 }
 
-CascadingFilter CascadingFilter::LowPass(double cutoff, std::size_t cascade_size) {
+CascadingFilter CascadingFilter::LowPass(double cutoff, size_t cascade_size) {
     std::vector<Filter> cascade(cascade_size);
-    for (std::size_t i = 0; i < cascade_size; i++) {
+    for (size_t i = 0; i < cascade_size; i++) {
         cascade[i] = Filter::LowPass(cutoff, CascadingBiquadQ(cascade_size, i));
     }
     return CascadingFilter{std::move(cascade)};

src/audio_core/algorithm/filter.h

@@ -30,7 +30,7 @@ public:
     void Process(std::vector<s16>& signal);
 
 private:
-    static constexpr std::size_t channel_count = 2;
+    static constexpr size_t channel_count = 2;
 
     /// Coefficients are in normalized form (a0 = 1.0).
     double a1, a2, b0, b1, b2;
@@ -46,7 +46,7 @@ public:
     /// Creates a cascading low-pass filter.
     /// @param cutoff Determines the cutoff frequency. A value from 0.0 to 1.0.
     /// @param cascade_size Number of biquads in cascade.
-    static CascadingFilter LowPass(double cutoff, std::size_t cascade_size);
+    static CascadingFilter LowPass(double cutoff, size_t cascade_size);
 
     /// Passthrough.
     CascadingFilter();

src/audio_core/algorithm/interpolate.cpp

@@ -14,7 +14,7 @@
 namespace AudioCore {
 
 /// The Lanczos kernel
-static double Lanczos(std::size_t a, double x) {
+static double Lanczos(size_t a, double x) {
     if (x == 0.0)
         return 1.0;
     const double px = M_PI * x;
@@ -37,15 +37,15 @@ std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,
     }
     state.nyquist.Process(input);
 
-    constexpr std::size_t taps = InterpolationState::lanczos_taps;
-    const std::size_t num_frames = input.size() / 2;
+    constexpr size_t taps = InterpolationState::lanczos_taps;
+    const size_t num_frames = input.size() / 2;
 
     std::vector<s16> output;
-    output.reserve(static_cast<std::size_t>(input.size() / ratio + 4));
+    output.reserve(static_cast<size_t>(input.size() / ratio + 4));
 
     double& pos = state.position;
     auto& h = state.history;
-    for (std::size_t i = 0; i < num_frames; ++i) {
+    for (size_t i = 0; i < num_frames; ++i) {
         std::rotate(h.begin(), h.end() - 1, h.end());
         h[0][0] = input[i * 2 + 0];
         h[0][1] = input[i * 2 + 1];
@@ -53,7 +53,7 @@ std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,
         while (pos <= 1.0) {
             double l = 0.0;
             double r = 0.0;
-            for (std::size_t j = 0; j < h.size(); j++) {
+            for (size_t j = 0; j < h.size(); j++) {
                 l += Lanczos(taps, pos + j - taps + 1) * h[j][0];
                 r += Lanczos(taps, pos + j - taps + 1) * h[j][1];
             }

src/audio_core/algorithm/interpolate.h

@@ -12,8 +12,8 @@
 namespace AudioCore {
 
 struct InterpolationState {
-    static constexpr std::size_t lanczos_taps = 4;
-    static constexpr std::size_t history_size = lanczos_taps * 2 - 1;
+    static constexpr size_t lanczos_taps = 4;
+    static constexpr size_t history_size = lanczos_taps * 2 - 1;
 
     double current_ratio = 0.0;
     CascadingFilter nyquist;

src/audio_core/audio_out.cpp

@@ -39,8 +39,7 @@ StreamPtr AudioOut::OpenStream(u32 sample_rate, u32 num_channels, std::string&&
         sink->AcquireSinkStream(sample_rate, num_channels, name), std::move(name));
 }
 
-std::vector<Buffer::Tag> AudioOut::GetTagsAndReleaseBuffers(StreamPtr stream,
-                                                            std::size_t max_count) {
+std::vector<Buffer::Tag> AudioOut::GetTagsAndReleaseBuffers(StreamPtr stream, size_t max_count) {
     return stream->GetTagsAndReleaseBuffers(max_count);
 }
 

src/audio_core/audio_out.h

@@ -25,7 +25,7 @@ public:
                          Stream::ReleaseCallback&& release_callback);
 
     /// Returns a vector of recently released buffers specified by tag for the specified stream
-    std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(StreamPtr stream, std::size_t max_count);
+    std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(StreamPtr stream, size_t max_count);
 
     /// Starts an audio stream for playback
     void StartStream(StreamPtr stream);

src/audio_core/audio_renderer.cpp

@@ -3,12 +3,9 @@
 // Refer to the license.txt file included.
 
 #include "audio_core/algorithm/interpolate.h"
-#include "audio_core/audio_out.h"
 #include "audio_core/audio_renderer.h"
-#include "audio_core/codec.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/hle/kernel/event.h"
 #include "core/memory.h"
 
 namespace AudioCore {
@@ -16,57 +13,20 @@ namespace AudioCore {
 constexpr u32 STREAM_SAMPLE_RATE{48000};
 constexpr u32 STREAM_NUM_CHANNELS{2};
 
-class AudioRenderer::VoiceState {
-public:
-    bool IsPlaying() const {
-        return is_in_use && info.play_state == PlayState::Started;
-    }
-
-    const VoiceOutStatus& GetOutStatus() const {
-        return out_status;
-    }
-
-    const VoiceInfo& GetInfo() const {
-        return info;
-    }
-
-    VoiceInfo& Info() {
-        return info;
-    }
-
-    void SetWaveIndex(std::size_t index);
-    std::vector<s16> DequeueSamples(std::size_t sample_count);
-    void UpdateState();
-    void RefreshBuffer();
-
-private:
-    bool is_in_use{};
-    bool is_refresh_pending{};
-    std::size_t wave_index{};
-    std::size_t offset{};
-    Codec::ADPCMState adpcm_state{};
-    InterpolationState interp_state{};
-    std::vector<s16> samples;
-    VoiceOutStatus out_status{};
-    VoiceInfo info{};
-};
-
 AudioRenderer::AudioRenderer(AudioRendererParameter params,
                              Kernel::SharedPtr<Kernel::Event> buffer_event)
     : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count) {
 
-    audio_out = std::make_unique<AudioCore::AudioOut>();
-    stream = audio_out->OpenStream(STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS, "AudioRenderer",
-                                   [=]() { buffer_event->Signal(); });
-    audio_out->StartStream(stream);
+    audio_core = std::make_unique<AudioCore::AudioOut>();
+    stream = audio_core->OpenStream(STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS, "AudioRenderer",
+                                    [=]() { buffer_event->Signal(); });
+    audio_core->StartStream(stream);
 
     QueueMixedBuffer(0);
     QueueMixedBuffer(1);
     QueueMixedBuffer(2);
 }
 
-AudioRenderer::~AudioRenderer() = default;
-
 u32 AudioRenderer::GetSampleRate() const {
     return worker_params.sample_rate;
 }
@@ -92,8 +52,8 @@ std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_
                 memory_pool_count * sizeof(MemoryPoolInfo));
 
     // Copy VoiceInfo structs
-    std::size_t offset{sizeof(UpdateDataHeader) + config.behavior_size + config.memory_pools_size +
-                       config.voice_resource_size};
+    size_t offset{sizeof(UpdateDataHeader) + config.behavior_size + config.memory_pools_size +
+                  config.voice_resource_size};
     for (auto& voice : voices) {
         std::memcpy(&voice.Info(), input_params.data() + offset, sizeof(VoiceInfo));
         offset += sizeof(VoiceInfo);
@@ -112,7 +72,7 @@ std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_
 
     // Update memory pool state
     std::vector<MemoryPoolEntry> memory_pool(memory_pool_count);
-    for (std::size_t index = 0; index < memory_pool.size(); ++index) {
+    for (size_t index = 0; index < memory_pool.size(); ++index) {
         if (mem_pool_info[index].pool_state == MemoryPoolStates::RequestAttach) {
             memory_pool[index].state = MemoryPoolStates::Attached;
         } else if (mem_pool_info[index].pool_state == MemoryPoolStates::RequestDetach) {
@@ -133,7 +93,7 @@ std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_
                 response_data.memory_pools_size);
 
     // Copy output voice status
-    std::size_t voice_out_status_offset{sizeof(UpdateDataHeader) + response_data.memory_pools_size};
+    size_t voice_out_status_offset{sizeof(UpdateDataHeader) + response_data.memory_pools_size};
     for (const auto& voice : voices) {
         std::memcpy(output_params.data() + voice_out_status_offset, &voice.GetOutStatus(),
                     sizeof(VoiceOutStatus));
@@ -143,12 +103,12 @@ std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_
     return output_params;
 }
 
-void AudioRenderer::VoiceState::SetWaveIndex(std::size_t index) {
+void AudioRenderer::VoiceState::SetWaveIndex(size_t index) {
     wave_index = index & 3;
     is_refresh_pending = true;
 }
 
-std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(std::size_t sample_count) {
+std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(size_t sample_count) {
     if (!IsPlaying()) {
         return {};
     }
@@ -157,9 +117,9 @@ std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(std::size_t sample_co
         RefreshBuffer();
     }
 
-    const std::size_t max_size{samples.size() - offset};
-    const std::size_t dequeue_offset{offset};
-    std::size_t size{sample_count * STREAM_NUM_CHANNELS};
+    const size_t max_size{samples.size() - offset};
+    const size_t dequeue_offset{offset};
+    size_t size{sample_count * STREAM_NUM_CHANNELS};
     if (size > max_size) {
         size = max_size;
     }
@@ -224,7 +184,7 @@ void AudioRenderer::VoiceState::RefreshBuffer() {
     case 1:
         // 1 channel is upsampled to 2 channel
         samples.resize(new_samples.size() * 2);
-        for (std::size_t index = 0; index < new_samples.size(); ++index) {
+        for (size_t index = 0; index < new_samples.size(); ++index) {
             samples[index * 2] = new_samples[index];
             samples[index * 2 + 1] = new_samples[index];
         }
@@ -250,7 +210,7 @@ static constexpr s16 ClampToS16(s32 value) {
 }
 
 void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
-    constexpr std::size_t BUFFER_SIZE{512};
+    constexpr size_t BUFFER_SIZE{512};
     std::vector<s16> buffer(BUFFER_SIZE * stream->GetNumChannels());
 
     for (auto& voice : voices) {
@@ -258,7 +218,7 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
             continue;
         }
 
-        std::size_t offset{};
+        size_t offset{};
         s64 samples_remaining{BUFFER_SIZE};
         while (samples_remaining > 0) {
             const std::vector<s16> samples{voice.DequeueSamples(samples_remaining)};
@@ -276,11 +236,11 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
             }
         }
     }
-    audio_out->QueueBuffer(stream, tag, std::move(buffer));
+    audio_core->QueueBuffer(stream, tag, std::move(buffer));
 }
 
 void AudioRenderer::ReleaseAndQueueBuffers() {
-    const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream, 2)};
+    const auto released_buffers{audio_core->GetTagsAndReleaseBuffers(stream, 2)};
     for (const auto& tag : released_buffers) {
         QueueMixedBuffer(tag);
     }

src/audio_core/audio_renderer.h

@@ -8,20 +8,16 @@
 #include <memory>
 #include <vector>
 
+#include "audio_core/algorithm/interpolate.h"
+#include "audio_core/audio_out.h"
+#include "audio_core/codec.h"
 #include "audio_core/stream.h"
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/hle/kernel/object.h"
-
-namespace Kernel {
-class Event;
-}
+#include "core/hle/kernel/event.h"
 
 namespace AudioCore {
 
-class AudioOut;
-
 enum class PlayState : u8 {
     Started = 0,
     Stopped = 1,
@@ -162,8 +158,6 @@ static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size
 class AudioRenderer {
 public:
     AudioRenderer(AudioRendererParameter params, Kernel::SharedPtr<Kernel::Event> buffer_event);
-    ~AudioRenderer();
-
     std::vector<u8> UpdateAudioRenderer(const std::vector<u8>& input_params);
     void QueueMixedBuffer(Buffer::Tag tag);
     void ReleaseAndQueueBuffers();
@@ -172,12 +166,45 @@ public:
     u32 GetMixBufferCount() const;
 
 private:
-    class VoiceState;
+    class VoiceState {
+    public:
+        bool IsPlaying() const {
+            return is_in_use && info.play_state == PlayState::Started;
+        }
+
+        const VoiceOutStatus& GetOutStatus() const {
+            return out_status;
+        }
+
+        const VoiceInfo& GetInfo() const {
+            return info;
+        }
+
+        VoiceInfo& Info() {
+            return info;
+        }
+
+        void SetWaveIndex(size_t index);
+        std::vector<s16> DequeueSamples(size_t sample_count);
+        void UpdateState();
+        void RefreshBuffer();
+
+    private:
+        bool is_in_use{};
+        bool is_refresh_pending{};
+        size_t wave_index{};
+        size_t offset{};
+        Codec::ADPCMState adpcm_state{};
+        InterpolationState interp_state{};
+        std::vector<s16> samples;
+        VoiceOutStatus out_status{};
+        VoiceInfo info{};
+    };
 
     AudioRendererParameter worker_params;
     Kernel::SharedPtr<Kernel::Event> buffer_event;
     std::vector<VoiceState> voices;
-    std::unique_ptr<AudioOut> audio_out;
+    std::unique_ptr<AudioCore::AudioOut> audio_core;
     AudioCore::StreamPtr stream;
 };
 

src/audio_core/codec.cpp

@@ -8,27 +8,27 @@
 
 namespace AudioCore::Codec {
 
-std::vector<s16> DecodeADPCM(const u8* const data, std::size_t size, const ADPCM_Coeff& coeff,
+std::vector<s16> DecodeADPCM(const u8* const data, size_t size, const ADPCM_Coeff& coeff,
                              ADPCMState& state) {
     // GC-ADPCM with scale factor and variable coefficients.
     // Frames are 8 bytes long containing 14 samples each.
     // Samples are 4 bits (one nibble) long.
 
-    constexpr std::size_t FRAME_LEN = 8;
-    constexpr std::size_t SAMPLES_PER_FRAME = 14;
+    constexpr size_t FRAME_LEN = 8;
+    constexpr size_t SAMPLES_PER_FRAME = 14;
     constexpr std::array<int, 16> SIGNED_NIBBLES = {
         {0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1}};
 
-    const std::size_t sample_count = (size / FRAME_LEN) * SAMPLES_PER_FRAME;
-    const std::size_t ret_size =
+    const size_t sample_count = (size / FRAME_LEN) * SAMPLES_PER_FRAME;
+    const size_t ret_size =
         sample_count % 2 == 0 ? sample_count : sample_count + 1; // Ensure multiple of two.
     std::vector<s16> ret(ret_size);
 
     int yn1 = state.yn1, yn2 = state.yn2;
 
-    const std::size_t NUM_FRAMES =
+    const size_t NUM_FRAMES =
         (sample_count + (SAMPLES_PER_FRAME - 1)) / SAMPLES_PER_FRAME; // Round up.
-    for (std::size_t framei = 0; framei < NUM_FRAMES; framei++) {
+    for (size_t framei = 0; framei < NUM_FRAMES; framei++) {
         const int frame_header = data[framei * FRAME_LEN];
         const int scale = 1 << (frame_header & 0xF);
         const int idx = (frame_header >> 4) & 0x7;
@@ -53,9 +53,9 @@ std::vector<s16> DecodeADPCM(const u8* const data, std::size_t size, const ADPCM
             return static_cast<s16>(val);
         };
 
-        std::size_t outputi = framei * SAMPLES_PER_FRAME;
-        std::size_t datai = framei * FRAME_LEN + 1;
-        for (std::size_t i = 0; i < SAMPLES_PER_FRAME && outputi < sample_count; i += 2) {
+        size_t outputi = framei * SAMPLES_PER_FRAME;
+        size_t datai = framei * FRAME_LEN + 1;
+        for (size_t i = 0; i < SAMPLES_PER_FRAME && outputi < sample_count; i += 2) {
             const s16 sample1 = decode_sample(SIGNED_NIBBLES[data[datai] >> 4]);
             ret[outputi] = sample1;
             outputi++;

src/audio_core/codec.h

@@ -38,7 +38,7 @@ using ADPCM_Coeff = std::array<s16, 16>;
  * @param state ADPCM state, this is updated with new state
  * @return Decoded stereo signed PCM16 data, sample_count in length
  */
-std::vector<s16> DecodeADPCM(const u8* const data, std::size_t size, const ADPCM_Coeff& coeff,
+std::vector<s16> DecodeADPCM(const u8* const data, size_t size, const ADPCM_Coeff& coeff,
                              ADPCMState& state);
 
 }; // namespace AudioCore::Codec

src/audio_core/cubeb_sink.cpp

@@ -3,23 +3,27 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <atomic>
 #include <cstring>
+#include <mutex>
+
 #include "audio_core/cubeb_sink.h"
 #include "audio_core/stream.h"
-#include "audio_core/time_stretch.h"
 #include "common/logging/log.h"
-#include "common/ring_buffer.h"
-#include "core/settings.h"
 
 namespace AudioCore {
 
-class CubebSinkStream final : public SinkStream {
+class SinkStreamImpl final : public SinkStream {
 public:
-    CubebSinkStream(cubeb* ctx, u32 sample_rate, u32 num_channels_, cubeb_devid output_device,
-                    const std::string& name)
-        : ctx{ctx}, num_channels{std::min(num_channels_, 2u)}, time_stretch{sample_rate,
-                                                                            num_channels} {
+    SinkStreamImpl(cubeb* ctx, u32 sample_rate, u32 num_channels_, cubeb_devid output_device,
+                   const std::string& name)
+        : ctx{ctx}, num_channels{num_channels_} {
+
+        if (num_channels == 6) {
+            // 6-channel audio does not seem to work with cubeb + SDL, so we downsample this to 2
+            // channel for now
+            is_6_channel = true;
+            num_channels = 2;
+        }
 
         cubeb_stream_params params{};
         params.rate = sample_rate;
@@ -34,7 +38,7 @@ public:
 
         if (cubeb_stream_init(ctx, &stream_backend, name.c_str(), nullptr, nullptr, output_device,
                               &params, std::max(512u, minimum_latency),
-                              &CubebSinkStream::DataCallback, &CubebSinkStream::StateCallback,
+                              &SinkStreamImpl::DataCallback, &SinkStreamImpl::StateCallback,
                               this) != CUBEB_OK) {
             LOG_CRITICAL(Audio_Sink, "Error initializing cubeb stream");
             return;
@@ -46,7 +50,7 @@ public:
         }
     }
 
-    ~CubebSinkStream() {
+    ~SinkStreamImpl() {
         if (!ctx) {
             return;
         }
@@ -58,32 +62,27 @@ public:
         cubeb_stream_destroy(stream_backend);
     }
 
-    void EnqueueSamples(u32 source_num_channels, const std::vector<s16>& samples) override {
-        if (source_num_channels > num_channels) {
-            // Downsample 6 channels to 2
-            std::vector<s16> buf;
-            buf.reserve(samples.size() * num_channels / source_num_channels);
-            for (std::size_t i = 0; i < samples.size(); i += source_num_channels) {
-                for (std::size_t ch = 0; ch < num_channels; ch++) {
-                    buf.push_back(samples[i + ch]);
-                }
-            }
-            queue.Push(buf);
+    void EnqueueSamples(u32 num_channels, const std::vector<s16>& samples) override {
+        if (!ctx) {
             return;
         }
 
-        queue.Push(samples);
-    }
+        std::lock_guard lock{queue_mutex};
 
-    std::size_t SamplesInQueue(u32 num_channels) const override {
-        if (!ctx)
-            return 0;
+        queue.reserve(queue.size() + samples.size() * GetNumChannels());
 
-        return queue.Size() / num_channels;
-    }
-
-    void Flush() override {
-        should_flush = true;
+        if (is_6_channel) {
+            // Downsample 6 channels to 2
+            const size_t sample_count_copy_size = samples.size() * 2;
+            queue.reserve(sample_count_copy_size);
+            for (size_t i = 0; i < samples.size(); i += num_channels) {
+                queue.push_back(samples[i]);
+                queue.push_back(samples[i + 1]);
+            }
+        } else {
+            // Copy as-is
+            std::copy(samples.begin(), samples.end(), std::back_inserter(queue));
+        }
     }
 
     u32 GetNumChannels() const {
@@ -96,11 +95,10 @@ private:
     cubeb* ctx{};
     cubeb_stream* stream_backend{};
     u32 num_channels{};
+    bool is_6_channel{};
 
-    Common::RingBuffer<s16, 0x10000> queue;
-    std::array<s16, 2> last_frame;
-    std::atomic<bool> should_flush{};
-    TimeStretcher time_stretch;
+    std::mutex queue_mutex;
+    std::vector<s16> queue;
 
     static long DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
                              void* output_buffer, long num_frames);
@@ -119,10 +117,10 @@ CubebSink::CubebSink(std::string target_device_name) {
             LOG_WARNING(Audio_Sink, "Audio output device enumeration not supported");
         } else {
             const auto collection_end{collection.device + collection.count};
-            const auto device{
-                std::find_if(collection.device, collection_end, [&](const cubeb_device_info& info) {
-                    return target_device_name == info.friendly_name;
-                })};
+            const auto device{std::find_if(collection.device, collection_end,
+                                           [&](const cubeb_device_info& device) {
+                                               return target_device_name == device.friendly_name;
+                                           })};
             if (device != collection_end) {
                 output_device = device->devid;
             }
@@ -146,59 +144,44 @@ CubebSink::~CubebSink() {
 SinkStream& CubebSink::AcquireSinkStream(u32 sample_rate, u32 num_channels,
                                          const std::string& name) {
     sink_streams.push_back(
-        std::make_unique<CubebSinkStream>(ctx, sample_rate, num_channels, output_device, name));
+        std::make_unique<SinkStreamImpl>(ctx, sample_rate, num_channels, output_device, name));
     return *sink_streams.back();
 }
 
-long CubebSinkStream::DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
-                                   void* output_buffer, long num_frames) {
-    CubebSinkStream* impl = static_cast<CubebSinkStream*>(user_data);
+long SinkStreamImpl::DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
+                                  void* output_buffer, long num_frames) {
+    SinkStreamImpl* impl = static_cast<SinkStreamImpl*>(user_data);
     u8* buffer = reinterpret_cast<u8*>(output_buffer);
 
     if (!impl) {
         return {};
     }
 
-    const std::size_t num_channels = impl->GetNumChannels();
-    const std::size_t samples_to_write = num_channels * num_frames;
-    std::size_t samples_written;
+    std::lock_guard lock{impl->queue_mutex};
 
-    if (Settings::values.enable_audio_stretching) {
-        const std::vector<s16> in{impl->queue.Pop()};
-        const std::size_t num_in{in.size() / num_channels};
-        s16* const out{reinterpret_cast<s16*>(buffer)};
-        const std::size_t out_frames =
-            impl->time_stretch.Process(in.data(), num_in, out, num_frames);
-        samples_written = out_frames * num_channels;
+    const size_t frames_to_write{
+        std::min(impl->queue.size() / impl->GetNumChannels(), static_cast<size_t>(num_frames))};
 
-        if (impl->should_flush) {
-            impl->time_stretch.Flush();
-            impl->should_flush = false;
-        }
-    } else {
-        samples_written = impl->queue.Pop(buffer, samples_to_write);
-    }
+    memcpy(buffer, impl->queue.data(), frames_to_write * sizeof(s16) * impl->GetNumChannels());
+    impl->queue.erase(impl->queue.begin(),
+                      impl->queue.begin() + frames_to_write * impl->GetNumChannels());
 
-    if (samples_written >= num_channels) {
-        std::memcpy(&impl->last_frame[0], buffer + (samples_written - num_channels) * sizeof(s16),
-                    num_channels * sizeof(s16));
-    }
-
-    // Fill the rest of the frames with last_frame
-    for (std::size_t i = samples_written; i < samples_to_write; i += num_channels) {
-        std::memcpy(buffer + i * sizeof(s16), &impl->last_frame[0], num_channels * sizeof(s16));
+    if (frames_to_write < num_frames) {
+        // Fill the rest of the frames with silence
+        memset(buffer + frames_to_write * sizeof(s16) * impl->GetNumChannels(), 0,
+               (num_frames - frames_to_write) * sizeof(s16) * impl->GetNumChannels());
     }
 
     return num_frames;
 }
 
-void CubebSinkStream::StateCallback(cubeb_stream* stream, void* user_data, cubeb_state state) {}
+void SinkStreamImpl::StateCallback(cubeb_stream* stream, void* user_data, cubeb_state state) {}
 
 std::vector<std::string> ListCubebSinkDevices() {
     std::vector<std::string> device_list;
     cubeb* ctx;
 
-    if (cubeb_init(&ctx, "yuzu Device Enumerator", nullptr) != CUBEB_OK) {
+    if (cubeb_init(&ctx, "Citra Device Enumerator", nullptr) != CUBEB_OK) {
         LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
         return {};
     }
@@ -207,7 +190,7 @@ std::vector<std::string> ListCubebSinkDevices() {
     if (cubeb_enumerate_devices(ctx, CUBEB_DEVICE_TYPE_OUTPUT, &collection) != CUBEB_OK) {
         LOG_WARNING(Audio_Sink, "Audio output device enumeration not supported");
     } else {
-        for (std::size_t i = 0; i < collection.count; i++) {
+        for (size_t i = 0; i < collection.count; i++) {
             const cubeb_device_info& device = collection.device[i];
             if (device.friendly_name) {
                 device_list.emplace_back(device.friendly_name);

src/audio_core/null_sink.h

@@ -21,12 +21,6 @@ public:
 private:
     struct NullSinkStreamImpl final : SinkStream {
         void EnqueueSamples(u32 /*num_channels*/, const std::vector<s16>& /*samples*/) override {}
-
-        std::size_t SamplesInQueue(u32 /*num_channels*/) const override {
-            return 0;
-        }
-
-        void Flush() override {}
     } null_sink_stream;
 };
 

src/audio_core/sink_details.cpp

@@ -24,7 +24,7 @@ const std::vector<SinkDetails> g_sink_details = {
                 [] { return std::vector<std::string>{"null"}; }},
 };
 
-const SinkDetails& GetSinkDetails(std::string_view sink_id) {
+const SinkDetails& GetSinkDetails(std::string sink_id) {
     auto iter =
         std::find_if(g_sink_details.begin(), g_sink_details.end(),
                      [sink_id](const auto& sink_detail) { return sink_detail.id == sink_id; });

src/audio_core/sink_details.h

@@ -6,8 +6,6 @@
 
 #include <functional>
 #include <memory>
-#include <string>
-#include <string_view>
 #include <utility>
 #include <vector>
 
@@ -32,6 +30,6 @@ struct SinkDetails {
 
 extern const std::vector<SinkDetails> g_sink_details;
 
-const SinkDetails& GetSinkDetails(std::string_view sink_id);
+const SinkDetails& GetSinkDetails(std::string sink_id);
 
 } // namespace AudioCore

src/audio_core/sink_stream.h

@@ -25,10 +25,6 @@ public:
      * @param samples Samples in interleaved stereo PCM16 format.
      */
     virtual void EnqueueSamples(u32 num_channels, const std::vector<s16>& samples) = 0;
-
-    virtual std::size_t SamplesInQueue(u32 num_channels) const = 0;
-
-    virtual void Flush() = 0;
 };
 
 using SinkStreamPtr = std::unique_ptr<SinkStream>;

src/audio_core/stream.cpp

@@ -7,18 +7,16 @@
 
 #include "audio_core/sink.h"
 #include "audio_core/sink_details.h"
-#include "audio_core/sink_stream.h"
 #include "audio_core/stream.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "common/microprofile.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/settings.h"
 
 namespace AudioCore {
 
-constexpr std::size_t MaxAudioBufferCount{32};
+constexpr size_t MaxAudioBufferCount{32};
 
 u32 Stream::GetNumChannels() const {
     switch (format) {
@@ -53,7 +51,7 @@ void Stream::Stop() {
 }
 
 s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
-    const std::size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
+    const size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
     return CoreTiming::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);
 }
 
@@ -74,7 +72,6 @@ static void VolumeAdjustSamples(std::vector<s16>& samples) {
 void Stream::PlayNextBuffer() {
     if (!IsPlaying()) {
         // Ensure we are in playing state before playing the next buffer
-        sink_stream.Flush();
         return;
     }
 
@@ -85,7 +82,6 @@ void Stream::PlayNextBuffer() {
 
     if (queued_buffers.empty()) {
         // No queued buffers - we are effectively paused
-        sink_stream.Flush();
         return;
     }
 
@@ -93,16 +89,12 @@ void Stream::PlayNextBuffer() {
     queued_buffers.pop();
 
     VolumeAdjustSamples(active_buffer->Samples());
-
     sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());
 
     CoreTiming::ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
 }
 
-MICROPROFILE_DEFINE(AudioOutput, "Audio", "ReleaseActiveBuffer", MP_RGB(100, 100, 255));
-
 void Stream::ReleaseActiveBuffer() {
-    MICROPROFILE_SCOPE(AudioOutput);
     ASSERT(active_buffer);
     released_buffers.push(std::move(active_buffer));
     release_callback();
@@ -123,9 +115,9 @@ bool Stream::ContainsBuffer(Buffer::Tag tag) const {
     return {};
 }
 
-std::vector<Buffer::Tag> Stream::GetTagsAndReleaseBuffers(std::size_t max_count) {
+std::vector<Buffer::Tag> Stream::GetTagsAndReleaseBuffers(size_t max_count) {
     std::vector<Buffer::Tag> tags;
-    for (std::size_t count = 0; count < max_count && !released_buffers.empty(); ++count) {
+    for (size_t count = 0; count < max_count && !released_buffers.empty(); ++count) {
         tags.push_back(released_buffers.front()->GetTag());
         released_buffers.pop();
     }

src/audio_core/stream.h

@@ -11,16 +11,13 @@
 #include <queue>
 
 #include "audio_core/buffer.h"
+#include "audio_core/sink_stream.h"
+#include "common/assert.h"
 #include "common/common_types.h"
-
-namespace CoreTiming {
-struct EventType;
-}
+#include "core/core_timing.h"
 
 namespace AudioCore {
 
-class SinkStream;
-
 /**
  * Represents an audio stream, which is a sequence of queued buffers, to be outputed by AudioOut
  */
@@ -52,7 +49,7 @@ public:
     bool ContainsBuffer(Buffer::Tag tag) const;
 
     /// Returns a vector of recently released buffers specified by tag
-    std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(std::size_t max_count);
+    std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(size_t max_count);
 
     /// Returns true if the stream is currently playing
     bool IsPlaying() const {
@@ -60,7 +57,7 @@ public:
     }
 
     /// Returns the number of queued buffers
-    std::size_t GetQueueSize() const {
+    size_t GetQueueSize() const {
         return queued_buffers.size();
     }
 

src/audio_core/time_stretch.cpp

@@ -1,69 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <cmath>
-#include <cstddef>
-#include "audio_core/time_stretch.h"
-#include "common/logging/log.h"
-
-namespace AudioCore {
-
-TimeStretcher::TimeStretcher(u32 sample_rate, u32 channel_count)
-    : m_sample_rate(sample_rate), m_channel_count(channel_count) {
-    m_sound_touch.setChannels(channel_count);
-    m_sound_touch.setSampleRate(sample_rate);
-    m_sound_touch.setPitch(1.0);
-    m_sound_touch.setTempo(1.0);
-}
-
-void TimeStretcher::Clear() {
-    m_sound_touch.clear();
-}
-
-void TimeStretcher::Flush() {
-    m_sound_touch.flush();
-}
-
-std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,
-                                   std::size_t num_out) {
-    const double time_delta = static_cast<double>(num_out) / m_sample_rate; // seconds
-
-    // We were given actual_samples number of samples, and num_samples were requested from us.
-    double current_ratio = static_cast<double>(num_in) / static_cast<double>(num_out);
-
-    const double max_latency = 1.0; // seconds
-    const double max_backlog = m_sample_rate * max_latency;
-    const double backlog_fullness = m_sound_touch.numSamples() / max_backlog;
-    if (backlog_fullness > 5.0) {
-        // Too many samples in backlog: Don't push anymore on
-        num_in = 0;
-    }
-
-    // We ideally want the backlog to be about 50% full.
-    // This gives some headroom both ways to prevent underflow and overflow.
-    // We tweak current_ratio to encourage this.
-    constexpr double tweak_time_scale = 0.05; // seconds
-    const double tweak_correction = (backlog_fullness - 0.5) * (time_delta / tweak_time_scale);
-    current_ratio *= std::pow(1.0 + 2.0 * tweak_correction, tweak_correction < 0 ? 3.0 : 1.0);
-
-    // This low-pass filter smoothes out variance in the calculated stretch ratio.
-    // The time-scale determines how responsive this filter is.
-    constexpr double lpf_time_scale = 2.0; // seconds
-    const double lpf_gain = 1.0 - std::exp(-time_delta / lpf_time_scale);
-    m_stretch_ratio += lpf_gain * (current_ratio - m_stretch_ratio);
-
-    // Place a lower limit of 5% speed.  When a game boots up, there will be
-    // many silence samples.  These do not need to be timestretched.
-    m_stretch_ratio = std::max(m_stretch_ratio, 0.05);
-    m_sound_touch.setTempo(m_stretch_ratio);
-
-    LOG_DEBUG(Audio, "{:5}/{:5} ratio:{:0.6f} backlog:{:0.6f}", num_in, num_out, m_stretch_ratio,
-              backlog_fullness);
-
-    m_sound_touch.putSamples(in, static_cast<u32>(num_in));
-    return m_sound_touch.receiveSamples(out, static_cast<u32>(num_out));
-}
-
-} // namespace AudioCore

src/audio_core/time_stretch.h

@@ -1,35 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-#include <SoundTouch.h>
-#include "common/common_types.h"
-
-namespace AudioCore {
-
-class TimeStretcher {
-public:
-    TimeStretcher(u32 sample_rate, u32 channel_count);
-
-    /// @param in       Input sample buffer
-    /// @param num_in   Number of input frames in `in`
-    /// @param out      Output sample buffer
-    /// @param num_out  Desired number of output frames in `out`
-    /// @returns Actual number of frames written to `out`
-    std::size_t Process(const s16* in, std::size_t num_in, s16* out, std::size_t num_out);
-
-    void Clear();
-
-    void Flush();
-
-private:
-    u32 m_sample_rate;
-    u32 m_channel_count;
-    soundtouch::SoundTouch m_sound_touch;
-    double m_stretch_ratio = 1.0;
-};
-
-} // namespace AudioCore

src/common/CMakeLists.txt

@@ -1,16 +1,13 @@
 # Generate cpp with Git revision from template
-# Also if this is a CI build, add the build name (ie: Nightly, Canary) to the scm_rev file as well
+# Also if this is a CI build, add the build name (ie: Nightly, Bleeding Edge) to the scm_rev file as well
 set(REPO_NAME "")
-set(BUILD_VERSION "0")
 if ($ENV{CI})
   if ($ENV{TRAVIS})
     set(BUILD_REPOSITORY $ENV{TRAVIS_REPO_SLUG})
-    set(BUILD_TAG $ENV{TRAVIS_TAG})
   elseif($ENV{APPVEYOR})
     set(BUILD_REPOSITORY $ENV{APPVEYOR_REPO_NAME})
-    set(BUILD_TAG $ENV{APPVEYOR_REPO_TAG_NAME})
   endif()
-  # regex capture the string nightly or canary into CMAKE_MATCH_1
+  # regex capture the string nightly or bleeding-edge into CMAKE_MATCH_1
   string(REGEX MATCH "yuzu-emu/yuzu-?(.*)" OUTVAR ${BUILD_REPOSITORY})
   if (${CMAKE_MATCH_COUNT} GREATER 0)
     # capitalize the first letter of each word in the repo name.
@@ -19,21 +16,10 @@ if ($ENV{CI})
       string(SUBSTRING ${WORD} 0 1 FIRST_LETTER)
       string(SUBSTRING ${WORD} 1 -1 REMAINDER)
       string(TOUPPER ${FIRST_LETTER} FIRST_LETTER)
-      set(REPO_NAME "${REPO_NAME}${FIRST_LETTER}${REMAINDER}")
+      # this leaves a trailing space on the last word, but we actually want that
+      # because of how it's styled in the title bar.
+      set(REPO_NAME "${REPO_NAME}${FIRST_LETTER}${REMAINDER} ")
     endforeach()
-    if (BUILD_TAG)
-      string(REGEX MATCH "${CMAKE_MATCH_1}-([0-9]+)" OUTVAR ${BUILD_TAG})
-      if (${CMAKE_MATCH_COUNT} GREATER 0)
-        set(BUILD_VERSION ${CMAKE_MATCH_1})
-      endif()
-      if (BUILD_VERSION)
-        # This leaves a trailing space on the last word, but we actually want that
-        # because of how it's styled in the title bar.
-        set(BUILD_FULLNAME "${REPO_NAME} #${BUILD_VERSION} ")
-      else()
-        set(BUILD_FULLNAME "")
-      endif()
-    endif()
   endif()
 endif()
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in" "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp" @ONLY)
@@ -71,7 +57,6 @@ add_library(common STATIC
     param_package.cpp
     param_package.h
     quaternion.h
-    ring_buffer.h
     scm_rev.cpp
     scm_rev.h
     scope_exit.h

src/common/alignment.h

@@ -8,13 +8,13 @@
 namespace Common {
 
 template <typename T>
-constexpr T AlignUp(T value, std::size_t size) {
+constexpr T AlignUp(T value, size_t size) {
     static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
     return static_cast<T>(value + (size - value % size) % size);
 }
 
 template <typename T>
-constexpr T AlignDown(T value, std::size_t size) {
+constexpr T AlignDown(T value, size_t size) {
     static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
     return static_cast<T>(value - value % size);
 }

src/common/bit_field.h

@@ -129,8 +129,8 @@ private:
 
 public:
     /// Constants to allow limited introspection of fields if needed
-    static constexpr std::size_t position = Position;
-    static constexpr std::size_t bits = Bits;
+    static constexpr size_t position = Position;
+    static constexpr size_t bits = Bits;
     static constexpr StorageType mask = (((StorageTypeU)~0) >> (8 * sizeof(T) - bits)) << position;
 
     /**

src/common/bit_set.h

@@ -170,14 +170,14 @@ public:
             m_val |= (IntTy)1 << bit;
     }
 
-    static BitSet AllTrue(std::size_t count) {
+    static BitSet AllTrue(size_t count) {
         return BitSet(count == sizeof(IntTy) * 8 ? ~(IntTy)0 : (((IntTy)1 << count) - 1));
     }
 
-    Ref operator[](std::size_t bit) {
+    Ref operator[](size_t bit) {
         return Ref(this, (IntTy)1 << bit);
     }
-    const Ref operator[](std::size_t bit) const {
+    const Ref operator[](size_t bit) const {
         return (*const_cast<BitSet*>(this))[bit];
     }
     bool operator==(BitSet other) const {

src/common/cityhash.cpp

@@ -114,7 +114,7 @@ static uint64 HashLen16(uint64 u, uint64 v, uint64 mul) {
     return b;
 }
 
-static uint64 HashLen0to16(const char* s, std::size_t len) {
+static uint64 HashLen0to16(const char* s, size_t len) {
     if (len >= 8) {
         uint64 mul = k2 + len * 2;
         uint64 a = Fetch64(s) + k2;
@@ -141,7 +141,7 @@ static uint64 HashLen0to16(const char* s, std::size_t len) {
 
 // This probably works well for 16-byte strings as well, but it may be overkill
 // in that case.
-static uint64 HashLen17to32(const char* s, std::size_t len) {
+static uint64 HashLen17to32(const char* s, size_t len) {
     uint64 mul = k2 + len * 2;
     uint64 a = Fetch64(s) * k1;
     uint64 b = Fetch64(s + 8);
@@ -170,7 +170,7 @@ static pair<uint64, uint64> WeakHashLen32WithSeeds(const char* s, uint64 a, uint
 }
 
 // Return an 8-byte hash for 33 to 64 bytes.
-static uint64 HashLen33to64(const char* s, std::size_t len) {
+static uint64 HashLen33to64(const char* s, size_t len) {
     uint64 mul = k2 + len * 2;
     uint64 a = Fetch64(s) * k2;
     uint64 b = Fetch64(s + 8);
@@ -191,7 +191,7 @@ static uint64 HashLen33to64(const char* s, std::size_t len) {
     return b + x;
 }
 
-uint64 CityHash64(const char* s, std::size_t len) {
+uint64 CityHash64(const char* s, size_t len) {
     if (len <= 32) {
         if (len <= 16) {
             return HashLen0to16(s, len);
@@ -212,7 +212,7 @@ uint64 CityHash64(const char* s, std::size_t len) {
     x = x * k1 + Fetch64(s);
 
     // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
-    len = (len - 1) & ~static_cast<std::size_t>(63);
+    len = (len - 1) & ~static_cast<size_t>(63);
     do {
         x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
         y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
@@ -229,17 +229,17 @@ uint64 CityHash64(const char* s, std::size_t len) {
                      HashLen16(v.second, w.second) + x);
 }
 
-uint64 CityHash64WithSeed(const char* s, std::size_t len, uint64 seed) {
+uint64 CityHash64WithSeed(const char* s, size_t len, uint64 seed) {
     return CityHash64WithSeeds(s, len, k2, seed);
 }
 
-uint64 CityHash64WithSeeds(const char* s, std::size_t len, uint64 seed0, uint64 seed1) {
+uint64 CityHash64WithSeeds(const char* s, size_t len, uint64 seed0, uint64 seed1) {
     return HashLen16(CityHash64(s, len) - seed0, seed1);
 }
 
 // A subroutine for CityHash128().  Returns a decent 128-bit hash for strings
 // of any length representable in signed long.  Based on City and Murmur.
-static uint128 CityMurmur(const char* s, std::size_t len, uint128 seed) {
+static uint128 CityMurmur(const char* s, size_t len, uint128 seed) {
     uint64 a = Uint128Low64(seed);
     uint64 b = Uint128High64(seed);
     uint64 c = 0;
@@ -269,7 +269,7 @@ static uint128 CityMurmur(const char* s, std::size_t len, uint128 seed) {
     return uint128(a ^ b, HashLen16(b, a));
 }
 
-uint128 CityHash128WithSeed(const char* s, std::size_t len, uint128 seed) {
+uint128 CityHash128WithSeed(const char* s, size_t len, uint128 seed) {
     if (len < 128) {
         return CityMurmur(s, len, seed);
     }
@@ -313,7 +313,7 @@ uint128 CityHash128WithSeed(const char* s, std::size_t len, uint128 seed) {
     w.first *= 9;
     v.first *= k0;
     // If 0 < len < 128, hash up to 4 chunks of 32 bytes each from the end of s.
-    for (std::size_t tail_done = 0; tail_done < len;) {
+    for (size_t tail_done = 0; tail_done < len;) {
         tail_done += 32;
         y = Rotate(x + y, 42) * k0 + v.second;
         w.first += Fetch64(s + len - tail_done + 16);
@@ -331,7 +331,7 @@ uint128 CityHash128WithSeed(const char* s, std::size_t len, uint128 seed) {
     return uint128(HashLen16(x + v.second, w.second) + y, HashLen16(x + w.second, y + v.second));
 }
 
-uint128 CityHash128(const char* s, std::size_t len) {
+uint128 CityHash128(const char* s, size_t len) {
     return len >= 16
                ? CityHash128WithSeed(s + 16, len - 16, uint128(Fetch64(s), Fetch64(s + 8) + k0))
                : CityHash128WithSeed(s, len, uint128(k0, k1));

src/common/cityhash.h

@@ -63,7 +63,7 @@
 
 #include <utility>
 #include <stdint.h>
-#include <stdlib.h> // for std::size_t.
+#include <stdlib.h> // for size_t.
 
 namespace Common {
 
@@ -77,22 +77,22 @@ inline uint64_t Uint128High64(const uint128& x) {
 }
 
 // Hash function for a byte array.
-uint64_t CityHash64(const char* buf, std::size_t len);
+uint64_t CityHash64(const char* buf, size_t len);
 
 // Hash function for a byte array.  For convenience, a 64-bit seed is also
 // hashed into the result.
-uint64_t CityHash64WithSeed(const char* buf, std::size_t len, uint64_t seed);
+uint64_t CityHash64WithSeed(const char* buf, size_t len, uint64_t seed);
 
 // Hash function for a byte array.  For convenience, two seeds are also
 // hashed into the result.
-uint64_t CityHash64WithSeeds(const char* buf, std::size_t len, uint64_t seed0, uint64_t seed1);
+uint64_t CityHash64WithSeeds(const char* buf, size_t len, uint64_t seed0, uint64_t seed1);
 
 // Hash function for a byte array.
-uint128 CityHash128(const char* s, std::size_t len);
+uint128 CityHash128(const char* s, size_t len);
 
 // Hash function for a byte array.  For convenience, a 128-bit seed is also
 // hashed into the result.
-uint128 CityHash128WithSeed(const char* s, std::size_t len, uint128 seed);
+uint128 CityHash128WithSeed(const char* s, size_t len, uint128 seed);
 
 // Hash 128 input bits down to 64 bits of output.
 // This is intended to be a reasonably good hash function.

src/common/file_util.cpp

@@ -76,7 +76,7 @@ namespace FileUtil {
 // Modifies argument.
 static void StripTailDirSlashes(std::string& fname) {
     if (fname.length() > 1) {
-        std::size_t i = fname.length();
+        size_t i = fname.length();
         while (i > 0 && fname[i - 1] == DIR_SEP_CHR)
             --i;
         fname.resize(i);
@@ -201,7 +201,7 @@ bool CreateFullPath(const std::string& fullPath) {
         return true;
     }
 
-    std::size_t position = 0;
+    size_t position = 0;
     while (true) {
         // Find next sub path
         position = fullPath.find(DIR_SEP_CHR, position);
@@ -299,7 +299,7 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
     std::array<char, 1024> buffer;
     while (!feof(input.get())) {
         // read input
-        std::size_t rnum = fread(buffer.data(), sizeof(char), buffer.size(), input.get());
+        size_t rnum = fread(buffer.data(), sizeof(char), buffer.size(), input.get());
         if (rnum != buffer.size()) {
             if (ferror(input.get()) != 0) {
                 LOG_ERROR(Common_Filesystem, "failed reading from source, {} --> {}: {}",
@@ -309,7 +309,7 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
         }
 
         // write output
-        std::size_t wnum = fwrite(buffer.data(), sizeof(char), rnum, output.get());
+        size_t wnum = fwrite(buffer.data(), sizeof(char), rnum, output.get());
         if (wnum != rnum) {
             LOG_ERROR(Common_Filesystem, "failed writing to output, {} --> {}: {}", srcFilename,
                       destFilename, GetLastErrorMsg());
@@ -756,11 +756,11 @@ std::string GetNANDRegistrationDir(bool system) {
     return GetUserPath(UserPath::NANDDir) + "user/Contents/registered/";
 }
 
-std::size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename) {
+size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename) {
     return FileUtil::IOFile(filename, text_file ? "w" : "wb").WriteBytes(str.data(), str.size());
 }
 
-std::size_t ReadFileToString(bool text_file, const char* filename, std::string& str) {
+size_t ReadFileToString(bool text_file, const char* filename, std::string& str) {
     IOFile file(filename, text_file ? "r" : "rb");
 
     if (!file.IsOpen())
@@ -829,7 +829,7 @@ std::vector<std::string> SplitPathComponents(std::string_view filename) {
 std::string_view GetParentPath(std::string_view path) {
     const auto name_bck_index = path.rfind('\\');
     const auto name_fwd_index = path.rfind('/');
-    std::size_t name_index;
+    size_t name_index;
 
     if (name_bck_index == std::string_view::npos || name_fwd_index == std::string_view::npos) {
         name_index = std::min(name_bck_index, name_fwd_index);
@@ -868,7 +868,7 @@ std::string_view GetFilename(std::string_view path) {
 }
 
 std::string_view GetExtensionFromFilename(std::string_view name) {
-    const std::size_t index = name.rfind('.');
+    const size_t index = name.rfind('.');
 
     if (index == std::string_view::npos) {
         return {};

src/common/file_util.h

@@ -143,9 +143,8 @@ const std::string& GetExeDirectory();
 std::string AppDataRoamingDirectory();
 #endif
 
-std::size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename);
-
-std::size_t ReadFileToString(bool text_file, const char* filename, std::string& str);
+size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename);
+size_t ReadFileToString(bool text_file, const char* filename, std::string& str);
 
 /**
  * Splits the filename into 8.3 format
@@ -178,10 +177,10 @@ std::string_view RemoveTrailingSlash(std::string_view path);
 
 // Creates a new vector containing indices [first, last) from the original.
 template <typename T>
-std::vector<T> SliceVector(const std::vector<T>& vector, std::size_t first, std::size_t last) {
+std::vector<T> SliceVector(const std::vector<T>& vector, size_t first, size_t last) {
     if (first >= last)
         return {};
-    last = std::min<std::size_t>(last, vector.size());
+    last = std::min<size_t>(last, vector.size());
     return std::vector<T>(vector.begin() + first, vector.begin() + first + last);
 }
 
@@ -214,47 +213,47 @@ public:
     bool Close();
 
     template <typename T>
-    std::size_t ReadArray(T* data, std::size_t length) const {
+    size_t ReadArray(T* data, size_t length) const {
         static_assert(std::is_trivially_copyable_v<T>,
                       "Given array does not consist of trivially copyable objects");
 
         if (!IsOpen()) {
-            return std::numeric_limits<std::size_t>::max();
+            return std::numeric_limits<size_t>::max();
         }
 
         return std::fread(data, sizeof(T), length, m_file);
     }
 
     template <typename T>
-    std::size_t WriteArray(const T* data, std::size_t length) {
+    size_t WriteArray(const T* data, size_t length) {
         static_assert(std::is_trivially_copyable_v<T>,
                       "Given array does not consist of trivially copyable objects");
         if (!IsOpen()) {
-            return std::numeric_limits<std::size_t>::max();
+            return std::numeric_limits<size_t>::max();
         }
 
         return std::fwrite(data, sizeof(T), length, m_file);
     }
 
     template <typename T>
-    std::size_t ReadBytes(T* data, std::size_t length) const {
+    size_t ReadBytes(T* data, size_t length) const {
         static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
         return ReadArray(reinterpret_cast<char*>(data), length);
     }
 
     template <typename T>
-    std::size_t WriteBytes(const T* data, std::size_t length) {
+    size_t WriteBytes(const T* data, size_t length) {
         static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
         return WriteArray(reinterpret_cast<const char*>(data), length);
     }
 
     template <typename T>
-    std::size_t WriteObject(const T& object) {
+    size_t WriteObject(const T& object) {
         static_assert(!std::is_pointer_v<T>, "WriteObject arguments must not be a pointer");
         return WriteArray(&object, 1);
     }
 
-    std::size_t WriteString(const std::string& str) {
+    size_t WriteString(const std::string& str) {
         return WriteArray(str.c_str(), str.length());
     }
 

src/common/hash.h

@@ -17,7 +17,7 @@ namespace Common {
  * @param len Length of data (in bytes) to compute hash over
  * @returns 64-bit hash value that was computed over the data block
  */
-static inline u64 ComputeHash64(const void* data, std::size_t len) {
+static inline u64 ComputeHash64(const void* data, size_t len) {
     return CityHash64(static_cast<const char*>(data), len);
 }
 
@@ -63,7 +63,7 @@ struct HashableStruct {
         return !(*this == o);
     };
 
-    std::size_t Hash() const {
+    size_t Hash() const {
         return Common::ComputeStructHash64(state);
     }
 };

src/common/hex_util.cpp

@@ -18,7 +18,7 @@ u8 ToHexNibble(char c1) {
     return 0;
 }
 
-std::array<u8, 16> operator""_array16(const char* str, std::size_t len) {
+std::array<u8, 16> operator""_array16(const char* str, size_t len) {
     if (len != 32) {
         LOG_ERROR(Common,
                   "Attempting to parse string to array that is not of correct size (expected=32, "
@@ -29,7 +29,7 @@ std::array<u8, 16> operator""_array16(const char* str, std::size_t len) {
     return HexStringToArray<16>(str);
 }
 
-std::array<u8, 32> operator""_array32(const char* str, std::size_t len) {
+std::array<u8, 32> operator""_array32(const char* str, size_t len) {
     if (len != 64) {
         LOG_ERROR(Common,
                   "Attempting to parse string to array that is not of correct size (expected=64, "

src/common/hex_util.h

@@ -14,20 +14,20 @@ namespace Common {
 
 u8 ToHexNibble(char c1);
 
-template <std::size_t Size, bool le = false>
+template <size_t Size, bool le = false>
 std::array<u8, Size> HexStringToArray(std::string_view str) {
     std::array<u8, Size> out{};
     if constexpr (le) {
-        for (std::size_t i = 2 * Size - 2; i <= 2 * Size; i -= 2)
+        for (size_t i = 2 * Size - 2; i <= 2 * Size; i -= 2)
             out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]);
     } else {
-        for (std::size_t i = 0; i < 2 * Size; i += 2)
+        for (size_t i = 0; i < 2 * Size; i += 2)
             out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]);
     }
     return out;
 }
 
-template <std::size_t Size>
+template <size_t Size>
 std::string HexArrayToString(std::array<u8, Size> array, bool upper = true) {
     std::string out;
     for (u8 c : array)
@@ -35,7 +35,7 @@ std::string HexArrayToString(std::array<u8, Size> array, bool upper = true) {
     return out;
 }
 
-std::array<u8, 0x10> operator"" _array16(const char* str, std::size_t len);
-std::array<u8, 0x20> operator"" _array32(const char* str, std::size_t len);
+std::array<u8, 0x10> operator"" _array16(const char* str, size_t len);
+std::array<u8, 0x20> operator"" _array32(const char* str, size_t len);
 
 } // namespace Common

src/common/logging/backend.cpp

@@ -135,7 +135,7 @@ FileBackend::FileBackend(const std::string& filename)
 void FileBackend::Write(const Entry& entry) {
     // prevent logs from going over the maximum size (in case its spamming and the user doesn't
     // know)
-    constexpr std::size_t MAX_BYTES_WRITTEN = 50 * 1024L * 1024L;
+    constexpr size_t MAX_BYTES_WRITTEN = 50 * 1024L * 1024L;
     if (!file.IsOpen() || bytes_written > MAX_BYTES_WRITTEN) {
         return;
     }

src/common/logging/backend.h

@@ -100,7 +100,7 @@ public:
 
 private:
     FileUtil::IOFile file;
-    std::size_t bytes_written;
+    size_t bytes_written;
 };
 
 void AddBackend(std::unique_ptr<Backend> backend);

src/common/logging/filter.cpp

@@ -71,7 +71,7 @@ void Filter::ResetAll(Level level) {
 }
 
 void Filter::SetClassLevel(Class log_class, Level level) {
-    class_levels[static_cast<std::size_t>(log_class)] = level;
+    class_levels[static_cast<size_t>(log_class)] = level;
 }
 
 void Filter::ParseFilterString(std::string_view filter_view) {
@@ -93,8 +93,7 @@ void Filter::ParseFilterString(std::string_view filter_view) {
 }
 
 bool Filter::CheckMessage(Class log_class, Level level) const {
-    return static_cast<u8>(level) >=
-           static_cast<u8>(class_levels[static_cast<std::size_t>(log_class)]);
+    return static_cast<u8>(level) >= static_cast<u8>(class_levels[static_cast<size_t>(log_class)]);
 }
 
 bool Filter::IsDebug() const {

src/common/logging/filter.h

@@ -19,7 +19,7 @@ namespace Log {
 class Filter {
 public:
     /// Initializes the filter with all classes having `default_level` as the minimum level.
-    explicit Filter(Level default_level = Level::Info);
+    Filter(Level default_level = Level::Info);
 
     /// Resets the filter so that all classes have `level` as the minimum displayed level.
     void ResetAll(Level level);
@@ -49,6 +49,6 @@ public:
     bool IsDebug() const;
 
 private:
-    std::array<Level, static_cast<std::size_t>(Class::Count)> class_levels;
+    std::array<Level, (size_t)Class::Count> class_levels;
 };
 } // namespace Log

src/common/logging/log.h

@@ -12,14 +12,14 @@ namespace Log {
 /// Specifies the severity or level of detail of the log message.
 enum class Level : u8 {
     Trace,    ///< Extremely detailed and repetitive debugging information that is likely to
-              ///< pollute logs.
+              ///  pollute logs.
     Debug,    ///< Less detailed debugging information.
     Info,     ///< Status information from important points during execution.
     Warning,  ///< Minor or potential problems found during execution of a task.
     Error,    ///< Major problems found during execution of a task that prevent it from being
-              ///< completed.
-    Critical, ///< Major problems during execution that threaten the stability of the entire
-              ///< application.
+              ///  completed.
+    Critical, ///< Major problems during execution that threathen the stability of the entire
+              ///  application.
 
     Count ///< Total number of logging levels
 };
@@ -49,7 +49,7 @@ enum class Class : ClassType {
     Kernel,            ///< The HLE implementation of the CTR kernel
     Kernel_SVC,        ///< Kernel system calls
     Service,           ///< HLE implementation of system services. Each major service
-                       ///< should have its own subclass.
+                       ///  should have its own subclass.
     Service_ACC,       ///< The ACC (Accounts) service
     Service_AM,        ///< The AM (Applet manager) service
     Service_AOC,       ///< The AOC (AddOn Content) service

src/common/logging/text_formatter.h

@@ -15,6 +15,6 @@ struct Entry;
 std::string FormatLogMessage(const Entry& entry);
 /// Formats and prints a log entry to stderr.
 void PrintMessage(const Entry& entry);
-/// Prints the same message as `PrintMessage`, but colored according to the severity level.
+/// Prints the same message as `PrintMessage`, but colored acoording to the severity level.
 void PrintColoredMessage(const Entry& entry);
 } // namespace Log

src/common/memory_util.cpp

@@ -25,7 +25,7 @@
 // This is purposely not a full wrapper for virtualalloc/mmap, but it
 // provides exactly the primitive operations that Dolphin needs.
 
-void* AllocateExecutableMemory(std::size_t size, bool low) {
+void* AllocateExecutableMemory(size_t size, bool low) {
 #if defined(_WIN32)
     void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
 #else
@@ -74,7 +74,7 @@ void* AllocateExecutableMemory(std::size_t size, bool low) {
     return ptr;
 }
 
-void* AllocateMemoryPages(std::size_t size) {
+void* AllocateMemoryPages(size_t size) {
 #ifdef _WIN32
     void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
 #else
@@ -90,7 +90,7 @@ void* AllocateMemoryPages(std::size_t size) {
     return ptr;
 }
 
-void* AllocateAlignedMemory(std::size_t size, std::size_t alignment) {
+void* AllocateAlignedMemory(size_t size, size_t alignment) {
 #ifdef _WIN32
     void* ptr = _aligned_malloc(size, alignment);
 #else
@@ -109,7 +109,7 @@ void* AllocateAlignedMemory(std::size_t size, std::size_t alignment) {
     return ptr;
 }
 
-void FreeMemoryPages(void* ptr, std::size_t size) {
+void FreeMemoryPages(void* ptr, size_t size) {
     if (ptr) {
 #ifdef _WIN32
         if (!VirtualFree(ptr, 0, MEM_RELEASE))
@@ -130,7 +130,7 @@ void FreeAlignedMemory(void* ptr) {
     }
 }
 
-void WriteProtectMemory(void* ptr, std::size_t size, bool allowExecute) {
+void WriteProtectMemory(void* ptr, size_t size, bool allowExecute) {
 #ifdef _WIN32
     DWORD oldValue;
     if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READ : PAGE_READONLY, &oldValue))
@@ -140,7 +140,7 @@ void WriteProtectMemory(void* ptr, std::size_t size, bool allowExecute) {
 #endif
 }
 
-void UnWriteProtectMemory(void* ptr, std::size_t size, bool allowExecute) {
+void UnWriteProtectMemory(void* ptr, size_t size, bool allowExecute) {
 #ifdef _WIN32
     DWORD oldValue;
     if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE,

src/common/memory_util.h

@@ -7,13 +7,13 @@
 #include <cstddef>
 #include <string>
 
-void* AllocateExecutableMemory(std::size_t size, bool low = true);
-void* AllocateMemoryPages(std::size_t size);
-void FreeMemoryPages(void* ptr, std::size_t size);
-void* AllocateAlignedMemory(std::size_t size, std::size_t alignment);
+void* AllocateExecutableMemory(size_t size, bool low = true);
+void* AllocateMemoryPages(size_t size);
+void FreeMemoryPages(void* ptr, size_t size);
+void* AllocateAlignedMemory(size_t size, size_t alignment);
 void FreeAlignedMemory(void* ptr);
-void WriteProtectMemory(void* ptr, std::size_t size, bool executable = false);
-void UnWriteProtectMemory(void* ptr, std::size_t size, bool allowExecute = false);
+void WriteProtectMemory(void* ptr, size_t size, bool executable = false);
+void UnWriteProtectMemory(void* ptr, size_t size, bool allowExecute = false);
 std::string MemUsage();
 
 inline int GetPageSize() {

src/common/misc.cpp

@@ -16,7 +16,7 @@
 // Call directly after the command or use the error num.
 // This function might change the error code.
 std::string GetLastErrorMsg() {
-    static const std::size_t buff_size = 255;
+    static const size_t buff_size = 255;
     char err_str[buff_size];
 
 #ifdef _WIN32

src/common/ring_buffer.h

@@ -1,111 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <cstddef>
-#include <cstring>
-#include <type_traits>
-#include <vector>
-#include "common/common_types.h"
-
-namespace Common {
-
-/// SPSC ring buffer
-/// @tparam T            Element type
-/// @tparam capacity     Number of slots in ring buffer
-/// @tparam granularity  Slot size in terms of number of elements
-template <typename T, std::size_t capacity, std::size_t granularity = 1>
-class RingBuffer {
-    /// A "slot" is made of `granularity` elements of `T`.
-    static constexpr std::size_t slot_size = granularity * sizeof(T);
-    // T must be safely memcpy-able and have a trivial default constructor.
-    static_assert(std::is_trivial_v<T>);
-    // Ensure capacity is sensible.
-    static_assert(capacity < std::numeric_limits<std::size_t>::max() / 2 / granularity);
-    static_assert((capacity & (capacity - 1)) == 0, "capacity must be a power of two");
-    // Ensure lock-free.
-    static_assert(std::atomic<std::size_t>::is_always_lock_free);
-
-public:
-    /// Pushes slots into the ring buffer
-    /// @param new_slots   Pointer to the slots to push
-    /// @param slot_count  Number of slots to push
-    /// @returns The number of slots actually pushed
-    std::size_t Push(const void* new_slots, std::size_t slot_count) {
-        const std::size_t write_index = m_write_index.load();
-        const std::size_t slots_free = capacity + m_read_index.load() - write_index;
-        const std::size_t push_count = std::min(slot_count, slots_free);
-
-        const std::size_t pos = write_index % capacity;
-        const std::size_t first_copy = std::min(capacity - pos, push_count);
-        const std::size_t second_copy = push_count - first_copy;
-
-        const char* in = static_cast<const char*>(new_slots);
-        std::memcpy(m_data.data() + pos * granularity, in, first_copy * slot_size);
-        in += first_copy * slot_size;
-        std::memcpy(m_data.data(), in, second_copy * slot_size);
-
-        m_write_index.store(write_index + push_count);
-
-        return push_count;
-    }
-
-    std::size_t Push(const std::vector<T>& input) {
-        return Push(input.data(), input.size());
-    }
-
-    /// Pops slots from the ring buffer
-    /// @param output     Where to store the popped slots
-    /// @param max_slots  Maximum number of slots to pop
-    /// @returns The number of slots actually popped
-    std::size_t Pop(void* output, std::size_t max_slots = ~std::size_t(0)) {
-        const std::size_t read_index = m_read_index.load();
-        const std::size_t slots_filled = m_write_index.load() - read_index;
-        const std::size_t pop_count = std::min(slots_filled, max_slots);
-
-        const std::size_t pos = read_index % capacity;
-        const std::size_t first_copy = std::min(capacity - pos, pop_count);
-        const std::size_t second_copy = pop_count - first_copy;
-
-        char* out = static_cast<char*>(output);
-        std::memcpy(out, m_data.data() + pos * granularity, first_copy * slot_size);
-        out += first_copy * slot_size;
-        std::memcpy(out, m_data.data(), second_copy * slot_size);
-
-        m_read_index.store(read_index + pop_count);
-
-        return pop_count;
-    }
-
-    std::vector<T> Pop(std::size_t max_slots = ~std::size_t(0)) {
-        std::vector<T> out(std::min(max_slots, capacity) * granularity);
-        const std::size_t count = Pop(out.data(), out.size() / granularity);
-        out.resize(count * granularity);
-        return out;
-    }
-
-    /// @returns Number of slots used
-    std::size_t Size() const {
-        return m_write_index.load() - m_read_index.load();
-    }
-
-    /// @returns Maximum size of ring buffer
-    constexpr std::size_t Capacity() const {
-        return capacity;
-    }
-
-private:
-    // It is important to align the below variables for performance reasons:
-    // Having them on the same cache-line would result in false-sharing between them.
-    alignas(128) std::atomic<std::size_t> m_read_index{0};
-    alignas(128) std::atomic<std::size_t> m_write_index{0};
-
-    std::array<T, granularity * capacity> m_data;
-};
-
-} // namespace Common

src/common/scm_rev.cpp.in

@@ -9,8 +9,6 @@
 #define GIT_DESC     "@GIT_DESC@"
 #define BUILD_NAME   "@REPO_NAME@"
 #define BUILD_DATE   "@BUILD_DATE@"
-#define BUILD_FULLNAME "@BUILD_FULLNAME@"
-#define BUILD_VERSION "@BUILD_VERSION@"
 
 namespace Common {
 
@@ -19,8 +17,6 @@ const char g_scm_branch[]   = GIT_BRANCH;
 const char g_scm_desc[]     = GIT_DESC;
 const char g_build_name[]   = BUILD_NAME;
 const char g_build_date[]   = BUILD_DATE;
-const char g_build_fullname[] = BUILD_FULLNAME;
-const char g_build_version[]  = BUILD_VERSION;
 
 } // namespace
 

src/common/scm_rev.h

@@ -11,7 +11,5 @@ extern const char g_scm_branch[];
 extern const char g_scm_desc[];
 extern const char g_build_name[];
 extern const char g_build_date[];
-extern const char g_build_fullname[];
-extern const char g_build_version[];
 
 } // namespace Common

src/common/string_util.cpp

@@ -37,7 +37,7 @@ std::string ToUpper(std::string str) {
 }
 
 // For Debugging. Read out an u8 array.
-std::string ArrayToString(const u8* data, std::size_t size, int line_len, bool spaces) {
+std::string ArrayToString(const u8* data, size_t size, int line_len, bool spaces) {
     std::ostringstream oss;
     oss << std::setfill('0') << std::hex;
 
@@ -60,7 +60,7 @@ std::string StringFromBuffer(const std::vector<u8>& data) {
 
 // Turns "  hej " into "hej". Also handles tabs.
 std::string StripSpaces(const std::string& str) {
-    const std::size_t s = str.find_first_not_of(" \t\r\n");
+    const size_t s = str.find_first_not_of(" \t\r\n");
 
     if (str.npos != s)
         return str.substr(s, str.find_last_not_of(" \t\r\n") - s + 1);
@@ -121,10 +121,10 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
     if (full_path.empty())
         return false;
 
-    std::size_t dir_end = full_path.find_last_of("/"
+    size_t dir_end = full_path.find_last_of("/"
 // windows needs the : included for something like just "C:" to be considered a directory
 #ifdef _WIN32
-                                                 "\\:"
+                                            "\\:"
 #endif
     );
     if (std::string::npos == dir_end)
@@ -132,7 +132,7 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
     else
         dir_end += 1;
 
-    std::size_t fname_end = full_path.rfind('.');
+    size_t fname_end = full_path.rfind('.');
     if (fname_end < dir_end || std::string::npos == fname_end)
         fname_end = full_path.size();
 
@@ -172,7 +172,7 @@ void SplitString(const std::string& str, const char delim, std::vector<std::stri
 }
 
 std::string TabsToSpaces(int tab_size, std::string in) {
-    std::size_t i = 0;
+    size_t i = 0;
 
     while ((i = in.find('\t')) != std::string::npos) {
         in.replace(i, 1, tab_size, ' ');
@@ -182,7 +182,7 @@ std::string TabsToSpaces(int tab_size, std::string in) {
 }
 
 std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest) {
-    std::size_t pos = 0;
+    size_t pos = 0;
 
     if (src == dest)
         return result;
@@ -280,22 +280,22 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
         return {};
     }
 
-    const std::size_t in_bytes = sizeof(T) * input.size();
+    const size_t in_bytes = sizeof(T) * input.size();
     // Multiply by 4, which is the max number of bytes to encode a codepoint
-    const std::size_t out_buffer_size = 4 * in_bytes;
+    const size_t out_buffer_size = 4 * in_bytes;
 
     std::string out_buffer(out_buffer_size, '\0');
 
     auto src_buffer = &input[0];
-    std::size_t src_bytes = in_bytes;
+    size_t src_bytes = in_bytes;
     auto dst_buffer = &out_buffer[0];
-    std::size_t dst_bytes = out_buffer.size();
+    size_t dst_bytes = out_buffer.size();
 
     while (0 != src_bytes) {
-        std::size_t const iconv_result =
+        size_t const iconv_result =
             iconv(conv_desc, (char**)(&src_buffer), &src_bytes, &dst_buffer, &dst_bytes);
 
-        if (static_cast<std::size_t>(-1) == iconv_result) {
+        if (static_cast<size_t>(-1) == iconv_result) {
             if (EILSEQ == errno || EINVAL == errno) {
                 // Try to skip the bad character
                 if (0 != src_bytes) {
@@ -326,22 +326,22 @@ std::u16string UTF8ToUTF16(const std::string& input) {
         return {};
     }
 
-    const std::size_t in_bytes = sizeof(char) * input.size();
+    const size_t in_bytes = sizeof(char) * input.size();
     // Multiply by 4, which is the max number of bytes to encode a codepoint
-    const std::size_t out_buffer_size = 4 * sizeof(char16_t) * in_bytes;
+    const size_t out_buffer_size = 4 * sizeof(char16_t) * in_bytes;
 
     std::u16string out_buffer(out_buffer_size, char16_t{});
 
     char* src_buffer = const_cast<char*>(&input[0]);
-    std::size_t src_bytes = in_bytes;
+    size_t src_bytes = in_bytes;
     char* dst_buffer = (char*)(&out_buffer[0]);
-    std::size_t dst_bytes = out_buffer.size();
+    size_t dst_bytes = out_buffer.size();
 
     while (0 != src_bytes) {
-        std::size_t const iconv_result =
+        size_t const iconv_result =
             iconv(conv_desc, &src_buffer, &src_bytes, &dst_buffer, &dst_bytes);
 
-        if (static_cast<std::size_t>(-1) == iconv_result) {
+        if (static_cast<size_t>(-1) == iconv_result) {
             if (EILSEQ == errno || EINVAL == errno) {
                 // Try to skip the bad character
                 if (0 != src_bytes) {
@@ -381,8 +381,8 @@ std::string SHIFTJISToUTF8(const std::string& input) {
 
 #endif
 
-std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, std::size_t max_len) {
-    std::size_t len = 0;
+std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, size_t max_len) {
+    size_t len = 0;
     while (len < max_len && buffer[len] != '\0')
         ++len;
 

src/common/string_util.h

@@ -19,7 +19,7 @@ std::string ToLower(std::string str);
 /// Make a string uppercase
 std::string ToUpper(std::string str);
 
-std::string ArrayToString(const u8* data, std::size_t size, int line_len = 20, bool spaces = true);
+std::string ArrayToString(const u8* data, size_t size, int line_len = 20, bool spaces = true);
 
 std::string StringFromBuffer(const std::vector<u8>& data);
 
@@ -118,7 +118,7 @@ bool ComparePartialString(InIt begin, InIt end, const char* other) {
  * Creates a std::string from a fixed-size NUL-terminated char buffer. If the buffer isn't
  * NUL-terminated then the string ends at max_len characters.
  */
-std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, std::size_t max_len);
+std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, size_t max_len);
 
 /**
  * Attempts to trim an arbitrary prefix from `path`, leaving only the part starting at `root`. It's

src/common/thread.h

@@ -60,12 +60,12 @@ private:
 
 class Barrier {
 public:
-    explicit Barrier(std::size_t count_) : count(count_), waiting(0), generation(0) {}
+    explicit Barrier(size_t count_) : count(count_), waiting(0), generation(0) {}
 
     /// Blocks until all "count" threads have called Sync()
     void Sync() {
         std::unique_lock<std::mutex> lk(mutex);
-        const std::size_t current_generation = generation;
+        const size_t current_generation = generation;
 
         if (++waiting == count) {
             generation++;
@@ -80,9 +80,9 @@ public:
 private:
     std::condition_variable condvar;
     std::mutex mutex;
-    const std::size_t count;
-    std::size_t waiting;
-    std::size_t generation; // Incremented once each time the barrier is used
+    const size_t count;
+    size_t waiting;
+    size_t generation; // Incremented once each time the barrier is used
 };
 
 void SleepCurrentThread(int ms);

src/common/x64/xbyak_abi.h

@@ -97,7 +97,7 @@ const BitSet32 ABI_ALL_CALLEE_SAVED = BuildRegSet({
     Xbyak::util::xmm15,
 });
 
-constexpr std::size_t ABI_SHADOW_SPACE = 0x20;
+constexpr size_t ABI_SHADOW_SPACE = 0x20;
 
 #else
 
@@ -147,23 +147,22 @@ const BitSet32 ABI_ALL_CALLEE_SAVED = BuildRegSet({
     Xbyak::util::r15,
 });
 
-constexpr std::size_t ABI_SHADOW_SPACE = 0;
+constexpr size_t ABI_SHADOW_SPACE = 0;
 
 #endif
 
-inline void ABI_CalculateFrameSize(BitSet32 regs, std::size_t rsp_alignment,
-                                   std::size_t needed_frame_size, s32* out_subtraction,
-                                   s32* out_xmm_offset) {
+inline void ABI_CalculateFrameSize(BitSet32 regs, size_t rsp_alignment, size_t needed_frame_size,
+                                   s32* out_subtraction, s32* out_xmm_offset) {
     int count = (regs & ABI_ALL_GPRS).Count();
     rsp_alignment -= count * 8;
-    std::size_t subtraction = 0;
+    size_t subtraction = 0;
     int xmm_count = (regs & ABI_ALL_XMMS).Count();
     if (xmm_count) {
         // If we have any XMMs to save, we must align the stack here.
         subtraction = rsp_alignment & 0xF;
     }
     subtraction += 0x10 * xmm_count;
-    std::size_t xmm_base_subtraction = subtraction;
+    size_t xmm_base_subtraction = subtraction;
     subtraction += needed_frame_size;
     subtraction += ABI_SHADOW_SPACE;
     // Final alignment.
@@ -174,9 +173,8 @@ inline void ABI_CalculateFrameSize(BitSet32 regs, std::size_t rsp_alignment,
     *out_xmm_offset = (s32)(subtraction - xmm_base_subtraction);
 }
 
-inline std::size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet32 regs,
-                                                   std::size_t rsp_alignment,
-                                                   std::size_t needed_frame_size = 0) {
+inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet32 regs,
+                                              size_t rsp_alignment, size_t needed_frame_size = 0) {
     s32 subtraction, xmm_offset;
     ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size, &subtraction, &xmm_offset);
 
@@ -197,8 +195,7 @@ inline std::size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, B
 }
 
 inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, BitSet32 regs,
-                                           std::size_t rsp_alignment,
-                                           std::size_t needed_frame_size = 0) {
+                                           size_t rsp_alignment, size_t needed_frame_size = 0) {
     s32 subtraction, xmm_offset;
     ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size, &subtraction, &xmm_offset);
 

src/common/x64/xbyak_util.h

@@ -34,7 +34,7 @@ inline bool IsWithin2G(const Xbyak::CodeGenerator& code, uintptr_t target) {
 template <typename T>
 inline void CallFarFunction(Xbyak::CodeGenerator& code, const T f) {
     static_assert(std::is_pointer_v<T>, "Argument must be a (function) pointer.");
-    std::size_t addr = reinterpret_cast<std::size_t>(f);
+    size_t addr = reinterpret_cast<size_t>(f);
     if (IsWithin2G(code, addr)) {
         code.call(f);
     } else {

src/core/CMakeLists.txt

@@ -35,12 +35,8 @@ add_library(core STATIC
     file_sys/mode.h
     file_sys/nca_metadata.cpp
     file_sys/nca_metadata.h
-    file_sys/nca_patch.cpp
-    file_sys/nca_patch.h
     file_sys/partition_filesystem.cpp
     file_sys/partition_filesystem.h
-    file_sys/patch_manager.cpp
-    file_sys/patch_manager.h
     file_sys/program_metadata.cpp
     file_sys/program_metadata.h
     file_sys/registered_cache.cpp
@@ -53,8 +49,6 @@ add_library(core STATIC
     file_sys/savedata_factory.h
     file_sys/sdmc_factory.cpp
     file_sys/sdmc_factory.h
-    file_sys/submission_package.cpp
-    file_sys/submission_package.h
     file_sys/vfs.cpp
     file_sys/vfs.h
     file_sys/vfs_concat.cpp
@@ -365,8 +359,6 @@ add_library(core STATIC
     loader/nro.h
     loader/nso.cpp
     loader/nso.h
-    loader/nsp.cpp
-    loader/nsp.h
     loader/xci.cpp
     loader/xci.h
     memory.cpp
@@ -388,7 +380,7 @@ add_library(core STATIC
 create_target_directory_groups(core)
 
 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static mbedtls opus unicorn open_source_archives)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static mbedtls opus unicorn)
 
 if (ARCHITECTURE_x86_64)
     target_sources(core PRIVATE

src/core/arm/arm_interface.h

@@ -10,7 +10,7 @@
 
 namespace Core {
 
-/// Generic ARMv8 CPU interface
+/// Generic ARM11 CPU interface
 class ARM_Interface : NonCopyable {
 public:
     virtual ~ARM_Interface() {}
@@ -19,9 +19,9 @@ public:
         std::array<u64, 31> cpu_registers;
         u64 sp;
         u64 pc;
-        u64 pstate;
-        std::array<u128, 32> vector_registers;
-        u64 fpcr;
+        u64 cpsr;
+        std::array<u128, 32> fpu_registers;
+        u64 fpscr;
     };
 
     /// Runs the CPU until an event happens
@@ -31,11 +31,11 @@ public:
     virtual void Step() = 0;
 
     /// Maps a backing memory region for the CPU
-    virtual void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
+    virtual void MapBackingMemory(VAddr address, size_t size, u8* memory,
                                   Kernel::VMAPermission perms) = 0;
 
     /// Unmaps a region of memory that was previously mapped using MapBackingMemory
-    virtual void UnmapMemory(VAddr address, std::size_t size) = 0;
+    virtual void UnmapMemory(VAddr address, size_t size) = 0;
 
     /// Clear all instruction cache
     virtual void ClearInstructionCache() = 0;
@@ -69,50 +69,42 @@ public:
      */
     virtual void SetReg(int index, u64 value) = 0;
 
-    /**
-     * Gets the value of a specified vector register.
-     *
-     * @param index The index of the vector register.
-     * @return the value within the vector register.
-     */
-    virtual u128 GetVectorReg(int index) const = 0;
+    virtual u128 GetExtReg(int index) const = 0;
+
+    virtual void SetExtReg(int index, u128 value) = 0;
 
     /**
-     * Sets a given value into a vector register.
-     *
-     * @param index The index of the vector register.
-     * @param value The new value to place in the register.
+     * Gets the value of a VFP register
+     * @param index Register index (0-31)
+     * @return Returns the value in the register
      */
-    virtual void SetVectorReg(int index, u128 value) = 0;
+    virtual u32 GetVFPReg(int index) const = 0;
 
     /**
-     * Get the current PSTATE register
-     * @return Returns the value of the PSTATE register
+     * Sets a VFP register to the given value
+     * @param index Register index (0-31)
+     * @param value Value to set register to
      */
-    virtual u32 GetPSTATE() const = 0;
+    virtual void SetVFPReg(int index, u32 value) = 0;
 
     /**
-     * Set the current PSTATE register
-     * @param pstate Value to set PSTATE to
+     * Get the current CPSR register
+     * @return Returns the value of the CPSR register
      */
-    virtual void SetPSTATE(u32 pstate) = 0;
+    virtual u32 GetCPSR() const = 0;
+
+    /**
+     * Set the current CPSR register
+     * @param cpsr Value to set CPSR to
+     */
+    virtual void SetCPSR(u32 cpsr) = 0;
 
     virtual VAddr GetTlsAddress() const = 0;
 
     virtual void SetTlsAddress(VAddr address) = 0;
 
-    /**
-     * Gets the value within the TPIDR_EL0 (read/write software thread ID) register.
-     *
-     * @return the value within the register.
-     */
     virtual u64 GetTPIDR_EL0() const = 0;
 
-    /**
-     * Sets a new value within the TPIDR_EL0 (read/write software thread ID) register.
-     *
-     * @param value The new value to place in the register.
-     */
     virtual void SetTPIDR_EL0(u64 value) = 0;
 
     /**
@@ -127,7 +119,6 @@ public:
      */
     virtual void LoadContext(const ThreadContext& ctx) = 0;
 
-    /// Clears the exclusive monitor's state.
     virtual void ClearExclusiveState() = 0;
 
     /// Prepare core for thread reschedule (if needed to correctly handle state)

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -7,10 +7,8 @@
 #include <dynarmic/A64/a64.h>
 #include <dynarmic/A64/config.h>
 #include "common/logging/log.h"
-#include "common/microprofile.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"
@@ -58,7 +56,7 @@ public:
         Memory::Write64(vaddr + 8, value[1]);
     }
 
-    void InterpreterFallback(u64 pc, std::size_t num_instructions) override {
+    void InterpreterFallback(u64 pc, size_t num_instructions) override {
         LOG_INFO(Core_ARM, "Unicorn fallback @ 0x{:X} for {} instructions (instr = {:08X})", pc,
                  num_instructions, MemoryReadCode(pc));
 
@@ -81,7 +79,7 @@ public:
             return;
         default:
             ASSERT_MSG(false, "ExceptionRaised(exception = {}, pc = {:X})",
-                       static_cast<std::size_t>(exception), pc);
+                       static_cast<size_t>(exception), pc);
         }
     }
 
@@ -110,7 +108,7 @@ public:
     }
 
     ARM_Dynarmic& parent;
-    std::size_t num_interpreted_instructions = 0;
+    size_t num_interpreted_instructions = 0;
     u64 tpidrro_el0 = 0;
     u64 tpidr_el0 = 0;
 };
@@ -144,10 +142,7 @@ std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
     return std::make_unique<Dynarmic::A64::Jit>(config);
 }
 
-MICROPROFILE_DEFINE(ARM_Jit_Dynarmic, "ARM JIT", "Dynarmic", MP_RGB(255, 64, 64));
-
 void ARM_Dynarmic::Run() {
-    MICROPROFILE_SCOPE(ARM_Jit_Dynarmic);
     ASSERT(Memory::GetCurrentPageTable() == current_page_table);
 
     jit->Run();
@@ -157,8 +152,7 @@ void ARM_Dynarmic::Step() {
     cb->InterpreterFallback(jit->GetPC(), 1);
 }
 
-ARM_Dynarmic::ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
-                           std::size_t core_index)
+ARM_Dynarmic::ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor, size_t core_index)
     : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), core_index{core_index},
       exclusive_monitor{std::dynamic_pointer_cast<DynarmicExclusiveMonitor>(exclusive_monitor)} {
     ThreadContext ctx;
@@ -169,12 +163,12 @@ ARM_Dynarmic::ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
 
 ARM_Dynarmic::~ARM_Dynarmic() = default;
 
-void ARM_Dynarmic::MapBackingMemory(u64 address, std::size_t size, u8* memory,
+void ARM_Dynarmic::MapBackingMemory(u64 address, size_t size, u8* memory,
                                     Kernel::VMAPermission perms) {
     inner_unicorn.MapBackingMemory(address, size, memory, perms);
 }
 
-void ARM_Dynarmic::UnmapMemory(u64 address, std::size_t size) {
+void ARM_Dynarmic::UnmapMemory(u64 address, size_t size) {
     inner_unicorn.UnmapMemory(address, size);
 }
 
@@ -194,20 +188,29 @@ void ARM_Dynarmic::SetReg(int index, u64 value) {
     jit->SetRegister(index, value);
 }
 
-u128 ARM_Dynarmic::GetVectorReg(int index) const {
+u128 ARM_Dynarmic::GetExtReg(int index) const {
     return jit->GetVector(index);
 }
 
-void ARM_Dynarmic::SetVectorReg(int index, u128 value) {
+void ARM_Dynarmic::SetExtReg(int index, u128 value) {
     jit->SetVector(index, value);
 }
 
-u32 ARM_Dynarmic::GetPSTATE() const {
+u32 ARM_Dynarmic::GetVFPReg(int /*index*/) const {
+    UNIMPLEMENTED();
+    return {};
+}
+
+void ARM_Dynarmic::SetVFPReg(int /*index*/, u32 /*value*/) {
+    UNIMPLEMENTED();
+}
+
+u32 ARM_Dynarmic::GetCPSR() const {
     return jit->GetPstate();
 }
 
-void ARM_Dynarmic::SetPSTATE(u32 pstate) {
-    jit->SetPstate(pstate);
+void ARM_Dynarmic::SetCPSR(u32 cpsr) {
+    jit->SetPstate(cpsr);
 }
 
 u64 ARM_Dynarmic::GetTlsAddress() const {
@@ -230,18 +233,18 @@ void ARM_Dynarmic::SaveContext(ThreadContext& ctx) {
     ctx.cpu_registers = jit->GetRegisters();
     ctx.sp = jit->GetSP();
     ctx.pc = jit->GetPC();
-    ctx.pstate = jit->GetPstate();
-    ctx.vector_registers = jit->GetVectors();
-    ctx.fpcr = jit->GetFpcr();
+    ctx.cpsr = jit->GetPstate();
+    ctx.fpu_registers = jit->GetVectors();
+    ctx.fpscr = jit->GetFpcr();
 }
 
 void ARM_Dynarmic::LoadContext(const ThreadContext& ctx) {
     jit->SetRegisters(ctx.cpu_registers);
     jit->SetSP(ctx.sp);
     jit->SetPC(ctx.pc);
-    jit->SetPstate(static_cast<u32>(ctx.pstate));
-    jit->SetVectors(ctx.vector_registers);
-    jit->SetFpcr(static_cast<u32>(ctx.fpcr));
+    jit->SetPstate(static_cast<u32>(ctx.cpsr));
+    jit->SetVectors(ctx.fpu_registers);
+    jit->SetFpcr(static_cast<u32>(ctx.fpscr));
 }
 
 void ARM_Dynarmic::PrepareReschedule() {
@@ -261,10 +264,10 @@ void ARM_Dynarmic::PageTableChanged() {
     current_page_table = Memory::GetCurrentPageTable();
 }
 
-DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(std::size_t core_count) : monitor(core_count) {}
+DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(size_t core_count) : monitor(core_count) {}
 DynarmicExclusiveMonitor::~DynarmicExclusiveMonitor() = default;
 
-void DynarmicExclusiveMonitor::SetExclusive(std::size_t core_index, VAddr addr) {
+void DynarmicExclusiveMonitor::SetExclusive(size_t core_index, VAddr addr) {
     // Size doesn't actually matter.
     monitor.Mark(core_index, addr, 16);
 }
@@ -273,30 +276,30 @@ void DynarmicExclusiveMonitor::ClearExclusive() {
     monitor.Clear();
 }
 
-bool DynarmicExclusiveMonitor::ExclusiveWrite8(std::size_t core_index, VAddr vaddr, u8 value) {
+bool DynarmicExclusiveMonitor::ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) {
     return monitor.DoExclusiveOperation(core_index, vaddr, 1,
                                         [&] { Memory::Write8(vaddr, value); });
 }
 
-bool DynarmicExclusiveMonitor::ExclusiveWrite16(std::size_t core_index, VAddr vaddr, u16 value) {
+bool DynarmicExclusiveMonitor::ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) {
     return monitor.DoExclusiveOperation(core_index, vaddr, 2,
                                         [&] { Memory::Write16(vaddr, value); });
 }
 
-bool DynarmicExclusiveMonitor::ExclusiveWrite32(std::size_t core_index, VAddr vaddr, u32 value) {
+bool DynarmicExclusiveMonitor::ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) {
     return monitor.DoExclusiveOperation(core_index, vaddr, 4,
                                         [&] { Memory::Write32(vaddr, value); });
 }
 
-bool DynarmicExclusiveMonitor::ExclusiveWrite64(std::size_t core_index, VAddr vaddr, u64 value) {
+bool DynarmicExclusiveMonitor::ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) {
     return monitor.DoExclusiveOperation(core_index, vaddr, 8,
                                         [&] { Memory::Write64(vaddr, value); });
 }
 
-bool DynarmicExclusiveMonitor::ExclusiveWrite128(std::size_t core_index, VAddr vaddr, u128 value) {
+bool DynarmicExclusiveMonitor::ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) {
     return monitor.DoExclusiveOperation(core_index, vaddr, 16, [&] {
-        Memory::Write64(vaddr + 0, value[0]);
-        Memory::Write64(vaddr + 8, value[1]);
+        Memory::Write64(vaddr, value[0]);
+        Memory::Write64(vaddr, value[1]);
     });
 }
 

src/core/arm/dynarmic/arm_dynarmic.h

@@ -19,22 +19,24 @@ class DynarmicExclusiveMonitor;
 
 class ARM_Dynarmic final : public ARM_Interface {
 public:
-    ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor, std::size_t core_index);
+    ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor, size_t core_index);
     ~ARM_Dynarmic();
 
-    void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
+    void MapBackingMemory(VAddr address, size_t size, u8* memory,
                           Kernel::VMAPermission perms) override;
-    void UnmapMemory(u64 address, std::size_t size) override;
+    void UnmapMemory(u64 address, size_t size) override;
     void SetPC(u64 pc) override;
     u64 GetPC() const override;
     u64 GetReg(int index) const override;
     void SetReg(int index, u64 value) override;
-    u128 GetVectorReg(int index) const override;
-    void SetVectorReg(int index, u128 value) override;
-    u32 GetPSTATE() const override;
-    void SetPSTATE(u32 pstate) override;
+    u128 GetExtReg(int index) const override;
+    void SetExtReg(int index, u128 value) override;
+    u32 GetVFPReg(int index) const override;
+    void SetVFPReg(int index, u32 value) override;
+    u32 GetCPSR() const override;
     void Run() override;
     void Step() override;
+    void SetCPSR(u32 cpsr) override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
     void SetTPIDR_EL0(u64 value) override;
@@ -57,7 +59,7 @@ private:
     std::unique_ptr<Dynarmic::A64::Jit> jit;
     ARM_Unicorn inner_unicorn;
 
-    std::size_t core_index;
+    size_t core_index;
     std::shared_ptr<DynarmicExclusiveMonitor> exclusive_monitor;
 
     Memory::PageTable* current_page_table = nullptr;
@@ -65,17 +67,17 @@ private:
 
 class DynarmicExclusiveMonitor final : public ExclusiveMonitor {
 public:
-    explicit DynarmicExclusiveMonitor(std::size_t core_count);
+    explicit DynarmicExclusiveMonitor(size_t core_count);
     ~DynarmicExclusiveMonitor();
 
-    void SetExclusive(std::size_t core_index, VAddr addr) override;
+    void SetExclusive(size_t core_index, VAddr addr) override;
     void ClearExclusive() override;
 
-    bool ExclusiveWrite8(std::size_t core_index, VAddr vaddr, u8 value) override;
-    bool ExclusiveWrite16(std::size_t core_index, VAddr vaddr, u16 value) override;
-    bool ExclusiveWrite32(std::size_t core_index, VAddr vaddr, u32 value) override;
-    bool ExclusiveWrite64(std::size_t core_index, VAddr vaddr, u64 value) override;
-    bool ExclusiveWrite128(std::size_t core_index, VAddr vaddr, u128 value) override;
+    bool ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) override;
+    bool ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) override;
+    bool ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) override;
+    bool ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) override;
+    bool ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) override;
 
 private:
     friend class ARM_Dynarmic;

src/core/arm/exclusive_monitor.h

@@ -12,14 +12,14 @@ class ExclusiveMonitor {
 public:
     virtual ~ExclusiveMonitor();
 
-    virtual void SetExclusive(std::size_t core_index, VAddr addr) = 0;
+    virtual void SetExclusive(size_t core_index, VAddr addr) = 0;
     virtual void ClearExclusive() = 0;
 
-    virtual bool ExclusiveWrite8(std::size_t core_index, VAddr vaddr, u8 value) = 0;
-    virtual bool ExclusiveWrite16(std::size_t core_index, VAddr vaddr, u16 value) = 0;
-    virtual bool ExclusiveWrite32(std::size_t core_index, VAddr vaddr, u32 value) = 0;
-    virtual bool ExclusiveWrite64(std::size_t core_index, VAddr vaddr, u64 value) = 0;
-    virtual bool ExclusiveWrite128(std::size_t core_index, VAddr vaddr, u128 value) = 0;
+    virtual bool ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) = 0;
+    virtual bool ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) = 0;
+    virtual bool ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) = 0;
+    virtual bool ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) = 0;
+    virtual bool ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) = 0;
 };
 
 } // namespace Core

src/core/arm/unicorn/arm_unicorn.cpp

@@ -90,12 +90,12 @@ ARM_Unicorn::~ARM_Unicorn() {
     CHECKED(uc_close(uc));
 }
 
-void ARM_Unicorn::MapBackingMemory(VAddr address, std::size_t size, u8* memory,
+void ARM_Unicorn::MapBackingMemory(VAddr address, size_t size, u8* memory,
                                    Kernel::VMAPermission perms) {
     CHECKED(uc_mem_map_ptr(uc, address, size, static_cast<u32>(perms), memory));
 }
 
-void ARM_Unicorn::UnmapMemory(VAddr address, std::size_t size) {
+void ARM_Unicorn::UnmapMemory(VAddr address, size_t size) {
     CHECKED(uc_mem_unmap(uc, address, size));
 }
 
@@ -131,24 +131,33 @@ void ARM_Unicorn::SetReg(int regn, u64 val) {
     CHECKED(uc_reg_write(uc, treg, &val));
 }
 
-u128 ARM_Unicorn::GetVectorReg(int /*index*/) const {
+u128 ARM_Unicorn::GetExtReg(int /*index*/) const {
     UNIMPLEMENTED();
     static constexpr u128 res{};
     return res;
 }
 
-void ARM_Unicorn::SetVectorReg(int /*index*/, u128 /*value*/) {
+void ARM_Unicorn::SetExtReg(int /*index*/, u128 /*value*/) {
     UNIMPLEMENTED();
 }
 
-u32 ARM_Unicorn::GetPSTATE() const {
+u32 ARM_Unicorn::GetVFPReg(int /*index*/) const {
+    UNIMPLEMENTED();
+    return {};
+}
+
+void ARM_Unicorn::SetVFPReg(int /*index*/, u32 /*value*/) {
+    UNIMPLEMENTED();
+}
+
+u32 ARM_Unicorn::GetCPSR() const {
     u64 nzcv{};
     CHECKED(uc_reg_read(uc, UC_ARM64_REG_NZCV, &nzcv));
     return static_cast<u32>(nzcv);
 }
 
-void ARM_Unicorn::SetPSTATE(u32 pstate) {
-    u64 nzcv = pstate;
+void ARM_Unicorn::SetCPSR(u32 cpsr) {
+    u64 nzcv = cpsr;
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_NZCV, &nzcv));
 }
 
@@ -184,10 +193,10 @@ void ARM_Unicorn::Step() {
     ExecuteInstructions(1);
 }
 
-MICROPROFILE_DEFINE(ARM_Jit_Unicorn, "ARM JIT", "Unicorn", MP_RGB(255, 64, 64));
+MICROPROFILE_DEFINE(ARM_Jit, "ARM JIT", "ARM JIT", MP_RGB(255, 64, 64));
 
 void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
-    MICROPROFILE_SCOPE(ARM_Jit_Unicorn);
+    MICROPROFILE_SCOPE(ARM_Jit);
     CHECKED(uc_emu_start(uc, GetPC(), 1ULL << 63, 0, num_instructions));
     CoreTiming::AddTicks(num_instructions);
     if (GDBStub::IsServerEnabled()) {
@@ -210,7 +219,7 @@ void ARM_Unicorn::SaveContext(ThreadContext& ctx) {
 
     CHECKED(uc_reg_read(uc, UC_ARM64_REG_SP, &ctx.sp));
     CHECKED(uc_reg_read(uc, UC_ARM64_REG_PC, &ctx.pc));
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_NZCV, &ctx.pstate));
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_NZCV, &ctx.cpsr));
 
     for (auto i = 0; i < 29; ++i) {
         uregs[i] = UC_ARM64_REG_X0 + i;
@@ -225,7 +234,7 @@ void ARM_Unicorn::SaveContext(ThreadContext& ctx) {
 
     for (int i = 0; i < 32; ++i) {
         uregs[i] = UC_ARM64_REG_Q0 + i;
-        tregs[i] = &ctx.vector_registers[i];
+        tregs[i] = &ctx.fpu_registers[i];
     }
 
     CHECKED(uc_reg_read_batch(uc, uregs, tregs, 32));
@@ -237,7 +246,7 @@ void ARM_Unicorn::LoadContext(const ThreadContext& ctx) {
 
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_SP, &ctx.sp));
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_PC, &ctx.pc));
-    CHECKED(uc_reg_write(uc, UC_ARM64_REG_NZCV, &ctx.pstate));
+    CHECKED(uc_reg_write(uc, UC_ARM64_REG_NZCV, &ctx.cpsr));
 
     for (int i = 0; i < 29; ++i) {
         uregs[i] = UC_ARM64_REG_X0 + i;
@@ -252,7 +261,7 @@ void ARM_Unicorn::LoadContext(const ThreadContext& ctx) {
 
     for (auto i = 0; i < 32; ++i) {
         uregs[i] = UC_ARM64_REG_Q0 + i;
-        tregs[i] = (void*)&ctx.vector_registers[i];
+        tregs[i] = (void*)&ctx.fpu_registers[i];
     }
 
     CHECKED(uc_reg_write_batch(uc, uregs, tregs, 32));

src/core/arm/unicorn/arm_unicorn.h

@@ -15,17 +15,19 @@ class ARM_Unicorn final : public ARM_Interface {
 public:
     ARM_Unicorn();
     ~ARM_Unicorn();
-    void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
+    void MapBackingMemory(VAddr address, size_t size, u8* memory,
                           Kernel::VMAPermission perms) override;
-    void UnmapMemory(VAddr address, std::size_t size) override;
+    void UnmapMemory(VAddr address, size_t size) override;
     void SetPC(u64 pc) override;
     u64 GetPC() const override;
     u64 GetReg(int index) const override;
     void SetReg(int index, u64 value) override;
-    u128 GetVectorReg(int index) const override;
-    void SetVectorReg(int index, u128 value) override;
-    u32 GetPSTATE() const override;
-    void SetPSTATE(u32 pstate) override;
+    u128 GetExtReg(int index) const override;
+    void SetExtReg(int index, u128 value) override;
+    u32 GetVFPReg(int index) const override;
+    void SetVFPReg(int index, u32 value) override;
+    u32 GetCPSR() const override;
+    void SetCPSR(u32 cpsr) override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
     void SetTPIDR_EL0(u64 value) override;

src/core/core.cpp

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

src/core/core.h

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

@@ -9,7 +9,6 @@
 #ifdef ARCHITECTURE_x86_64
 #include "core/arm/dynarmic/arm_dynarmic.h"
 #endif
-#include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
@@ -50,7 +49,7 @@ bool CpuBarrier::Rendezvous() {
 }
 
 Cpu::Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
-         std::shared_ptr<CpuBarrier> cpu_barrier, std::size_t core_index)
+         std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index)
     : cpu_barrier{std::move(cpu_barrier)}, core_index{core_index} {
 
     if (Settings::values.use_cpu_jit) {
@@ -67,9 +66,7 @@ Cpu::Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
     scheduler = std::make_shared<Kernel::Scheduler>(arm_interface.get());
 }
 
-Cpu::~Cpu() = default;
-
-std::shared_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(std::size_t num_cores) {
+std::shared_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(size_t num_cores) {
     if (Settings::values.use_cpu_jit) {
 #ifdef ARCHITECTURE_x86_64
         return std::make_shared<DynarmicExclusiveMonitor>(num_cores);

src/core/core_cpu.h

@@ -6,10 +6,11 @@
 
 #include <atomic>
 #include <condition_variable>
-#include <cstddef>
 #include <memory>
 #include <mutex>
+#include <string>
 #include "common/common_types.h"
+#include "core/arm/exclusive_monitor.h"
 
 namespace Kernel {
 class Scheduler;
@@ -18,7 +19,6 @@ class Scheduler;
 namespace Core {
 
 class ARM_Interface;
-class ExclusiveMonitor;
 
 constexpr unsigned NUM_CPU_CORES{4};
 
@@ -42,8 +42,7 @@ private:
 class Cpu {
 public:
     Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
-        std::shared_ptr<CpuBarrier> cpu_barrier, std::size_t core_index);
-    ~Cpu();
+        std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index);
 
     void RunLoop(bool tight_loop = true);
 
@@ -67,11 +66,11 @@ public:
         return core_index == 0;
     }
 
-    std::size_t CoreIndex() const {
+    size_t CoreIndex() const {
         return core_index;
     }
 
-    static std::shared_ptr<ExclusiveMonitor> MakeExclusiveMonitor(std::size_t num_cores);
+    static std::shared_ptr<ExclusiveMonitor> MakeExclusiveMonitor(size_t num_cores);
 
 private:
     void Reschedule();
@@ -81,7 +80,7 @@ private:
     std::shared_ptr<Kernel::Scheduler> scheduler;
 
     std::atomic<bool> reschedule_pending = false;
-    std::size_t core_index;
+    size_t core_index;
 };
 
 } // namespace Core

src/core/crypto/aes_util.cpp

@@ -10,9 +10,9 @@
 
 namespace Core::Crypto {
 namespace {
-std::vector<u8> CalculateNintendoTweak(std::size_t sector_id) {
+std::vector<u8> CalculateNintendoTweak(size_t sector_id) {
     std::vector<u8> out(0x10);
-    for (std::size_t i = 0xF; i <= 0xF; --i) {
+    for (size_t i = 0xF; i <= 0xF; --i) {
         out[i] = sector_id & 0xFF;
         sector_id >>= 8;
     }
@@ -20,14 +20,11 @@ std::vector<u8> CalculateNintendoTweak(std::size_t sector_id) {
 }
 } // Anonymous namespace
 
-static_assert(static_cast<std::size_t>(Mode::CTR) ==
-                  static_cast<std::size_t>(MBEDTLS_CIPHER_AES_128_CTR),
+static_assert(static_cast<size_t>(Mode::CTR) == static_cast<size_t>(MBEDTLS_CIPHER_AES_128_CTR),
               "CTR has incorrect value.");
-static_assert(static_cast<std::size_t>(Mode::ECB) ==
-                  static_cast<std::size_t>(MBEDTLS_CIPHER_AES_128_ECB),
+static_assert(static_cast<size_t>(Mode::ECB) == static_cast<size_t>(MBEDTLS_CIPHER_AES_128_ECB),
               "ECB has incorrect value.");
-static_assert(static_cast<std::size_t>(Mode::XTS) ==
-                  static_cast<std::size_t>(MBEDTLS_CIPHER_AES_128_XTS),
+static_assert(static_cast<size_t>(Mode::XTS) == static_cast<size_t>(MBEDTLS_CIPHER_AES_128_XTS),
               "XTS has incorrect value.");
 
 // Structure to hide mbedtls types from header file
@@ -36,7 +33,7 @@ struct CipherContext {
     mbedtls_cipher_context_t decryption_context;
 };
 
-template <typename Key, std::size_t KeySize>
+template <typename Key, size_t KeySize>
 Crypto::AESCipher<Key, KeySize>::AESCipher(Key key, Mode mode)
     : ctx(std::make_unique<CipherContext>()) {
     mbedtls_cipher_init(&ctx->encryption_context);
@@ -57,26 +54,26 @@ Crypto::AESCipher<Key, KeySize>::AESCipher(Key key, Mode mode)
     //"Failed to set key on mbedtls ciphers.");
 }
 
-template <typename Key, std::size_t KeySize>
+template <typename Key, size_t KeySize>
 AESCipher<Key, KeySize>::~AESCipher() {
     mbedtls_cipher_free(&ctx->encryption_context);
     mbedtls_cipher_free(&ctx->decryption_context);
 }
 
-template <typename Key, std::size_t KeySize>
+template <typename Key, size_t KeySize>
 void AESCipher<Key, KeySize>::SetIV(std::vector<u8> iv) {
     ASSERT_MSG((mbedtls_cipher_set_iv(&ctx->encryption_context, iv.data(), iv.size()) ||
                 mbedtls_cipher_set_iv(&ctx->decryption_context, iv.data(), iv.size())) == 0,
                "Failed to set IV on mbedtls ciphers.");
 }
 
-template <typename Key, std::size_t KeySize>
-void AESCipher<Key, KeySize>::Transcode(const u8* src, std::size_t size, u8* dest, Op op) const {
+template <typename Key, size_t KeySize>
+void AESCipher<Key, KeySize>::Transcode(const u8* src, size_t size, u8* dest, Op op) const {
     auto* const context = op == Op::Encrypt ? &ctx->encryption_context : &ctx->decryption_context;
 
     mbedtls_cipher_reset(context);
 
-    std::size_t written = 0;
+    size_t written = 0;
     if (mbedtls_cipher_get_cipher_mode(context) == MBEDTLS_MODE_XTS) {
         mbedtls_cipher_update(context, src, size, dest, &written);
         if (written != size) {
@@ -85,25 +82,11 @@ void AESCipher<Key, KeySize>::Transcode(const u8* src, std::size_t size, u8* des
         }
     } else {
         const auto block_size = mbedtls_cipher_get_block_size(context);
-        if (size < block_size) {
-            std::vector<u8> block(block_size);
-            std::memcpy(block.data(), src, size);
-            Transcode(block.data(), block.size(), block.data(), op);
-            std::memcpy(dest, block.data(), size);
-            return;
-        }
 
-        for (std::size_t offset = 0; offset < size; offset += block_size) {
-            auto length = std::min<std::size_t>(block_size, size - offset);
+        for (size_t offset = 0; offset < size; offset += block_size) {
+            auto length = std::min<size_t>(block_size, size - offset);
             mbedtls_cipher_update(context, src + offset, length, dest + offset, &written);
             if (written != length) {
-                if (length < block_size) {
-                    std::vector<u8> block(block_size);
-                    std::memcpy(block.data(), src + offset, length);
-                    Transcode(block.data(), block.size(), block.data(), op);
-                    std::memcpy(dest + offset, block.data(), length);
-                    return;
-                }
                 LOG_WARNING(Crypto, "Not all data was decrypted requested={:016X}, actual={:016X}.",
                             length, written);
             }
@@ -113,12 +96,12 @@ void AESCipher<Key, KeySize>::Transcode(const u8* src, std::size_t size, u8* des
     mbedtls_cipher_finish(context, nullptr, nullptr);
 }
 
-template <typename Key, std::size_t KeySize>
-void AESCipher<Key, KeySize>::XTSTranscode(const u8* src, std::size_t size, u8* dest,
-                                           std::size_t sector_id, std::size_t sector_size, Op op) {
+template <typename Key, size_t KeySize>
+void AESCipher<Key, KeySize>::XTSTranscode(const u8* src, size_t size, u8* dest, size_t sector_id,
+                                           size_t sector_size, Op op) {
     ASSERT_MSG(size % sector_size == 0, "XTS decryption size must be a multiple of sector size.");
 
-    for (std::size_t i = 0; i < size; i += sector_size) {
+    for (size_t i = 0; i < size; i += sector_size) {
         SetIV(CalculateNintendoTweak(sector_id++));
         Transcode<u8, u8>(src + i, sector_size, dest + i, op);
     }

src/core/crypto/aes_util.h

@@ -25,7 +25,7 @@ enum class Op {
     Decrypt,
 };
 
-template <typename Key, std::size_t KeySize = sizeof(Key)>
+template <typename Key, size_t KeySize = sizeof(Key)>
 class AESCipher {
     static_assert(std::is_same_v<Key, std::array<u8, KeySize>>, "Key must be std::array of u8.");
     static_assert(KeySize == 0x10 || KeySize == 0x20, "KeySize must be 128 or 256.");
@@ -38,25 +38,25 @@ public:
     void SetIV(std::vector<u8> iv);
 
     template <typename Source, typename Dest>
-    void Transcode(const Source* src, std::size_t size, Dest* dest, Op op) const {
+    void Transcode(const Source* src, size_t size, Dest* dest, Op op) const {
         static_assert(std::is_trivially_copyable_v<Source> && std::is_trivially_copyable_v<Dest>,
                       "Transcode source and destination types must be trivially copyable.");
         Transcode(reinterpret_cast<const u8*>(src), size, reinterpret_cast<u8*>(dest), op);
     }
 
-    void Transcode(const u8* src, std::size_t size, u8* dest, Op op) const;
+    void Transcode(const u8* src, size_t size, u8* dest, Op op) const;
 
     template <typename Source, typename Dest>
-    void XTSTranscode(const Source* src, std::size_t size, Dest* dest, std::size_t sector_id,
-                      std::size_t sector_size, Op op) {
+    void XTSTranscode(const Source* src, size_t size, Dest* dest, size_t sector_id,
+                      size_t sector_size, Op op) {
         static_assert(std::is_trivially_copyable_v<Source> && std::is_trivially_copyable_v<Dest>,
                       "XTSTranscode source and destination types must be trivially copyable.");
         XTSTranscode(reinterpret_cast<const u8*>(src), size, reinterpret_cast<u8*>(dest), sector_id,
                      sector_size, op);
     }
 
-    void XTSTranscode(const u8* src, std::size_t size, u8* dest, std::size_t sector_id,
-                      std::size_t sector_size, Op op);
+    void XTSTranscode(const u8* src, size_t size, u8* dest, size_t sector_id, size_t sector_size,
+                      Op op);
 
 private:
     std::unique_ptr<CipherContext> ctx;

src/core/crypto/ctr_encryption_layer.cpp

@@ -8,12 +8,11 @@
 
 namespace Core::Crypto {
 
-CTREncryptionLayer::CTREncryptionLayer(FileSys::VirtualFile base_, Key128 key_,
-                                       std::size_t base_offset)
+CTREncryptionLayer::CTREncryptionLayer(FileSys::VirtualFile base_, Key128 key_, size_t base_offset)
     : EncryptionLayer(std::move(base_)), base_offset(base_offset), cipher(key_, Mode::CTR),
       iv(16, 0) {}
 
-std::size_t CTREncryptionLayer::Read(u8* data, std::size_t length, std::size_t offset) const {
+size_t CTREncryptionLayer::Read(u8* data, size_t length, size_t offset) const {
     if (length == 0)
         return 0;
 
@@ -22,14 +21,14 @@ std::size_t CTREncryptionLayer::Read(u8* data, std::size_t length, std::size_t o
         UpdateIV(base_offset + offset);
         std::vector<u8> raw = base->ReadBytes(length, offset);
         cipher.Transcode(raw.data(), raw.size(), data, Op::Decrypt);
-        return length;
+        return raw.size();
     }
 
     // offset does not fall on block boundary (0x10)
     std::vector<u8> block = base->ReadBytes(0x10, offset - sector_offset);
     UpdateIV(base_offset + offset - sector_offset);
     cipher.Transcode(block.data(), block.size(), block.data(), Op::Decrypt);
-    std::size_t read = 0x10 - sector_offset;
+    size_t read = 0x10 - sector_offset;
 
     if (length + sector_offset < 0x10) {
         std::memcpy(data, block.data() + sector_offset, std::min<u64>(length, read));
@@ -44,9 +43,9 @@ void CTREncryptionLayer::SetIV(const std::vector<u8>& iv_) {
     iv.assign(iv_.cbegin(), iv_.cbegin() + length);
 }
 
-void CTREncryptionLayer::UpdateIV(std::size_t offset) const {
+void CTREncryptionLayer::UpdateIV(size_t offset) const {
     offset >>= 4;
-    for (std::size_t i = 0; i < 8; ++i) {
+    for (size_t i = 0; i < 8; ++i) {
         iv[16 - i - 1] = offset & 0xFF;
         offset >>= 8;
     }

src/core/crypto/ctr_encryption_layer.h

@@ -14,20 +14,20 @@ namespace Core::Crypto {
 // Sits on top of a VirtualFile and provides CTR-mode AES decription.
 class CTREncryptionLayer : public EncryptionLayer {
 public:
-    CTREncryptionLayer(FileSys::VirtualFile base, Key128 key, std::size_t base_offset);
+    CTREncryptionLayer(FileSys::VirtualFile base, Key128 key, size_t base_offset);
 
-    std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override;
+    size_t Read(u8* data, size_t length, size_t offset) const override;
 
     void SetIV(const std::vector<u8>& iv);
 
 private:
-    std::size_t base_offset;
+    size_t base_offset;
 
     // Must be mutable as operations modify cipher contexts.
     mutable AESCipher<Key128> cipher;
     mutable std::vector<u8> iv;
 
-    void UpdateIV(std::size_t offset) const;
+    void UpdateIV(size_t offset) const;
 };
 
 } // namespace Core::Crypto

src/core/crypto/encryption_layer.cpp

@@ -12,11 +12,11 @@ std::string EncryptionLayer::GetName() const {
     return base->GetName();
 }
 
-std::size_t EncryptionLayer::GetSize() const {
+size_t EncryptionLayer::GetSize() const {
     return base->GetSize();
 }
 
-bool EncryptionLayer::Resize(std::size_t new_size) {
+bool EncryptionLayer::Resize(size_t new_size) {
     return false;
 }
 
@@ -32,7 +32,7 @@ bool EncryptionLayer::IsReadable() const {
     return true;
 }
 
-std::size_t EncryptionLayer::Write(const u8* data, std::size_t length, std::size_t offset) {
+size_t EncryptionLayer::Write(const u8* data, size_t length, size_t offset) {
     return 0;
 }
 

src/core/crypto/encryption_layer.h

@@ -15,15 +15,15 @@ class EncryptionLayer : public FileSys::VfsFile {
 public:
     explicit EncryptionLayer(FileSys::VirtualFile base);
 
-    std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override = 0;
+    size_t Read(u8* data, size_t length, size_t offset) const override = 0;
 
     std::string GetName() const override;
-    std::size_t GetSize() const override;
-    bool Resize(std::size_t new_size) override;
+    size_t GetSize() const override;
+    bool Resize(size_t new_size) override;
     std::shared_ptr<FileSys::VfsDirectory> GetContainingDirectory() const override;
     bool IsWritable() const override;
     bool IsReadable() const override;
-    std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override;
+    size_t Write(const u8* data, size_t length, size_t offset) override;
     bool Rename(std::string_view name) override;
 
 protected:

src/core/crypto/key_manager.cpp

@@ -8,15 +8,12 @@
 #include <locale>
 #include <sstream>
 #include <string_view>
-#include <tuple>
-#include <vector>
 #include "common/common_paths.h"
 #include "common/file_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/key_manager.h"
-#include "core/loader/loader.h"
 #include "core/settings.h"
 
 namespace Core::Crypto {
@@ -54,7 +51,7 @@ boost::optional<Key128> DeriveSDSeed() {
         return boost::none;
 
     std::array<u8, 0x10> buffer{};
-    std::size_t offset = 0;
+    size_t offset = 0;
     for (; offset + 0x10 < save_43.GetSize(); ++offset) {
         save_43.Seek(offset, SEEK_SET);
         save_43.ReadBytes(buffer.data(), buffer.size());
@@ -105,7 +102,7 @@ Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, const KeyManag
 
     // Combine sources and seed
     for (auto& source : sd_key_sources) {
-        for (std::size_t i = 0; i < source.size(); ++i)
+        for (size_t i = 0; i < source.size(); ++i)
             source[i] ^= sd_seed[i & 0xF];
     }
 
@@ -207,7 +204,7 @@ Key256 KeyManager::GetKey(S256KeyType id, u64 field1, u64 field2) const {
     return s256_keys.at({id, field1, field2});
 }
 
-template <std::size_t Size>
+template <size_t Size>
 void KeyManager::WriteKeyToFile(bool title_key, std::string_view keyname,
                                 const std::array<u8, Size>& key) {
     const std::string yuzu_keys_dir = FileUtil::GetUserPath(FileUtil::UserPath::KeysDir);
@@ -231,28 +228,18 @@ void KeyManager::WriteKeyToFile(bool title_key, std::string_view keyname,
 }
 
 void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
-    if (s128_keys.find({id, field1, field2}) != s128_keys.end())
-        return;
-    if (id == S128KeyType::Titlekey) {
-        Key128 rights_id;
-        std::memcpy(rights_id.data(), &field2, sizeof(u64));
-        std::memcpy(rights_id.data() + sizeof(u64), &field1, sizeof(u64));
-        WriteKeyToFile(true, Common::HexArrayToString(rights_id), key);
-    }
-    const auto iter2 = std::find_if(
+    const auto iter = std::find_if(
         s128_file_id.begin(), s128_file_id.end(),
         [&id, &field1, &field2](const std::pair<std::string, KeyIndex<S128KeyType>> elem) {
             return std::tie(elem.second.type, elem.second.field1, elem.second.field2) ==
                    std::tie(id, field1, field2);
         });
-    if (iter2 != s128_file_id.end())
-        WriteKeyToFile(false, iter2->first, key);
+    if (iter != s128_file_id.end())
+        WriteKeyToFile(id == S128KeyType::Titlekey, iter->first, key);
     s128_keys[{id, field1, field2}] = key;
 }
 
 void KeyManager::SetKey(S256KeyType id, Key256 key, u64 field1, u64 field2) {
-    if (s256_keys.find({id, field1, field2}) != s256_keys.end())
-        return;
     const auto iter = std::find_if(
         s256_file_id.begin(), s256_file_id.end(),
         [&id, &field1, &field2](const std::pair<std::string, KeyIndex<S256KeyType>> elem) {

src/core/crypto/key_manager.h

@@ -6,19 +6,16 @@
 
 #include <array>
 #include <string>
+#include <string_view>
+#include <type_traits>
+#include <vector>
 #include <boost/container/flat_map.hpp>
-#include <boost/optional.hpp>
 #include <fmt/format.h>
 #include "common/common_types.h"
-
-namespace Loader {
-enum class ResultStatus : u16;
-}
+#include "core/loader/loader.h"
 
 namespace Core::Crypto {
 
-constexpr u64 TICKET_FILE_TITLEKEY_OFFSET = 0x180;
-
 using Key128 = std::array<u8, 0x10>;
 using Key256 = std::array<u8, 0x20>;
 using SHA256Hash = std::array<u8, 0x20>;
@@ -108,7 +105,7 @@ private:
     void LoadFromFile(const std::string& filename, bool is_title_keys);
     void AttemptLoadKeyFile(const std::string& dir1, const std::string& dir2,
                             const std::string& filename, bool title);
-    template <std::size_t Size>
+    template <size_t Size>
     void WriteKeyToFile(bool title_key, std::string_view keyname, const std::array<u8, Size>& key);
 
     static const boost::container::flat_map<std::string, KeyIndex<S128KeyType>> s128_file_id;

src/core/crypto/xts_encryption_layer.cpp

@@ -14,7 +14,7 @@ constexpr u64 XTS_SECTOR_SIZE = 0x4000;
 XTSEncryptionLayer::XTSEncryptionLayer(FileSys::VirtualFile base_, Key256 key_)
     : EncryptionLayer(std::move(base_)), cipher(key_, Mode::XTS) {}
 
-std::size_t XTSEncryptionLayer::Read(u8* data, std::size_t length, std::size_t offset) const {
+size_t XTSEncryptionLayer::Read(u8* data, size_t length, size_t offset) const {
     if (length == 0)
         return 0;
 
@@ -46,7 +46,7 @@ std::size_t XTSEncryptionLayer::Read(u8* data, std::size_t length, std::size_t o
         block.resize(XTS_SECTOR_SIZE);
     cipher.XTSTranscode(block.data(), block.size(), block.data(),
                         (offset - sector_offset) / XTS_SECTOR_SIZE, XTS_SECTOR_SIZE, Op::Decrypt);
-    const std::size_t read = XTS_SECTOR_SIZE - sector_offset;
+    const size_t read = XTS_SECTOR_SIZE - sector_offset;
 
     if (length + sector_offset < XTS_SECTOR_SIZE) {
         std::memcpy(data, block.data() + sector_offset, std::min<u64>(length, read));

src/core/crypto/xts_encryption_layer.h

@@ -15,7 +15,7 @@ class XTSEncryptionLayer : public EncryptionLayer {
 public:
     XTSEncryptionLayer(FileSys::VirtualFile base, Key256 key);
 
-    std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override;
+    size_t Read(u8* data, size_t length, size_t offset) const override;
 
 private:
     // Must be mutable as operations modify cipher contexts.

src/core/file_sys/bis_factory.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "core/file_sys/bis_factory.h"
-#include "core/file_sys/registered_cache.h"
 
 namespace FileSys {
 
@@ -14,8 +13,6 @@ BISFactory::BISFactory(VirtualDir nand_root_)
       usrnand_cache(std::make_shared<RegisteredCache>(
           GetOrCreateDirectoryRelative(nand_root, "/user/Contents/registered"))) {}
 
-BISFactory::~BISFactory() = default;
-
 std::shared_ptr<RegisteredCache> BISFactory::GetSystemNANDContents() const {
     return sysnand_cache;
 }

src/core/file_sys/bis_factory.h

@@ -5,20 +5,17 @@
 #pragma once
 
 #include <memory>
-
-#include "core/file_sys/vfs.h"
+#include "core/loader/loader.h"
+#include "registered_cache.h"
 
 namespace FileSys {
 
-class RegisteredCache;
-
 /// File system interface to the Built-In Storage
 /// This is currently missing accessors to BIS partitions, but seemed like a good place for the NAND
 /// registered caches.
 class BISFactory {
 public:
     explicit BISFactory(VirtualDir nand_root);
-    ~BISFactory();
 
     std::shared_ptr<RegisteredCache> GetSystemNANDContents() const;
     std::shared_ptr<RegisteredCache> GetUserNANDContents() const;

src/core/file_sys/card_image.cpp

@@ -9,10 +9,7 @@
 
 #include "common/logging/log.h"
 #include "core/file_sys/card_image.h"
-#include "core/file_sys/content_archive.h"
-#include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/partition_filesystem.h"
-#include "core/file_sys/submission_package.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/loader/loader.h"
 
@@ -41,25 +38,20 @@ XCI::XCI(VirtualFile file_) : file(std::move(file_)), partitions(0x4) {
 
     for (XCIPartition partition :
          {XCIPartition::Update, XCIPartition::Normal, XCIPartition::Secure, XCIPartition::Logo}) {
-        auto raw = main_hfs.GetFile(partition_names[static_cast<std::size_t>(partition)]);
+        auto raw = main_hfs.GetFile(partition_names[static_cast<size_t>(partition)]);
         if (raw != nullptr)
-            partitions[static_cast<std::size_t>(partition)] =
-                std::make_shared<PartitionFilesystem>(raw);
+            partitions[static_cast<size_t>(partition)] = std::make_shared<PartitionFilesystem>(raw);
     }
 
-    secure_partition = std::make_shared<NSP>(
-        main_hfs.GetFile(partition_names[static_cast<std::size_t>(XCIPartition::Secure)]));
+    program_nca_status = Loader::ResultStatus::ErrorXCIMissingProgramNCA;
 
-    const auto secure_ncas = secure_partition->GetNCAsCollapsed();
-    std::copy(secure_ncas.begin(), secure_ncas.end(), std::back_inserter(ncas));
+    auto result = AddNCAFromPartition(XCIPartition::Secure);
+    if (result != Loader::ResultStatus::Success) {
+        status = result;
+        return;
+    }
 
-    program =
-        secure_partition->GetNCA(secure_partition->GetProgramTitleID(), ContentRecordType::Program);
-    program_nca_status = secure_partition->GetProgramStatus(secure_partition->GetProgramTitleID());
-    if (program_nca_status == Loader::ResultStatus::ErrorNSPMissingProgramNCA)
-        program_nca_status = Loader::ResultStatus::ErrorXCIMissingProgramNCA;
-
-    auto result = AddNCAFromPartition(XCIPartition::Update);
+    result = AddNCAFromPartition(XCIPartition::Update);
     if (result != Loader::ResultStatus::Success) {
         status = result;
         return;
@@ -82,8 +74,6 @@ XCI::XCI(VirtualFile file_) : file(std::move(file_)), partitions(0x4) {
     status = Loader::ResultStatus::Success;
 }
 
-XCI::~XCI() = default;
-
 Loader::ResultStatus XCI::GetStatus() const {
     return status;
 }
@@ -93,11 +83,7 @@ Loader::ResultStatus XCI::GetProgramNCAStatus() const {
 }
 
 VirtualDir XCI::GetPartition(XCIPartition partition) const {
-    return partitions[static_cast<std::size_t>(partition)];
-}
-
-std::shared_ptr<NSP> XCI::GetSecurePartitionNSP() const {
-    return secure_partition;
+    return partitions[static_cast<size_t>(partition)];
 }
 
 VirtualDir XCI::GetSecurePartition() const {
@@ -116,20 +102,6 @@ VirtualDir XCI::GetLogoPartition() const {
     return GetPartition(XCIPartition::Logo);
 }
 
-u64 XCI::GetProgramTitleID() const {
-    return secure_partition->GetProgramTitleID();
-}
-
-std::shared_ptr<NCA> XCI::GetProgramNCA() const {
-    return program;
-}
-
-VirtualFile XCI::GetProgramNCAFile() const {
-    if (GetProgramNCA() == nullptr)
-        return nullptr;
-    return GetProgramNCA()->GetBaseFile();
-}
-
 const std::vector<std::shared_ptr<NCA>>& XCI::GetNCAs() const {
     return ncas;
 }
@@ -169,11 +141,11 @@ bool XCI::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
 }
 
 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
-    if (partitions[static_cast<std::size_t>(part)] == nullptr) {
+    if (partitions[static_cast<size_t>(part)] == nullptr) {
         return Loader::ResultStatus::ErrorXCIMissingPartition;
     }
 
-    for (const VirtualFile& file : partitions[static_cast<std::size_t>(part)]->GetFiles()) {
+    for (const VirtualFile& file : partitions[static_cast<size_t>(part)]->GetFiles()) {
         if (file->GetExtension() != "nca")
             continue;
         auto nca = std::make_shared<NCA>(file);
@@ -188,7 +160,7 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
         } else {
             const u16 error_id = static_cast<u16>(nca->GetStatus());
             LOG_CRITICAL(Loader, "Could not load NCA {}/{}, failed with error code {:04X} ({})",
-                         partition_names[static_cast<std::size_t>(part)], nca->GetName(), error_id,
+                         partition_names[static_cast<size_t>(part)], nca->GetName(), error_id,
                          nca->GetStatus());
         }
     }

src/core/file_sys/card_image.h

@@ -5,22 +5,15 @@
 #pragma once
 
 #include <array>
-#include <memory>
 #include <vector>
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "core/file_sys/content_archive.h"
 #include "core/file_sys/vfs.h"
-
-namespace Loader {
-enum class ResultStatus : u16;
-}
+#include "core/loader/loader.h"
 
 namespace FileSys {
 
-class NCA;
-enum class NCAContentType : u8;
-class NSP;
-
 enum class GamecardSize : u8 {
     S_1GB = 0xFA,
     S_2GB = 0xF8,
@@ -64,7 +57,6 @@ enum class XCIPartition : u8 { Update, Normal, Secure, Logo };
 class XCI : public ReadOnlyVfsDirectory {
 public:
     explicit XCI(VirtualFile file);
-    ~XCI() override;
 
     Loader::ResultStatus GetStatus() const;
     Loader::ResultStatus GetProgramNCAStatus() const;
@@ -72,16 +64,11 @@ public:
     u8 GetFormatVersion() const;
 
     VirtualDir GetPartition(XCIPartition partition) const;
-    std::shared_ptr<NSP> GetSecurePartitionNSP() const;
     VirtualDir GetSecurePartition() const;
     VirtualDir GetNormalPartition() const;
     VirtualDir GetUpdatePartition() const;
     VirtualDir GetLogoPartition() const;
 
-    u64 GetProgramTitleID() const;
-
-    std::shared_ptr<NCA> GetProgramNCA() const;
-    VirtualFile GetProgramNCAFile() const;
     const std::vector<std::shared_ptr<NCA>>& GetNCAs() const;
     std::shared_ptr<NCA> GetNCAByType(NCAContentType type) const;
     VirtualFile GetNCAFileByType(NCAContentType type) const;
@@ -107,8 +94,6 @@ private:
     Loader::ResultStatus program_nca_status;
 
     std::vector<VirtualDir> partitions;
-    std::shared_ptr<NSP> secure_partition;
-    std::shared_ptr<NCA> program;
     std::vector<std::shared_ptr<NCA>> ncas;
 };
 } // namespace FileSys

src/core/file_sys/content_archive.cpp

@@ -3,17 +3,12 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <cstring>
 #include <utility>
-
 #include <boost/optional.hpp>
-
 #include "common/logging/log.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/ctr_encryption_layer.h"
 #include "core/file_sys/content_archive.h"
-#include "core/file_sys/nca_patch.h"
-#include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/romfs.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/loader/loader.h"
@@ -69,31 +64,10 @@ struct RomFSSuperblock {
 };
 static_assert(sizeof(RomFSSuperblock) == 0x200, "RomFSSuperblock has incorrect size.");
 
-struct BKTRHeader {
-    u64_le offset;
-    u64_le size;
-    u32_le magic;
-    INSERT_PADDING_BYTES(0x4);
-    u32_le number_entries;
-    INSERT_PADDING_BYTES(0x4);
-};
-static_assert(sizeof(BKTRHeader) == 0x20, "BKTRHeader has incorrect size.");
-
-struct BKTRSuperblock {
-    NCASectionHeaderBlock header_block;
-    IVFCHeader ivfc;
-    INSERT_PADDING_BYTES(0x18);
-    BKTRHeader relocation;
-    BKTRHeader subsection;
-    INSERT_PADDING_BYTES(0xC0);
-};
-static_assert(sizeof(BKTRSuperblock) == 0x200, "BKTRSuperblock has incorrect size.");
-
 union NCASectionHeader {
     NCASectionRaw raw;
     PFS0Superblock pfs0;
     RomFSSuperblock romfs;
-    BKTRSuperblock bktr;
 };
 static_assert(sizeof(NCASectionHeader) == 0x200, "NCASectionHeader has incorrect size.");
 
@@ -126,7 +100,7 @@ boost::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType ty
     Core::Crypto::Key128 out;
     if (type == NCASectionCryptoType::XTS)
         std::copy(key_area.begin(), key_area.begin() + 0x10, out.begin());
-    else if (type == NCASectionCryptoType::CTR || type == NCASectionCryptoType::BKTR)
+    else if (type == NCASectionCryptoType::CTR)
         std::copy(key_area.begin() + 0x20, key_area.begin() + 0x30, out.begin());
     else
         LOG_CRITICAL(Crypto, "Called GetKeyAreaKey on invalid NCASectionCryptoType type={:02X}",
@@ -176,9 +150,6 @@ VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting
         LOG_DEBUG(Crypto, "called with mode=NONE");
         return in;
     case NCASectionCryptoType::CTR:
-    // During normal BKTR decryption, this entire function is skipped. This is for the metadata,
-    // which uses the same CTR as usual.
-    case NCASectionCryptoType::BKTR:
         LOG_DEBUG(Crypto, "called with mode=CTR, starting_offset={:016X}", starting_offset);
         {
             boost::optional<Core::Crypto::Key128> key = boost::none;
@@ -215,9 +186,7 @@ VirtualFile NCA::Decrypt(NCASectionHeader s_header, VirtualFile in, u64 starting
     }
 }
 
-NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_offset)
-    : file(std::move(file_)),
-      bktr_base_romfs(bktr_base_romfs_ ? std::move(bktr_base_romfs_) : nullptr) {
+NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
     status = Loader::ResultStatus::Success;
 
     if (file == nullptr) {
@@ -292,21 +261,22 @@ NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_off
     is_update = std::find_if(sections.begin(), sections.end(), [](const NCASectionHeader& header) {
                     return header.raw.header.crypto_type == NCASectionCryptoType::BKTR;
                 }) != sections.end();
-    ivfc_offset = 0;
 
     for (std::ptrdiff_t i = 0; i < number_sections; ++i) {
         auto section = sections[i];
 
         if (section.raw.header.filesystem_type == NCASectionFilesystemType::ROMFS) {
-            const std::size_t base_offset =
-                header.section_tables[i].media_offset * MEDIA_OFFSET_MULTIPLIER;
-            ivfc_offset = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
-            const std::size_t romfs_offset = base_offset + ivfc_offset;
-            const std::size_t romfs_size = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].size;
-            auto raw = std::make_shared<OffsetVfsFile>(file, romfs_size, romfs_offset);
-            auto dec = Decrypt(section, raw, romfs_offset);
-
-            if (dec == nullptr) {
+            const size_t romfs_offset =
+                header.section_tables[i].media_offset * MEDIA_OFFSET_MULTIPLIER +
+                section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
+            const size_t romfs_size = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].size;
+            auto dec =
+                Decrypt(section, std::make_shared<OffsetVfsFile>(file, romfs_size, romfs_offset),
+                        romfs_offset);
+            if (dec != nullptr) {
+                files.push_back(std::move(dec));
+                romfs = files.back();
+            } else {
                 if (status != Loader::ResultStatus::Success)
                     return;
                 if (has_rights_id)
@@ -315,117 +285,6 @@ NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_off
                     status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
                 return;
             }
-
-            if (section.raw.header.crypto_type == NCASectionCryptoType::BKTR) {
-                if (section.bktr.relocation.magic != Common::MakeMagic('B', 'K', 'T', 'R') ||
-                    section.bktr.subsection.magic != Common::MakeMagic('B', 'K', 'T', 'R')) {
-                    status = Loader::ResultStatus::ErrorBadBKTRHeader;
-                    return;
-                }
-
-                if (section.bktr.relocation.offset + section.bktr.relocation.size !=
-                    section.bktr.subsection.offset) {
-                    status = Loader::ResultStatus::ErrorBKTRSubsectionNotAfterRelocation;
-                    return;
-                }
-
-                const u64 size =
-                    MEDIA_OFFSET_MULTIPLIER * (header.section_tables[i].media_end_offset -
-                                               header.section_tables[i].media_offset);
-                if (section.bktr.subsection.offset + section.bktr.subsection.size != size) {
-                    status = Loader::ResultStatus::ErrorBKTRSubsectionNotAtEnd;
-                    return;
-                }
-
-                const u64 offset = section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset;
-                RelocationBlock relocation_block{};
-                if (dec->ReadObject(&relocation_block, section.bktr.relocation.offset - offset) !=
-                    sizeof(RelocationBlock)) {
-                    status = Loader::ResultStatus::ErrorBadRelocationBlock;
-                    return;
-                }
-                SubsectionBlock subsection_block{};
-                if (dec->ReadObject(&subsection_block, section.bktr.subsection.offset - offset) !=
-                    sizeof(RelocationBlock)) {
-                    status = Loader::ResultStatus::ErrorBadSubsectionBlock;
-                    return;
-                }
-
-                std::vector<RelocationBucketRaw> relocation_buckets_raw(
-                    (section.bktr.relocation.size - sizeof(RelocationBlock)) /
-                    sizeof(RelocationBucketRaw));
-                if (dec->ReadBytes(relocation_buckets_raw.data(),
-                                   section.bktr.relocation.size - sizeof(RelocationBlock),
-                                   section.bktr.relocation.offset + sizeof(RelocationBlock) -
-                                       offset) !=
-                    section.bktr.relocation.size - sizeof(RelocationBlock)) {
-                    status = Loader::ResultStatus::ErrorBadRelocationBuckets;
-                    return;
-                }
-
-                std::vector<SubsectionBucketRaw> subsection_buckets_raw(
-                    (section.bktr.subsection.size - sizeof(SubsectionBlock)) /
-                    sizeof(SubsectionBucketRaw));
-                if (dec->ReadBytes(subsection_buckets_raw.data(),
-                                   section.bktr.subsection.size - sizeof(SubsectionBlock),
-                                   section.bktr.subsection.offset + sizeof(SubsectionBlock) -
-                                       offset) !=
-                    section.bktr.subsection.size - sizeof(SubsectionBlock)) {
-                    status = Loader::ResultStatus::ErrorBadSubsectionBuckets;
-                    return;
-                }
-
-                std::vector<RelocationBucket> relocation_buckets(relocation_buckets_raw.size());
-                std::transform(relocation_buckets_raw.begin(), relocation_buckets_raw.end(),
-                               relocation_buckets.begin(), &ConvertRelocationBucketRaw);
-                std::vector<SubsectionBucket> subsection_buckets(subsection_buckets_raw.size());
-                std::transform(subsection_buckets_raw.begin(), subsection_buckets_raw.end(),
-                               subsection_buckets.begin(), &ConvertSubsectionBucketRaw);
-
-                u32 ctr_low;
-                std::memcpy(&ctr_low, section.raw.section_ctr.data(), sizeof(ctr_low));
-                subsection_buckets.back().entries.push_back(
-                    {section.bktr.relocation.offset, {0}, ctr_low});
-                subsection_buckets.back().entries.push_back({size, {0}, 0});
-
-                boost::optional<Core::Crypto::Key128> key = boost::none;
-                if (encrypted) {
-                    if (has_rights_id) {
-                        status = Loader::ResultStatus::Success;
-                        key = GetTitlekey();
-                        if (key == boost::none) {
-                            status = Loader::ResultStatus::ErrorMissingTitlekey;
-                            return;
-                        }
-                    } else {
-                        key = GetKeyAreaKey(NCASectionCryptoType::BKTR);
-                        if (key == boost::none) {
-                            status = Loader::ResultStatus::ErrorMissingKeyAreaKey;
-                            return;
-                        }
-                    }
-                }
-
-                if (bktr_base_romfs == nullptr) {
-                    status = Loader::ResultStatus::ErrorMissingBKTRBaseRomFS;
-                    return;
-                }
-
-                auto bktr = std::make_shared<BKTR>(
-                    bktr_base_romfs, std::make_shared<OffsetVfsFile>(file, romfs_size, base_offset),
-                    relocation_block, relocation_buckets, subsection_block, subsection_buckets,
-                    encrypted, encrypted ? key.get() : Core::Crypto::Key128{}, base_offset,
-                    bktr_base_ivfc_offset, section.raw.section_ctr);
-
-                // BKTR applies to entire IVFC, so make an offset version to level 6
-
-                files.push_back(std::make_shared<OffsetVfsFile>(
-                    bktr, romfs_size, section.romfs.ivfc.levels[IVFC_MAX_LEVEL - 1].offset));
-                romfs = files.back();
-            } else {
-                files.push_back(std::move(dec));
-                romfs = files.back();
-            }
         } else if (section.raw.header.filesystem_type == NCASectionFilesystemType::PFS0) {
             u64 offset = (static_cast<u64>(header.section_tables[i].media_offset) *
                           MEDIA_OFFSET_MULTIPLIER) +
@@ -441,12 +300,6 @@ NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_off
                     dirs.push_back(std::move(npfs));
                     if (IsDirectoryExeFS(dirs.back()))
                         exefs = dirs.back();
-                } else {
-                    if (has_rights_id)
-                        status = Loader::ResultStatus::ErrorIncorrectTitlekeyOrTitlekek;
-                    else
-                        status = Loader::ResultStatus::ErrorIncorrectKeyAreaKey;
-                    return;
                 }
             } else {
                 if (status != Loader::ResultStatus::Success)
@@ -492,15 +345,11 @@ NCAContentType NCA::GetType() const {
 }
 
 u64 NCA::GetTitleId() const {
-    if (is_update || status == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS)
-        return header.title_id | 0x800;
+    if (status != Loader::ResultStatus::Success)
+        return {};
     return header.title_id;
 }
 
-bool NCA::IsUpdate() const {
-    return is_update;
-}
-
 VirtualFile NCA::GetRomFS() const {
     return romfs;
 }
@@ -513,8 +362,8 @@ VirtualFile NCA::GetBaseFile() const {
     return file;
 }
 
-u64 NCA::GetBaseIVFCOffset() const {
-    return ivfc_offset;
+bool NCA::IsUpdate() const {
+    return is_update;
 }
 
 bool NCA::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {

src/core/file_sys/content_archive.h

@@ -12,12 +12,10 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "control_metadata.h"
 #include "core/crypto/key_manager.h"
-#include "core/file_sys/vfs.h"
-
-namespace Loader {
-enum class ResultStatus : u16;
-}
+#include "core/file_sys/partition_filesystem.h"
+#include "core/loader/loader.h"
 
 namespace FileSys {
 
@@ -79,8 +77,7 @@ bool IsValidNCA(const NCAHeader& header);
 // After construction, use GetStatus to determine if the file is valid and ready to be used.
 class NCA : public ReadOnlyVfsDirectory {
 public:
-    explicit NCA(VirtualFile file, VirtualFile bktr_base_romfs = nullptr,
-                 u64 bktr_base_ivfc_offset = 0);
+    explicit NCA(VirtualFile file);
     Loader::ResultStatus GetStatus() const;
 
     std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
@@ -90,15 +87,13 @@ public:
 
     NCAContentType GetType() const;
     u64 GetTitleId() const;
-    bool IsUpdate() const;
 
     VirtualFile GetRomFS() const;
     VirtualDir GetExeFS() const;
 
     VirtualFile GetBaseFile() const;
 
-    // Returns the base ivfc offset used in BKTR patching.
-    u64 GetBaseIVFCOffset() const;
+    bool IsUpdate() const;
 
 protected:
     bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;
@@ -115,16 +110,14 @@ private:
     VirtualFile romfs = nullptr;
     VirtualDir exefs = nullptr;
     VirtualFile file;
-    VirtualFile bktr_base_romfs;
-    u64 ivfc_offset;
 
     NCAHeader header{};
     bool has_rights_id{};
+    bool is_update{};
 
     Loader::ResultStatus status{};
 
     bool encrypted;
-    bool is_update;
 
     Core::Crypto::KeyManager keys;
 };