service: Add missing headers inclusions where applicable

Gets rid of a few indirect inclusions.

.travis.yml

@@ -29,6 +29,19 @@ matrix:
       script: "./.travis/macos/build.sh"
       after_success: "./.travis/macos/upload.sh"
       cache: ccache
+    - os: linux
+      env: NAME="MinGW build"
+      sudo: required
+      dist: trusty
+      services: docker
+      addons:
+        apt:
+          packages:
+            - p7zip-full
+      install: "./.travis/linux-mingw/deps.sh"
+      script: "./.travis/linux-mingw/build.sh"
+      after_success: "./.travis/linux-mingw/upload.sh"
+      cache: ccache
 
 deploy:
   provider: releases

.travis/common/post-upload.sh

@@ -11,6 +11,9 @@ if [ -z $TRAVIS_TAG ]; then
     RELEASE_NAME=head
 else
     RELEASE_NAME=$(echo $TRAVIS_TAG | cut -d- -f1)
+    if [ "$NAME" = "MinGW build" ]; then
+        RELEASE_NAME="${RELEASE_NAME}-mingw"
+    fi
 fi
 
 mv "$REV_NAME" $RELEASE_NAME

.travis/linux-mingw/build.sh

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

.travis/linux-mingw/deps.sh

@@ -0,0 +1,3 @@
+#!/bin/sh -ex
+
+docker pull ubuntu:18.04

.travis/linux-mingw/docker.sh

@@ -0,0 +1,59 @@
+#!/bin/bash -ex
+
+cd /yuzu
+MINGW_PACKAGES="sdl2-mingw-w64 qt5base-mingw-w64 qt5tools-mingw-w64 libsamplerate-mingw-w64 qt5multimedia-mingw-w64"
+apt-get update
+apt-get install -y gpg wget git python3-pip python ccache g++-mingw-w64-x86-64 gcc-mingw-w64-x86-64 mingw-w64-tools cmake
+echo 'deb http://ppa.launchpad.net/tobydox/mingw-w64/ubuntu bionic main ' > /etc/apt/sources.list.d/extras.list
+apt-key adv --keyserver keyserver.ubuntu.com --recv '72931B477E22FEFD47F8DECE02FE5F12ADDE29B2'
+apt-get update
+apt-get install -y ${MINGW_PACKAGES}
+
+# fix a problem in current MinGW headers
+wget -q https://raw.githubusercontent.com/Alexpux/mingw-w64/d0d7f784833bbb0b2d279310ddc6afb52fe47a46/mingw-w64-headers/crt/errno.h -O /usr/x86_64-w64-mingw32/include/errno.h
+# override Travis CI unreasonable ccache size
+echo 'max_size = 3.0G' > "$HOME/.ccache/ccache.conf"
+
+# Dirty hack to trick unicorn makefile into believing we are in a MINGW system
+mv /bin/uname /bin/uname1 && echo -e '#!/bin/sh\necho MINGW64' >> /bin/uname
+chmod +x /bin/uname
+
+# Dirty hack to trick unicorn makefile into believing we have cmd
+echo '' >> /bin/cmd
+chmod +x /bin/cmd
+
+mkdir build && cd build
+cmake .. -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
+make -j4
+
+# Clean up the dirty hacks
+rm /bin/uname && mv /bin/uname1 /bin/uname
+rm /bin/cmd
+
+ccache -s
+
+echo "Tests skipped"
+#ctest -VV -C Release
+
+echo 'Prepare binaries...'
+cd ..
+mkdir package
+
+QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/'
+find build/ -name "yuzu*.exe" -exec cp {} 'package' \;
+
+# copy Qt plugins
+mkdir package/platforms
+cp "${QT_PLATFORM_DLL_PATH}/qwindows.dll" package/platforms/
+cp -rv "${QT_PLATFORM_DLL_PATH}/../mediaservice/" package/
+cp -rv "${QT_PLATFORM_DLL_PATH}/../imageformats/" package/
+rm -f package/mediaservice/*d.dll
+
+for i in package/*.exe; do
+  # we need to process pdb here, however, cv2pdb
+  # does not work here, so we just simply strip all the debug symbols
+  x86_64-w64-mingw32-strip "${i}"
+done
+
+pip3 install pefile
+python3 .travis/linux-mingw/scan_dll.py package/*.exe "package/"

.travis/linux-mingw/scan_dll.py

@@ -0,0 +1,106 @@
+import pefile
+import sys
+import re
+import os
+import queue
+import shutil
+
+# constant definitions
+KNOWN_SYS_DLLS = ['WINMM.DLL', 'MSVCRT.DLL', 'VERSION.DLL', 'MPR.DLL',
+                  'DWMAPI.DLL', 'UXTHEME.DLL', 'DNSAPI.DLL', 'IPHLPAPI.DLL']
+# below is for Ubuntu 18.04 with specified PPA enabled, if you are using
+# other distro or different repositories, change the following accordingly
+DLL_PATH = [
+    '/usr/x86_64-w64-mingw32/bin/',
+    '/usr/x86_64-w64-mingw32/lib/',
+    '/usr/lib/gcc/x86_64-w64-mingw32/7.3-posix/'
+]
+
+missing = []
+
+
+def parse_imports(file_name):
+    results = []
+    pe = pefile.PE(file_name, fast_load=True)
+    pe.parse_data_directories()
+
+    for entry in pe.DIRECTORY_ENTRY_IMPORT:
+        current = entry.dll.decode()
+        current_u = current.upper()  # b/c Windows is often case insensitive
+        # here we filter out system dlls
+        # dll w/ names like *32.dll are likely to be system dlls
+        if current_u.upper() not in KNOWN_SYS_DLLS and not re.match(string=current_u, pattern=r'.*32\.DLL'):
+            results.append(current)
+
+    return results
+
+
+def parse_imports_recursive(file_name, path_list=[]):
+    q = queue.Queue()  # create a FIFO queue
+    # file_name can be a string or a list for the convience
+    if isinstance(file_name, str):
+        q.put(file_name)
+    elif isinstance(file_name, list):
+        for i in file_name:
+            q.put(i)
+    full_list = []
+    while q.qsize():
+        current = q.get_nowait()
+        print('> %s' % current)
+        deps = parse_imports(current)
+        # if this dll does not have any import, ignore it
+        if not deps:
+            continue
+        for dep in deps:
+            # the dependency already included in the list, skip
+            if dep in full_list:
+                continue
+            # find the requested dll in the provided paths
+            full_path = find_dll(dep)
+            if not full_path:
+                missing.append(dep)
+                continue
+            full_list.append(dep)
+            q.put(full_path)
+            path_list.append(full_path)
+    return full_list
+
+
+def find_dll(name):
+    for path in DLL_PATH:
+        for root, _, files in os.walk(path):
+            for f in files:
+                if name.lower() == f.lower():
+                    return os.path.join(root, f)
+
+
+def deploy(name, dst, dry_run=False):
+    dlls_path = []
+    parse_imports_recursive(name, dlls_path)
+    for dll_entry in dlls_path:
+        if not dry_run:
+            shutil.copy(dll_entry, dst)
+        else:
+            print('[Dry-Run] Copy %s to %s' % (dll_entry, dst))
+    print('Deploy completed.')
+    return dlls_path
+
+
+def main():
+    if len(sys.argv) < 3:
+        print('Usage: %s [files to examine ...] [target deploy directory]')
+        return 1
+    to_deploy = sys.argv[1:-1]
+    tgt_dir = sys.argv[-1]
+    if not os.path.isdir(tgt_dir):
+        print('%s is not a directory.' % tgt_dir)
+        return 1
+    print('Scanning dependencies...')
+    deploy(to_deploy, tgt_dir)
+    if missing:
+        print('Following DLLs are not found: %s' % ('\n'.join(missing)))
+    return 0
+
+
+if __name__ == '__main__':
+    main()

.travis/linux-mingw/upload.sh

@@ -0,0 +1,13 @@
+#!/bin/bash -ex
+
+. .travis/common/pre-upload.sh
+
+REV_NAME="yuzu-windows-mingw-${GITDATE}-${GITREV}"
+ARCHIVE_NAME="${REV_NAME}.tar.gz"
+COMPRESSION_FLAGS="-czvf"
+
+mkdir "$REV_NAME"
+# get around the permission issues
+cp -r package/* "$REV_NAME"
+
+. .travis/common/post-upload.sh

.travis/linux/docker.sh

@@ -6,7 +6,9 @@ apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev
 cd /yuzu
 
 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
+cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -G Ninja
 ninja
 
+ccache -s
+
 ctest -VV -C Release

.travis/macos/build.sh

@@ -9,7 +9,9 @@ export PATH="/usr/local/opt/ccache/libexec:$PATH"
 
 mkdir build && cd build
 cmake --version
-cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON
+cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON
 make -j4
 
+ccache -s
+
 ctest -VV -C Release

CMakeLists.txt

@@ -269,10 +269,18 @@ if (YUZU_USE_BUNDLED_UNICORN)
 
         find_package(PythonInterp 2.7 REQUIRED)
 
-        add_custom_command(OUTPUT ${LIBUNICORN_LIBRARY}
-            COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" /bin/sh make.sh macos-universal-no
-            WORKING_DIRECTORY ${UNICORN_PREFIX}
-        )
+        if (MINGW)
+            add_custom_command(OUTPUT ${LIBUNICORN_LIBRARY}
+                COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" /bin/sh make.sh cross-win64
+                WORKING_DIRECTORY ${UNICORN_PREFIX}
+            )
+        else()
+            add_custom_command(OUTPUT ${LIBUNICORN_LIBRARY}
+                COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" /bin/sh make.sh macos-universal-no
+                WORKING_DIRECTORY ${UNICORN_PREFIX}
+            )
+        endif()
+
         # ALL makes this custom target build every time
         # but it won't actually build if LIBUNICORN_LIBRARY is up to date
         add_custom_target(unicorn-build ALL
@@ -286,6 +294,7 @@ endif()
 
 if (UNICORN_FOUND)
     add_library(unicorn INTERFACE)
+    add_dependencies(unicorn unicorn-build)
     target_link_libraries(unicorn INTERFACE "${LIBUNICORN_LIBRARY}")
     target_include_directories(unicorn INTERFACE "${LIBUNICORN_INCLUDE_DIR}")
 else()
@@ -431,8 +440,12 @@ 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)
+# Set yuzu project or yuzu-cmd project as default StartUp Project in Visual Studio depending on whether QT is enabled or not
+if(ENABLE_QT)
+    set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT yuzu)
+else()
+    set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT yuzu-cmd)
+endif()
 
 
 # Installation instructions

CMakeModules/MinGWCross.cmake

@@ -0,0 +1,54 @@
+set(MINGW_PREFIX   /usr/x86_64-w64-mingw32/)
+set(CMAKE_SYSTEM_NAME               Windows)
+set(CMAKE_SYSTEM_PROCESSOR           x86_64)
+# Actually a hack, w/o this will cause some strange errors
+set(CMAKE_HOST_WIN32                 TRUE)
+
+
+set(CMAKE_FIND_ROOT_PATH            ${MINGW_PREFIX})
+set(SDL2_PATH                       ${MINGW_PREFIX})
+set(MINGW_TOOL_PREFIX               ${CMAKE_SYSTEM_PROCESSOR}-w64-mingw32-)
+
+# Specify the cross compiler
+set(CMAKE_C_COMPILER            ${MINGW_TOOL_PREFIX}gcc-posix)
+set(CMAKE_CXX_COMPILER          ${MINGW_TOOL_PREFIX}g++-posix)
+set(CMAKE_RC_COMPILER           ${MINGW_TOOL_PREFIX}windres)
+
+# Mingw tools
+set(STRIP                       ${MINGW_TOOL_PREFIX}strip)
+set(WINDRES                     ${MINGW_TOOL_PREFIX}windres)
+set(ENV{PKG_CONFIG}             ${MINGW_TOOL_PREFIX}pkg-config)
+
+# ccache wrapper
+option(USE_CCACHE "Use ccache for compilation" OFF)
+if(USE_CCACHE)
+    find_program(CCACHE ccache)
+    if(CCACHE)
+        message(STATUS "Using ccache found in PATH")
+        set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE})
+        set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE})
+    else(CCACHE)
+        message(WARNING "USE_CCACHE enabled, but no ccache found")
+    endif(CCACHE)
+endif(USE_CCACHE)
+
+# Search for programs in the build host directories
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+
+
+# Echo modified cmake vars to screen for debugging purposes
+if(NOT DEFINED ENV{MINGW_DEBUG_INFO})
+        message("")
+        message("Custom cmake vars: (blank = system default)")
+        message("-----------------------------------------")
+        message("* CMAKE_C_COMPILER                     : ${CMAKE_C_COMPILER}")
+        message("* CMAKE_CXX_COMPILER                   : ${CMAKE_CXX_COMPILER}")
+        message("* CMAKE_RC_COMPILER                    : ${CMAKE_RC_COMPILER}")
+        message("* WINDRES                              : ${WINDRES}")
+        message("* ENV{PKG_CONFIG}                      : $ENV{PKG_CONFIG}")
+        message("* STRIP                                : ${STRIP}")
+        message("* USE_CCACHE                           : ${USE_CCACHE}")
+        message("")
+        # So that the debug info only appears once
+        set(ENV{MINGW_DEBUG_INFO} SHOWN)
+endif()

src/audio_core/audio_renderer.cpp

@@ -79,6 +79,10 @@ u32 AudioRenderer::GetMixBufferCount() const {
     return worker_params.mix_buffer_count;
 }
 
+u32 AudioRenderer::GetState() const {
+    return stream->GetState();
+}
+
 std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params) {
     // Copy UpdateDataHeader struct
     UpdateDataHeader config{};

src/audio_core/audio_renderer.h

@@ -170,6 +170,7 @@ public:
     u32 GetSampleRate() const;
     u32 GetSampleCount() const;
     u32 GetMixBufferCount() const;
+    u32 GetState() const;
 
 private:
     class VoiceState;

src/audio_core/stream.cpp

@@ -49,9 +49,14 @@ void Stream::Play() {
 }
 
 void Stream::Stop() {
+    state = State::Stopped;
     ASSERT_MSG(false, "Unimplemented");
 }
 
+u32 Stream::GetState() const {
+    return static_cast<u32>(state);
+}
+
 s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
     const std::size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
     return CoreTiming::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);

src/audio_core/stream.h

@@ -72,6 +72,9 @@ public:
     /// Gets the number of channels
     u32 GetNumChannels() const;
 
+    /// Get the state
+    u32 GetState() const;
+
 private:
     /// Current state of the stream
     enum class State {

src/audio_core/time_stretch.cpp

@@ -59,7 +59,7 @@ std::size_t TimeStretcher::Process(const s16* in, std::size_t num_in, s16* out,
     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,
+    LOG_TRACE(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));

src/common/logging/backend.cpp

@@ -183,6 +183,7 @@ void FileBackend::Write(const Entry& entry) {
     SUB(Service, FS)                                                                               \
     SUB(Service, GRC)                                                                              \
     SUB(Service, HID)                                                                              \
+    SUB(Service, IRS)                                                                              \
     SUB(Service, LBL)                                                                              \
     SUB(Service, LDN)                                                                              \
     SUB(Service, LDR)                                                                              \

src/common/logging/log.h

@@ -70,6 +70,7 @@ enum class Class : ClassType {
     Service_FS,        ///< The FS (Filesystem) service
     Service_GRC,       ///< The game recording service
     Service_HID,       ///< The HID (Human interface device) service
+    Service_IRS,       ///< The IRS service
     Service_LBL,       ///< The LBL (LCD backlight) service
     Service_LDN,       ///< The LDN (Local domain network) service
     Service_LDR,       ///< The loader service

src/common/ring_buffer.h

@@ -9,6 +9,7 @@
 #include <atomic>
 #include <cstddef>
 #include <cstring>
+#include <new>
 #include <type_traits>
 #include <vector>
 #include "common/common_types.h"
@@ -29,7 +30,7 @@ class RingBuffer {
     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);
+    static_assert(std::atomic_size_t::is_always_lock_free);
 
 public:
     /// Pushes slots into the ring buffer
@@ -102,8 +103,15 @@ public:
 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};
+    // TODO: Remove this ifdef whenever clang and GCC support
+    //       std::hardware_destructive_interference_size.
+#if defined(_MSC_VER) && _MSC_VER >= 1911
+    alignas(std::hardware_destructive_interference_size) std::atomic_size_t m_read_index{0};
+    alignas(std::hardware_destructive_interference_size) std::atomic_size_t m_write_index{0};
+#else
+    alignas(128) std::atomic_size_t m_read_index{0};
+    alignas(128) std::atomic_size_t m_write_index{0};
+#endif
 
     std::array<T, granularity * capacity> m_data;
 };

src/common/thread.h

@@ -87,14 +87,6 @@ private:
 
 void SleepCurrentThread(int ms);
 void SwitchCurrentThread(); // On Linux, this is equal to sleep 1ms
-
-// Use this function during a spin-wait to make the current thread
-// relax while another thread is working. This may be more efficient
-// than using events because event functions use kernel calls.
-inline void YieldCPU() {
-    std::this_thread::yield();
-}
-
 void SetCurrentThreadName(const char* name);
 
 } // namespace Common

src/core/arm/arm_interface.h

@@ -6,7 +6,10 @@
 
 #include <array>
 #include "common/common_types.h"
-#include "core/hle/kernel/vm_manager.h"
+
+namespace Kernel {
+enum class VMAPermission : u8;
+}
 
 namespace Core {
 

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -15,6 +15,7 @@
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc.h"
+#include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"
 
 namespace Core {

src/core/arm/dynarmic/arm_dynarmic.h

@@ -12,6 +12,10 @@
 #include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
 
+namespace Memory {
+struct PageTable;
+}
+
 namespace Core {
 
 class ARM_Dynarmic_Callbacks;

src/core/file_sys/content_archive.cpp

@@ -463,6 +463,8 @@ NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_off
     status = Loader::ResultStatus::Success;
 }
 
+NCA::~NCA() = default;
+
 Loader::ResultStatus NCA::GetStatus() const {
     return status;
 }

src/core/file_sys/content_archive.h

@@ -81,6 +81,8 @@ class NCA : public ReadOnlyVfsDirectory {
 public:
     explicit NCA(VirtualFile file, VirtualFile bktr_base_romfs = nullptr,
                  u64 bktr_base_ivfc_offset = 0);
+    ~NCA() override;
+
     Loader::ResultStatus GetStatus() const;
 
     std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;

src/core/file_sys/control_metadata.cpp

@@ -28,6 +28,8 @@ NACP::NACP(VirtualFile file) : raw(std::make_unique<RawNACP>()) {
     file->ReadObject(raw.get());
 }
 
+NACP::~NACP() = default;
+
 const LanguageEntry& NACP::GetLanguageEntry(Language language) const {
     if (language != Language::Default) {
         return raw->language_entries.at(static_cast<u8>(language));

src/core/file_sys/control_metadata.h

@@ -73,6 +73,8 @@ extern const std::array<const char*, 15> LANGUAGE_NAMES;
 class NACP {
 public:
     explicit NACP(VirtualFile file);
+    ~NACP();
+
     const LanguageEntry& GetLanguageEntry(Language language = Language::Default) const;
     std::string GetApplicationName(Language language = Language::Default) const;
     std::string GetDeveloperName(Language language = Language::Default) const;

src/core/file_sys/nca_metadata.cpp

@@ -51,6 +51,8 @@ CNMT::CNMT(CNMTHeader header, OptionalHeader opt_header, std::vector<ContentReco
     : header(std::move(header)), opt_header(std::move(opt_header)),
       content_records(std::move(content_records)), meta_records(std::move(meta_records)) {}
 
+CNMT::~CNMT() = default;
+
 u64 CNMT::GetTitleID() const {
     return header.title_id;
 }

src/core/file_sys/nca_metadata.h

@@ -87,6 +87,7 @@ public:
     explicit CNMT(VirtualFile file);
     CNMT(CNMTHeader header, OptionalHeader opt_header, std::vector<ContentRecord> content_records,
          std::vector<MetaRecord> meta_records);
+    ~CNMT();
 
     u64 GetTitleID() const;
     u32 GetTitleVersion() const;

src/core/file_sys/partition_filesystem.cpp

@@ -72,6 +72,8 @@ PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
     status = Loader::ResultStatus::Success;
 }
 
+PartitionFilesystem::~PartitionFilesystem() = default;
+
 Loader::ResultStatus PartitionFilesystem::GetStatus() const {
     return status;
 }

src/core/file_sys/partition_filesystem.h

@@ -25,6 +25,8 @@ namespace FileSys {
 class PartitionFilesystem : public ReadOnlyVfsDirectory {
 public:
     explicit PartitionFilesystem(std::shared_ptr<VfsFile> file);
+    ~PartitionFilesystem() override;
+
     Loader::ResultStatus GetStatus() const;
 
     std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;

src/core/file_sys/patch_manager.cpp

@@ -41,6 +41,8 @@ std::string FormatPatchTypeName(PatchType type) {
 
 PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}
 
+PatchManager::~PatchManager() = default;
+
 VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     LOG_INFO(Loader, "Patching ExeFS for title_id={:016X}", title_id);
 

src/core/file_sys/patch_manager.h

@@ -34,6 +34,7 @@ std::string FormatPatchTypeName(PatchType type);
 class PatchManager {
 public:
     explicit PatchManager(u64 title_id);
+    ~PatchManager();
 
     // Currently tracked ExeFS patches:
     // - Game Updates

src/core/file_sys/program_metadata.cpp

@@ -12,6 +12,10 @@
 
 namespace FileSys {
 
+ProgramMetadata::ProgramMetadata() = default;
+
+ProgramMetadata::~ProgramMetadata() = default;
+
 Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
     std::size_t total_size = static_cast<std::size_t>(file->GetSize());
     if (total_size < sizeof(Header))

src/core/file_sys/program_metadata.h

@@ -36,6 +36,9 @@ enum class ProgramFilePermission : u64 {
  */
 class ProgramMetadata {
 public:
+    ProgramMetadata();
+    ~ProgramMetadata();
+
     Loader::ResultStatus Load(VirtualFile file);
 
     bool Is64BitProgram() const;

src/core/file_sys/romfs_factory.cpp

@@ -28,6 +28,8 @@ RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
     ivfc_offset = app_loader.ReadRomFSIVFCOffset();
 }
 
+RomFSFactory::~RomFSFactory() = default;
+
 ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess() {
     if (!updatable)
         return MakeResult<VirtualFile>(file);

src/core/file_sys/romfs_factory.h

@@ -30,6 +30,7 @@ enum class StorageId : u8 {
 class RomFSFactory {
 public:
     explicit RomFSFactory(Loader::AppLoader& app_loader);
+    ~RomFSFactory();
 
     ResultVal<VirtualFile> OpenCurrentProcess();
     ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type);

src/core/file_sys/savedata_factory.cpp

@@ -20,6 +20,8 @@ std::string SaveDataDescriptor::DebugInfo() const {
 
 SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {}
 
+SaveDataFactory::~SaveDataFactory() = default;
+
 ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, SaveDataDescriptor meta) {
     if (meta.type == SaveDataType::SystemSaveData || meta.type == SaveDataType::SaveData) {
         if (meta.zero_1 != 0) {

src/core/file_sys/savedata_factory.h

@@ -48,6 +48,7 @@ static_assert(sizeof(SaveDataDescriptor) == 0x40, "SaveDataDescriptor has incorr
 class SaveDataFactory {
 public:
     explicit SaveDataFactory(VirtualDir dir);
+    ~SaveDataFactory();
 
     ResultVal<VirtualDir> Open(SaveDataSpaceId space, SaveDataDescriptor meta);
 

src/core/file_sys/submission_package.h

@@ -24,7 +24,7 @@ enum class ContentRecordType : u8;
 class NSP : public ReadOnlyVfsDirectory {
 public:
     explicit NSP(VirtualFile file);
-    ~NSP();
+    ~NSP() override;
 
     Loader::ResultStatus GetStatus() const;
     Loader::ResultStatus GetProgramStatus(u64 title_id) const;

src/core/file_sys/vfs_concat.cpp

@@ -27,6 +27,8 @@ ConcatenatedVfsFile::ConcatenatedVfsFile(std::vector<VirtualFile> files_, std::s
     }
 }
 
+ConcatenatedVfsFile::~ConcatenatedVfsFile() = default;
+
 std::string ConcatenatedVfsFile::GetName() const {
     if (files.empty())
         return "";

src/core/file_sys/vfs_concat.h

@@ -22,6 +22,8 @@ class ConcatenatedVfsFile : public VfsFile {
     ConcatenatedVfsFile(std::vector<VirtualFile> files, std::string name);
 
 public:
+    ~ConcatenatedVfsFile() override;
+
     std::string GetName() const override;
     std::size_t GetSize() const override;
     bool Resize(std::size_t new_size) override;

src/core/file_sys/vfs_offset.cpp

@@ -14,6 +14,8 @@ OffsetVfsFile::OffsetVfsFile(std::shared_ptr<VfsFile> file_, std::size_t size_,
     : file(file_), offset(offset_), size(size_), name(std::move(name_)),
       parent(parent_ == nullptr ? file->GetContainingDirectory() : std::move(parent_)) {}
 
+OffsetVfsFile::~OffsetVfsFile() = default;
+
 std::string OffsetVfsFile::GetName() const {
     return name.empty() ? file->GetName() : name;
 }

src/core/file_sys/vfs_offset.h

@@ -19,6 +19,7 @@ class OffsetVfsFile : public VfsFile {
 public:
     OffsetVfsFile(std::shared_ptr<VfsFile> file, std::size_t size, std::size_t offset = 0,
                   std::string new_name = "", VirtualDir new_parent = nullptr);
+    ~OffsetVfsFile() override;
 
     std::string GetName() const override;
     std::size_t GetSize() const override;

src/core/file_sys/vfs_vector.cpp

@@ -13,6 +13,8 @@ VectorVfsDirectory::VectorVfsDirectory(std::vector<VirtualFile> files_,
     : files(std::move(files_)), dirs(std::move(dirs_)), parent(std::move(parent_)),
       name(std::move(name_)) {}
 
+VectorVfsDirectory::~VectorVfsDirectory() = default;
+
 std::vector<std::shared_ptr<VfsFile>> VectorVfsDirectory::GetFiles() const {
     return files;
 }

src/core/file_sys/vfs_vector.h

@@ -15,6 +15,7 @@ public:
     explicit VectorVfsDirectory(std::vector<VirtualFile> files = {},
                                 std::vector<VirtualDir> dirs = {}, std::string name = "",
                                 VirtualDir parent = nullptr);
+    ~VectorVfsDirectory() override;
 
     std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
     std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;

src/core/file_sys/xts_archive.cpp

@@ -69,6 +69,8 @@ NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
                                Common::HexArrayToString(nca_id, false)));
 }
 
+NAX::~NAX() = default;
+
 Loader::ResultStatus NAX::Parse(std::string_view path) {
     if (file->ReadObject(header.get()) != sizeof(NAXHeader))
         return Loader::ResultStatus::ErrorBadNAXHeader;

src/core/file_sys/xts_archive.h

@@ -33,6 +33,7 @@ class NAX : public ReadOnlyVfsDirectory {
 public:
     explicit NAX(VirtualFile file);
     explicit NAX(VirtualFile file, std::array<u8, 0x10> nca_id);
+    ~NAX() override;
 
     Loader::ResultStatus GetStatus() const;
 

src/core/hle/kernel/mutex.cpp

@@ -16,6 +16,7 @@
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/result.h"
+#include "core/memory.h"
 
 namespace Kernel {
 

src/core/hle/kernel/process.cpp

@@ -7,10 +7,12 @@
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
+#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"
@@ -125,7 +127,92 @@ void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) {
     vm_manager.LogLayout();
     status = ProcessStatus::Running;
 
-    Kernel::SetupMainThread(kernel, entry_point, main_thread_priority, this);
+    Kernel::SetupMainThread(kernel, entry_point, main_thread_priority, *this);
+}
+
+void Process::PrepareForTermination() {
+    status = ProcessStatus::Exited;
+
+    const auto stop_threads = [this](const std::vector<SharedPtr<Thread>>& thread_list) {
+        for (auto& thread : thread_list) {
+            if (thread->owner_process != this)
+                continue;
+
+            if (thread == GetCurrentThread())
+                continue;
+
+            // TODO(Subv): When are the other running/ready threads terminated?
+            ASSERT_MSG(thread->status == ThreadStatus::WaitSynchAny ||
+                           thread->status == ThreadStatus::WaitSynchAll,
+                       "Exiting processes with non-waiting threads is currently unimplemented");
+
+            thread->Stop();
+        }
+    };
+
+    auto& system = Core::System::GetInstance();
+    stop_threads(system.Scheduler(0)->GetThreadList());
+    stop_threads(system.Scheduler(1)->GetThreadList());
+    stop_threads(system.Scheduler(2)->GetThreadList());
+    stop_threads(system.Scheduler(3)->GetThreadList());
+}
+
+/**
+ * Finds a free location for the TLS section of a thread.
+ * @param tls_slots The TLS page array of the thread's owner process.
+ * Returns a tuple of (page, slot, alloc_needed) where:
+ * page: The index of the first allocated TLS page that has free slots.
+ * slot: The index of the first free slot in the indicated page.
+ * alloc_needed: Whether there's a need to allocate a new TLS page (All pages are full).
+ */
+static std::tuple<std::size_t, std::size_t, bool> FindFreeThreadLocalSlot(
+    const std::vector<std::bitset<8>>& tls_slots) {
+    // Iterate over all the allocated pages, and try to find one where not all slots are used.
+    for (std::size_t page = 0; page < tls_slots.size(); ++page) {
+        const auto& page_tls_slots = tls_slots[page];
+        if (!page_tls_slots.all()) {
+            // We found a page with at least one free slot, find which slot it is
+            for (std::size_t slot = 0; slot < page_tls_slots.size(); ++slot) {
+                if (!page_tls_slots.test(slot)) {
+                    return std::make_tuple(page, slot, false);
+                }
+            }
+        }
+    }
+
+    return std::make_tuple(0, 0, true);
+}
+
+VAddr Process::MarkNextAvailableTLSSlotAsUsed(Thread& thread) {
+    auto [available_page, available_slot, needs_allocation] = FindFreeThreadLocalSlot(tls_slots);
+
+    if (needs_allocation) {
+        tls_slots.emplace_back(0); // The page is completely available at the start
+        available_page = tls_slots.size() - 1;
+        available_slot = 0; // Use the first slot in the new page
+
+        // Allocate some memory from the end of the linear heap for this region.
+        auto& tls_memory = thread.GetTLSMemory();
+        tls_memory->insert(tls_memory->end(), Memory::PAGE_SIZE, 0);
+
+        vm_manager.RefreshMemoryBlockMappings(tls_memory.get());
+
+        vm_manager.MapMemoryBlock(Memory::TLS_AREA_VADDR + available_page * Memory::PAGE_SIZE,
+                                  tls_memory, 0, Memory::PAGE_SIZE, MemoryState::ThreadLocal);
+    }
+
+    tls_slots[available_page].set(available_slot);
+
+    return Memory::TLS_AREA_VADDR + available_page * Memory::PAGE_SIZE +
+           available_slot * Memory::TLS_ENTRY_SIZE;
+}
+
+void Process::FreeTLSSlot(VAddr tls_address) {
+    const VAddr tls_base = tls_address - Memory::TLS_AREA_VADDR;
+    const VAddr tls_page = tls_base / Memory::PAGE_SIZE;
+    const VAddr tls_slot = (tls_base % Memory::PAGE_SIZE) / Memory::TLS_ENTRY_SIZE;
+
+    tls_slots[tls_page].reset(tls_slot);
 }
 
 void Process::LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr) {

src/core/hle/kernel/process.h

@@ -131,6 +131,16 @@ public:
         return HANDLE_TYPE;
     }
 
+    /// Gets the current status of the process
+    ProcessStatus GetStatus() const {
+        return status;
+    }
+
+    /// Gets the unique ID that identifies this particular process.
+    u32 GetProcessID() const {
+        return process_id;
+    }
+
     /// Title ID corresponding to the process
     u64 program_id;
 
@@ -154,11 +164,6 @@ public:
     u32 allowed_processor_mask = THREADPROCESSORID_DEFAULT_MASK;
     u32 allowed_thread_priority_mask = 0xFFFFFFFF;
     u32 is_virtual_address_memory_enabled = 0;
-    /// Current status of the process
-    ProcessStatus status;
-
-    /// The ID of this process
-    u32 process_id = 0;
 
     /**
      * Parses a list of kernel capability descriptors (as found in the ExHeader) and applies them
@@ -171,13 +176,42 @@ public:
      */
     void Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size);
 
+    /**
+     * Prepares a process for termination by stopping all of its threads
+     * and clearing any other resources.
+     */
+    void PrepareForTermination();
+
     void LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr);
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // Memory Management
 
+    // Marks the next available region as used and returns the address of the slot.
+    VAddr MarkNextAvailableTLSSlotAsUsed(Thread& thread);
+
+    // Frees a used TLS slot identified by the given address
+    void FreeTLSSlot(VAddr tls_address);
+
+    ResultVal<VAddr> HeapAllocate(VAddr target, u64 size, VMAPermission perms);
+    ResultCode HeapFree(VAddr target, u32 size);
+
+    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size);
+
+    ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size);
+
     VMManager vm_manager;
 
+private:
+    explicit Process(KernelCore& kernel);
+    ~Process() override;
+
+    /// Current status of the process
+    ProcessStatus status;
+
+    /// The ID of this process
+    u32 process_id = 0;
+
     // Memory used to back the allocations in the regular heap. A single vector is used to cover
     // the entire virtual address space extents that bound the allocations, including any holes.
     // This makes deallocation and reallocation of holes fast and keeps process memory contiguous
@@ -197,17 +231,6 @@ public:
     std::vector<std::bitset<8>> tls_slots;
 
     std::string name;
-
-    ResultVal<VAddr> HeapAllocate(VAddr target, u64 size, VMAPermission perms);
-    ResultCode HeapFree(VAddr target, u32 size);
-
-    ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size);
-
-    ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size);
-
-private:
-    explicit Process(KernelCore& kernel);
-    ~Process() override;
 };
 
 } // namespace Kernel

src/core/hle/kernel/svc.cpp

@@ -169,7 +169,7 @@ static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
         return ERR_INVALID_HANDLE;
     }
 
-    *process_id = process->process_id;
+    *process_id = process->GetProcessID();
     return RESULT_SUCCESS;
 }
 
@@ -530,35 +530,13 @@ static ResultCode QueryMemory(MemoryInfo* memory_info, PageInfo* page_info, VAdd
 
 /// Exits the current process
 static void ExitProcess() {
-    LOG_INFO(Kernel_SVC, "Process {} exiting", Core::CurrentProcess()->process_id);
+    auto& current_process = Core::CurrentProcess();
 
-    ASSERT_MSG(Core::CurrentProcess()->status == ProcessStatus::Running,
+    LOG_INFO(Kernel_SVC, "Process {} exiting", current_process->GetProcessID());
+    ASSERT_MSG(current_process->GetStatus() == ProcessStatus::Running,
                "Process has already exited");
 
-    Core::CurrentProcess()->status = ProcessStatus::Exited;
-
-    auto stop_threads = [](const std::vector<SharedPtr<Thread>>& thread_list) {
-        for (auto& thread : thread_list) {
-            if (thread->owner_process != Core::CurrentProcess())
-                continue;
-
-            if (thread == GetCurrentThread())
-                continue;
-
-            // TODO(Subv): When are the other running/ready threads terminated?
-            ASSERT_MSG(thread->status == ThreadStatus::WaitSynchAny ||
-                           thread->status == ThreadStatus::WaitSynchAll,
-                       "Exiting processes with non-waiting threads is currently unimplemented");
-
-            thread->Stop();
-        }
-    };
-
-    auto& system = Core::System::GetInstance();
-    stop_threads(system.Scheduler(0)->GetThreadList());
-    stop_threads(system.Scheduler(1)->GetThreadList());
-    stop_threads(system.Scheduler(2)->GetThreadList());
-    stop_threads(system.Scheduler(3)->GetThreadList());
+    current_process->PrepareForTermination();
 
     // Kill the current thread
     GetCurrentThread()->Stop();
@@ -1039,7 +1017,7 @@ static const FunctionDef SVC_Table[] = {
     {0x2B, nullptr, "FlushDataCache"},
     {0x2C, nullptr, "MapPhysicalMemory"},
     {0x2D, nullptr, "UnmapPhysicalMemory"},
-    {0x2E, nullptr, "GetNextThreadInfo"},
+    {0x2E, nullptr, "GetFutureThreadInfo"},
     {0x2F, nullptr, "GetLastThreadInfo"},
     {0x30, nullptr, "GetResourceLimitLimitValue"},
     {0x31, nullptr, "GetResourceLimitCurrentValue"},
@@ -1065,11 +1043,11 @@ static const FunctionDef SVC_Table[] = {
     {0x45, nullptr, "CreateEvent"},
     {0x46, nullptr, "Unknown"},
     {0x47, nullptr, "Unknown"},
-    {0x48, nullptr, "AllocateUnsafeMemory"},
-    {0x49, nullptr, "FreeUnsafeMemory"},
-    {0x4A, nullptr, "SetUnsafeAllocationLimit"},
-    {0x4B, nullptr, "CreateJitMemory"},
-    {0x4C, nullptr, "MapJitMemory"},
+    {0x48, nullptr, "MapPhysicalMemoryUnsafe"},
+    {0x49, nullptr, "UnmapPhysicalMemoryUnsafe"},
+    {0x4A, nullptr, "SetUnsafeLimit"},
+    {0x4B, nullptr, "CreateCodeMemory"},
+    {0x4C, nullptr, "ControlCodeMemory"},
     {0x4D, nullptr, "SleepSystem"},
     {0x4E, nullptr, "ReadWriteRegister"},
     {0x4F, nullptr, "SetProcessActivity"},
@@ -1104,7 +1082,7 @@ static const FunctionDef SVC_Table[] = {
     {0x6C, nullptr, "SetHardwareBreakPoint"},
     {0x6D, nullptr, "GetDebugThreadParam"},
     {0x6E, nullptr, "Unknown"},
-    {0x6F, nullptr, "GetMemoryInfo"},
+    {0x6F, nullptr, "GetSystemInfo"},
     {0x70, nullptr, "CreatePort"},
     {0x71, nullptr, "ManageNamedPort"},
     {0x72, nullptr, "ConnectToPort"},

src/core/hle/kernel/thread.cpp

@@ -65,10 +65,7 @@ void Thread::Stop() {
     wait_objects.clear();
 
     // Mark the TLS slot in the thread's page as free.
-    const u64 tls_page = (tls_address - Memory::TLS_AREA_VADDR) / Memory::PAGE_SIZE;
-    const u64 tls_slot =
-        ((tls_address - Memory::TLS_AREA_VADDR) % Memory::PAGE_SIZE) / Memory::TLS_ENTRY_SIZE;
-    Core::CurrentProcess()->tls_slots[tls_page].reset(tls_slot);
+    owner_process->FreeTLSSlot(tls_address);
 }
 
 void WaitCurrentThread_Sleep() {
@@ -177,32 +174,6 @@ void Thread::ResumeFromWait() {
     Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
 }
 
-/**
- * Finds a free location for the TLS section of a thread.
- * @param tls_slots The TLS page array of the thread's owner process.
- * Returns a tuple of (page, slot, alloc_needed) where:
- * page: The index of the first allocated TLS page that has free slots.
- * slot: The index of the first free slot in the indicated page.
- * alloc_needed: Whether there's a need to allocate a new TLS page (All pages are full).
- */
-static std::tuple<std::size_t, std::size_t, bool> GetFreeThreadLocalSlot(
-    const std::vector<std::bitset<8>>& tls_slots) {
-    // Iterate over all the allocated pages, and try to find one where not all slots are used.
-    for (std::size_t page = 0; page < tls_slots.size(); ++page) {
-        const auto& page_tls_slots = tls_slots[page];
-        if (!page_tls_slots.all()) {
-            // We found a page with at least one free slot, find which slot it is
-            for (std::size_t slot = 0; slot < page_tls_slots.size(); ++slot) {
-                if (!page_tls_slots.test(slot)) {
-                    return std::make_tuple(page, slot, false);
-                }
-            }
-        }
-    }
-
-    return std::make_tuple(0, 0, true);
-}
-
 /**
  * Resets a thread context, making it ready to be scheduled and run by the CPU
  * @param context Thread context to reset
@@ -264,32 +235,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
     thread->owner_process = owner_process;
     thread->scheduler = Core::System::GetInstance().Scheduler(processor_id);
     thread->scheduler->AddThread(thread, priority);
-
-    // Find the next available TLS index, and mark it as used
-    auto& tls_slots = owner_process->tls_slots;
-
-    auto [available_page, available_slot, needs_allocation] = GetFreeThreadLocalSlot(tls_slots);
-    if (needs_allocation) {
-        tls_slots.emplace_back(0); // The page is completely available at the start
-        available_page = tls_slots.size() - 1;
-        available_slot = 0; // Use the first slot in the new page
-
-        // Allocate some memory from the end of the linear heap for this region.
-        const std::size_t offset = thread->tls_memory->size();
-        thread->tls_memory->insert(thread->tls_memory->end(), Memory::PAGE_SIZE, 0);
-
-        auto& vm_manager = owner_process->vm_manager;
-        vm_manager.RefreshMemoryBlockMappings(thread->tls_memory.get());
-
-        vm_manager.MapMemoryBlock(Memory::TLS_AREA_VADDR + available_page * Memory::PAGE_SIZE,
-                                  thread->tls_memory, 0, Memory::PAGE_SIZE,
-                                  MemoryState::ThreadLocal);
-    }
-
-    // Mark the slot as used
-    tls_slots[available_page].set(available_slot);
-    thread->tls_address = Memory::TLS_AREA_VADDR + available_page * Memory::PAGE_SIZE +
-                          available_slot * Memory::TLS_ENTRY_SIZE;
+    thread->tls_address = thread->owner_process->MarkNextAvailableTLSSlotAsUsed(*thread);
 
     // TODO(peachum): move to ScheduleThread() when scheduler is added so selected core is used
     // to initialize the context
@@ -311,13 +257,13 @@ void Thread::BoostPriority(u32 priority) {
 }
 
 SharedPtr<Thread> SetupMainThread(KernelCore& kernel, VAddr entry_point, u32 priority,
-                                  SharedPtr<Process> owner_process) {
+                                  Process& owner_process) {
     // Setup page table so we can write to memory
-    SetCurrentPageTable(&Core::CurrentProcess()->vm_manager.page_table);
+    SetCurrentPageTable(&owner_process.vm_manager.page_table);
 
     // Initialize new "main" thread
     auto thread_res = Thread::Create(kernel, "main", entry_point, priority, 0, THREADPROCESSORID_0,
-                                     Memory::STACK_AREA_VADDR_END, std::move(owner_process));
+                                     Memory::STACK_AREA_VADDR_END, &owner_process);
 
     SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
 

src/core/hle/kernel/thread.h

@@ -62,6 +62,9 @@ enum class ThreadWakeupReason {
 
 class Thread final : public WaitObject {
 public:
+    using TLSMemory = std::vector<u8>;
+    using TLSMemoryPtr = std::shared_ptr<TLSMemory>;
+
     /**
      * Creates and returns a new thread. The new thread is immediately scheduled
      * @param kernel The kernel instance this thread will be created under.
@@ -134,6 +137,14 @@ public:
         return thread_id;
     }
 
+    TLSMemoryPtr& GetTLSMemory() {
+        return tls_memory;
+    }
+
+    const TLSMemoryPtr& GetTLSMemory() const {
+        return tls_memory;
+    }
+
     /**
      * Resumes a thread from waiting
      */
@@ -269,7 +280,7 @@ private:
     explicit Thread(KernelCore& kernel);
     ~Thread() override;
 
-    std::shared_ptr<std::vector<u8>> tls_memory = std::make_shared<std::vector<u8>>();
+    TLSMemoryPtr tls_memory = std::make_shared<TLSMemory>();
 };
 
 /**
@@ -281,7 +292,7 @@ private:
  * @return A shared pointer to the main thread
  */
 SharedPtr<Thread> SetupMainThread(KernelCore& kernel, VAddr entry_point, u32 priority,
-                                  SharedPtr<Process> owner_process);
+                                  Process& owner_process);
 
 /**
  * Gets the current thread

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

@@ -10,6 +10,7 @@
 #include "common/alignment.h"
 #include "common/common_funcs.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/hle_ipc.h"
@@ -25,7 +26,7 @@ public:
             {0, &IAudioRenderer::GetAudioRendererSampleRate, "GetAudioRendererSampleRate"},
             {1, &IAudioRenderer::GetAudioRendererSampleCount, "GetAudioRendererSampleCount"},
             {2, &IAudioRenderer::GetAudioRendererMixBufferCount, "GetAudioRendererMixBufferCount"},
-            {3, nullptr, "GetAudioRendererState"},
+            {3, &IAudioRenderer::GetAudioRendererState, "GetAudioRendererState"},
             {4, &IAudioRenderer::RequestUpdateAudioRenderer, "RequestUpdateAudioRenderer"},
             {5, &IAudioRenderer::StartAudioRenderer, "StartAudioRenderer"},
             {6, &IAudioRenderer::StopAudioRenderer, "StopAudioRenderer"},
@@ -62,6 +63,13 @@ private:
         LOG_DEBUG(Service_Audio, "called");
     }
 
+    void GetAudioRendererState(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push<u32>(renderer->GetState());
+        LOG_DEBUG(Service_Audio, "called");
+    }
+
     void GetAudioRendererMixBufferCount(Kernel::HLERequestContext& ctx) {
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);

src/core/hle/service/fatal/fatal.cpp

@@ -2,8 +2,17 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <array>
+#include <cstring>
+#include <ctime>
+#include <fmt/time.h>
+#include "common/file_util.h"
 #include "common/logging/log.h"
+#include "common/scm_rev.h"
+#include "common/swap.h"
+#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/process.h"
 #include "core/hle/service/fatal/fatal.h"
 #include "core/hle/service/fatal/fatal_p.h"
 #include "core/hle/service/fatal/fatal_u.h"
@@ -15,16 +24,142 @@ Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
 
 Module::Interface::~Interface() = default;
 
+struct FatalInfo {
+    std::array<u64_le, 31> registers{}; // TODO(ogniK): See if this actually is registers or
+                                        // not(find a game which has non zero valeus)
+    u64_le unk0{};
+    u64_le unk1{};
+    u64_le unk2{};
+    u64_le unk3{};
+    u64_le unk4{};
+    u64_le unk5{};
+    u64_le unk6{};
+
+    std::array<u64_le, 32> backtrace{};
+    u64_le unk7{};
+    u64_le unk8{};
+    u32_le backtrace_size{};
+    u32_le unk9{};
+    u32_le unk10{}; // TODO(ogniK): Is this even used or is it just padding?
+};
+static_assert(sizeof(FatalInfo) == 0x250, "FatalInfo is an invalid size");
+
+enum class FatalType : u32 {
+    ErrorReportAndScreen = 0,
+    ErrorReport = 1,
+    ErrorScreen = 2,
+};
+
+static void GenerateErrorReport(ResultCode error_code, const FatalInfo& info) {
+    const auto title_id = Core::CurrentProcess()->program_id;
+    std::string crash_report =
+        fmt::format("Yuzu {}-{} crash report\n"
+                    "Title ID:                        {:016x}\n"
+                    "Result:                          0x{:X} ({:04}-{:04d})\n"
+                    "\n",
+                    Common::g_scm_branch, Common::g_scm_desc, title_id, error_code.raw,
+                    2000 + static_cast<u32>(error_code.module.Value()),
+                    static_cast<u32>(error_code.description.Value()), info.unk8, info.unk7);
+    if (info.backtrace_size != 0x0) {
+        crash_report += "Registers:\n";
+        // TODO(ogniK): This is just a guess, find a game which actually has non zero values
+        for (size_t i = 0; i < info.registers.size(); i++) {
+            crash_report +=
+                fmt::format("    X[{:02d}]:                       {:016x}\n", i, info.registers[i]);
+        }
+        crash_report += fmt::format("    Unknown 0:                   {:016x}\n", info.unk0);
+        crash_report += fmt::format("    Unknown 1:                   {:016x}\n", info.unk1);
+        crash_report += fmt::format("    Unknown 2:                   {:016x}\n", info.unk2);
+        crash_report += fmt::format("    Unknown 3:                   {:016x}\n", info.unk3);
+        crash_report += fmt::format("    Unknown 4:                   {:016x}\n", info.unk4);
+        crash_report += fmt::format("    Unknown 5:                   {:016x}\n", info.unk5);
+        crash_report += fmt::format("    Unknown 6:                   {:016x}\n", info.unk6);
+        crash_report += "\nBacktrace:\n";
+        for (size_t i = 0; i < info.backtrace_size; i++) {
+            crash_report +=
+                fmt::format("    Backtrace[{:02d}]:               {:016x}\n", i, info.backtrace[i]);
+        }
+        crash_report += fmt::format("\nUnknown 7:                       0x{:016x}\n", info.unk7);
+        crash_report += fmt::format("Unknown 8:                       0x{:016x}\n", info.unk8);
+        crash_report += fmt::format("Unknown 9:                       0x{:016x}\n", info.unk9);
+        crash_report += fmt::format("Unknown 10:                      0x{:016x}\n", info.unk10);
+    }
+
+    LOG_ERROR(Service_Fatal, "{}", crash_report);
+
+    const std::string crashreport_dir =
+        FileUtil::GetUserPath(FileUtil::UserPath::LogDir) + "crash_logs";
+
+    if (!FileUtil::CreateFullPath(crashreport_dir)) {
+        LOG_ERROR(
+            Service_Fatal,
+            "Unable to create crash report directory. Possible log directory permissions issue.");
+        return;
+    }
+
+    const std::time_t t = std::time(nullptr);
+    const std::string crashreport_filename =
+        fmt::format("{}/{:016x}-{:%F-%H%M%S}.log", crashreport_dir, title_id, *std::localtime(&t));
+
+    auto file = FileUtil::IOFile(crashreport_filename, "wb");
+    if (file.IsOpen()) {
+        file.WriteString(crash_report);
+        LOG_ERROR(Service_Fatal, "Saving error report to {}", crashreport_filename);
+    } else {
+        LOG_ERROR(Service_Fatal, "Failed to save error report to {}", crashreport_filename);
+    }
+}
+
+static void ThrowFatalError(ResultCode error_code, FatalType fatal_type, const FatalInfo& info) {
+    LOG_ERROR(Service_Fatal, "Threw fatal error type {}", static_cast<u32>(fatal_type));
+    switch (fatal_type) {
+    case FatalType::ErrorReportAndScreen:
+        GenerateErrorReport(error_code, info);
+        [[fallthrough]];
+    case FatalType::ErrorScreen:
+        // Since we have no fatal:u error screen. We should just kill execution instead
+        ASSERT(false);
+        break;
+        // Should not throw a fatal screen but should generate an error report
+    case FatalType::ErrorReport:
+        GenerateErrorReport(error_code, info);
+        break;
+    };
+}
+
+void Module::Interface::ThrowFatal(Kernel::HLERequestContext& ctx) {
+    LOG_ERROR(Service_Fatal, "called");
+    IPC::RequestParser rp{ctx};
+    auto error_code = rp.Pop<ResultCode>();
+
+    ThrowFatalError(error_code, FatalType::ErrorScreen, {});
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
 void Module::Interface::ThrowFatalWithPolicy(Kernel::HLERequestContext& ctx) {
+    LOG_ERROR(Service_Fatal, "called");
     IPC::RequestParser rp(ctx);
-    u32 error_code = rp.Pop<u32>();
-    LOG_WARNING(Service_Fatal, "(STUBBED) called, error_code=0x{:X}", error_code);
+    auto error_code = rp.Pop<ResultCode>();
+    auto fatal_type = rp.PopEnum<FatalType>();
+
+    ThrowFatalError(error_code, fatal_type, {}); // No info is passed with ThrowFatalWithPolicy
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
 void Module::Interface::ThrowFatalWithCpuContext(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_Fatal, "(STUBBED) called");
+    LOG_ERROR(Service_Fatal, "called");
+    IPC::RequestParser rp(ctx);
+    auto error_code = rp.Pop<ResultCode>();
+    auto fatal_type = rp.PopEnum<FatalType>();
+    auto fatal_info = ctx.ReadBuffer();
+    FatalInfo info{};
+
+    ASSERT_MSG(fatal_info.size() == sizeof(FatalInfo), "Invalid fatal info buffer size!");
+    std::memcpy(&info, fatal_info.data(), sizeof(FatalInfo));
+
+    ThrowFatalError(error_code, fatal_type, info);
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }

src/core/hle/service/fatal/fatal.h

@@ -15,6 +15,7 @@ public:
         explicit Interface(std::shared_ptr<Module> module, const char* name);
         ~Interface() override;
 
+        void ThrowFatal(Kernel::HLERequestContext& ctx);
         void ThrowFatalWithPolicy(Kernel::HLERequestContext& ctx);
         void ThrowFatalWithCpuContext(Kernel::HLERequestContext& ctx);
 

src/core/hle/service/fatal/fatal_u.cpp

@@ -8,7 +8,7 @@ namespace Service::Fatal {
 
 Fatal_U::Fatal_U(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "fatal:u") {
     static const FunctionInfo functions[] = {
-        {0, nullptr, "ThrowFatal"},
+        {0, &Fatal_U::ThrowFatal, "ThrowFatal"},
         {1, &Fatal_U::ThrowFatalWithPolicy, "ThrowFatalWithPolicy"},
         {2, &Fatal_U::ThrowFatalWithCpuContext, "ThrowFatalWithCpuContext"},
     };

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

@@ -2,6 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/swap.h"
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/shared_memory.h"
 #include "core/hle/service/hid/irs.h"
 
 namespace Service::HID {
@@ -9,28 +14,145 @@ namespace Service::HID {
 IRS::IRS() : ServiceFramework{"irs"} {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {302, nullptr, "ActivateIrsensor"},
-        {303, nullptr, "DeactivateIrsensor"},
-        {304, nullptr, "GetIrsensorSharedMemoryHandle"},
-        {305, nullptr, "StopImageProcessor"},
-        {306, nullptr, "RunMomentProcessor"},
-        {307, nullptr, "RunClusteringProcessor"},
-        {308, nullptr, "RunImageTransferProcessor"},
-        {309, nullptr, "GetImageTransferProcessorState"},
-        {310, nullptr, "RunTeraPluginProcessor"},
-        {311, nullptr, "GetNpadIrCameraHandle"},
-        {312, nullptr, "RunPointingProcessor"},
-        {313, nullptr, "SuspendImageProcessor"},
-        {314, nullptr, "CheckFirmwareVersion"},
-        {315, nullptr, "SetFunctionLevel"},
-        {316, nullptr, "RunImageTransferExProcessor"},
-        {317, nullptr, "RunIrLedProcessor"},
-        {318, nullptr, "StopImageProcessorAsync"},
-        {319, nullptr, "ActivateIrsensorWithFunctionLevel"},
+        {302, &IRS::ActivateIrsensor, "ActivateIrsensor"},
+        {303, &IRS::DeactivateIrsensor, "DeactivateIrsensor"},
+        {304, &IRS::GetIrsensorSharedMemoryHandle, "GetIrsensorSharedMemoryHandle"},
+        {305, &IRS::StopImageProcessor, "StopImageProcessor"},
+        {306, &IRS::RunMomentProcessor, "RunMomentProcessor"},
+        {307, &IRS::RunClusteringProcessor, "RunClusteringProcessor"},
+        {308, &IRS::RunImageTransferProcessor, "RunImageTransferProcessor"},
+        {309, &IRS::GetImageTransferProcessorState, "GetImageTransferProcessorState"},
+        {310, &IRS::RunTeraPluginProcessor, "RunTeraPluginProcessor"},
+        {311, &IRS::GetNpadIrCameraHandle, "GetNpadIrCameraHandle"},
+        {312, &IRS::RunPointingProcessor, "RunPointingProcessor"},
+        {313, &IRS::SuspendImageProcessor, "SuspendImageProcessor"},
+        {314, &IRS::CheckFirmwareVersion, "CheckFirmwareVersion"},
+        {315, &IRS::SetFunctionLevel, "SetFunctionLevel"},
+        {316, &IRS::RunImageTransferExProcessor, "RunImageTransferExProcessor"},
+        {317, &IRS::RunIrLedProcessor, "RunIrLedProcessor"},
+        {318, &IRS::StopImageProcessorAsync, "StopImageProcessorAsync"},
+        {319, &IRS::ActivateIrsensorWithFunctionLevel, "ActivateIrsensorWithFunctionLevel"},
     };
     // clang-format on
 
     RegisterHandlers(functions);
+
+    auto& kernel = Core::System::GetInstance().Kernel();
+    shared_mem = Kernel::SharedMemory::Create(
+        kernel, nullptr, 0x8000, Kernel::MemoryPermission::ReadWrite,
+        Kernel::MemoryPermission::Read, 0, Kernel::MemoryRegion::BASE, "IRS:SharedMemory");
+}
+
+void IRS::ActivateIrsensor(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::DeactivateIrsensor(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::GetIrsensorSharedMemoryHandle(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushCopyObjects(shared_mem);
+    LOG_DEBUG(Service_IRS, "called");
+}
+
+void IRS::StopImageProcessor(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::RunMomentProcessor(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::RunClusteringProcessor(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::RunImageTransferProcessor(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::GetImageTransferProcessorState(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 5};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushRaw<u64>(CoreTiming::GetTicks());
+    rb.PushRaw<u32>(0);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::RunTeraPluginProcessor(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::GetNpadIrCameraHandle(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushRaw<u32>(device_handle);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::RunPointingProcessor(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::SuspendImageProcessor(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::CheckFirmwareVersion(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::SetFunctionLevel(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::RunImageTransferExProcessor(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::RunIrLedProcessor(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::StopImageProcessorAsync(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
+}
+
+void IRS::ActivateIrsensorWithFunctionLevel(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+    LOG_WARNING(Service_IRS, "(STUBBED) called");
 }
 
 IRS::~IRS() = default;

src/core/hle/service/hid/irs.h

@@ -4,14 +4,41 @@
 
 #pragma once
 
+#include "core/hle/kernel/object.h"
 #include "core/hle/service/service.h"
 
+namespace Kernel {
+class SharedMemory;
+}
+
 namespace Service::HID {
 
 class IRS final : public ServiceFramework<IRS> {
 public:
     explicit IRS();
     ~IRS() override;
+
+private:
+    void ActivateIrsensor(Kernel::HLERequestContext& ctx);
+    void DeactivateIrsensor(Kernel::HLERequestContext& ctx);
+    void GetIrsensorSharedMemoryHandle(Kernel::HLERequestContext& ctx);
+    void StopImageProcessor(Kernel::HLERequestContext& ctx);
+    void RunMomentProcessor(Kernel::HLERequestContext& ctx);
+    void RunClusteringProcessor(Kernel::HLERequestContext& ctx);
+    void RunImageTransferProcessor(Kernel::HLERequestContext& ctx);
+    void GetImageTransferProcessorState(Kernel::HLERequestContext& ctx);
+    void RunTeraPluginProcessor(Kernel::HLERequestContext& ctx);
+    void GetNpadIrCameraHandle(Kernel::HLERequestContext& ctx);
+    void RunPointingProcessor(Kernel::HLERequestContext& ctx);
+    void SuspendImageProcessor(Kernel::HLERequestContext& ctx);
+    void CheckFirmwareVersion(Kernel::HLERequestContext& ctx);
+    void SetFunctionLevel(Kernel::HLERequestContext& ctx);
+    void RunImageTransferExProcessor(Kernel::HLERequestContext& ctx);
+    void RunIrLedProcessor(Kernel::HLERequestContext& ctx);
+    void StopImageProcessorAsync(Kernel::HLERequestContext& ctx);
+    void ActivateIrsensorWithFunctionLevel(Kernel::HLERequestContext& ctx);
+    Kernel::SharedPtr<Kernel::SharedMemory> shared_mem;
+    const u32 device_handle{0xABCD};
 };
 
 class IRS_SYS final : public ServiceFramework<IRS_SYS> {

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

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/service/hid/hid.h"

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

@@ -31,7 +31,7 @@ public:
             {1, &IRequest::GetResult, "GetResult"},
             {2, &IRequest::GetSystemEventReadableHandles, "GetSystemEventReadableHandles"},
             {3, &IRequest::Cancel, "Cancel"},
-            {4, nullptr, "Submit"},
+            {4, &IRequest::Submit, "Submit"},
             {5, nullptr, "SetRequirement"},
             {6, nullptr, "SetRequirementPreset"},
             {8, nullptr, "SetPriority"},
@@ -61,11 +61,17 @@ public:
     }
 
 private:
+    void Submit(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_NIFM, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
     void GetRequestState(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_NIFM, "(STUBBED) called");
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(3);
+        rb.Push<u32>(0);
     }
 
     void GetResult(Kernel::HLERequestContext& ctx) {

src/core/hle/service/nim/nim.cpp

@@ -4,6 +4,7 @@
 
 #include <chrono>
 #include <ctime>
+#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/service/nim/nim.h"

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

@@ -2,8 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/client_session.h"
+#include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/session.h"
 #include "core/hle/service/sm/controller.h"
 

src/core/hle/service/ssl/ssl.cpp

@@ -103,6 +103,7 @@ public:
     }
 
 private:
+    u32 ssl_version{};
     void CreateContext(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_SSL, "(STUBBED) called");
 
@@ -112,10 +113,9 @@ private:
     }
 
     void SetInterfaceVersion(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_SSL, "(STUBBED) called");
+        LOG_DEBUG(Service_SSL, "called");
         IPC::RequestParser rp{ctx};
-        u32 unk1 = rp.Pop<u32>(); // Probably minor/major?
-        u32 unk2 = rp.Pop<u32>(); // TODO(ogniK): Figure out what this does
+        ssl_version = rp.Pop<u32>();
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);

src/core/loader/nso.cpp

@@ -32,11 +32,18 @@ static_assert(sizeof(NsoSegmentHeader) == 0x10, "NsoSegmentHeader has incorrect
 
 struct NsoHeader {
     u32_le magic;
-    INSERT_PADDING_BYTES(0xc);
+    u32_le version;
+    INSERT_PADDING_WORDS(1);
+    u8 flags;
     std::array<NsoSegmentHeader, 3> segments; // Text, RoData, Data (in that order)
     u32_le bss_size;
     INSERT_PADDING_BYTES(0x1c);
     std::array<u32_le, 3> segments_compressed_size;
+
+    bool IsSegmentCompressed(size_t segment_num) const {
+        ASSERT_MSG(segment_num < 3, "Invalid segment {}", segment_num);
+        return ((flags >> segment_num) & 1);
+    }
 };
 static_assert(sizeof(NsoHeader) == 0x6c, "NsoHeader has incorrect size.");
 static_assert(std::is_trivially_copyable_v<NsoHeader>, "NsoHeader isn't trivially copyable.");
@@ -105,9 +112,11 @@ VAddr AppLoader_NSO::LoadModule(FileSys::VirtualFile file, VAddr load_base) {
     Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create(kernel, "");
     std::vector<u8> program_image;
     for (std::size_t i = 0; i < nso_header.segments.size(); ++i) {
-        const std::vector<u8> compressed_data =
+        std::vector<u8> data =
             file->ReadBytes(nso_header.segments_compressed_size[i], nso_header.segments[i].offset);
-        std::vector<u8> data = DecompressSegment(compressed_data, nso_header.segments[i]);
+        if (nso_header.IsSegmentCompressed(i)) {
+            data = DecompressSegment(data, nso_header.segments[i]);
+        }
         program_image.resize(nso_header.segments[i].location);
         program_image.insert(program_image.end(), data.begin(), data.end());
         codeset->segments[i].addr = nso_header.segments[i].location;

src/video_core/engines/shader_bytecode.h

@@ -5,9 +5,8 @@
 #pragma once
 
 #include <bitset>
-#include <cstring>
-#include <map>
 #include <string>
+#include <tuple>
 #include <vector>
 
 #include <boost/optional.hpp>
@@ -315,17 +314,29 @@ enum class TextureMiscMode : u64 {
     PTP,
 };
 
-enum class IpaInterpMode : u64 { Linear = 0, Perspective = 1, Flat = 2, Sc = 3 };
-enum class IpaSampleMode : u64 { Default = 0, Centroid = 1, Offset = 2 };
+enum class IpaInterpMode : u64 {
+    Linear = 0,
+    Perspective = 1,
+    Flat = 2,
+    Sc = 3,
+};
+
+enum class IpaSampleMode : u64 {
+    Default = 0,
+    Centroid = 1,
+    Offset = 2,
+};
 
 struct IpaMode {
     IpaInterpMode interpolation_mode;
     IpaSampleMode sampling_mode;
-    inline bool operator==(const IpaMode& a) {
-        return (a.interpolation_mode == interpolation_mode) && (a.sampling_mode == sampling_mode);
+
+    bool operator==(const IpaMode& a) const {
+        return std::tie(interpolation_mode, sampling_mode) ==
+               std::tie(a.interpolation_mode, a.sampling_mode);
     }
-    inline bool operator!=(const IpaMode& a) {
-        return !((*this) == a);
+    bool operator!=(const IpaMode& a) const {
+        return !operator==(a);
     }
 };
 

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -383,7 +383,7 @@ void RasterizerOpenGL::Clear() {
     bool use_stencil{};
 
     OpenGLState clear_state;
-    clear_state.draw.draw_framebuffer = state.draw.draw_framebuffer;
+    clear_state.draw.draw_framebuffer = framebuffer.handle;
     clear_state.color_mask.red_enabled = regs.clear_buffers.R ? GL_TRUE : GL_FALSE;
     clear_state.color_mask.green_enabled = regs.clear_buffers.G ? GL_TRUE : GL_FALSE;
     clear_state.color_mask.blue_enabled = regs.clear_buffers.B ? GL_TRUE : GL_FALSE;

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -141,8 +141,8 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
      true}, // BC7U
     {GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8,
-     ComponentType::UNorm, true}, // BC6H_UF16
-    {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
+     ComponentType::Float, true}, // BC6H_UF16
+    {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::Float,
      true},                                                                    // BC6H_SF16
     {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},        // ASTC_2D_4X4
     {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},            // G8R8U
@@ -501,6 +501,9 @@ CachedSurface::CachedSurface(const SurfaceParams& params)
     glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(SurfaceTargetToGL(params.target), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+    VideoCore::LabelGLObject(GL_TEXTURE, texture.handle, params.addr,
+                             SurfaceParams::SurfaceTargetName(params.target));
 }
 
 static void ConvertS8Z24ToZ24S8(std::vector<u8>& data, u32 width, u32 height) {

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -137,6 +137,27 @@ struct SurfaceParams {
         }
     }
 
+    static std::string SurfaceTargetName(SurfaceTarget target) {
+        switch (target) {
+        case SurfaceTarget::Texture1D:
+            return "Texture1D";
+        case SurfaceTarget::Texture2D:
+            return "Texture2D";
+        case SurfaceTarget::Texture3D:
+            return "Texture3D";
+        case SurfaceTarget::Texture1DArray:
+            return "Texture1DArray";
+        case SurfaceTarget::Texture2DArray:
+            return "Texture2DArray";
+        case SurfaceTarget::TextureCubemap:
+            return "TextureCubemap";
+        default:
+            LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", static_cast<u32>(target));
+            UNREACHABLE();
+            return fmt::format("TextureUnknown({})", static_cast<u32>(target));
+        }
+    }
+
     /**
      * Gets the compression factor for the specified PixelFormat. This applies to just the
      * "compressed width" and "compressed height", not the overall compression factor of a

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -8,6 +8,7 @@
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_opengl/gl_shader_cache.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
+#include "video_core/utils.h"
 
 namespace OpenGL {
 
@@ -83,6 +84,7 @@ CachedShader::CachedShader(VAddr addr, Maxwell::ShaderProgram program_type)
     shader.Create(program_result.first.c_str(), gl_type);
     program.Create(true, shader.handle);
     SetShaderUniformBlockBindings(program.handle);
+    VideoCore::LabelGLObject(GL_PROGRAM, program.handle, addr);
 }
 
 GLuint CachedShader::GetProgramResourceIndex(const GLShader::ConstBufferEntry& buffer) {

src/video_core/renderer_opengl/gl_state.cpp

@@ -4,6 +4,7 @@
 
 #include <iterator>
 #include <glad/glad.h>
+#include "common/assert.h"
 #include "common/logging/log.h"
 #include "video_core/renderer_opengl/gl_state.h"
 

src/video_core/renderer_opengl/gl_state.h

@@ -7,12 +7,8 @@
 #include <array>
 #include <glad/glad.h>
 
-#include "video_core/engines/maxwell_3d.h"
-
 namespace OpenGL {
 
-using Regs = Tegra::Engines::Maxwell3D::Regs;
-
 namespace TextureUnits {
 
 struct TextureUnit {

src/video_core/renderer_opengl/gl_stream_buffer.cpp

@@ -74,7 +74,7 @@ std::tuple<u8*, GLintptr, bool> OGLStreamBuffer::Map(GLsizeiptr size, GLintptr a
         }
     }
 
-    if (invalidate | !persistent) {
+    if (invalidate || !persistent) {
         GLbitfield flags = GL_MAP_WRITE_BIT | (persistent ? GL_MAP_PERSISTENT_BIT : 0) |
                            (coherent ? GL_MAP_COHERENT_BIT : GL_MAP_FLUSH_EXPLICIT_BIT) |
                            (invalidate ? GL_MAP_INVALIDATE_BUFFER_BIT : GL_MAP_UNSYNCHRONIZED_BIT);

src/video_core/utils.h

@@ -161,4 +161,26 @@ static inline void MortonCopyPixels128(u32 width, u32 height, u32 bytes_per_pixe
     }
 }
 
+static void LabelGLObject(GLenum identifier, GLuint handle, VAddr addr,
+                          std::string extra_info = "") {
+    if (!GLAD_GL_KHR_debug) {
+        return; // We don't need to throw an error as this is just for debugging
+    }
+    const std::string nice_addr = fmt::format("0x{:016x}", addr);
+    std::string object_label;
+
+    switch (identifier) {
+    case GL_TEXTURE:
+        object_label = extra_info + "@" + nice_addr;
+        break;
+    case GL_PROGRAM:
+        object_label = "ShaderProgram@" + nice_addr;
+        break;
+    default:
+        object_label = fmt::format("Object(0x{:x})@{}", identifier, nice_addr);
+        break;
+    }
+    glObjectLabel(identifier, handle, -1, static_cast<const GLchar*>(object_label.c_str()));
+}
+
 } // namespace VideoCore

src/yuzu/debugger/wait_tree.cpp

@@ -15,6 +15,7 @@
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
 #include "core/hle/kernel/wait_object.h"
+#include "core/memory.h"
 
 WaitTreeItem::WaitTreeItem() = default;
 WaitTreeItem::~WaitTreeItem() = default;

src/yuzu/game_list.cpp

@@ -89,15 +89,7 @@ bool GameList::SearchField::KeyReleaseEater::eventFilter(QObject* obj, QEvent* e
 }
 
 void GameList::SearchField::setFilterResult(int visible, int total) {
-    QString result_of_text = tr("of");
-    QString result_text;
-    if (total == 1) {
-        result_text = tr("result");
-    } else {
-        result_text = tr("results");
-    }
-    label_filter_result->setText(
-        QString("%1 %2 %3 %4").arg(visible).arg(result_of_text).arg(total).arg(result_text));
+    label_filter_result->setText(tr("%1 of %n result(s)", "", total).arg(visible));
 }
 
 void GameList::SearchField::clear() {

src/yuzu/game_list_p.h

@@ -68,7 +68,7 @@ public:
         if (!picture.loadFromData(picture_data.data(), static_cast<u32>(picture_data.size()))) {
             picture = GetDefaultIcon(size);
         }
-        picture = picture.scaled(size, size);
+        picture = picture.scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 
         setData(picture, Qt::DecorationRole);
     }

src/yuzu_cmd/config.cpp

@@ -120,7 +120,7 @@ void Config::ReadValues() {
                           sdl2_config->Get("Data Storage", "nand_directory",
                                            FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)));
     FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir,
-                          sdl2_config->Get("Data Storage", "nand_directory",
+                          sdl2_config->Get("Data Storage", "sdmc_directory",
                                            FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)));
 
     // System

src/yuzu_cmd/yuzu.cpp

@@ -20,8 +20,10 @@
 #include "common/string_util.h"
 #include "common/telemetry.h"
 #include "core/core.h"
+#include "core/crypto/key_manager.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/gdbstub/gdbstub.h"
+#include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
 #include "core/settings.h"
 #include "core/telemetry_session.h"
@@ -29,7 +31,6 @@
 #include "yuzu_cmd/emu_window/emu_window_sdl2.h"
 
 #include <getopt.h>
-#include "core/crypto/key_manager.h"
 #ifndef _MSC_VER
 #include <unistd.h>
 #endif
@@ -169,6 +170,7 @@ int main(int argc, char** argv) {
 
     Core::System& system{Core::System::GetInstance()};
     system.SetFilesystem(std::make_shared<FileSys::RealVfsFilesystem>());
+    Service::FileSystem::CreateFactories(system.GetFilesystem());
 
     SCOPE_EXIT({ system.Shutdown(); });