shader_bytecode: Implement other TEXS masks.

file_util: Remove goto usages from Copy()

.gitignore

@@ -11,6 +11,7 @@ src/common/scm_rev.cpp
 .idea/
 .vs/
 .vscode/
+CMakeLists.txt.user
 
 # *nix related
 # Common convention for backup or temporary files

externals/cmake-modules/WindowsCopyFiles.cmake

@@ -1,4 +1,4 @@
-# Copyright 2016 Citra Emulator Project
+# Copyright 2018 Yuzu Emulator Project
 # Licensed under GPLv2 or any later version
 # Refer to the license.txt file included.
 
@@ -22,7 +22,7 @@ function(windows_copy_files TARGET SOURCE_DIR DEST_DIR)
     # cmake adds an extra check for command success which doesn't work too well with robocopy
     # so trick it into thinking the command was successful with the || cmd /c "exit /b 0"
     add_custom_command(TARGET ${TARGET} POST_BUILD
-        COMMAND if not exist ${DEST_DIR} mkdir ${DEST_DIR} 2> nul
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${DEST_DIR}
         COMMAND robocopy ${SOURCE_DIR} ${DEST_DIR} ${ARGN} /NJH /NJS /NDL /NFL /NC /NS /NP || cmd /c "exit /b 0"
     )
-endfunction()
+endfunction()

externals/glad/include/KHR/khrplatform.h

@@ -2,7 +2,7 @@
 #define __khrplatform_h_
 
 /*
-** Copyright (c) 2008-2009 The Khronos Group Inc.
+** Copyright (c) 2008-2018 The Khronos Group Inc.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a
 ** copy of this software and/or associated documentation files (the
@@ -26,18 +26,16 @@
 
 /* Khronos platform-specific types and definitions.
  *
- * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
  *
  * Adopters may modify this file to suit their platform. Adopters are
  * encouraged to submit platform specific modifications to the Khronos
  * group so that they can be included in future versions of this file.
- * Please submit changes by sending them to the public Khronos Bugzilla
- * (http://khronos.org/bugzilla) by filing a bug against product
- * "Khronos (general)" component "Registry".
- *
- * A predefined template which fills in some of the bug fields can be
- * reached using http://tinyurl.com/khrplatform-h-bugreport, but you
- * must create a Bugzilla login first.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
  *
  *
  * See the Implementer's Guidelines for information about where this file

src/common/CMakeLists.txt

@@ -63,7 +63,6 @@ add_library(common STATIC
     string_util.cpp
     string_util.h
     swap.h
-    synchronized_wrapper.h
     telemetry.cpp
     telemetry.h
     thread.cpp

src/common/assert.h

@@ -52,5 +52,5 @@ __declspec(noinline, noreturn)
 #define DEBUG_ASSERT_MSG(_a_, _desc_, ...)
 #endif
 
-#define UNIMPLEMENTED() DEBUG_ASSERT_MSG(false, "Unimplemented code!")
+#define UNIMPLEMENTED() LOG_CRITICAL(Debug, "Unimplemented code!")
 #define UNIMPLEMENTED_MSG(...) ASSERT_MSG(false, __VA_ARGS__)

src/common/common_funcs.h

@@ -4,7 +4,9 @@
 
 #pragma once
 
-#if !defined(ARCHITECTURE_x86_64) && !defined(_M_ARM)
+#include <string>
+
+#if !defined(ARCHITECTURE_x86_64) && !defined(ARCHITECTURE_ARM)
 #include <cstdlib> // for exit
 #endif
 #include "common/common_types.h"
@@ -30,46 +32,12 @@
 
 #ifdef ARCHITECTURE_x86_64
 #define Crash() __asm__ __volatile__("int $3")
-#elif defined(_M_ARM)
+#elif defined(ARCHITECTURE_ARM)
 #define Crash() __asm__ __volatile__("trap")
 #else
 #define Crash() exit(1)
 #endif
 
-// GCC 4.8 defines all the rotate functions now
-// Small issue with GCC's lrotl/lrotr intrinsics is they are still 32bit while we require 64bit
-#ifdef _rotl
-#define rotl _rotl
-#else
-inline u32 rotl(u32 x, int shift) {
-    shift &= 31;
-    if (!shift)
-        return x;
-    return (x << shift) | (x >> (32 - shift));
-}
-#endif
-
-#ifdef _rotr
-#define rotr _rotr
-#else
-inline u32 rotr(u32 x, int shift) {
-    shift &= 31;
-    if (!shift)
-        return x;
-    return (x >> shift) | (x << (32 - shift));
-}
-#endif
-
-inline u64 _rotl64(u64 x, unsigned int shift) {
-    unsigned int n = shift % 64;
-    return (x << n) | (x >> (64 - n));
-}
-
-inline u64 _rotr64(u64 x, unsigned int shift) {
-    unsigned int n = shift % 64;
-    return (x >> n) | (x << (64 - n));
-}
-
 #else // _MSC_VER
 
 // Locale Cross-Compatibility
@@ -80,17 +48,13 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
 }
 #define Crash() DebugBreak()
 
-// cstdlib provides these on MSVC
-#define rotr _rotr
-#define rotl _rotl
-
 #endif // _MSC_VER ndef
 
 // Generic function to get last error message.
 // Call directly after the command or use the error num.
 // This function might change the error code.
 // Defined in Misc.cpp.
-const char* GetLastErrorMsg();
+std::string GetLastErrorMsg();
 
 namespace Common {
 

src/common/common_paths.h

@@ -26,7 +26,7 @@
 #define USA_DIR "USA"
 #define JAP_DIR "JAP"
 
-// Subdirs in the User dir returned by GetUserPath(D_USER_IDX)
+// Subdirs in the User dir returned by GetUserPath(UserPath::UserDir)
 #define CONFIG_DIR "config"
 #define CACHE_DIR "cache"
 #define SDMC_DIR "sdmc"
@@ -35,11 +35,11 @@
 #define LOG_DIR "log"
 
 // Filenames
-// Files in the directory returned by GetUserPath(D_CONFIG_IDX)
+// Files in the directory returned by GetUserPath(UserPath::ConfigDir)
 #define EMU_CONFIG "emu.ini"
 #define DEBUGGER_CONFIG "debugger.ini"
 #define LOGGER_CONFIG "logger.ini"
-// Files in the directory returned by GetUserPath(D_LOGS_IDX)
+// Files in the directory returned by GetUserPath(UserPath::LogDir)
 #define LOG_FILE "yuzu_log.txt"
 
 // Sys files

src/common/file_util.cpp

@@ -2,7 +2,10 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <array>
+#include <memory>
 #include <sstream>
+#include <unordered_map>
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_paths.h"
@@ -274,14 +277,10 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
               GetLastErrorMsg());
     return false;
 #else
-
-// buffer size
-#define BSIZE 1024
-
-    char buffer[BSIZE];
+    using CFilePointer = std::unique_ptr<FILE, decltype(&std::fclose)>;
 
     // Open input file
-    FILE* input = fopen(srcFilename.c_str(), "rb");
+    CFilePointer input{fopen(srcFilename.c_str(), "rb"), std::fclose};
     if (!input) {
         LOG_ERROR(Common_Filesystem, "opening input failed {} --> {}: {}", srcFilename,
                   destFilename, GetLastErrorMsg());
@@ -289,44 +288,36 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
     }
 
     // open output file
-    FILE* output = fopen(destFilename.c_str(), "wb");
+    CFilePointer output{fopen(destFilename.c_str(), "wb"), std::fclose};
     if (!output) {
-        fclose(input);
         LOG_ERROR(Common_Filesystem, "opening output failed {} --> {}: {}", srcFilename,
                   destFilename, GetLastErrorMsg());
         return false;
     }
 
     // copy loop
-    while (!feof(input)) {
+    std::array<char, 1024> buffer;
+    while (!feof(input.get())) {
         // read input
-        size_t rnum = fread(buffer, sizeof(char), BSIZE, input);
-        if (rnum != BSIZE) {
-            if (ferror(input) != 0) {
+        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, {} --> {}: {}",
                           srcFilename, destFilename, GetLastErrorMsg());
-                goto bail;
+                return false;
             }
         }
 
         // write output
-        size_t wnum = fwrite(buffer, sizeof(char), rnum, output);
+        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());
-            goto bail;
+            return false;
         }
     }
-    // close files
-    fclose(input);
-    fclose(output);
+
     return true;
-bail:
-    if (input)
-        fclose(input);
-    if (output)
-        fclose(output);
-    return false;
 #endif
 }
 
@@ -395,12 +386,12 @@ bool CreateEmptyFile(const std::string& filename) {
     return true;
 }
 
-bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directory,
+bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
                            DirectoryEntryCallable callback) {
     LOG_TRACE(Common_Filesystem, "directory {}", directory);
 
     // How many files + directories we found
-    unsigned found_entries = 0;
+    u64 found_entries = 0;
 
     // Save the status of callback function
     bool callback_error = false;
@@ -430,7 +421,7 @@ bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directo
         if (virtual_name == "." || virtual_name == "..")
             continue;
 
-        unsigned ret_entries = 0;
+        u64 ret_entries = 0;
         if (!callback(&ret_entries, directory, virtual_name)) {
             callback_error = true;
             break;
@@ -454,9 +445,9 @@ bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directo
     return true;
 }
 
-unsigned ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
-                           unsigned int recursion) {
-    const auto callback = [recursion, &parent_entry](unsigned* num_entries_out,
+u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
+                      unsigned int recursion) {
+    const auto callback = [recursion, &parent_entry](u64* num_entries_out,
                                                      const std::string& directory,
                                                      const std::string& virtual_name) -> bool {
         FSTEntry entry;
@@ -468,7 +459,7 @@ unsigned ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
             // is a directory, lets go inside if we didn't recurse to often
             if (recursion > 0) {
                 entry.size = ScanDirectoryTree(entry.physicalName, entry, recursion - 1);
-                *num_entries_out += (int)entry.size;
+                *num_entries_out += entry.size;
             } else {
                 entry.size = 0;
             }
@@ -479,16 +470,16 @@ unsigned ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
         (*num_entries_out)++;
 
         // Push into the tree
-        parent_entry.children.push_back(entry);
+        parent_entry.children.push_back(std::move(entry));
         return true;
     };
 
-    unsigned num_entries;
+    u64 num_entries;
     return ForeachDirectoryEntry(&num_entries, directory, callback) ? num_entries : 0;
 }
 
 bool DeleteDirRecursively(const std::string& directory, unsigned int recursion) {
-    const auto callback = [recursion](unsigned* num_entries_out, const std::string& directory,
+    const auto callback = [recursion](u64* num_entries_out, const std::string& directory,
                                       const std::string& virtual_name) -> bool {
         std::string new_path = directory + DIR_SEP_CHR + virtual_name;
 
@@ -592,7 +583,7 @@ std::string GetBundleDirectory() {
 #endif
 
 #ifdef _WIN32
-std::string& GetExeDirectory() {
+const std::string& GetExeDirectory() {
     static std::string exe_path;
     if (exe_path.empty()) {
         wchar_t wchar_exe_path[2048];
@@ -681,67 +672,68 @@ std::string GetSysDirectory() {
 
 // Returns a string with a yuzu data dir or file in the user's home
 // directory. To be used in "multi-user" mode (that is, installed).
-const std::string& GetUserPath(const unsigned int DirIDX, const std::string& newPath) {
-    static std::string paths[NUM_PATH_INDICES];
+const std::string& GetUserPath(UserPath path, const std::string& new_path) {
+    static std::unordered_map<UserPath, std::string> paths;
+    auto& user_path = paths[UserPath::UserDir];
 
     // Set up all paths and files on the first run
-    if (paths[D_USER_IDX].empty()) {
+    if (user_path.empty()) {
 #ifdef _WIN32
-        paths[D_USER_IDX] = GetExeDirectory() + DIR_SEP USERDATA_DIR DIR_SEP;
-        if (!FileUtil::IsDirectory(paths[D_USER_IDX])) {
-            paths[D_USER_IDX] = AppDataRoamingDirectory() + DIR_SEP EMU_DATA_DIR DIR_SEP;
+        user_path = GetExeDirectory() + DIR_SEP USERDATA_DIR DIR_SEP;
+        if (!FileUtil::IsDirectory(user_path)) {
+            user_path = AppDataRoamingDirectory() + DIR_SEP EMU_DATA_DIR DIR_SEP;
         } else {
             LOG_INFO(Common_Filesystem, "Using the local user directory");
         }
 
-        paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
-        paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
+        paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP);
+        paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP);
 #else
         if (FileUtil::Exists(ROOT_DIR DIR_SEP USERDATA_DIR)) {
-            paths[D_USER_IDX] = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
-            paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
-            paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
+            user_path = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
+            paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP);
+            paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP);
         } else {
             std::string data_dir = GetUserDirectory("XDG_DATA_HOME");
             std::string config_dir = GetUserDirectory("XDG_CONFIG_HOME");
             std::string cache_dir = GetUserDirectory("XDG_CACHE_HOME");
 
-            paths[D_USER_IDX] = data_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
-            paths[D_CONFIG_IDX] = config_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
-            paths[D_CACHE_IDX] = cache_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
+            user_path = data_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
+            paths.emplace(UserPath::ConfigDir, config_dir + DIR_SEP EMU_DATA_DIR DIR_SEP);
+            paths.emplace(UserPath::CacheDir, cache_dir + DIR_SEP EMU_DATA_DIR DIR_SEP);
         }
 #endif
-        paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;
-        paths[D_NAND_IDX] = paths[D_USER_IDX] + NAND_DIR DIR_SEP;
-        paths[D_SYSDATA_IDX] = paths[D_USER_IDX] + SYSDATA_DIR DIR_SEP;
+        paths.emplace(UserPath::SDMCDir, user_path + SDMC_DIR DIR_SEP);
+        paths.emplace(UserPath::NANDDir, user_path + NAND_DIR DIR_SEP);
+        paths.emplace(UserPath::SysDataDir, user_path + SYSDATA_DIR DIR_SEP);
         // TODO: Put the logs in a better location for each OS
-        paths[D_LOGS_IDX] = paths[D_USER_IDX] + LOG_DIR DIR_SEP;
+        paths.emplace(UserPath::LogDir, user_path + LOG_DIR DIR_SEP);
     }
 
-    if (!newPath.empty()) {
-        if (!FileUtil::IsDirectory(newPath)) {
-            LOG_ERROR(Common_Filesystem, "Invalid path specified {}", newPath);
-            return paths[DirIDX];
+    if (!new_path.empty()) {
+        if (!FileUtil::IsDirectory(new_path)) {
+            LOG_ERROR(Common_Filesystem, "Invalid path specified {}", new_path);
+            return paths[path];
         } else {
-            paths[DirIDX] = newPath;
+            paths[path] = new_path;
         }
 
-        switch (DirIDX) {
-        case D_ROOT_IDX:
-            paths[D_USER_IDX] = paths[D_ROOT_IDX] + DIR_SEP;
+        switch (path) {
+        case UserPath::RootDir:
+            user_path = paths[UserPath::RootDir] + DIR_SEP;
             break;
 
-        case D_USER_IDX:
-            paths[D_USER_IDX] = paths[D_ROOT_IDX] + DIR_SEP;
-            paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
-            paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
-            paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;
-            paths[D_NAND_IDX] = paths[D_USER_IDX] + NAND_DIR DIR_SEP;
+        case UserPath::UserDir:
+            user_path = paths[UserPath::RootDir] + DIR_SEP;
+            paths[UserPath::ConfigDir] = user_path + CONFIG_DIR DIR_SEP;
+            paths[UserPath::CacheDir] = user_path + CACHE_DIR DIR_SEP;
+            paths[UserPath::SDMCDir] = user_path + SDMC_DIR DIR_SEP;
+            paths[UserPath::NANDDir] = user_path + NAND_DIR DIR_SEP;
             break;
         }
     }
 
-    return paths[DirIDX];
+    return paths[path];
 }
 
 size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename) {
@@ -826,6 +818,19 @@ std::string GetParentPath(const std::string& path) {
     return out.erase(name_index);
 }
 
+std::string GetPathWithoutTop(std::string path) {
+    if (path.empty())
+        return "";
+    while (path[0] == '\\' || path[0] == '/') {
+        path = path.substr(1);
+        if (path.empty())
+            return "";
+    }
+    const auto name_bck_index = path.find_first_of('\\');
+    const auto name_fwd_index = path.find_first_of('/');
+    return path.substr(std::min(name_bck_index, name_fwd_index) + 1);
+}
+
 std::string GetFilename(std::string path) {
     std::replace(path.begin(), path.end(), '\\', '/');
     auto name_index = path.find_last_of('/');

src/common/file_util.h

@@ -16,21 +16,20 @@
 #include "common/string_util.h"
 #endif
 
-// User directory indices for GetUserPath
-enum {
-    D_USER_IDX,
-    D_ROOT_IDX,
-    D_CONFIG_IDX,
-    D_CACHE_IDX,
-    D_SDMC_IDX,
-    D_NAND_IDX,
-    D_SYSDATA_IDX,
-    D_LOGS_IDX,
-    NUM_PATH_INDICES
-};
-
 namespace FileUtil {
 
+// User paths for GetUserPath
+enum class UserPath {
+    CacheDir,
+    ConfigDir,
+    LogDir,
+    NANDDir,
+    RootDir,
+    SDMCDir,
+    SysDataDir,
+    UserDir,
+};
+
 // FileSystem tree node/
 struct FSTEntry {
     bool isDirectory;
@@ -85,7 +84,7 @@ bool CreateEmptyFile(const std::string& filename);
  * @return whether handling the entry succeeded
  */
 using DirectoryEntryCallable = std::function<bool(
-    unsigned* num_entries_out, const std::string& directory, const std::string& virtual_name)>;
+    u64* num_entries_out, const std::string& directory, const std::string& virtual_name)>;
 
 /**
  * Scans a directory, calling the callback for each file/directory contained within.
@@ -96,7 +95,7 @@ using DirectoryEntryCallable = std::function<bool(
  * @param callback The callback which will be called for each entry
  * @return whether scanning the directory succeeded
  */
-bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directory,
+bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
                            DirectoryEntryCallable callback);
 
 /**
@@ -106,8 +105,8 @@ bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directo
  * @param recursion Number of children directories to read before giving up.
  * @return the total number of files/directories found
  */
-unsigned ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
-                           unsigned int recursion = 0);
+u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
+                      unsigned int recursion = 0);
 
 // deletes the given directory and anything under it. Returns true on success.
 bool DeleteDirRecursively(const std::string& directory, unsigned int recursion = 256);
@@ -123,7 +122,7 @@ bool SetCurrentDir(const std::string& directory);
 
 // Returns a pointer to a string with a yuzu data dir in the user's home
 // directory. To be used in "multi-user" mode (that is, installed).
-const std::string& GetUserPath(const unsigned int DirIDX, const std::string& newPath = "");
+const std::string& GetUserPath(UserPath path, const std::string& new_path = "");
 
 // Returns the path to where the sys file are
 std::string GetSysDirectory();
@@ -133,7 +132,7 @@ std::string GetBundleDirectory();
 #endif
 
 #ifdef _WIN32
-std::string& GetExeDirectory();
+const std::string& GetExeDirectory();
 std::string AppDataRoamingDirectory();
 #endif
 
@@ -154,9 +153,12 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam
 // i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
 std::vector<std::string> SplitPathComponents(const std::string& filename);
 
-// Gets all of the text prior to the last '/' or '\' in the path.
+// Gets all of the text up to the last '/' or '\' in the path.
 std::string GetParentPath(const std::string& path);
 
+// Gets all of the text after the first '/' or '\' in the path.
+std::string GetPathWithoutTop(std::string path);
+
 // Gets the filename of the path
 std::string GetFilename(std::string path);
 

src/common/logging/backend.cpp

@@ -3,18 +3,20 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <array>
+#include <atomic>
 #include <chrono>
+#include <climits>
 #include <condition_variable>
 #include <memory>
+#include <mutex>
 #include <thread>
+#include <vector>
 #ifdef _WIN32
 #include <share.h> // For _SH_DENYWR
 #else
 #define _SH_DENYWR 0
 #endif
 #include "common/assert.h"
-#include "common/common_funcs.h" // snprintf compatibility define
 #include "common/logging/backend.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
@@ -47,11 +49,11 @@ public:
         backends.push_back(std::move(backend));
     }
 
-    void RemoveBackend(const std::string& backend_name) {
+    void RemoveBackend(std::string_view backend_name) {
         std::lock_guard<std::mutex> lock(writing_mutex);
-        auto it = std::remove_if(backends.begin(), backends.end(), [&backend_name](const auto& i) {
-            return !strcmp(i->GetName(), backend_name.c_str());
-        });
+        const auto it =
+            std::remove_if(backends.begin(), backends.end(),
+                           [&backend_name](const auto& i) { return backend_name == i->GetName(); });
         backends.erase(it, backends.end());
     }
 
@@ -63,10 +65,10 @@ public:
         filter = f;
     }
 
-    Backend* GetBackend(const std::string& backend_name) {
-        auto it = std::find_if(backends.begin(), backends.end(), [&backend_name](const auto& i) {
-            return !strcmp(i->GetName(), backend_name.c_str());
-        });
+    Backend* GetBackend(std::string_view backend_name) {
+        const auto it =
+            std::find_if(backends.begin(), backends.end(),
+                         [&backend_name](const auto& i) { return backend_name == i->GetName(); });
         if (it == backends.end())
             return nullptr;
         return it->get();
@@ -83,8 +85,10 @@ private:
                 }
             };
             while (true) {
-                std::unique_lock<std::mutex> lock(message_mutex);
-                message_cv.wait(lock, [&] { return !running || message_queue.Pop(entry); });
+                {
+                    std::unique_lock<std::mutex> lock(message_mutex);
+                    message_cv.wait(lock, [&] { return !running || message_queue.Pop(entry); });
+                }
                 if (!running) {
                     break;
                 }
@@ -92,7 +96,7 @@ private:
             }
             // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a case
             // where a system is repeatedly spamming logs even on close.
-            constexpr int MAX_LOGS_TO_WRITE = 100;
+            const int MAX_LOGS_TO_WRITE = filter.IsDebug() ? INT_MAX : 100;
             int logs_written = 0;
             while (logs_written++ < MAX_LOGS_TO_WRITE && message_queue.Pop(entry)) {
                 write_logs(entry);
@@ -262,11 +266,11 @@ void AddBackend(std::unique_ptr<Backend> backend) {
     Impl::Instance().AddBackend(std::move(backend));
 }
 
-void RemoveBackend(const std::string& backend_name) {
+void RemoveBackend(std::string_view backend_name) {
     Impl::Instance().RemoveBackend(backend_name);
 }
 
-Backend* GetBackend(const std::string& backend_name) {
+Backend* GetBackend(std::string_view backend_name) {
     return Impl::Instance().GetBackend(backend_name);
 }
 
@@ -282,4 +286,4 @@ void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
 
     Impl::Instance().PushEntry(std::move(entry));
 }
-} // namespace Log
+} // namespace Log

src/common/logging/backend.h

@@ -4,10 +4,9 @@
 #pragma once
 
 #include <chrono>
-#include <cstdarg>
 #include <memory>
 #include <string>
-#include <utility>
+#include <string_view>
 #include "common/file_util.h"
 #include "common/logging/filter.h"
 #include "common/logging/log.h"
@@ -106,9 +105,9 @@ private:
 
 void AddBackend(std::unique_ptr<Backend> backend);
 
-void RemoveBackend(const std::string& backend_name);
+void RemoveBackend(std::string_view backend_name);
 
-Backend* GetBackend(const std::string& backend_name);
+Backend* GetBackend(std::string_view backend_name);
 
 /**
  * Returns the name of the passed log class as a C-string. Subclasses are separated by periods

src/common/logging/filter.cpp

@@ -8,39 +8,9 @@
 #include "common/string_util.h"
 
 namespace Log {
-
-Filter::Filter(Level default_level) {
-    ResetAll(default_level);
-}
-
-void Filter::ResetAll(Level level) {
-    class_levels.fill(level);
-}
-
-void Filter::SetClassLevel(Class log_class, Level level) {
-    class_levels[static_cast<size_t>(log_class)] = level;
-}
-
-void Filter::ParseFilterString(const std::string& filter_str) {
-    auto clause_begin = filter_str.cbegin();
-    while (clause_begin != filter_str.cend()) {
-        auto clause_end = std::find(clause_begin, filter_str.cend(), ' ');
-
-        // If clause isn't empty
-        if (clause_end != clause_begin) {
-            ParseFilterRule(clause_begin, clause_end);
-        }
-
-        if (clause_end != filter_str.cend()) {
-            // Skip over the whitespace
-            ++clause_end;
-        }
-        clause_begin = clause_end;
-    }
-}
-
+namespace {
 template <typename It>
-static Level GetLevelByName(const It begin, const It end) {
+Level GetLevelByName(const It begin, const It end) {
     for (u8 i = 0; i < static_cast<u8>(Level::Count); ++i) {
         const char* level_name = GetLevelName(static_cast<Level>(i));
         if (Common::ComparePartialString(begin, end, level_name)) {
@@ -51,7 +21,7 @@ static Level GetLevelByName(const It begin, const It end) {
 }
 
 template <typename It>
-static Class GetClassByName(const It begin, const It end) {
+Class GetClassByName(const It begin, const It end) {
     for (ClassType i = 0; i < static_cast<ClassType>(Class::Count); ++i) {
         const char* level_name = GetLogClassName(static_cast<Class>(i));
         if (Common::ComparePartialString(begin, end, level_name)) {
@@ -61,8 +31,8 @@ static Class GetClassByName(const It begin, const It end) {
     return Class::Count;
 }
 
-bool Filter::ParseFilterRule(const std::string::const_iterator begin,
-                             const std::string::const_iterator end) {
+template <typename Iterator>
+bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     auto level_separator = std::find(begin, end, ':');
     if (level_separator == end) {
         LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: {}",
@@ -77,7 +47,7 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
     }
 
     if (Common::ComparePartialString(begin, level_separator, "*")) {
-        ResetAll(level);
+        instance.ResetAll(level);
         return true;
     }
 
@@ -87,11 +57,49 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
         return false;
     }
 
-    SetClassLevel(log_class, level);
+    instance.SetClassLevel(log_class, level);
     return true;
 }
+} // Anonymous namespace
+
+Filter::Filter(Level default_level) {
+    ResetAll(default_level);
+}
+
+void Filter::ResetAll(Level level) {
+    class_levels.fill(level);
+}
+
+void Filter::SetClassLevel(Class log_class, Level level) {
+    class_levels[static_cast<size_t>(log_class)] = level;
+}
+
+void Filter::ParseFilterString(std::string_view filter_view) {
+    auto clause_begin = filter_view.cbegin();
+    while (clause_begin != filter_view.cend()) {
+        auto clause_end = std::find(clause_begin, filter_view.cend(), ' ');
+
+        // If clause isn't empty
+        if (clause_end != clause_begin) {
+            ParseFilterRule(*this, clause_begin, clause_end);
+        }
+
+        if (clause_end != filter_view.cend()) {
+            // Skip over the whitespace
+            ++clause_end;
+        }
+        clause_begin = clause_end;
+    }
+}
 
 bool Filter::CheckMessage(Class log_class, Level level) const {
     return static_cast<u8>(level) >= static_cast<u8>(class_levels[static_cast<size_t>(log_class)]);
 }
+
+bool Filter::IsDebug() const {
+    return std::any_of(class_levels.begin(), class_levels.end(), [](const Level& l) {
+        return static_cast<u8>(l) <= static_cast<u8>(Level::Debug);
+    });
+}
+
 } // namespace Log

src/common/logging/filter.h

@@ -6,7 +6,7 @@
 
 #include <array>
 #include <cstddef>
-#include <string>
+#include <string_view>
 #include "common/logging/log.h"
 
 namespace Log {
@@ -40,13 +40,14 @@ public:
      *  - `Service:Info` -- Sets the level of Service to Info.
      *  - `Service.FS:Trace` -- Sets the level of the Service.FS class to Trace.
      */
-    void ParseFilterString(const std::string& filter_str);
-    bool ParseFilterRule(const std::string::const_iterator start,
-                         const std::string::const_iterator end);
+    void ParseFilterString(std::string_view filter_view);
 
     /// Matches class/level combination against the filter, returning true if it passed.
     bool CheckMessage(Class log_class, Level level) const;
 
+    /// Returns true if any logging classes are set to debug
+    bool IsDebug() const;
+
 private:
     std::array<Level, (size_t)Class::Count> class_levels;
 };

src/common/logging/log.h

@@ -103,7 +103,7 @@ template <typename... Args>
 void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
                    const char* function, const char* format, const Args&... args) {
     FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
-                      fmt::make_args(args...));
+                      fmt::make_format_args(args...));
 }
 
 } // namespace Log

src/common/memory_util.cpp

@@ -16,7 +16,7 @@
 #include <sys/mman.h>
 #endif
 
-#if !defined(_WIN32) && defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
+#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
 #include <unistd.h>
 #define PAGE_MASK (getpagesize() - 1)
 #define round_page(x) ((((unsigned long)(x)) + PAGE_MASK) & ~(PAGE_MASK))
@@ -30,7 +30,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
     void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
 #else
     static char* map_hint = nullptr;
-#if defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
+#if defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
     // This OS has no flag to enforce allocation below the 4 GB boundary,
     // but if we hint that we want a low address it is very likely we will
     // get one.
@@ -42,7 +42,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
 #endif
     void* ptr = mmap(map_hint, size, PROT_READ | PROT_WRITE | PROT_EXEC,
                      MAP_ANON | MAP_PRIVATE
-#if defined(ARCHITECTURE_X64) && defined(MAP_32BIT)
+#if defined(ARCHITECTURE_x86_64) && defined(MAP_32BIT)
                          | (low ? MAP_32BIT : 0)
 #endif
                          ,
@@ -57,7 +57,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
 #endif
         LOG_ERROR(Common_Memory, "Failed to allocate executable memory");
     }
-#if !defined(_WIN32) && defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
+#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
     else {
         if (low) {
             map_hint += size;

src/common/misc.cpp

@@ -4,34 +4,28 @@
 
 #include <cstddef>
 #ifdef _WIN32
-#include <windows.h>
+#include <Windows.h>
 #else
 #include <cerrno>
 #include <cstring>
 #endif
 
-// Neither Android nor OS X support TLS
-#if defined(__APPLE__) || (ANDROID && __clang__)
-#define __thread
-#endif
+#include "common/common_funcs.h"
 
 // Generic function to get last error message.
 // Call directly after the command or use the error num.
 // This function might change the error code.
-const char* GetLastErrorMsg() {
+std::string GetLastErrorMsg() {
     static const size_t buff_size = 255;
+    char err_str[buff_size];
 
 #ifdef _WIN32
-    static __declspec(thread) char err_str[buff_size] = {};
-
     FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, GetLastError(),
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), err_str, buff_size, nullptr);
 #else
-    static __thread char err_str[buff_size] = {};
-
     // Thread safe (XSI-compliant)
     strerror_r(errno, err_str, buff_size);
 #endif
 
-    return err_str;
+    return std::string(err_str, buff_size);
 }

src/common/param_package.cpp

@@ -3,7 +3,9 @@
 // Refer to the license.txt file included.
 
 #include <array>
+#include <utility>
 #include <vector>
+
 #include "common/logging/log.h"
 #include "common/param_package.h"
 #include "common/string_util.h"
@@ -12,10 +14,11 @@ namespace Common {
 
 constexpr char KEY_VALUE_SEPARATOR = ':';
 constexpr char PARAM_SEPARATOR = ',';
+
 constexpr char ESCAPE_CHARACTER = '$';
-const std::string KEY_VALUE_SEPARATOR_ESCAPE{ESCAPE_CHARACTER, '0'};
-const std::string PARAM_SEPARATOR_ESCAPE{ESCAPE_CHARACTER, '1'};
-const std::string ESCAPE_CHARACTER_ESCAPE{ESCAPE_CHARACTER, '2'};
+constexpr char KEY_VALUE_SEPARATOR_ESCAPE[] = "$0";
+constexpr char PARAM_SEPARATOR_ESCAPE[] = "$1";
+constexpr char ESCAPE_CHARACTER_ESCAPE[] = "$2";
 
 ParamPackage::ParamPackage(const std::string& serialized) {
     std::vector<std::string> pairs;
@@ -35,7 +38,7 @@ ParamPackage::ParamPackage(const std::string& serialized) {
             part = Common::ReplaceAll(part, ESCAPE_CHARACTER_ESCAPE, {ESCAPE_CHARACTER});
         }
 
-        Set(key_value[0], key_value[1]);
+        Set(key_value[0], std::move(key_value[1]));
     }
 }
 
@@ -101,16 +104,16 @@ float ParamPackage::Get(const std::string& key, float default_value) const {
     }
 }
 
-void ParamPackage::Set(const std::string& key, const std::string& value) {
-    data[key] = value;
+void ParamPackage::Set(const std::string& key, std::string value) {
+    data.insert_or_assign(key, std::move(value));
 }
 
 void ParamPackage::Set(const std::string& key, int value) {
-    data[key] = std::to_string(value);
+    data.insert_or_assign(key, std::to_string(value));
 }
 
 void ParamPackage::Set(const std::string& key, float value) {
-    data[key] = std::to_string(value);
+    data.insert_or_assign(key, std::to_string(value));
 }
 
 bool ParamPackage::Has(const std::string& key) const {

src/common/param_package.h

@@ -28,7 +28,7 @@ public:
     std::string Get(const std::string& key, const std::string& default_value) const;
     int Get(const std::string& key, int default_value) const;
     float Get(const std::string& key, float default_value) const;
-    void Set(const std::string& key, const std::string& value);
+    void Set(const std::string& key, std::string value);
     void Set(const std::string& key, int value);
     void Set(const std::string& key, float value);
     bool Has(const std::string& key) const;

src/common/string_util.cpp

@@ -34,18 +34,6 @@ std::string ToUpper(std::string str) {
     return str;
 }
 
-// faster than sscanf
-bool AsciiToHex(const char* _szValue, u32& result) {
-    char* endptr = nullptr;
-    const u32 value = strtoul(_szValue, &endptr, 16);
-
-    if (!endptr || *endptr)
-        return false;
-
-    result = value;
-    return true;
-}
-
 // For Debugging. Read out an u8 array.
 std::string ArrayToString(const u8* data, size_t size, int line_len, bool spaces) {
     std::ostringstream oss;
@@ -134,7 +122,7 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
     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)

src/common/string_util.h

@@ -57,9 +57,6 @@ static bool TryParse(const std::string& str, N* const output) {
         return false;
 }
 
-// TODO: kill this
-bool AsciiToHex(const char* _szValue, u32& result);
-
 std::string TabsToSpaces(int tab_size, const std::string& in);
 
 void SplitString(const std::string& str, char delim, std::vector<std::string>& output);

src/common/swap.h

@@ -69,7 +69,7 @@ inline u32 swap32(u32 _data) {
 inline u64 swap64(u64 _data) {
     return _byteswap_uint64(_data);
 }
-#elif _M_ARM
+#elif ARCHITECTURE_ARM
 inline u16 swap16(u16 _data) {
     u32 data = _data;
     __asm__("rev16 %0, %1\n" : "=l"(data) : "l"(data));
@@ -167,7 +167,7 @@ inline double swapd(double f) {
 
 template <typename T, typename F>
 struct swap_struct_t {
-    typedef swap_struct_t<T, F> swapped_t;
+    using swapped_t = swap_struct_t;
 
 protected:
     T value = T();
@@ -177,7 +177,7 @@ protected:
     }
 
 public:
-    T const swap() const {
+    T swap() const {
         return swap(value);
     }
     swap_struct_t() = default;
@@ -185,39 +185,39 @@ public:
 
     template <typename S>
     swapped_t& operator=(const S& source) {
-        value = swap((T)source);
+        value = swap(static_cast<T>(source));
         return *this;
     }
 
     operator s8() const {
-        return (s8)swap();
+        return static_cast<s8>(swap());
     }
     operator u8() const {
-        return (u8)swap();
+        return static_cast<u8>(swap());
     }
     operator s16() const {
-        return (s16)swap();
+        return static_cast<s16>(swap());
     }
     operator u16() const {
-        return (u16)swap();
+        return static_cast<u16>(swap());
     }
     operator s32() const {
-        return (s32)swap();
+        return static_cast<s32>(swap());
     }
     operator u32() const {
-        return (u32)swap();
+        return static_cast<u32>(swap());
     }
     operator s64() const {
-        return (s64)swap();
+        return static_cast<s64>(swap());
     }
     operator u64() const {
-        return (u64)swap();
+        return static_cast<u64>(swap());
     }
     operator float() const {
-        return (float)swap();
+        return static_cast<float>(swap());
     }
     operator double() const {
-        return (double)swap();
+        return static_cast<double>(swap());
     }
 
     // +v
@@ -253,7 +253,7 @@ public:
     }
     template <typename S>
     swapped_t operator+(const S& i) const {
-        return swap() + (T)i;
+        return swap() + static_cast<T>(i);
     }
     // v - 5
     swapped_t operator-(const swapped_t& i) const {
@@ -261,7 +261,7 @@ public:
     }
     template <typename S>
     swapped_t operator-(const S& i) const {
-        return swap() - (T)i;
+        return swap() - static_cast<T>(i);
     }
 
     // v += 5
@@ -271,7 +271,7 @@ public:
     }
     template <typename S>
     swapped_t& operator+=(const S& i) {
-        value = swap(swap() + (T)i);
+        value = swap(swap() + static_cast<T>(i));
         return *this;
     }
     // v -= 5
@@ -281,7 +281,7 @@ public:
     }
     template <typename S>
     swapped_t& operator-=(const S& i) {
-        value = swap(swap() - (T)i);
+        value = swap(swap() - static_cast<T>(i));
         return *this;
     }
 
@@ -541,7 +541,7 @@ S operator&(const S& i, const swap_struct_t<T, F> v) {
 
 template <typename S, typename T, typename F>
 S operator&(const swap_struct_t<T, F> v, const S& i) {
-    return (S)(v.swap() & i);
+    return static_cast<S>(v.swap() & i);
 }
 
 // Comparaison
@@ -606,51 +606,51 @@ struct swap_double_t {
 };
 
 #if COMMON_LITTLE_ENDIAN
-typedef u32 u32_le;
-typedef u16 u16_le;
-typedef u64 u64_le;
+using u16_le = u16;
+using u32_le = u32;
+using u64_le = u64;
 
-typedef s32 s32_le;
-typedef s16 s16_le;
-typedef s64 s64_le;
+using s16_le = s16;
+using s32_le = s32;
+using s64_le = s64;
 
-typedef float float_le;
-typedef double double_le;
+using float_le = float;
+using double_le = double;
 
-typedef swap_struct_t<u64, swap_64_t<u64>> u64_be;
-typedef swap_struct_t<s64, swap_64_t<s64>> s64_be;
+using u64_be = swap_struct_t<u64, swap_64_t<u64>>;
+using s64_be = swap_struct_t<s64, swap_64_t<s64>>;
 
-typedef swap_struct_t<u32, swap_32_t<u32>> u32_be;
-typedef swap_struct_t<s32, swap_32_t<s32>> s32_be;
+using u32_be = swap_struct_t<u32, swap_32_t<u32>>;
+using s32_be = swap_struct_t<s32, swap_32_t<s32>>;
 
-typedef swap_struct_t<u16, swap_16_t<u16>> u16_be;
-typedef swap_struct_t<s16, swap_16_t<s16>> s16_be;
+using u16_be = swap_struct_t<u16, swap_16_t<u16>>;
+using s16_be = swap_struct_t<s16, swap_16_t<s16>>;
 
-typedef swap_struct_t<float, swap_float_t<float>> float_be;
-typedef swap_struct_t<double, swap_double_t<double>> double_be;
+using float_be = swap_struct_t<float, swap_float_t<float>>;
+using double_be = swap_struct_t<double, swap_double_t<double>>;
 #else
 
-typedef swap_struct_t<u64, swap_64_t<u64>> u64_le;
-typedef swap_struct_t<s64, swap_64_t<s64>> s64_le;
+using u64_le = swap_struct_t<u64, swap_64_t<u64>>;
+using s64_le = swap_struct_t<s64, swap_64_t<s64>>;
 
-typedef swap_struct_t<u32, swap_32_t<u32>> u32_le;
-typedef swap_struct_t<s32, swap_32_t<s32>> s32_le;
+using u32_le = swap_struct_t<u32, swap_32_t<u32>>;
+using s32_le = swap_struct_t<s32, swap_32_t<s32>>;
 
-typedef swap_struct_t<u16, swap_16_t<u16>> u16_le;
-typedef swap_struct_t<s16, swap_16_t<s16>> s16_le;
+using u16_le = swap_struct_t<u16, swap_16_t<u16>>;
+using s16_le = swap_struct_t<s16, swap_16_t<s16>>;
 
-typedef swap_struct_t<float, swap_float_t<float>> float_le;
-typedef swap_struct_t<double, swap_double_t<double>> double_le;
+using float_le = swap_struct_t<float, swap_float_t<float>>;
+using double_le = swap_struct_t<double, swap_double_t<double>>;
 
-typedef u32 u32_be;
-typedef u16 u16_be;
-typedef u64 u64_be;
+using u16_be = u16;
+using u32_be = u32;
+using u64_be = u64;
 
-typedef s32 s32_be;
-typedef s16 s16_be;
-typedef s64 s64_be;
+using s16_be = s16;
+using s32_be = s32;
+using s64_be = s64;
 
-typedef float float_be;
-typedef double double_be;
+using float_be = float;
+using double_be = double;
 
 #endif

src/common/synchronized_wrapper.h

@@ -1,85 +0,0 @@
-// Copyright 2015 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <algorithm>
-#include <mutex>
-
-namespace Common {
-
-template <typename T>
-class SynchronizedWrapper;
-
-/**
- * Synchronized reference, that keeps a SynchronizedWrapper's mutex locked during its lifetime. This
- * greatly reduces the chance that someone will access the wrapped resource without locking the
- * mutex.
- */
-template <typename T>
-class SynchronizedRef {
-public:
-    SynchronizedRef(SynchronizedWrapper<T>& wrapper) : wrapper(&wrapper) {
-        wrapper.mutex.lock();
-    }
-
-    SynchronizedRef(SynchronizedRef&) = delete;
-    SynchronizedRef(SynchronizedRef&& o) : wrapper(o.wrapper) {
-        o.wrapper = nullptr;
-    }
-
-    ~SynchronizedRef() {
-        if (wrapper)
-            wrapper->mutex.unlock();
-    }
-
-    SynchronizedRef& operator=(SynchronizedRef&) = delete;
-    SynchronizedRef& operator=(SynchronizedRef&& o) {
-        std::swap(wrapper, o.wrapper);
-        return *this;
-    }
-
-    T& operator*() {
-        return wrapper->data;
-    }
-    const T& operator*() const {
-        return wrapper->data;
-    }
-
-    T* operator->() {
-        return &wrapper->data;
-    }
-    const T* operator->() const {
-        return &wrapper->data;
-    }
-
-private:
-    SynchronizedWrapper<T>* wrapper;
-};
-
-/**
- * Wraps an object, only allowing access to it via a locking reference wrapper. Good to ensure no
- * one forgets to lock a mutex before acessing an object. To access the wrapped object construct a
- * SyncronizedRef on this wrapper. Inspired by Rust's Mutex type
- * (http://doc.rust-lang.org/std/sync/struct.Mutex.html).
- */
-template <typename T>
-class SynchronizedWrapper {
-public:
-    template <typename... Args>
-    SynchronizedWrapper(Args&&... args) : data(std::forward<Args>(args)...) {}
-
-    SynchronizedRef<T> Lock() {
-        return {*this};
-    }
-
-private:
-    template <typename U>
-    friend class SynchronizedRef;
-
-    std::mutex mutex;
-    T data;
-};
-
-} // namespace Common

src/common/telemetry.h

@@ -52,27 +52,14 @@ public:
 template <typename T>
 class Field : public FieldInterface {
 public:
-    Field(FieldType type, std::string name, const T& value)
-        : name(std::move(name)), type(type), value(value) {}
-
-    Field(FieldType type, std::string name, T&& value)
+    Field(FieldType type, std::string name, T value)
         : name(std::move(name)), type(type), value(std::move(value)) {}
 
-    Field(const Field& other) : Field(other.type, other.name, other.value) {}
+    Field(const Field&) = default;
+    Field& operator=(const Field&) = default;
 
-    Field& operator=(const Field& other) {
-        type = other.type;
-        name = other.name;
-        value = other.value;
-        return *this;
-    }
-
-    Field& operator=(Field&& other) {
-        type = other.type;
-        name = std::move(other.name);
-        value = std::move(other.value);
-        return *this;
-    }
+    Field(Field&&) = default;
+    Field& operator=(Field&& other) = default;
 
     void Accept(VisitorInterface& visitor) const override;
 
@@ -94,11 +81,11 @@ public:
         return value;
     }
 
-    inline bool operator==(const Field<T>& other) {
+    bool operator==(const Field& other) const {
         return (type == other.type) && (name == other.name) && (value == other.value);
     }
 
-    inline bool operator!=(const Field<T>& other) {
+    bool operator!=(const Field& other) const {
         return !(*this == other);
     }
 

src/core/CMakeLists.txt

@@ -12,15 +12,17 @@ add_library(core STATIC
     file_sys/content_archive.h
     file_sys/directory.h
     file_sys/errors.h
-    file_sys/filesystem.cpp
-    file_sys/filesystem.h
+    file_sys/mode.h
     file_sys/partition_filesystem.cpp
     file_sys/partition_filesystem.h
-    file_sys/path_parser.cpp
-    file_sys/path_parser.h
     file_sys/program_metadata.cpp
     file_sys/program_metadata.h
-    file_sys/storage.h
+    file_sys/romfs_factory.cpp
+    file_sys/romfs_factory.h
+    file_sys/savedata_factory.cpp
+    file_sys/savedata_factory.h
+    file_sys/sdmc_factory.cpp
+    file_sys/sdmc_factory.h
     file_sys/vfs.cpp
     file_sys/vfs.h
     file_sys/vfs_offset.cpp

src/core/arm/arm_interface.h

@@ -20,9 +20,6 @@ public:
         u64 cpsr;
         std::array<u128, 32> fpu_registers;
         u64 fpscr;
-
-        // TODO(bunnei): Fix once we have proper support for tpidrro_el0, etc. in the JIT
-        VAddr tls_address;
     };
 
     /// Runs the CPU until an event happens
@@ -104,6 +101,10 @@ public:
 
     virtual void SetTlsAddress(VAddr address) = 0;
 
+    virtual u64 GetTPIDR_EL0() const = 0;
+
+    virtual void SetTPIDR_EL0(u64 value) = 0;
+
     /**
      * Saves the current CPU context
      * @param ctx Thread context to save
@@ -116,6 +117,8 @@ public:
      */
     virtual void LoadContext(const ThreadContext& ctx) = 0;
 
+    virtual void ClearExclusiveState() = 0;
+
     /// Prepare core for thread reschedule (if needed to correctly handle state)
     virtual void PrepareReschedule() = 0;
 };

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -196,6 +196,14 @@ void ARM_Dynarmic::SetTlsAddress(u64 address) {
     cb->tpidrro_el0 = address;
 }
 
+u64 ARM_Dynarmic::GetTPIDR_EL0() const {
+    return cb->tpidr_el0;
+}
+
+void ARM_Dynarmic::SetTPIDR_EL0(u64 value) {
+    cb->tpidr_el0 = value;
+}
+
 void ARM_Dynarmic::SaveContext(ARM_Interface::ThreadContext& ctx) {
     ctx.cpu_registers = jit->GetRegisters();
     ctx.sp = jit->GetSP();
@@ -203,7 +211,6 @@ void ARM_Dynarmic::SaveContext(ARM_Interface::ThreadContext& ctx) {
     ctx.cpsr = jit->GetPstate();
     ctx.fpu_registers = jit->GetVectors();
     ctx.fpscr = jit->GetFpcr();
-    ctx.tls_address = cb->tpidrro_el0;
 }
 
 void ARM_Dynarmic::LoadContext(const ARM_Interface::ThreadContext& ctx) {
@@ -213,7 +220,6 @@ void ARM_Dynarmic::LoadContext(const ARM_Interface::ThreadContext& ctx) {
     jit->SetPstate(static_cast<u32>(ctx.cpsr));
     jit->SetVectors(ctx.fpu_registers);
     jit->SetFpcr(static_cast<u32>(ctx.fpscr));
-    cb->tpidrro_el0 = ctx.tls_address;
 }
 
 void ARM_Dynarmic::PrepareReschedule() {
@@ -226,6 +232,10 @@ void ARM_Dynarmic::ClearInstructionCache() {
     jit->ClearCache();
 }
 
+void ARM_Dynarmic::ClearExclusiveState() {
+    jit->ClearExclusiveState();
+}
+
 void ARM_Dynarmic::PageTableChanged() {
     jit = MakeJit(cb);
     current_page_table = Memory::GetCurrentPageTable();

src/core/arm/dynarmic/arm_dynarmic.h

@@ -34,11 +34,14 @@ public:
     void SetCPSR(u32 cpsr) override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
+    void SetTPIDR_EL0(u64 value) override;
+    u64 GetTPIDR_EL0() const override;
 
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;
 
     void PrepareReschedule() override;
+    void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
     void PageTableChanged() override;

src/core/arm/unicorn/arm_unicorn.cpp

@@ -169,6 +169,16 @@ void ARM_Unicorn::SetTlsAddress(VAddr base) {
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDRRO_EL0, &base));
 }
 
+u64 ARM_Unicorn::GetTPIDR_EL0() const {
+    u64 value{};
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_TPIDR_EL0, &value));
+    return value;
+}
+
+void ARM_Unicorn::SetTPIDR_EL0(u64 value) {
+    CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDR_EL0, &value));
+}
+
 void ARM_Unicorn::Run() {
     if (GDBStub::IsServerEnabled()) {
         ExecuteInstructions(std::max(4000000, 0));
@@ -193,11 +203,11 @@ void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
         }
         Kernel::Thread* thread = Kernel::GetCurrentThread();
         SaveContext(thread->context);
-        if (last_bkpt_hit) {
+        if (last_bkpt_hit || (num_instructions == 1)) {
             last_bkpt_hit = false;
             GDBStub::Break();
+            GDBStub::SendTrap(thread, 5);
         }
-        GDBStub::SendTrap(thread, 5);
     }
 }
 
@@ -220,8 +230,6 @@ void ARM_Unicorn::SaveContext(ARM_Interface::ThreadContext& ctx) {
 
     CHECKED(uc_reg_read_batch(uc, uregs, tregs, 31));
 
-    ctx.tls_address = GetTlsAddress();
-
     for (int i = 0; i < 32; ++i) {
         uregs[i] = UC_ARM64_REG_Q0 + i;
         tregs[i] = &ctx.fpu_registers[i];
@@ -249,8 +257,6 @@ void ARM_Unicorn::LoadContext(const ARM_Interface::ThreadContext& ctx) {
 
     CHECKED(uc_reg_write_batch(uc, uregs, tregs, 31));
 
-    SetTlsAddress(ctx.tls_address);
-
     for (auto i = 0; i < 32; ++i) {
         uregs[i] = UC_ARM64_REG_Q0 + i;
         tregs[i] = (void*)&ctx.fpu_registers[i];
@@ -263,6 +269,8 @@ void ARM_Unicorn::PrepareReschedule() {
     CHECKED(uc_emu_stop(uc));
 }
 
+void ARM_Unicorn::ClearExclusiveState() {}
+
 void ARM_Unicorn::ClearInstructionCache() {}
 
 void ARM_Unicorn::RecordBreak(GDBStub::BreakpointAddress bkpt) {

src/core/arm/unicorn/arm_unicorn.h

@@ -28,9 +28,12 @@ public:
     void SetCPSR(u32 cpsr) override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
+    void SetTPIDR_EL0(u64 value) override;
+    u64 GetTPIDR_EL0() const override;
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;
     void PrepareReschedule() override;
+    void ClearExclusiveState() override;
     void ExecuteInstructions(int num_instructions);
     void Run() override;
     void Step() override;

src/core/core.cpp

@@ -26,11 +26,13 @@ namespace Core {
 
 /*static*/ System System::s_instance;
 
+System::System() = default;
+
 System::~System() = default;
 
 /// Runs a CPU core while the system is powered on
 static void RunCpuCore(std::shared_ptr<Cpu> cpu_state) {
-    while (Core::System().GetInstance().IsPoweredOn()) {
+    while (Core::System::GetInstance().IsPoweredOn()) {
         cpu_state->RunLoop(true);
     }
 }

src/core/core.h

@@ -168,6 +168,8 @@ public:
     }
 
 private:
+    System();
+
     /// Returns the currently running CPU core
     Cpu& CurrentCpuCore();
 

src/core/file_sys/content_archive.cpp

@@ -2,6 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <algorithm>
+#include <utility>
+
 #include "common/logging/log.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/vfs_offset.h"
@@ -17,7 +20,10 @@ constexpr u64 SECTION_HEADER_OFFSET = 0x400;
 
 constexpr u32 IVFC_MAX_LEVEL = 6;
 
-enum class NCASectionFilesystemType : u8 { PFS0 = 0x2, ROMFS = 0x3 };
+enum class NCASectionFilesystemType : u8 {
+    PFS0 = 0x2,
+    ROMFS = 0x3,
+};
 
 struct NCASectionHeaderBlock {
     INSERT_PADDING_BYTES(3);
@@ -58,7 +64,7 @@ struct RomFSSuperblock {
 };
 static_assert(sizeof(RomFSSuperblock) == 0xE8, "RomFSSuperblock has incorrect size.");
 
-NCA::NCA(VirtualFile file_) : file(file_) {
+NCA::NCA(VirtualFile file_) : file(std::move(file_)) {
     if (sizeof(NCAHeader) != file->ReadObject(&header))
         LOG_CRITICAL(Loader, "File reader errored out during header read.");
 

src/core/file_sys/content_archive.h

@@ -4,6 +4,11 @@
 
 #pragma once
 
+#include <array>
+#include <memory>
+#include <string>
+#include <vector>
+
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
@@ -11,7 +16,13 @@
 
 namespace FileSys {
 
-enum class NCAContentType : u8 { Program = 0, Meta = 1, Control = 2, Manual = 3, Data = 4 };
+enum class NCAContentType : u8 {
+    Program = 0,
+    Meta = 1,
+    Control = 2,
+    Manual = 3,
+    Data = 4,
+};
 
 struct NCASectionTableEntry {
     u32_le media_offset;
@@ -42,12 +53,12 @@ struct NCAHeader {
 };
 static_assert(sizeof(NCAHeader) == 0x400, "NCAHeader has incorrect size.");
 
-static bool IsDirectoryExeFS(std::shared_ptr<FileSys::VfsDirectory> pfs) {
+inline bool IsDirectoryExeFS(const std::shared_ptr<VfsDirectory>& pfs) {
     // According to switchbrew, an exefs must only contain these two files:
     return pfs->GetFile("main") != nullptr && pfs->GetFile("main.npdm") != nullptr;
 }
 
-static bool IsValidNCA(const NCAHeader& header) {
+inline bool IsValidNCA(const NCAHeader& header) {
     return header.magic == Common::MakeMagic('N', 'C', 'A', '2') ||
            header.magic == Common::MakeMagic('N', 'C', 'A', '3');
 }

src/core/file_sys/directory.h

@@ -8,13 +8,17 @@
 #include <cstddef>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "core/file_sys/filesystem.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // FileSys namespace
 
 namespace FileSys {
 
+enum EntryType : u8 {
+    Directory = 0,
+    File = 1,
+};
+
 // Structure of a directory entry, from
 // http://switchbrew.org/index.php?title=Filesystem_services#DirectoryEntry
 const size_t FILENAME_LENGTH = 0x300;

src/core/file_sys/errors.h

@@ -11,19 +11,22 @@ namespace FileSys {
 namespace ErrCodes {
 enum {
     NotFound = 1,
+    TitleNotFound = 1002,
+    SdCardNotFound = 2001,
+    RomFSNotFound = 2520,
 };
 }
 
 constexpr ResultCode ERROR_PATH_NOT_FOUND(ErrorModule::FS, ErrCodes::NotFound);
 
 // TODO(bunnei): Replace these with correct errors for Switch OS
-constexpr ResultCode ERROR_INVALID_PATH(ResultCode(-1));
-constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(ResultCode(-1));
-constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(ResultCode(-1));
-constexpr ResultCode ERROR_FILE_NOT_FOUND(ResultCode(-1));
-constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(ResultCode(-1));
-constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(ResultCode(-1));
-constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(ResultCode(-1));
-constexpr ResultCode ERROR_DIRECTORY_NOT_EMPTY(ResultCode(-1));
+constexpr ResultCode ERROR_INVALID_PATH(-1);
+constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(-1);
+constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(-1);
+constexpr ResultCode ERROR_FILE_NOT_FOUND(-1);
+constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(-1);
+constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(-1);
+constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(-1);
+constexpr ResultCode ERROR_DIRECTORY_NOT_EMPTY(-1);
 
 } // namespace FileSys

src/core/file_sys/filesystem.cpp

@@ -1,122 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstddef>
-#include <iomanip>
-#include <sstream>
-#include "common/logging/log.h"
-#include "common/string_util.h"
-#include "core/file_sys/filesystem.h"
-#include "core/memory.h"
-
-namespace FileSys {
-
-Path::Path(LowPathType type, u32 size, u32 pointer) : type(type) {
-    switch (type) {
-    case Binary: {
-        binary.resize(size);
-        Memory::ReadBlock(pointer, binary.data(), binary.size());
-        break;
-    }
-
-    case Char: {
-        string.resize(size - 1); // Data is always null-terminated.
-        Memory::ReadBlock(pointer, &string[0], string.size());
-        break;
-    }
-
-    case Wchar: {
-        u16str.resize(size / 2 - 1); // Data is always null-terminated.
-        Memory::ReadBlock(pointer, &u16str[0], u16str.size() * sizeof(char16_t));
-        break;
-    }
-
-    default:
-        break;
-    }
-}
-
-std::string Path::DebugStr() const {
-    switch (GetType()) {
-    case Invalid:
-    default:
-        return "[Invalid]";
-    case Empty:
-        return "[Empty]";
-    case Binary: {
-        std::stringstream res;
-        res << "[Binary: ";
-        for (unsigned byte : binary)
-            res << std::hex << std::setw(2) << std::setfill('0') << byte;
-        res << ']';
-        return res.str();
-    }
-    case Char:
-        return "[Char: " + AsString() + ']';
-    case Wchar:
-        return "[Wchar: " + AsString() + ']';
-    }
-}
-
-std::string Path::AsString() const {
-    switch (GetType()) {
-    case Char:
-        return string;
-    case Wchar:
-        return Common::UTF16ToUTF8(u16str);
-    case Empty:
-        return {};
-    case Invalid:
-    case Binary:
-    default:
-        // TODO(yuriks): Add assert
-        LOG_ERROR(Service_FS, "LowPathType cannot be converted to string!");
-        return {};
-    }
-}
-
-std::u16string Path::AsU16Str() const {
-    switch (GetType()) {
-    case Char:
-        return Common::UTF8ToUTF16(string);
-    case Wchar:
-        return u16str;
-    case Empty:
-        return {};
-    case Invalid:
-    case Binary:
-        // TODO(yuriks): Add assert
-        LOG_ERROR(Service_FS, "LowPathType cannot be converted to u16string!");
-        return {};
-    }
-
-    UNREACHABLE();
-}
-
-std::vector<u8> Path::AsBinary() const {
-    switch (GetType()) {
-    case Binary:
-        return binary;
-    case Char:
-        return std::vector<u8>(string.begin(), string.end());
-    case Wchar: {
-        // use two u8 for each character of u16str
-        std::vector<u8> to_return(u16str.size() * 2);
-        for (size_t i = 0; i < u16str.size(); ++i) {
-            u16 tmp_char = u16str.at(i);
-            to_return[i * 2] = (tmp_char & 0xFF00) >> 8;
-            to_return[i * 2 + 1] = (tmp_char & 0x00FF);
-        }
-        return to_return;
-    }
-    case Empty:
-        return {};
-    case Invalid:
-    default:
-        // TODO(yuriks): Add assert
-        LOG_ERROR(Service_FS, "LowPathType cannot be converted to binary!");
-        return {};
-    }
-}
-} // namespace FileSys

src/core/file_sys/filesystem.h

@@ -1,69 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/hle/result.h"
-
-namespace FileSys {
-
-class StorageBackend;
-class DirectoryBackend;
-
-// Path string type
-enum LowPathType : u32 {
-    Invalid = 0,
-    Empty = 1,
-    Binary = 2,
-    Char = 3,
-    Wchar = 4,
-};
-
-enum EntryType : u8 {
-    Directory = 0,
-    File = 1,
-};
-
-enum class Mode : u32 {
-    Read = 1,
-    Write = 2,
-    Append = 4,
-};
-
-class Path {
-public:
-    Path() : type(Invalid) {}
-    Path(const char* path) : type(Char), string(path) {}
-    Path(std::vector<u8> binary_data) : type(Binary), binary(std::move(binary_data)) {}
-    Path(LowPathType type, u32 size, u32 pointer);
-
-    LowPathType GetType() const {
-        return type;
-    }
-
-    /**
-     * Gets the string representation of the path for debugging
-     * @return String representation of the path for debugging
-     */
-    std::string DebugStr() const;
-
-    std::string AsString() const;
-    std::u16string AsU16Str() const;
-    std::vector<u8> AsBinary() const;
-
-private:
-    LowPathType type;
-    std::vector<u8> binary;
-    std::string string;
-    std::u16string u16str;
-};
-
-} // namespace FileSys

src/core/file_sys/mode.h

@@ -0,0 +1,17 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace FileSys {
+
+enum class Mode : u32 {
+    Read = 1,
+    Write = 2,
+    Append = 4,
+};
+
+} // namespace FileSys

src/core/file_sys/partition_filesystem.cpp

@@ -2,7 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <algorithm>
+#include <cstddef>
+#include <cstring>
+#include <iterator>
 #include <utility>
+
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "core/file_sys/partition_filesystem.h"
@@ -11,6 +16,11 @@
 
 namespace FileSys {
 
+bool PartitionFilesystem::Header::HasValidMagicValue() const {
+    return magic == Common::MakeMagic('H', 'F', 'S', '0') ||
+           magic == Common::MakeMagic('P', 'F', 'S', '0');
+}
+
 PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
     // At least be as large as the header
     if (file->GetSize() < sizeof(Header)) {
@@ -20,19 +30,17 @@ PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
 
     // For cartridges, HFSs can get very large, so we need to calculate the size up to
     // the actual content itself instead of just blindly reading in the entire file.
-    Header pfs_header;
     if (sizeof(Header) != file->ReadObject(&pfs_header)) {
         status = Loader::ResultStatus::Error;
         return;
     }
 
-    if (pfs_header.magic != Common::MakeMagic('H', 'F', 'S', '0') &&
-        pfs_header.magic != Common::MakeMagic('P', 'F', 'S', '0')) {
+    if (!pfs_header.HasValidMagicValue()) {
         status = Loader::ResultStatus::ErrorInvalidFormat;
         return;
     }
 
-    bool is_hfs = pfs_header.magic == Common::MakeMagic('H', 'F', 'S', '0');
+    is_hfs = pfs_header.magic == Common::MakeMagic('H', 'F', 'S', '0');
 
     size_t entry_size = is_hfs ? sizeof(HFSEntry) : sizeof(PFSEntry);
     size_t metadata_size =
@@ -40,27 +48,13 @@ PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
 
     // Actually read in now...
     std::vector<u8> file_data = file->ReadBytes(metadata_size);
+    const size_t total_size = file_data.size();
 
-    if (file_data.size() != metadata_size) {
+    if (total_size != metadata_size) {
         status = Loader::ResultStatus::Error;
         return;
     }
 
-    size_t total_size = file_data.size();
-    if (total_size < sizeof(Header)) {
-        status = Loader::ResultStatus::Error;
-        return;
-    }
-
-    memcpy(&pfs_header, file_data.data(), sizeof(Header));
-    if (pfs_header.magic != Common::MakeMagic('H', 'F', 'S', '0') &&
-        pfs_header.magic != Common::MakeMagic('P', 'F', 'S', '0')) {
-        status = Loader::ResultStatus::ErrorInvalidFormat;
-        return;
-    }
-
-    is_hfs = pfs_header.magic == Common::MakeMagic('H', 'F', 'S', '0');
-
     size_t entries_offset = sizeof(Header);
     size_t strtab_offset = entries_offset + (pfs_header.num_entries * entry_size);
     content_offset = strtab_offset + pfs_header.strtab_size;
@@ -87,7 +81,7 @@ std::vector<std::shared_ptr<VfsFile>> PartitionFilesystem::GetFiles() const {
 }
 
 std::vector<std::shared_ptr<VfsDirectory>> PartitionFilesystem::GetSubdirectories() const {
-    return {};
+    return pfs_dirs;
 }
 
 std::string PartitionFilesystem::GetName() const {
@@ -110,14 +104,15 @@ void PartitionFilesystem::PrintDebugInfo() const {
 }
 
 bool PartitionFilesystem::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
-    auto iter = std::find(pfs_files.begin(), pfs_files.end(), file);
+    const auto iter = std::find(pfs_files.begin(), pfs_files.end(), file);
     if (iter == pfs_files.end())
         return false;
 
-    pfs_files[iter - pfs_files.begin()] = pfs_files.back();
+    const std::ptrdiff_t offset = std::distance(pfs_files.begin(), iter);
+    pfs_files[offset] = pfs_files.back();
     pfs_files.pop_back();
 
-    pfs_dirs.emplace_back(dir);
+    pfs_dirs.emplace_back(std::move(dir));
 
     return true;
 }

src/core/file_sys/partition_filesystem.h

@@ -42,6 +42,8 @@ private:
         u32_le num_entries;
         u32_le strtab_size;
         INSERT_PADDING_BYTES(0x4);
+
+        bool HasValidMagicValue() const;
     };
 
     static_assert(sizeof(Header) == 0x10, "PFS/HFS header structure size is wrong");
@@ -73,11 +75,11 @@ private:
 
 #pragma pack(pop)
 
-    Loader::ResultStatus status;
+    Loader::ResultStatus status{};
 
-    Header pfs_header;
-    bool is_hfs;
-    size_t content_offset;
+    Header pfs_header{};
+    bool is_hfs = false;
+    size_t content_offset = 0;
 
     std::vector<VirtualFile> pfs_files;
     std::vector<VirtualDir> pfs_dirs;

src/core/file_sys/path_parser.cpp

@@ -1,98 +0,0 @@
-// Copyright 2016 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <set>
-#include "common/file_util.h"
-#include "common/string_util.h"
-#include "core/file_sys/path_parser.h"
-
-namespace FileSys {
-
-PathParser::PathParser(const Path& path) {
-    if (path.GetType() != LowPathType::Char && path.GetType() != LowPathType::Wchar) {
-        is_valid = false;
-        return;
-    }
-
-    auto path_string = path.AsString();
-    if (path_string.size() == 0 || path_string[0] != '/') {
-        is_valid = false;
-        return;
-    }
-
-    // Filter out invalid characters for the host system.
-    // Although some of these characters are valid on 3DS, they are unlikely to be used by games.
-    if (std::find_if(path_string.begin(), path_string.end(), [](char c) {
-            static const std::set<char> invalid_chars{'<', '>', '\\', '|', ':', '\"', '*', '?'};
-            return invalid_chars.find(c) != invalid_chars.end();
-        }) != path_string.end()) {
-        is_valid = false;
-        return;
-    }
-
-    Common::SplitString(path_string, '/', path_sequence);
-
-    auto begin = path_sequence.begin();
-    auto end = path_sequence.end();
-    end = std::remove_if(begin, end, [](std::string& str) { return str == "" || str == "."; });
-    path_sequence = std::vector<std::string>(begin, end);
-
-    // checks if the path is out of bounds.
-    int level = 0;
-    for (auto& node : path_sequence) {
-        if (node == "..") {
-            --level;
-            if (level < 0) {
-                is_valid = false;
-                return;
-            }
-        } else {
-            ++level;
-        }
-    }
-
-    is_valid = true;
-    is_root = level == 0;
-}
-
-PathParser::HostStatus PathParser::GetHostStatus(const std::string& mount_point) const {
-    auto path = mount_point;
-    if (!FileUtil::IsDirectory(path))
-        return InvalidMountPoint;
-    if (path_sequence.empty()) {
-        return DirectoryFound;
-    }
-
-    for (auto iter = path_sequence.begin(); iter != path_sequence.end() - 1; iter++) {
-        if (path.back() != '/')
-            path += '/';
-        path += *iter;
-
-        if (!FileUtil::Exists(path))
-            return PathNotFound;
-        if (FileUtil::IsDirectory(path))
-            continue;
-        return FileInPath;
-    }
-
-    path += "/" + path_sequence.back();
-    if (!FileUtil::Exists(path))
-        return NotFound;
-    if (FileUtil::IsDirectory(path))
-        return DirectoryFound;
-    return FileFound;
-}
-
-std::string PathParser::BuildHostPath(const std::string& mount_point) const {
-    std::string path = mount_point;
-    for (auto& node : path_sequence) {
-        if (path.back() != '/')
-            path += '/';
-        path += node;
-    }
-    return path;
-}
-
-} // namespace FileSys

src/core/file_sys/path_parser.h

@@ -1,61 +0,0 @@
-// Copyright 2016 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-#include <vector>
-#include "core/file_sys/filesystem.h"
-
-namespace FileSys {
-
-/**
- * A helper class parsing and verifying a string-type Path.
- * Every archives with a sub file system should use this class to parse the path argument and check
- * the status of the file / directory in question on the host file system.
- */
-class PathParser {
-public:
-    explicit PathParser(const Path& path);
-
-    /**
-     * Checks if the Path is valid.
-     * This function should be called once a PathParser is constructed.
-     * A Path is valid if:
-     *  - it is a string path (with type LowPathType::Char or LowPathType::Wchar),
-     *  - it starts with "/" (this seems a hard requirement in real 3DS),
-     *  - it doesn't contain invalid characters, and
-     *  - it doesn't go out of the root directory using "..".
-     */
-    bool IsValid() const {
-        return is_valid;
-    }
-
-    /// Checks if the Path represents the root directory.
-    bool IsRootDirectory() const {
-        return is_root;
-    }
-
-    enum HostStatus {
-        InvalidMountPoint,
-        PathNotFound,   // "/a/b/c" when "a" doesn't exist
-        FileInPath,     // "/a/b/c" when "a" is a file
-        FileFound,      // "/a/b/c" when "c" is a file
-        DirectoryFound, // "/a/b/c" when "c" is a directory
-        NotFound        // "/a/b/c" when "a/b/" exists but "c" doesn't exist
-    };
-
-    /// Checks the status of the specified file / directory by the Path on the host file system.
-    HostStatus GetHostStatus(const std::string& mount_point) const;
-
-    /// Builds a full path on the host file system.
-    std::string BuildHostPath(const std::string& mount_point) const;
-
-private:
-    std::vector<std::string> path_sequence;
-    bool is_valid{};
-    bool is_root{};
-};
-
-} // namespace FileSys

src/core/file_sys/romfs_factory.cpp

@@ -0,0 +1,25 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <memory>
+#include "common/common_types.h"
+#include "common/logging/log.h"
+#include "core/file_sys/romfs_factory.h"
+
+namespace FileSys {
+
+RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
+    // Load the RomFS from the app
+    if (Loader::ResultStatus::Success != app_loader.ReadRomFS(file)) {
+        LOG_ERROR(Service_FS, "Unable to read RomFS!");
+    }
+}
+
+ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id) {
+    // TODO(DarkLordZach): Use title id.
+    return MakeResult<VirtualFile>(file);
+}
+
+} // namespace FileSys

src/core/file_sys/romfs_factory.h

@@ -0,0 +1,25 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include "common/common_types.h"
+#include "core/hle/result.h"
+#include "core/loader/loader.h"
+
+namespace FileSys {
+
+/// File system interface to the RomFS archive
+class RomFSFactory {
+public:
+    explicit RomFSFactory(Loader::AppLoader& app_loader);
+
+    ResultVal<VirtualFile> Open(u64 title_id);
+
+private:
+    VirtualFile file;
+};
+
+} // namespace FileSys

src/core/file_sys/savedata_factory.cpp

@@ -0,0 +1,106 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+#include "common/common_types.h"
+#include "common/logging/log.h"
+#include "core/core.h"
+#include "core/file_sys/savedata_factory.h"
+#include "core/hle/kernel/process.h"
+
+namespace FileSys {
+
+std::string SaveDataDescriptor::DebugInfo() const {
+    return fmt::format("[type={:02X}, title_id={:016X}, user_id={:016X}{:016X}, save_id={:016X}]",
+                       static_cast<u8>(type), title_id, user_id[1], user_id[0], save_id);
+}
+
+SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {}
+
+ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, SaveDataDescriptor meta) {
+    if (meta.type == SaveDataType::SystemSaveData || meta.type == SaveDataType::SaveData) {
+        if (meta.zero_1 != 0) {
+            LOG_WARNING(Service_FS,
+                        "Possibly incorrect SaveDataDescriptor, type is "
+                        "SystemSaveData||SaveData but offset 0x28 is non-zero ({:016X}).",
+                        meta.zero_1);
+        }
+        if (meta.zero_2 != 0) {
+            LOG_WARNING(Service_FS,
+                        "Possibly incorrect SaveDataDescriptor, type is "
+                        "SystemSaveData||SaveData but offset 0x30 is non-zero ({:016X}).",
+                        meta.zero_2);
+        }
+        if (meta.zero_3 != 0) {
+            LOG_WARNING(Service_FS,
+                        "Possibly incorrect SaveDataDescriptor, type is "
+                        "SystemSaveData||SaveData but offset 0x38 is non-zero ({:016X}).",
+                        meta.zero_3);
+        }
+    }
+
+    if (meta.type == SaveDataType::SystemSaveData && meta.title_id != 0) {
+        LOG_WARNING(Service_FS,
+                    "Possibly incorrect SaveDataDescriptor, type is SystemSaveData but title_id is "
+                    "non-zero ({:016X}).",
+                    meta.title_id);
+    }
+
+    std::string save_directory =
+        GetFullPath(space, meta.type, meta.title_id, meta.user_id, meta.save_id);
+
+    // TODO(DarkLordZach): Try to not create when opening, there are dedicated create save methods.
+    // But, user_ids don't match so this works for now.
+
+    auto out = dir->GetDirectoryRelative(save_directory);
+
+    if (out == nullptr) {
+        // TODO(bunnei): This is a work-around to always create a save data directory if it does not
+        // already exist. This is a hack, as we do not understand yet how this works on hardware.
+        // Without a save data directory, many games will assert on boot. This should not have any
+        // bad side-effects.
+        out = dir->CreateDirectoryRelative(save_directory);
+    }
+
+    // Return an error if the save data doesn't actually exist.
+    if (out == nullptr) {
+        // TODO(Subv): Find out correct error code.
+        return ResultCode(-1);
+    }
+
+    return MakeResult<VirtualDir>(std::move(out));
+}
+
+std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id,
+                                         u128 user_id, u64 save_id) const {
+    // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
+    // be interpreted as the title id of the current process.
+    if (type == SaveDataType::SaveData && title_id == 0)
+        title_id = Core::CurrentProcess()->program_id;
+
+    std::string out;
+
+    switch (space) {
+    case SaveDataSpaceId::NandSystem:
+        out = "/system/save/";
+        break;
+    case SaveDataSpaceId::NandUser:
+        out = "/user/save/";
+        break;
+    default:
+        ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
+    }
+
+    switch (type) {
+    case SaveDataType::SystemSaveData:
+        return fmt::format("{}{:016X}/{:016X}{:016X}", out, save_id, user_id[1], user_id[0]);
+    case SaveDataType::SaveData:
+        return fmt::format("{}{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
+                           title_id);
+    default:
+        ASSERT_MSG(false, "Unrecognized SaveDataType: {:02X}", static_cast<u8>(type));
+    }
+}
+
+} // namespace FileSys

src/core/file_sys/savedata_factory.h

@@ -0,0 +1,58 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include "common/common_types.h"
+#include "core/hle/result.h"
+
+namespace FileSys {
+
+enum class SaveDataSpaceId : u8 {
+    NandSystem = 0,
+    NandUser = 1,
+    SdCard = 2,
+    TemporaryStorage = 3,
+};
+
+enum class SaveDataType : u8 {
+    SystemSaveData = 0,
+    SaveData = 1,
+    BcatDeliveryCacheStorage = 2,
+    DeviceSaveData = 3,
+    TemporaryStorage = 4,
+    CacheStorage = 5,
+};
+
+struct SaveDataDescriptor {
+    u64_le title_id;
+    u128 user_id;
+    u64_le save_id;
+    SaveDataType type;
+    INSERT_PADDING_BYTES(7);
+    u64_le zero_1;
+    u64_le zero_2;
+    u64_le zero_3;
+
+    std::string DebugInfo() const;
+};
+static_assert(sizeof(SaveDataDescriptor) == 0x40, "SaveDataDescriptor has incorrect size.");
+
+/// File system interface to the SaveData archive
+class SaveDataFactory {
+public:
+    explicit SaveDataFactory(VirtualDir dir);
+
+    ResultVal<VirtualDir> Open(SaveDataSpaceId space, SaveDataDescriptor meta);
+
+private:
+    VirtualDir dir;
+
+    std::string GetFullPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id,
+                            u64 save_id) const;
+};
+
+} // namespace FileSys

src/core/file_sys/sdmc_factory.cpp

@@ -0,0 +1,17 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+#include "core/core.h"
+#include "core/file_sys/sdmc_factory.h"
+
+namespace FileSys {
+
+SDMCFactory::SDMCFactory(VirtualDir dir) : dir(std::move(dir)) {}
+
+ResultVal<VirtualDir> SDMCFactory::Open() {
+    return MakeResult<VirtualDir>(dir);
+}
+
+} // namespace FileSys

src/core/file_sys/sdmc_factory.h

@@ -0,0 +1,22 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/result.h"
+
+namespace FileSys {
+
+/// File system interface to the SDCard archive
+class SDMCFactory {
+public:
+    explicit SDMCFactory(VirtualDir dir);
+
+    ResultVal<VirtualDir> Open();
+
+private:
+    VirtualDir dir;
+};
+
+} // namespace FileSys

src/core/file_sys/storage.h

@@ -1,63 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-#include "common/common_types.h"
-#include "core/hle/result.h"
-
-namespace FileSys {
-
-class StorageBackend : NonCopyable {
-public:
-    StorageBackend() {}
-    virtual ~StorageBackend() {}
-
-    /**
-     * Read data from the file
-     * @param offset Offset in bytes to start reading data from
-     * @param length Length in bytes of data to read from file
-     * @param buffer Buffer to read data into
-     * @return Number of bytes read, or error code
-     */
-    virtual ResultVal<size_t> Read(u64 offset, size_t length, u8* buffer) const = 0;
-
-    /**
-     * Write data to the file
-     * @param offset Offset in bytes to start writing data to
-     * @param length Length in bytes of data to write to file
-     * @param flush The flush parameters (0 == do not flush)
-     * @param buffer Buffer to read data from
-     * @return Number of bytes written, or error code
-     */
-    virtual ResultVal<size_t> Write(u64 offset, size_t length, bool flush,
-                                    const u8* buffer) const = 0;
-
-    /**
-     * Flushes the file
-     */
-    virtual void Flush() const = 0;
-
-    /**
-     * Set the size of the file in bytes
-     * @param size New size of the file
-     * @return true if successful
-     */
-    virtual bool SetSize(u64 size) const = 0;
-
-    /**
-     * Get the size of the file in bytes
-     * @return Size of the file in bytes
-     */
-    virtual u64 GetSize() const = 0;
-
-    /**
-     * Close the file
-     * @return true if the file closed correctly
-     */
-    virtual bool Close() const = 0;
-};
-
-} // namespace FileSys

src/core/file_sys/vfs.cpp

@@ -5,6 +5,7 @@
 #include <algorithm>
 #include <numeric>
 #include "common/file_util.h"
+#include "common/logging/backend.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
@@ -41,7 +42,7 @@ bool VfsFile::WriteByte(u8 data, size_t offset) {
     return Write(&data, 1, offset) == 1;
 }
 
-size_t VfsFile::WriteBytes(std::vector<u8> data, size_t offset) {
+size_t VfsFile::WriteBytes(const std::vector<u8>& data, size_t offset) {
     return Write(data.data(), data.size(), offset);
 }
 
@@ -54,10 +55,10 @@ std::shared_ptr<VfsFile> VfsDirectory::GetFileRelative(const std::string& path)
     if (vec.size() == 1)
         return GetFile(vec[0]);
     auto dir = GetSubdirectory(vec[0]);
-    for (size_t i = 1; i < vec.size() - 1; ++i) {
+    for (size_t component = 1; component < vec.size() - 1; ++component) {
         if (dir == nullptr)
             return nullptr;
-        dir = dir->GetSubdirectory(vec[i]);
+        dir = dir->GetSubdirectory(vec[component]);
     }
     if (dir == nullptr)
         return nullptr;
@@ -76,11 +77,14 @@ std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryRelative(const std::stri
     vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
               vec.end());
     if (vec.empty())
-        // return std::shared_ptr<VfsDirectory>(this);
+        // TODO(DarkLordZach): Return this directory if path is '/' or similar. Can't currently
+        // because of const-ness
         return nullptr;
     auto dir = GetSubdirectory(vec[0]);
-    for (size_t i = 1; i < vec.size(); ++i) {
-        dir = dir->GetSubdirectory(vec[i]);
+    for (size_t component = 1; component < vec.size(); ++component) {
+        if (dir == nullptr)
+            return nullptr;
+        dir = dir->GetSubdirectory(vec[component]);
     }
     return dir;
 }
@@ -112,18 +116,65 @@ bool VfsDirectory::IsRoot() const {
 
 size_t VfsDirectory::GetSize() const {
     const auto& files = GetFiles();
-    const auto file_total =
-        std::accumulate(files.begin(), files.end(), 0ull,
-                        [](const auto& f1, const auto& f2) { return f1 + f2->GetSize(); });
+    const auto sum_sizes = [](const auto& range) {
+        return std::accumulate(range.begin(), range.end(), 0ULL,
+                               [](const auto& f1, const auto& f2) { return f1 + f2->GetSize(); });
+    };
 
+    const auto file_total = sum_sizes(files);
     const auto& sub_dir = GetSubdirectories();
-    const auto subdir_total =
-        std::accumulate(sub_dir.begin(), sub_dir.end(), 0ull,
-                        [](const auto& f1, const auto& f2) { return f1 + f2->GetSize(); });
+    const auto subdir_total = sum_sizes(sub_dir);
 
     return file_total + subdir_total;
 }
 
+std::shared_ptr<VfsFile> VfsDirectory::CreateFileRelative(const std::string& path) {
+    auto vec = FileUtil::SplitPathComponents(path);
+    vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
+              vec.end());
+    if (vec.empty())
+        return nullptr;
+    if (vec.size() == 1)
+        return CreateFile(vec[0]);
+    auto dir = GetSubdirectory(vec[0]);
+    if (dir == nullptr) {
+        dir = CreateSubdirectory(vec[0]);
+        if (dir == nullptr)
+            return nullptr;
+    }
+
+    return dir->CreateFileRelative(FileUtil::GetPathWithoutTop(path));
+}
+
+std::shared_ptr<VfsFile> VfsDirectory::CreateFileAbsolute(const std::string& path) {
+    if (IsRoot())
+        return CreateFileRelative(path);
+    return GetParentDirectory()->CreateFileAbsolute(path);
+}
+
+std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryRelative(const std::string& path) {
+    auto vec = FileUtil::SplitPathComponents(path);
+    vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
+              vec.end());
+    if (vec.empty())
+        return nullptr;
+    if (vec.size() == 1)
+        return CreateSubdirectory(vec[0]);
+    auto dir = GetSubdirectory(vec[0]);
+    if (dir == nullptr) {
+        dir = CreateSubdirectory(vec[0]);
+        if (dir == nullptr)
+            return nullptr;
+    }
+    return dir->CreateDirectoryRelative(FileUtil::GetPathWithoutTop(path));
+}
+
+std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryAbsolute(const std::string& path) {
+    if (IsRoot())
+        return CreateDirectoryRelative(path);
+    return GetParentDirectory()->CreateDirectoryAbsolute(path);
+}
+
 bool VfsDirectory::DeleteSubdirectoryRecursive(const std::string& name) {
     auto dir = GetSubdirectory(name);
     if (dir == nullptr)

src/core/file_sys/vfs.h

@@ -59,8 +59,7 @@ struct VfsFile : NonCopyable {
     // Returns the number of bytes (sizeof(T)*number_elements) read successfully.
     template <typename T>
     size_t ReadArray(T* data, size_t number_elements, size_t offset = 0) const {
-        static_assert(std::is_trivially_copyable<T>::value,
-                      "Data type must be trivially copyable.");
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
 
         return Read(reinterpret_cast<u8*>(data), number_elements * sizeof(T), offset);
     }
@@ -69,8 +68,7 @@ struct VfsFile : NonCopyable {
     // Returns the number of bytes read successfully.
     template <typename T>
     size_t ReadBytes(T* data, size_t size, size_t offset = 0) const {
-        static_assert(std::is_trivially_copyable<T>::value,
-                      "Data type must be trivially copyable.");
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
         return Read(reinterpret_cast<u8*>(data), size, offset);
     }
 
@@ -78,8 +76,7 @@ struct VfsFile : NonCopyable {
     // Returns the number of bytes read successfully (sizeof(T)).
     template <typename T>
     size_t ReadObject(T* data, size_t offset = 0) const {
-        static_assert(std::is_trivially_copyable<T>::value,
-                      "Data type must be trivially copyable.");
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
         return Read(reinterpret_cast<u8*>(data), sizeof(T), offset);
     }
 
@@ -88,33 +85,29 @@ struct VfsFile : NonCopyable {
     virtual bool WriteByte(u8 data, size_t offset = 0);
     // Writes a vector of bytes to offset in file and returns the number of bytes successfully
     // written.
-    virtual size_t WriteBytes(std::vector<u8> data, size_t offset = 0);
+    virtual size_t WriteBytes(const std::vector<u8>& data, size_t offset = 0);
 
     // Writes an array of type T, size number_elements to offset in file.
     // Returns the number of bytes (sizeof(T)*number_elements) written successfully.
     template <typename T>
-    size_t WriteArray(T* data, size_t number_elements, size_t offset = 0) {
-        static_assert(std::is_trivially_copyable<T>::value,
-                      "Data type must be trivially copyable.");
-
+    size_t WriteArray(const T* data, size_t number_elements, size_t offset = 0) {
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
         return Write(data, number_elements * sizeof(T), offset);
     }
 
     // Writes size bytes starting at memory location data to offset in file.
     // Returns the number of bytes written successfully.
     template <typename T>
-    size_t WriteBytes(T* data, size_t size, size_t offset = 0) {
-        static_assert(std::is_trivially_copyable<T>::value,
-                      "Data type must be trivially copyable.");
-        return Write(reinterpret_cast<u8*>(data), size, offset);
+    size_t WriteBytes(const T* data, size_t size, size_t offset = 0) {
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
+        return Write(reinterpret_cast<const u8*>(data), size, offset);
     }
 
     // Writes one object of type T to offset in file.
     // Returns the number of bytes written successfully (sizeof(T)).
     template <typename T>
     size_t WriteObject(const T& data, size_t offset = 0) {
-        static_assert(std::is_trivially_copyable<T>::value,
-                      "Data type must be trivially copyable.");
+        static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
         return Write(&data, sizeof(T), offset);
     }
 
@@ -173,6 +166,23 @@ struct VfsDirectory : NonCopyable {
     // operation failed.
     virtual std::shared_ptr<VfsFile> CreateFile(const std::string& name) = 0;
 
+    // Creates a new file at the path relative to this directory. Also creates directories if
+    // they do not exist and is supported by this implementation. Returns nullptr on any failure.
+    virtual std::shared_ptr<VfsFile> CreateFileRelative(const std::string& path);
+
+    // Creates a new file at the path relative to root of this directory. Also creates directories
+    // if they do not exist and is supported by this implementation. Returns nullptr on any failure.
+    virtual std::shared_ptr<VfsFile> CreateFileAbsolute(const std::string& path);
+
+    // Creates a new directory at the path relative to this directory. Also creates directories if
+    // they do not exist and is supported by this implementation. Returns nullptr on any failure.
+    virtual std::shared_ptr<VfsDirectory> CreateDirectoryRelative(const std::string& path);
+
+    // Creates a new directory at the path relative to root of this directory. Also creates
+    // directories if they do not exist and is supported by this implementation. Returns nullptr on
+    // any failure.
+    virtual std::shared_ptr<VfsDirectory> CreateDirectoryAbsolute(const std::string& path);
+
     // Deletes the subdirectory with name and returns true on success.
     virtual bool DeleteSubdirectory(const std::string& name) = 0;
     // Deletes all subdirectories and files of subdirectory with name recirsively and then deletes

src/core/file_sys/vfs_offset.cpp

@@ -2,13 +2,16 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <algorithm>
+#include <utility>
+
 #include "core/file_sys/vfs_offset.h"
 
 namespace FileSys {
 
 OffsetVfsFile::OffsetVfsFile(std::shared_ptr<VfsFile> file_, size_t size_, size_t offset_,
-                             const std::string& name_)
-    : file(file_), offset(offset_), size(size_), name(name_) {}
+                             std::string name_)
+    : file(std::move(file_)), offset(offset_), size(size_), name(std::move(name_)) {}
 
 std::string OffsetVfsFile::GetName() const {
     return name.empty() ? file->GetName() : name;
@@ -73,7 +76,7 @@ bool OffsetVfsFile::WriteByte(u8 data, size_t r_offset) {
     return false;
 }
 
-size_t OffsetVfsFile::WriteBytes(std::vector<u8> data, size_t r_offset) {
+size_t OffsetVfsFile::WriteBytes(const std::vector<u8>& data, size_t r_offset) {
     return file->Write(data.data(), TrimToFit(data.size(), r_offset), offset + r_offset);
 }
 
@@ -86,7 +89,7 @@ size_t OffsetVfsFile::GetOffset() const {
 }
 
 size_t OffsetVfsFile::TrimToFit(size_t r_size, size_t r_offset) const {
-    return std::max<size_t>(std::min<size_t>(size - r_offset, r_size), 0);
+    return std::clamp(r_size, size_t{0}, size - r_offset);
 }
 
 } // namespace FileSys

src/core/file_sys/vfs_offset.h

@@ -14,7 +14,7 @@ namespace FileSys {
 // the size of this wrapper.
 struct OffsetVfsFile : public VfsFile {
     OffsetVfsFile(std::shared_ptr<VfsFile> file, size_t size, size_t offset = 0,
-                  const std::string& new_name = "");
+                  std::string new_name = "");
 
     std::string GetName() const override;
     size_t GetSize() const override;
@@ -28,7 +28,7 @@ struct OffsetVfsFile : public VfsFile {
     std::vector<u8> ReadBytes(size_t size, size_t offset) const override;
     std::vector<u8> ReadAllBytes() const override;
     bool WriteByte(u8 data, size_t offset) override;
-    size_t WriteBytes(std::vector<u8> data, size_t offset) override;
+    size_t WriteBytes(const std::vector<u8>& data, size_t offset) override;
 
     bool Rename(const std::string& name) override;
 

src/core/file_sys/vfs_real.cpp

@@ -2,6 +2,11 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <algorithm>
+#include <cstddef>
+#include <iterator>
+#include <utility>
+
 #include "common/common_paths.h"
 #include "common/logging/log.h"
 #include "core/file_sys/vfs_real.h"
@@ -76,6 +81,10 @@ bool RealVfsFile::Rename(const std::string& name) {
     return out;
 }
 
+bool RealVfsFile::Close() {
+    return backing.Close();
+}
+
 RealVfsDirectory::RealVfsDirectory(const std::string& path_, Mode perms_)
     : path(FileUtil::RemoveTrailingSlash(path_)), parent_path(FileUtil::GetParentPath(path)),
       path_components(FileUtil::SplitPathComponents(path)),
@@ -83,29 +92,28 @@ RealVfsDirectory::RealVfsDirectory(const std::string& path_, Mode perms_)
       perms(perms_) {
     if (!FileUtil::Exists(path) && (perms == Mode::Write || perms == Mode::Append))
         FileUtil::CreateDir(path);
-    unsigned size;
-    if (perms != Mode::Append) {
-        FileUtil::ForeachDirectoryEntry(
-            &size, path,
-            [this](unsigned* entries_out, const std::string& directory,
-                   const std::string& filename) {
-                std::string full_path = directory + DIR_SEP + filename;
-                if (FileUtil::IsDirectory(full_path))
-                    subdirectories.emplace_back(
-                        std::make_shared<RealVfsDirectory>(full_path, perms));
-                else
-                    files.emplace_back(std::make_shared<RealVfsFile>(full_path, perms));
-                return true;
-            });
-    }
+
+    if (perms == Mode::Append)
+        return;
+
+    FileUtil::ForeachDirectoryEntry(
+        nullptr, path,
+        [this](u64* entries_out, const std::string& directory, const std::string& filename) {
+            std::string full_path = directory + DIR_SEP + filename;
+            if (FileUtil::IsDirectory(full_path))
+                subdirectories.emplace_back(std::make_shared<RealVfsDirectory>(full_path, perms));
+            else
+                files.emplace_back(std::make_shared<RealVfsFile>(full_path, perms));
+            return true;
+        });
 }
 
 std::vector<std::shared_ptr<VfsFile>> RealVfsDirectory::GetFiles() const {
-    return std::vector<std::shared_ptr<VfsFile>>(files);
+    return files;
 }
 
 std::vector<std::shared_ptr<VfsDirectory>> RealVfsDirectory::GetSubdirectories() const {
-    return std::vector<std::shared_ptr<VfsDirectory>>(subdirectories);
+    return subdirectories;
 }
 
 bool RealVfsDirectory::IsWritable() const {
@@ -146,6 +154,12 @@ bool RealVfsDirectory::DeleteSubdirectory(const std::string& name) {
 }
 
 bool RealVfsDirectory::DeleteFile(const std::string& name) {
+    auto file = GetFile(name);
+    if (file == nullptr)
+        return false;
+    files.erase(std::find(files.begin(), files.end(), file));
+    auto real_file = std::static_pointer_cast<RealVfsFile>(file);
+    real_file->Close();
     return FileUtil::Delete(path + DIR_SEP + name);
 }
 
@@ -154,14 +168,15 @@ bool RealVfsDirectory::Rename(const std::string& name) {
 }
 
 bool RealVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {
-    auto iter = std::find(files.begin(), files.end(), file);
+    const auto iter = std::find(files.begin(), files.end(), file);
     if (iter == files.end())
         return false;
 
-    files[iter - files.begin()] = files.back();
+    const std::ptrdiff_t offset = std::distance(files.begin(), iter);
+    files[offset] = files.back();
     files.pop_back();
 
-    subdirectories.emplace_back(dir);
+    subdirectories.emplace_back(std::move(dir));
 
     return true;
 }

src/core/file_sys/vfs_real.h

@@ -5,13 +5,15 @@
 #pragma once
 
 #include "common/file_util.h"
-#include "core/file_sys/filesystem.h"
+#include "core/file_sys/mode.h"
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
 // An implmentation of VfsFile that represents a file on the user's computer.
 struct RealVfsFile : public VfsFile {
+    friend struct RealVfsDirectory;
+
     RealVfsFile(const std::string& name, Mode perms = Mode::Read);
 
     std::string GetName() const override;
@@ -25,6 +27,8 @@ struct RealVfsFile : public VfsFile {
     bool Rename(const std::string& name) override;
 
 private:
+    bool Close();
+
     FileUtil::IOFile backing;
     std::string path;
     std::string parent_path;

src/core/gdbstub/gdbstub.cpp

@@ -61,10 +61,16 @@ const u32 SIGTERM = 15;
 const u32 MSG_WAITALL = 8;
 #endif
 
-const u32 X30_REGISTER = 30;
+const u32 LR_REGISTER = 30;
 const u32 SP_REGISTER = 31;
 const u32 PC_REGISTER = 32;
 const u32 CPSR_REGISTER = 33;
+const u32 UC_ARM64_REG_Q0 = 34;
+const u32 FPSCR_REGISTER = 66;
+
+// TODO/WiP - Used while working on support for FPU
+const u32 TODO_DUMMY_REG_997 = 997;
+const u32 TODO_DUMMY_REG_998 = 998;
 
 // For sample XML files see the GDB source /gdb/features
 // GDB also wants the l character at the start
@@ -130,6 +136,8 @@ static const char* target_xml =
     </flags>
     <reg name="cpsr" bitsize="32" type="cpsr_flags"/>
   </feature>
+  <feature name="org.gnu.gdb.aarch64.fpu">
+  </feature>
 </target>
 )";
 
@@ -144,6 +152,7 @@ static u32 latest_signal = 0;
 static bool memory_break = false;
 
 static Kernel::Thread* current_thread = nullptr;
+static u32 current_core = 0;
 
 // Binding to a port within the reserved ports range (0-1023) requires root permissions,
 // so default to a port outside of that range.
@@ -171,20 +180,41 @@ static std::map<u64, Breakpoint> breakpoints_execute;
 static std::map<u64, Breakpoint> breakpoints_read;
 static std::map<u64, Breakpoint> breakpoints_write;
 
+struct Module {
+    std::string name;
+    PAddr beg;
+    PAddr end;
+};
+
+static std::vector<Module> modules;
+
+void RegisterModule(std::string name, PAddr beg, PAddr end, bool add_elf_ext) {
+    Module module;
+    if (add_elf_ext) {
+        Common::SplitPath(name, nullptr, &module.name, nullptr);
+        module.name += ".elf";
+    } else {
+        module.name = std::move(name);
+    }
+    module.beg = beg;
+    module.end = end;
+    modules.push_back(std::move(module));
+}
+
 static Kernel::Thread* FindThreadById(int id) {
-    for (int core = 0; core < Core::NUM_CPU_CORES; core++) {
-        auto threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
-        for (auto thread : threads) {
-            if (thread->GetThreadId() == id) {
-                current_thread = thread.get();
-                return current_thread;
+    for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
+        const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
+        for (auto& thread : threads) {
+            if (thread->GetThreadId() == static_cast<u32>(id)) {
+                current_core = core;
+                return thread.get();
             }
         }
     }
     return nullptr;
 }
 
-static u64 RegRead(int id, Kernel::Thread* thread = nullptr) {
+static u64 RegRead(std::size_t id, Kernel::Thread* thread = nullptr) {
     if (!thread) {
         return 0;
     }
@@ -197,12 +227,14 @@ static u64 RegRead(int id, Kernel::Thread* thread = nullptr) {
         return thread->context.pc;
     } else if (id == CPSR_REGISTER) {
         return thread->context.cpsr;
+    } else if (id > CPSR_REGISTER && id < FPSCR_REGISTER) {
+        return thread->context.fpu_registers[id - UC_ARM64_REG_Q0][0];
     } else {
         return 0;
     }
 }
 
-static void RegWrite(int id, u64 val, Kernel::Thread* thread = nullptr) {
+static void RegWrite(std::size_t id, u64 val, Kernel::Thread* thread = nullptr) {
     if (!thread) {
         return;
     }
@@ -215,6 +247,8 @@ static void RegWrite(int id, u64 val, Kernel::Thread* thread = nullptr) {
         thread->context.pc = val;
     } else if (id == CPSR_REGISTER) {
         thread->context.cpsr = val;
+    } else if (id > CPSR_REGISTER && id < FPSCR_REGISTER) {
+        thread->context.fpu_registers[id - (CPSR_REGISTER + 1)][0] = val;
     }
 }
 
@@ -534,7 +568,11 @@ static void HandleQuery() {
         SendReply("T0");
     } else if (strncmp(query, "Supported", strlen("Supported")) == 0) {
         // PacketSize needs to be large enough for target xml
-        SendReply("PacketSize=2000;qXfer:features:read+");
+        std::string buffer = "PacketSize=2000;qXfer:features:read+;qXfer:threads:read+";
+        if (!modules.empty()) {
+            buffer += ";qXfer:libraries:read+";
+        }
+        SendReply(buffer.c_str());
     } else if (strncmp(query, "Xfer:features:read:target.xml:",
                        strlen("Xfer:features:read:target.xml:")) == 0) {
         SendReply(target_xml);
@@ -543,9 +581,9 @@ static void HandleQuery() {
         SendReply(buffer.c_str());
     } else if (strncmp(query, "fThreadInfo", strlen("fThreadInfo")) == 0) {
         std::string val = "m";
-        for (int core = 0; core < Core::NUM_CPU_CORES; core++) {
-            auto threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
-            for (auto thread : threads) {
+        for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
+            const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
+            for (const auto& thread : threads) {
                 val += fmt::format("{:x}", thread->GetThreadId());
                 val += ",";
             }
@@ -554,6 +592,31 @@ static void HandleQuery() {
         SendReply(val.c_str());
     } else if (strncmp(query, "sThreadInfo", strlen("sThreadInfo")) == 0) {
         SendReply("l");
+    } else if (strncmp(query, "Xfer:threads:read", strlen("Xfer:threads:read")) == 0) {
+        std::string buffer;
+        buffer += "l<?xml version=\"1.0\"?>";
+        buffer += "<threads>";
+        for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
+            const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
+            for (const auto& thread : threads) {
+                buffer +=
+                    fmt::format(R"*(<thread id="{:x}" core="{:d}" name="Thread {:x}"></thread>)*",
+                                thread->GetThreadId(), core, thread->GetThreadId());
+            }
+        }
+        buffer += "</threads>";
+        SendReply(buffer.c_str());
+    } else if (strncmp(query, "Xfer:libraries:read", strlen("Xfer:libraries:read")) == 0) {
+        std::string buffer;
+        buffer += "l<?xml version=\"1.0\"?>";
+        buffer += "<library-list>";
+        for (const auto& module : modules) {
+            buffer +=
+                fmt::format(R"*("<library name = "{}"><segment address = "0x{:x}"/></library>)*",
+                            module.name, module.beg);
+        }
+        buffer += "</library-list>";
+        SendReply(buffer.c_str());
     } else {
         SendReply("");
     }
@@ -561,33 +624,27 @@ static void HandleQuery() {
 
 /// Handle set thread command from gdb client.
 static void HandleSetThread() {
-    if (memcmp(command_buffer, "Hc", 2) == 0 || memcmp(command_buffer, "Hg", 2) == 0) {
-        int thread_id = -1;
-        if (command_buffer[2] != '-') {
-            thread_id = static_cast<int>(HexToInt(
-                command_buffer + 2,
-                command_length - 2 /*strlen(reinterpret_cast<char*>(command_buffer) + 2)*/));
-        }
-        if (thread_id >= 1) {
-            current_thread = FindThreadById(thread_id);
-        }
-        if (!current_thread) {
-            thread_id = 1;
-            current_thread = FindThreadById(thread_id);
-        }
-        if (current_thread) {
-            SendReply("OK");
-            return;
-        }
+    int thread_id = -1;
+    if (command_buffer[2] != '-') {
+        thread_id = static_cast<int>(HexToInt(command_buffer + 2, command_length - 2));
+    }
+    if (thread_id >= 1) {
+        current_thread = FindThreadById(thread_id);
+    }
+    if (!current_thread) {
+        thread_id = 1;
+        current_thread = FindThreadById(thread_id);
+    }
+    if (current_thread) {
+        SendReply("OK");
+        return;
     }
     SendReply("E01");
 }
 
 /// Handle thread alive command from gdb client.
 static void HandleThreadAlive() {
-    int thread_id = static_cast<int>(
-        HexToInt(command_buffer + 1,
-                 command_length - 1 /*strlen(reinterpret_cast<char*>(command_buffer) + 1)*/));
+    int thread_id = static_cast<int>(HexToInt(command_buffer + 1, command_length - 1));
     if (thread_id == 0) {
         thread_id = 1;
     }
@@ -610,16 +667,23 @@ static void SendSignal(Kernel::Thread* thread, u32 signal, bool full = true) {
 
     latest_signal = signal;
 
-    std::string buffer;
-    if (full) {
-        buffer = fmt::format("T{:02x}{:02x}:{:016x};{:02x}:{:016x};", latest_signal, PC_REGISTER,
-                             Common::swap64(RegRead(PC_REGISTER, thread)), SP_REGISTER,
-                             Common::swap64(RegRead(SP_REGISTER, thread)));
-    } else {
-        buffer = fmt::format("T{:02x};", latest_signal);
+    if (!thread) {
+        full = false;
     }
 
-    buffer += fmt::format("thread:{:x};", thread->GetThreadId());
+    std::string buffer;
+    if (full) {
+        buffer = fmt::format("T{:02x}{:02x}:{:016x};{:02x}:{:016x};{:02x}:{:016x}", latest_signal,
+                             PC_REGISTER, Common::swap64(RegRead(PC_REGISTER, thread)), SP_REGISTER,
+                             Common::swap64(RegRead(SP_REGISTER, thread)), LR_REGISTER,
+                             Common::swap64(RegRead(LR_REGISTER, thread)));
+    } else {
+        buffer = fmt::format("T{:02x}", latest_signal);
+    }
+
+    if (thread) {
+        buffer += fmt::format(";thread:{:x};", thread->GetThreadId());
+    }
 
     SendReply(buffer.c_str());
 }
@@ -680,7 +744,7 @@ static bool IsDataAvailable() {
     fd_set fd_socket;
 
     FD_ZERO(&fd_socket);
-    FD_SET(gdbserver_socket, &fd_socket);
+    FD_SET(static_cast<u32>(gdbserver_socket), &fd_socket);
 
     struct timeval t;
     t.tv_sec = 0;
@@ -711,8 +775,12 @@ static void ReadRegister() {
         LongToGdbHex(reply, RegRead(id, current_thread));
     } else if (id == CPSR_REGISTER) {
         IntToGdbHex(reply, (u32)RegRead(id, current_thread));
+    } else if (id >= UC_ARM64_REG_Q0 && id < FPSCR_REGISTER) {
+        LongToGdbHex(reply, RegRead(id, current_thread));
+    } else if (id == FPSCR_REGISTER) {
+        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_998, current_thread));
     } else {
-        return SendReply("E01");
+        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_997, current_thread));
     }
 
     SendReply(reinterpret_cast<char*>(reply));
@@ -725,11 +793,11 @@ static void ReadRegisters() {
 
     u8* bufptr = buffer;
 
-    for (int reg = 0; reg <= SP_REGISTER; reg++) {
+    for (u32 reg = 0; reg <= SP_REGISTER; reg++) {
         LongToGdbHex(bufptr + reg * 16, RegRead(reg, current_thread));
     }
 
-    bufptr += (32 * 16);
+    bufptr += 32 * 16;
 
     LongToGdbHex(bufptr, RegRead(PC_REGISTER, current_thread));
 
@@ -739,6 +807,16 @@ static void ReadRegisters() {
 
     bufptr += 8;
 
+    for (u32 reg = UC_ARM64_REG_Q0; reg <= UC_ARM64_REG_Q0 + 31; reg++) {
+        LongToGdbHex(bufptr + reg * 16, RegRead(reg, current_thread));
+    }
+
+    bufptr += 32 * 32;
+
+    LongToGdbHex(bufptr, RegRead(TODO_DUMMY_REG_998, current_thread));
+
+    bufptr += 8;
+
     SendReply(reinterpret_cast<char*>(buffer));
 }
 
@@ -759,10 +837,17 @@ static void WriteRegister() {
         RegWrite(id, GdbHexToLong(buffer_ptr), current_thread);
     } else if (id == CPSR_REGISTER) {
         RegWrite(id, GdbHexToInt(buffer_ptr), current_thread);
+    } else if (id >= UC_ARM64_REG_Q0 && id < FPSCR_REGISTER) {
+        RegWrite(id, GdbHexToLong(buffer_ptr), current_thread);
+    } else if (id == FPSCR_REGISTER) {
+        RegWrite(TODO_DUMMY_REG_998, GdbHexToLong(buffer_ptr), current_thread);
     } else {
-        return SendReply("E01");
+        RegWrite(TODO_DUMMY_REG_997, GdbHexToLong(buffer_ptr), current_thread);
     }
 
+    // Update Unicorn context skipping scheduler, no running threads at this point
+    Core::System::GetInstance().ArmInterface(current_core).LoadContext(current_thread->context);
+
     SendReply("OK");
 }
 
@@ -773,18 +858,25 @@ static void WriteRegisters() {
     if (command_buffer[0] != 'G')
         return SendReply("E01");
 
-    for (int i = 0, reg = 0; reg <= CPSR_REGISTER; i++, reg++) {
+    for (u32 i = 0, reg = 0; reg <= FPSCR_REGISTER; i++, reg++) {
         if (reg <= SP_REGISTER) {
             RegWrite(reg, GdbHexToLong(buffer_ptr + i * 16), current_thread);
         } else if (reg == PC_REGISTER) {
             RegWrite(PC_REGISTER, GdbHexToLong(buffer_ptr + i * 16), current_thread);
         } else if (reg == CPSR_REGISTER) {
             RegWrite(CPSR_REGISTER, GdbHexToInt(buffer_ptr + i * 16), current_thread);
+        } else if (reg >= UC_ARM64_REG_Q0 && reg < FPSCR_REGISTER) {
+            RegWrite(reg, GdbHexToLong(buffer_ptr + i * 16), current_thread);
+        } else if (reg == FPSCR_REGISTER) {
+            RegWrite(TODO_DUMMY_REG_998, GdbHexToLong(buffer_ptr + i * 16), current_thread);
         } else {
             UNIMPLEMENTED();
         }
     }
 
+    // Update Unicorn context skipping scheduler, no running threads at this point
+    Core::System::GetInstance().ArmInterface(current_core).LoadContext(current_thread->context);
+
     SendReply("OK");
 }
 
@@ -806,6 +898,10 @@ static void ReadMemory() {
         SendReply("E01");
     }
 
+    if (addr < Memory::PROCESS_IMAGE_VADDR || addr >= Memory::MAP_REGION_VADDR_END) {
+        return SendReply("E00");
+    }
+
     if (!Memory::IsValidVirtualAddress(addr)) {
         return SendReply("E00");
     }
@@ -840,16 +936,18 @@ static void WriteMemory() {
 }
 
 void Break(bool is_memory_break) {
-    if (!halt_loop) {
-        halt_loop = true;
-        send_trap = true;
-    }
+    send_trap = true;
 
     memory_break = is_memory_break;
 }
 
 /// Tell the CPU that it should perform a single step.
 static void Step() {
+    if (command_length > 1) {
+        RegWrite(PC_REGISTER, GdbHexToLong(command_buffer + 1), current_thread);
+        // Update Unicorn context skipping scheduler, no running threads at this point
+        Core::System::GetInstance().ArmInterface(current_core).LoadContext(current_thread->context);
+    }
     step_loop = true;
     halt_loop = true;
     send_trap = true;
@@ -1090,6 +1188,8 @@ static void Init(u16 port) {
     breakpoints_read.clear();
     breakpoints_write.clear();
 
+    modules.clear();
+
     // Start gdb server
     LOG_INFO(Debug_GDBStub, "Starting GDB server on port {}...", port);
 
@@ -1192,8 +1292,12 @@ void SetCpuStepFlag(bool is_step) {
 
 void SendTrap(Kernel::Thread* thread, int trap) {
     if (send_trap) {
+        if (!halt_loop || current_thread == thread) {
+            current_thread = thread;
+            SendSignal(thread, trap);
+        }
+        halt_loop = true;
         send_trap = false;
-        SendSignal(thread, trap);
     }
 }
 }; // namespace GDBStub

src/core/gdbstub/gdbstub.h

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <string>
 #include "common/common_types.h"
 #include "core/hle/kernel/thread.h"
 
@@ -51,6 +52,9 @@ bool IsServerEnabled();
 /// Returns true if there is an active socket connection.
 bool IsConnected();
 
+/// Register module.
+void RegisterModule(std::string name, PAddr beg, PAddr end, bool add_elf_ext = true);
+
 /**
  * Signal to the gdbstub server that it should halt CPU execution.
  *
@@ -80,10 +84,10 @@ BreakpointAddress GetNextBreakpointFromAddress(PAddr addr, GDBStub::BreakpointTy
  */
 bool CheckBreakpoint(PAddr addr, GDBStub::BreakpointType type);
 
-// If set to true, the CPU will halt at the beginning of the next CPU loop.
+/// If set to true, the CPU will halt at the beginning of the next CPU loop.
 bool GetCpuHaltFlag();
 
-// If set to true and the CPU is halted, the CPU will step one instruction.
+/// If set to true and the CPU is halted, the CPU will step one instruction.
 bool GetCpuStepFlag();
 
 /**

src/core/hle/ipc_helpers.h

@@ -174,6 +174,25 @@ public:
     template <typename First, typename... Other>
     void Push(const First& first_value, const Other&... other_values);
 
+    /**
+     * Helper function for pushing strongly-typed enumeration values.
+     *
+     * @tparam Enum The enumeration type to be pushed
+     *
+     * @param value The value to push.
+     *
+     * @note The underlying size of the enumeration type is the size of the
+     *       data that gets pushed. e.g. "enum class SomeEnum : u16" will
+     *       push a u16-sized amount of data.
+     */
+    template <typename Enum>
+    void PushEnum(Enum value) {
+        static_assert(std::is_enum_v<Enum>, "T must be an enum type within a PushEnum call.");
+        static_assert(!std::is_convertible_v<Enum, int>,
+                      "enum type in PushEnum must be a strongly typed enum.");
+        Push(static_cast<std::underlying_type_t<Enum>>(value));
+    }
+
     /**
      * @brief Copies the content of the given trivially copyable class to the buffer as a normal
      * param

src/core/hle/kernel/address_arbiter.cpp

@@ -20,7 +20,7 @@ namespace AddressArbiter {
 static ResultCode WaitForAddress(VAddr address, s64 timeout) {
     SharedPtr<Thread> current_thread = GetCurrentThread();
     current_thread->arb_wait_address = address;
-    current_thread->status = THREADSTATUS_WAIT_ARB;
+    current_thread->status = ThreadStatus::WaitArb;
     current_thread->wakeup_callback = nullptr;
 
     current_thread->WakeAfterDelay(timeout);
@@ -65,7 +65,7 @@ static void WakeThreads(std::vector<SharedPtr<Thread>>& waiting_threads, s32 num
 
     // Signal the waiting threads.
     for (size_t i = 0; i < last; i++) {
-        ASSERT(waiting_threads[i]->status = THREADSTATUS_WAIT_ARB);
+        ASSERT(waiting_threads[i]->status == ThreadStatus::WaitArb);
         waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
         waiting_threads[i]->arb_wait_address = 0;
         waiting_threads[i]->ResumeFromWait();
@@ -115,7 +115,7 @@ ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 valu
     s32 updated_value;
     if (waiting_threads.size() == 0) {
         updated_value = value - 1;
-    } else if (num_to_wake <= 0 || waiting_threads.size() <= num_to_wake) {
+    } else if (num_to_wake <= 0 || waiting_threads.size() <= static_cast<u32>(num_to_wake)) {
         updated_value = value + 1;
     } else {
         updated_value = value;
@@ -140,7 +140,9 @@ ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool
 
     s32 cur_value = static_cast<s32>(Memory::Read32(address));
     if (cur_value < value) {
-        Memory::Write32(address, static_cast<u32>(cur_value - 1));
+        if (should_decrement) {
+            Memory::Write32(address, static_cast<u32>(cur_value - 1));
+        }
     } else {
         return ERR_INVALID_STATE;
     }

src/core/hle/kernel/hle_ipc.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <utility>
+
 #include <boost/range/algorithm_ext/erase.hpp>
 #include "common/assert.h"
 #include "common/common_funcs.h"
@@ -19,30 +21,36 @@ namespace Kernel {
 
 void SessionRequestHandler::ClientConnected(SharedPtr<ServerSession> server_session) {
     server_session->SetHleHandler(shared_from_this());
-    connected_sessions.push_back(server_session);
+    connected_sessions.push_back(std::move(server_session));
 }
 
-void SessionRequestHandler::ClientDisconnected(SharedPtr<ServerSession> server_session) {
+void SessionRequestHandler::ClientDisconnected(const SharedPtr<ServerSession>& server_session) {
     server_session->SetHleHandler(nullptr);
     boost::range::remove_erase(connected_sessions, server_session);
 }
 
 SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> thread,
                                                       const std::string& reason, u64 timeout,
-                                                      WakeupCallback&& callback) {
+                                                      WakeupCallback&& callback,
+                                                      Kernel::SharedPtr<Kernel::Event> event) {
 
     // Put the client thread to sleep until the wait event is signaled or the timeout expires.
     thread->wakeup_callback =
         [context = *this, callback](ThreadWakeupReason reason, SharedPtr<Thread> thread,
                                     SharedPtr<WaitObject> object, size_t index) mutable -> bool {
-        ASSERT(thread->status == THREADSTATUS_WAIT_HLE_EVENT);
+        ASSERT(thread->status == ThreadStatus::WaitHLEEvent);
         callback(thread, context, reason);
         context.WriteToOutgoingCommandBuffer(*thread);
         return true;
     };
 
-    auto event = Kernel::Event::Create(Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
-    thread->status = THREADSTATUS_WAIT_HLE_EVENT;
+    if (!event) {
+        // Create event if not provided
+        event = Kernel::Event::Create(Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
+    }
+
+    event->Clear();
+    thread->status = ThreadStatus::WaitHLEEvent;
     thread->wait_objects = {event};
     event->AddWaitingThread(thread);
 
@@ -214,8 +222,8 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
             (sizeof(IPC::CommandHeader) + sizeof(IPC::HandleDescriptorHeader)) / sizeof(u32);
         ASSERT_MSG(!handle_descriptor_header->send_current_pid, "Sending PID is not implemented");
 
-        ASSERT_MSG(copy_objects.size() == handle_descriptor_header->num_handles_to_copy);
-        ASSERT_MSG(move_objects.size() == handle_descriptor_header->num_handles_to_move);
+        ASSERT(copy_objects.size() == handle_descriptor_header->num_handles_to_copy);
+        ASSERT(move_objects.size() == handle_descriptor_header->num_handles_to_move);
 
         // We don't make a distinction between copy and move handles when translating since HLE
         // services don't deal with handles directly. However, the guest applications might check
@@ -293,10 +301,6 @@ size_t HLERequestContext::WriteBuffer(const void* buffer, size_t size, int buffe
     return size;
 }
 
-size_t HLERequestContext::WriteBuffer(const std::vector<u8>& buffer, int buffer_index) const {
-    return WriteBuffer(buffer.data(), buffer.size());
-}
-
 size_t HLERequestContext::GetReadBufferSize(int buffer_index) const {
     const bool is_buffer_a{BufferDescriptorA().size() && BufferDescriptorA()[buffer_index].Size()};
     return is_buffer_a ? BufferDescriptorA()[buffer_index].Size()

src/core/hle/kernel/hle_ipc.h

@@ -5,8 +5,10 @@
 #pragma once
 
 #include <array>
+#include <iterator>
 #include <memory>
 #include <string>
+#include <type_traits>
 #include <vector>
 #include <boost/container/small_vector.hpp>
 #include "common/common_types.h"
@@ -59,12 +61,12 @@ public:
      * associated ServerSession.
      * @param server_session ServerSession associated with the connection.
      */
-    void ClientDisconnected(SharedPtr<ServerSession> server_session);
+    void ClientDisconnected(const SharedPtr<ServerSession>& server_session);
 
 protected:
     /// List of sessions that are connected to this handler.
     /// A ServerSession whose server endpoint is an HLE implementation is kept alive by this list
-    // for the duration of the connection.
+    /// for the duration of the connection.
     std::vector<SharedPtr<ServerSession>> connected_sessions;
 };
 
@@ -118,10 +120,12 @@ public:
      * @param callback Callback to be invoked when the thread is resumed. This callback must write
      * the entire command response once again, regardless of the state of it before this function
      * was called.
+     * @param event Event to use to wake up the thread. If unspecified, an event will be created.
      * @returns Event that when signaled will resume the thread and call the callback function.
      */
     SharedPtr<Event> SleepClientThread(SharedPtr<Thread> thread, const std::string& reason,
-                                       u64 timeout, WakeupCallback&& callback);
+                                       u64 timeout, WakeupCallback&& callback,
+                                       Kernel::SharedPtr<Kernel::Event> event = nullptr);
 
     void ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming);
 
@@ -169,8 +173,25 @@ public:
     /// Helper function to write a buffer using the appropriate buffer descriptor
     size_t WriteBuffer(const void* buffer, size_t size, int buffer_index = 0) const;
 
-    /// Helper function to write a buffer using the appropriate buffer descriptor
-    size_t WriteBuffer(const std::vector<u8>& buffer, int buffer_index = 0) const;
+    /* Helper function to write a buffer using the appropriate buffer descriptor
+     *
+     * @tparam ContiguousContainer an arbitrary container that satisfies the
+     *         ContiguousContainer concept in the C++ standard library.
+     *
+     * @param container    The container to write the data of into a buffer.
+     * @param buffer_index The buffer in particular to write to.
+     */
+    template <typename ContiguousContainer,
+              typename = std::enable_if_t<!std::is_pointer_v<ContiguousContainer>>>
+    size_t WriteBuffer(const ContiguousContainer& container, int buffer_index = 0) const {
+        using ContiguousType = typename ContiguousContainer::value_type;
+
+        static_assert(std::is_trivially_copyable_v<ContiguousType>,
+                      "Container to WriteBuffer must contain trivially copyable objects");
+
+        return WriteBuffer(std::data(container), std::size(container) * sizeof(ContiguousType),
+                           buffer_index);
+    }
 
     /// Helper function to get the size of the input buffer
     size_t GetReadBufferSize(int buffer_index = 0) const;

src/core/hle/kernel/mutex.cpp

@@ -28,7 +28,7 @@ static std::pair<SharedPtr<Thread>, u32> GetHighestPriorityMutexWaitingThread(
         if (thread->mutex_wait_address != mutex_addr)
             continue;
 
-        ASSERT(thread->status == THREADSTATUS_WAIT_MUTEX);
+        ASSERT(thread->status == ThreadStatus::WaitMutex);
 
         ++num_waiters;
         if (highest_priority_thread == nullptr ||
@@ -83,7 +83,7 @@ ResultCode Mutex::TryAcquire(VAddr address, Handle holding_thread_handle,
     GetCurrentThread()->mutex_wait_address = address;
     GetCurrentThread()->wait_handle = requesting_thread_handle;
 
-    GetCurrentThread()->status = THREADSTATUS_WAIT_MUTEX;
+    GetCurrentThread()->status = ThreadStatus::WaitMutex;
     GetCurrentThread()->wakeup_callback = nullptr;
 
     // Update the lock holder thread's priority to prevent priority inversion.
@@ -121,7 +121,7 @@ ResultCode Mutex::Release(VAddr address) {
     // Grant the mutex to the next waiting thread and resume it.
     Memory::Write32(address, mutex_value);
 
-    ASSERT(thread->status == THREADSTATUS_WAIT_MUTEX);
+    ASSERT(thread->status == ThreadStatus::WaitMutex);
     thread->ResumeFromWait();
 
     thread->lock_owner = nullptr;

src/core/hle/kernel/object_address_table.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <utility>
+
 #include "common/assert.h"
 #include "core/hle/kernel/object_address_table.h"
 
@@ -11,7 +13,7 @@ ObjectAddressTable g_object_address_table;
 
 void ObjectAddressTable::Insert(VAddr addr, SharedPtr<Object> obj) {
     ASSERT_MSG(objects.find(addr) == objects.end(), "Object already exists with addr=0x{:X}", addr);
-    objects[addr] = obj;
+    objects[addr] = std::move(obj);
 }
 
 void ObjectAddressTable::Close(VAddr addr) {

src/core/hle/kernel/scheduler.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <utility>
+
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/process.h"
@@ -32,7 +34,7 @@ Thread* Scheduler::PopNextReadyThread() {
     Thread* next = nullptr;
     Thread* thread = GetCurrentThread();
 
-    if (thread && thread->status == THREADSTATUS_RUNNING) {
+    if (thread && thread->status == ThreadStatus::Running) {
         // We have to do better than the current thread.
         // This call returns null when that's not possible.
         next = ready_queue.pop_first_better(thread->current_priority);
@@ -54,18 +56,20 @@ void Scheduler::SwitchContext(Thread* new_thread) {
     if (previous_thread) {
         previous_thread->last_running_ticks = CoreTiming::GetTicks();
         cpu_core->SaveContext(previous_thread->context);
+        // Save the TPIDR_EL0 system register in case it was modified.
+        previous_thread->tpidr_el0 = cpu_core->GetTPIDR_EL0();
 
-        if (previous_thread->status == THREADSTATUS_RUNNING) {
+        if (previous_thread->status == ThreadStatus::Running) {
             // This is only the case when a reschedule is triggered without the current thread
             // yielding execution (i.e. an event triggered, system core time-sliced, etc)
             ready_queue.push_front(previous_thread->current_priority, previous_thread);
-            previous_thread->status = THREADSTATUS_READY;
+            previous_thread->status = ThreadStatus::Ready;
         }
     }
 
     // Load context of new thread
     if (new_thread) {
-        ASSERT_MSG(new_thread->status == THREADSTATUS_READY,
+        ASSERT_MSG(new_thread->status == ThreadStatus::Ready,
                    "Thread must be ready to become running.");
 
         // Cancel any outstanding wakeup events for this thread
@@ -76,7 +80,7 @@ void Scheduler::SwitchContext(Thread* new_thread) {
         current_thread = new_thread;
 
         ready_queue.remove(new_thread->current_priority, new_thread);
-        new_thread->status = THREADSTATUS_RUNNING;
+        new_thread->status = ThreadStatus::Running;
 
         if (previous_process != current_thread->owner_process) {
             Core::CurrentProcess() = current_thread->owner_process;
@@ -85,6 +89,8 @@ void Scheduler::SwitchContext(Thread* new_thread) {
 
         cpu_core->LoadContext(new_thread->context);
         cpu_core->SetTlsAddress(new_thread->GetTLSAddress());
+        cpu_core->SetTPIDR_EL0(new_thread->GetTPIDR_EL0());
+        cpu_core->ClearExclusiveState();
     } else {
         current_thread = nullptr;
         // Note: We do not reset the current process and current page table when idling because
@@ -112,7 +118,7 @@ void Scheduler::Reschedule() {
 void Scheduler::AddThread(SharedPtr<Thread> thread, u32 priority) {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 
-    thread_list.push_back(thread);
+    thread_list.push_back(std::move(thread));
     ready_queue.prepare(priority);
 }
 
@@ -126,14 +132,14 @@ void Scheduler::RemoveThread(Thread* thread) {
 void Scheduler::ScheduleThread(Thread* thread, u32 priority) {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 
-    ASSERT(thread->status == THREADSTATUS_READY);
+    ASSERT(thread->status == ThreadStatus::Ready);
     ready_queue.push_back(priority, thread);
 }
 
 void Scheduler::UnscheduleThread(Thread* thread, u32 priority) {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 
-    ASSERT(thread->status == THREADSTATUS_READY);
+    ASSERT(thread->status == ThreadStatus::Ready);
     ready_queue.remove(priority, thread);
 }
 
@@ -141,7 +147,7 @@ void Scheduler::SetThreadPriority(Thread* thread, u32 priority) {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 
     // If thread was ready, adjust queues
-    if (thread->status == THREADSTATUS_READY)
+    if (thread->status == ThreadStatus::Ready)
         ready_queue.move(thread, thread->current_priority, priority);
     else
         ready_queue.prepare(priority);

src/core/hle/kernel/server_session.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <tuple>
+#include <utility>
 
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
@@ -109,10 +110,10 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
         result = hle_handler->HandleSyncRequest(context);
     }
 
-    if (thread->status == THREADSTATUS_RUNNING) {
+    if (thread->status == ThreadStatus::Running) {
         // Put the thread to sleep until the server replies, it will be awoken in
         // svcReplyAndReceive for LLE servers.
-        thread->status = THREADSTATUS_WAIT_IPC;
+        thread->status = ThreadStatus::WaitIPC;
 
         if (hle_handler != nullptr) {
             // For HLE services, we put the request threads to sleep for a short duration to
@@ -158,7 +159,7 @@ ServerSession::SessionPair ServerSession::CreateSessionPair(const std::string& n
     std::shared_ptr<Session> parent(new Session);
     parent->client = client_session.get();
     parent->server = server_session.get();
-    parent->port = port;
+    parent->port = std::move(port);
 
     client_session->parent = parent;
     server_session->parent = parent;

src/core/hle/kernel/shared_memory.cpp

@@ -2,7 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cstring>
+#include <utility>
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/kernel/errors.h"
@@ -21,7 +21,7 @@ SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u
                                              MemoryRegion region, std::string name) {
     SharedPtr<SharedMemory> shared_memory(new SharedMemory);
 
-    shared_memory->owner_process = owner_process;
+    shared_memory->owner_process = std::move(owner_process);
     shared_memory->name = std::move(name);
     shared_memory->size = size;
     shared_memory->permissions = permissions;
@@ -87,7 +87,7 @@ SharedPtr<SharedMemory> SharedMemory::CreateForApplet(std::shared_ptr<std::vecto
     shared_memory->size = size;
     shared_memory->permissions = permissions;
     shared_memory->other_permissions = other_permissions;
-    shared_memory->backing_block = heap_block;
+    shared_memory->backing_block = std::move(heap_block);
     shared_memory->backing_block_offset = offset;
     shared_memory->base_address = Memory::HEAP_VADDR + offset;
 

src/core/hle/kernel/svc.cpp

@@ -133,7 +133,7 @@ static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
 /// Default thread wakeup callback for WaitSynchronization
 static bool DefaultThreadWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thread> thread,
                                         SharedPtr<WaitObject> object, size_t index) {
-    ASSERT(thread->status == THREADSTATUS_WAIT_SYNCH_ANY);
+    ASSERT(thread->status == ThreadStatus::WaitSynchAny);
 
     if (reason == ThreadWakeupReason::Timeout) {
         thread->SetWaitSynchronizationResult(RESULT_TIMEOUT);
@@ -197,7 +197,7 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
         object->AddWaitingThread(thread);
 
     thread->wait_objects = std::move(objects);
-    thread->status = THREADSTATUS_WAIT_SYNCH_ANY;
+    thread->status = ThreadStatus::WaitSynchAny;
 
     // Create an event to wake the thread up after the specified nanosecond delay has passed
     thread->WakeAfterDelay(nano_seconds);
@@ -217,7 +217,7 @@ static ResultCode CancelSynchronization(Handle thread_handle) {
         return ERR_INVALID_HANDLE;
     }
 
-    ASSERT(thread->status == THREADSTATUS_WAIT_SYNCH_ANY);
+    ASSERT(thread->status == ThreadStatus::WaitSynchAny);
     thread->SetWaitSynchronizationResult(
         ResultCode(ErrorModule::Kernel, ErrCodes::SynchronizationCanceled));
     thread->ResumeFromWait();
@@ -468,8 +468,8 @@ static void ExitProcess() {
                 continue;
 
             // TODO(Subv): When are the other running/ready threads terminated?
-            ASSERT_MSG(thread->status == THREADSTATUS_WAIT_SYNCH_ANY ||
-                           thread->status == THREADSTATUS_WAIT_SYNCH_ALL,
+            ASSERT_MSG(thread->status == ThreadStatus::WaitSynchAny ||
+                           thread->status == ThreadStatus::WaitSynchAll,
                        "Exiting processes with non-waiting threads is currently unimplemented");
 
             thread->Stop();
@@ -545,7 +545,7 @@ static ResultCode StartThread(Handle thread_handle) {
         return ERR_INVALID_HANDLE;
     }
 
-    ASSERT(thread->status == THREADSTATUS_DORMANT);
+    ASSERT(thread->status == ThreadStatus::Dormant);
 
     thread->ResumeFromWait();
     Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
@@ -596,7 +596,7 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
     current_thread->condvar_wait_address = condition_variable_addr;
     current_thread->mutex_wait_address = mutex_addr;
     current_thread->wait_handle = thread_handle;
-    current_thread->status = THREADSTATUS_WAIT_MUTEX;
+    current_thread->status = ThreadStatus::WaitMutex;
     current_thread->wakeup_callback = nullptr;
 
     current_thread->WakeAfterDelay(nano_seconds);
@@ -656,7 +656,7 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
         if (mutex_val == 0) {
             // We were able to acquire the mutex, resume this thread.
             Memory::Write32(thread->mutex_wait_address, thread->wait_handle);
-            ASSERT(thread->status == THREADSTATUS_WAIT_MUTEX);
+            ASSERT(thread->status == ThreadStatus::WaitMutex);
             thread->ResumeFromWait();
 
             auto lock_owner = thread->lock_owner;
@@ -672,8 +672,8 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
             Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
             auto owner = g_handle_table.Get<Thread>(owner_handle);
             ASSERT(owner);
-            ASSERT(thread->status != THREADSTATUS_RUNNING);
-            thread->status = THREADSTATUS_WAIT_MUTEX;
+            ASSERT(thread->status != ThreadStatus::Running);
+            thread->status = ThreadStatus::WaitMutex;
             thread->wakeup_callback = nullptr;
 
             // Signal that the mutex now has a waiting thread.
@@ -795,8 +795,9 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
         return ERR_INVALID_HANDLE;
     }
 
-    if (core == THREADPROCESSORID_DEFAULT) {
-        ASSERT(thread->owner_process->ideal_processor != THREADPROCESSORID_DEFAULT);
+    if (core == static_cast<u32>(THREADPROCESSORID_DEFAULT)) {
+        ASSERT(thread->owner_process->ideal_processor !=
+               static_cast<u8>(THREADPROCESSORID_DEFAULT));
         // Set the target CPU to the one specified in the process' exheader.
         core = thread->owner_process->ideal_processor;
         mask = 1ull << core;
@@ -811,7 +812,7 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
 
     if (core == OnlyChangeMask) {
         core = thread->ideal_core;
-    } else if (core >= Core::NUM_CPU_CORES && core != -1) {
+    } else if (core >= Core::NUM_CPU_CORES && core != static_cast<u32>(-1)) {
         return ResultCode(ErrorModule::Kernel, ErrCodes::InvalidProcessorId);
     }
 

src/core/hle/kernel/thread.cpp

@@ -30,7 +30,7 @@ namespace Kernel {
 static CoreTiming::EventType* ThreadWakeupEventType = nullptr;
 
 bool Thread::ShouldWait(Thread* thread) const {
-    return status != THREADSTATUS_DEAD;
+    return status != ThreadStatus::Dead;
 }
 
 void Thread::Acquire(Thread* thread) {
@@ -63,11 +63,11 @@ void Thread::Stop() {
 
     // Clean up thread from ready queue
     // This is only needed when the thread is termintated forcefully (SVC TerminateProcess)
-    if (status == THREADSTATUS_READY) {
+    if (status == ThreadStatus::Ready) {
         scheduler->UnscheduleThread(this, current_priority);
     }
 
-    status = THREADSTATUS_DEAD;
+    status = ThreadStatus::Dead;
 
     WakeupAllWaitingThreads();
 
@@ -86,7 +86,7 @@ void Thread::Stop() {
 
 void WaitCurrentThread_Sleep() {
     Thread* thread = GetCurrentThread();
-    thread->status = THREADSTATUS_WAIT_SLEEP;
+    thread->status = ThreadStatus::WaitSleep;
 }
 
 void ExitCurrentThread() {
@@ -110,10 +110,9 @@ static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
 
     bool resume = true;
 
-    if (thread->status == THREADSTATUS_WAIT_SYNCH_ANY ||
-        thread->status == THREADSTATUS_WAIT_SYNCH_ALL ||
-        thread->status == THREADSTATUS_WAIT_HLE_EVENT) {
-
+    if (thread->status == ThreadStatus::WaitSynchAny ||
+        thread->status == ThreadStatus::WaitSynchAll ||
+        thread->status == ThreadStatus::WaitHLEEvent) {
         // Remove the thread from each of its waiting objects' waitlists
         for (auto& object : thread->wait_objects)
             object->RemoveWaitingThread(thread.get());
@@ -126,7 +125,7 @@ static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
 
     if (thread->mutex_wait_address != 0 || thread->condvar_wait_address != 0 ||
         thread->wait_handle) {
-        ASSERT(thread->status == THREADSTATUS_WAIT_MUTEX);
+        ASSERT(thread->status == ThreadStatus::WaitMutex);
         thread->mutex_wait_address = 0;
         thread->condvar_wait_address = 0;
         thread->wait_handle = 0;
@@ -141,7 +140,7 @@ static void ThreadWakeupCallback(u64 thread_handle, int cycles_late) {
     }
 
     if (thread->arb_wait_address != 0) {
-        ASSERT(thread->status == THREADSTATUS_WAIT_ARB);
+        ASSERT(thread->status == ThreadStatus::WaitArb);
         thread->arb_wait_address = 0;
     }
 
@@ -165,7 +164,7 @@ void Thread::CancelWakeupTimer() {
 static boost::optional<s32> GetNextProcessorId(u64 mask) {
     for (s32 index = 0; index < Core::NUM_CPU_CORES; ++index) {
         if (mask & (1ULL << index)) {
-            if (!Core::System().GetInstance().Scheduler(index)->GetCurrentThread()) {
+            if (!Core::System::GetInstance().Scheduler(index)->GetCurrentThread()) {
                 // Core is enabled and not running any threads, use this one
                 return index;
             }
@@ -178,28 +177,28 @@ void Thread::ResumeFromWait() {
     ASSERT_MSG(wait_objects.empty(), "Thread is waking up while waiting for objects");
 
     switch (status) {
-    case THREADSTATUS_WAIT_SYNCH_ALL:
-    case THREADSTATUS_WAIT_SYNCH_ANY:
-    case THREADSTATUS_WAIT_HLE_EVENT:
-    case THREADSTATUS_WAIT_SLEEP:
-    case THREADSTATUS_WAIT_IPC:
-    case THREADSTATUS_WAIT_MUTEX:
-    case THREADSTATUS_WAIT_ARB:
+    case ThreadStatus::WaitSynchAll:
+    case ThreadStatus::WaitSynchAny:
+    case ThreadStatus::WaitHLEEvent:
+    case ThreadStatus::WaitSleep:
+    case ThreadStatus::WaitIPC:
+    case ThreadStatus::WaitMutex:
+    case ThreadStatus::WaitArb:
         break;
 
-    case THREADSTATUS_READY:
+    case ThreadStatus::Ready:
         // The thread's wakeup callback must have already been cleared when the thread was first
         // awoken.
         ASSERT(wakeup_callback == nullptr);
         // If the thread is waiting on multiple wait objects, it might be awoken more than once
         // before actually resuming. We can ignore subsequent wakeups if the thread status has
-        // already been set to THREADSTATUS_READY.
+        // already been set to ThreadStatus::Ready.
         return;
 
-    case THREADSTATUS_RUNNING:
+    case ThreadStatus::Running:
         DEBUG_ASSERT_MSG(false, "Thread with object id {} has already resumed.", GetObjectId());
         return;
-    case THREADSTATUS_DEAD:
+    case ThreadStatus::Dead:
         // This should never happen, as threads must complete before being stopped.
         DEBUG_ASSERT_MSG(false, "Thread with object id {} cannot be resumed because it's DEAD.",
                          GetObjectId());
@@ -208,21 +207,21 @@ void Thread::ResumeFromWait() {
 
     wakeup_callback = nullptr;
 
-    status = THREADSTATUS_READY;
+    status = ThreadStatus::Ready;
 
     boost::optional<s32> new_processor_id = GetNextProcessorId(affinity_mask);
     if (!new_processor_id) {
         new_processor_id = processor_id;
     }
     if (ideal_core != -1 &&
-        Core::System().GetInstance().Scheduler(ideal_core)->GetCurrentThread() == nullptr) {
+        Core::System::GetInstance().Scheduler(ideal_core)->GetCurrentThread() == nullptr) {
         new_processor_id = ideal_core;
     }
 
     ASSERT(*new_processor_id < 4);
 
     // Add thread to new core's scheduler
-    auto& next_scheduler = Core::System().GetInstance().Scheduler(*new_processor_id);
+    auto& next_scheduler = Core::System::GetInstance().Scheduler(*new_processor_id);
 
     if (*new_processor_id != processor_id) {
         // Remove thread from previous core's scheduler
@@ -310,9 +309,10 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
     SharedPtr<Thread> thread(new Thread);
 
     thread->thread_id = NewThreadId();
-    thread->status = THREADSTATUS_DORMANT;
+    thread->status = ThreadStatus::Dormant;
     thread->entry_point = entry_point;
     thread->stack_top = stack_top;
+    thread->tpidr_el0 = 0;
     thread->nominal_priority = thread->current_priority = priority;
     thread->last_running_ticks = CoreTiming::GetTicks();
     thread->processor_id = processor_id;
@@ -325,7 +325,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
     thread->name = std::move(name);
     thread->callback_handle = wakeup_callback_handle_table.Create(thread).Unwrap();
     thread->owner_process = owner_process;
-    thread->scheduler = Core::System().GetInstance().Scheduler(processor_id);
+    thread->scheduler = Core::System::GetInstance().Scheduler(processor_id);
     thread->scheduler->AddThread(thread, priority);
 
     // Find the next available TLS index, and mark it as used
@@ -400,7 +400,7 @@ SharedPtr<Thread> SetupMainThread(VAddr entry_point, u32 priority,
 
     // Initialize new "main" thread
     auto thread_res = Thread::Create("main", entry_point, priority, 0, THREADPROCESSORID_0,
-                                     Memory::STACK_AREA_VADDR_END, owner_process);
+                                     Memory::STACK_AREA_VADDR_END, std::move(owner_process));
 
     SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
 
@@ -471,7 +471,7 @@ void Thread::ChangeCore(u32 core, u64 mask) {
     ideal_core = core;
     affinity_mask = mask;
 
-    if (status != THREADSTATUS_READY) {
+    if (status != ThreadStatus::Ready) {
         return;
     }
 
@@ -481,14 +481,14 @@ void Thread::ChangeCore(u32 core, u64 mask) {
         new_processor_id = processor_id;
     }
     if (ideal_core != -1 &&
-        Core::System().GetInstance().Scheduler(ideal_core)->GetCurrentThread() == nullptr) {
+        Core::System::GetInstance().Scheduler(ideal_core)->GetCurrentThread() == nullptr) {
         new_processor_id = ideal_core;
     }
 
     ASSERT(*new_processor_id < 4);
 
     // Add thread to new core's scheduler
-    auto& next_scheduler = Core::System().GetInstance().Scheduler(*new_processor_id);
+    auto& next_scheduler = Core::System::GetInstance().Scheduler(*new_processor_id);
 
     if (*new_processor_id != processor_id) {
         // Remove thread from previous core's scheduler

src/core/hle/kernel/thread.h

@@ -36,18 +36,18 @@ enum ThreadProcessorId : s32 {
                                      (1 << THREADPROCESSORID_2) | (1 << THREADPROCESSORID_3)
 };
 
-enum ThreadStatus {
-    THREADSTATUS_RUNNING,        ///< Currently running
-    THREADSTATUS_READY,          ///< Ready to run
-    THREADSTATUS_WAIT_HLE_EVENT, ///< Waiting for hle event to finish
-    THREADSTATUS_WAIT_SLEEP,     ///< Waiting due to a SleepThread SVC
-    THREADSTATUS_WAIT_IPC,       ///< Waiting for the reply from an IPC request
-    THREADSTATUS_WAIT_SYNCH_ANY, ///< Waiting due to WaitSynch1 or WaitSynchN with wait_all = false
-    THREADSTATUS_WAIT_SYNCH_ALL, ///< Waiting due to WaitSynchronizationN with wait_all = true
-    THREADSTATUS_WAIT_MUTEX,     ///< Waiting due to an ArbitrateLock/WaitProcessWideKey svc
-    THREADSTATUS_WAIT_ARB,       ///< Waiting due to a SignalToAddress/WaitForAddress svc
-    THREADSTATUS_DORMANT,        ///< Created but not yet made ready
-    THREADSTATUS_DEAD            ///< Run to completion, or forcefully terminated
+enum class ThreadStatus {
+    Running,      ///< Currently running
+    Ready,        ///< Ready to run
+    WaitHLEEvent, ///< Waiting for hle event to finish
+    WaitSleep,    ///< Waiting due to a SleepThread SVC
+    WaitIPC,      ///< Waiting for the reply from an IPC request
+    WaitSynchAny, ///< Waiting due to WaitSynch1 or WaitSynchN with wait_all = false
+    WaitSynchAll, ///< Waiting due to WaitSynchronizationN with wait_all = true
+    WaitMutex,    ///< Waiting due to an ArbitrateLock/WaitProcessWideKey svc
+    WaitArb,      ///< Waiting due to a SignalToAddress/WaitForAddress svc
+    Dormant,      ///< Created but not yet made ready
+    Dead          ///< Run to completion, or forcefully terminated
 };
 
 enum class ThreadWakeupReason {
@@ -182,6 +182,14 @@ public:
         return tls_address;
     }
 
+    /*
+     * Returns the value of the TPIDR_EL0 Read/Write system register for this thread.
+     * @returns The value of the TPIDR_EL0 register.
+     */
+    u64 GetTPIDR_EL0() const {
+        return tpidr_el0;
+    }
+
     /*
      * Returns the address of the current thread's command buffer, located in the TLS.
      * @returns VAddr of the thread's command buffer.
@@ -194,14 +202,14 @@ public:
      * with wait_all = true.
      */
     bool IsSleepingOnWaitAll() const {
-        return status == THREADSTATUS_WAIT_SYNCH_ALL;
+        return status == ThreadStatus::WaitSynchAll;
     }
 
     ARM_Interface::ThreadContext context;
 
     u32 thread_id;
 
-    u32 status;
+    ThreadStatus status;
     VAddr entry_point;
     VAddr stack_top;
 
@@ -213,6 +221,7 @@ public:
     s32 processor_id;
 
     VAddr tls_address; ///< Virtual address of the Thread Local Storage of the thread
+    u64 tpidr_el0;     ///< TPIDR_EL0 read/write system register.
 
     SharedPtr<Process> owner_process; ///< Process that owns this thread
 

src/core/hle/kernel/vm_manager.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <iterator>
+#include <utility>
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/arm/arm_interface.h"
@@ -16,30 +17,20 @@
 namespace Kernel {
 
 static const char* GetMemoryStateName(MemoryState state) {
-    static const char* names[] = {
-        "Unmapped",
-        "Io",
-        "Normal",
-        "CodeStatic",
-        "CodeMutable",
-        "Heap",
-        "Shared",
-        "Unknown1"
-        "ModuleCodeStatic",
-        "ModuleCodeMutable",
-        "IpcBuffer0",
-        "Mapped",
-        "ThreadLocal",
-        "TransferMemoryIsolated",
-        "TransferMemory",
-        "ProcessMemory",
-        "Unknown2"
-        "IpcBuffer1",
-        "IpcBuffer3",
-        "KernelStack",
+    static constexpr const char* names[] = {
+        "Unmapped",         "Io",
+        "Normal",           "CodeStatic",
+        "CodeMutable",      "Heap",
+        "Shared",           "Unknown1",
+        "ModuleCodeStatic", "ModuleCodeMutable",
+        "IpcBuffer0",       "Mapped",
+        "ThreadLocal",      "TransferMemoryIsolated",
+        "TransferMemory",   "ProcessMemory",
+        "Unknown2",         "IpcBuffer1",
+        "IpcBuffer3",       "KernelStack",
     };
 
-    return names[(int)state];
+    return names[static_cast<int>(state)];
 }
 
 bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const {
@@ -117,7 +108,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
     final_vma.type = VMAType::AllocatedMemoryBlock;
     final_vma.permissions = VMAPermission::ReadWrite;
     final_vma.meminfo_state = state;
-    final_vma.backing_block = block;
+    final_vma.backing_block = std::move(block);
     final_vma.offset = offset;
     UpdatePageTableForVMA(final_vma);
 
@@ -160,7 +151,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMMIO(VAddr target, PAddr paddr, u6
     final_vma.permissions = VMAPermission::ReadWrite;
     final_vma.meminfo_state = state;
     final_vma.paddr = paddr;
-    final_vma.mmio_handler = mmio_handler;
+    final_vma.mmio_handler = std::move(mmio_handler);
     UpdatePageTableForVMA(final_vma);
 
     return MakeResult<VMAHandle>(MergeAdjacent(vma_handle));

src/core/hle/kernel/wait_object.cpp

@@ -38,9 +38,9 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
 
     for (const auto& thread : waiting_threads) {
         // The list of waiting threads must not contain threads that are not waiting to be awakened.
-        ASSERT_MSG(thread->status == THREADSTATUS_WAIT_SYNCH_ANY ||
-                       thread->status == THREADSTATUS_WAIT_SYNCH_ALL ||
-                       thread->status == THREADSTATUS_WAIT_HLE_EVENT,
+        ASSERT_MSG(thread->status == ThreadStatus::WaitSynchAny ||
+                       thread->status == ThreadStatus::WaitSynchAll ||
+                       thread->status == ThreadStatus::WaitHLEEvent,
                    "Inconsistent thread statuses in waiting_threads");
 
         if (thread->current_priority >= candidate_priority)
@@ -49,10 +49,10 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
         if (ShouldWait(thread.get()))
             continue;
 
-        // A thread is ready to run if it's either in THREADSTATUS_WAIT_SYNCH_ANY or
-        // in THREADSTATUS_WAIT_SYNCH_ALL and the rest of the objects it is waiting on are ready.
+        // A thread is ready to run if it's either in ThreadStatus::WaitSynchAny or
+        // in ThreadStatus::WaitSynchAll and the rest of the objects it is waiting on are ready.
         bool ready_to_run = true;
-        if (thread->status == THREADSTATUS_WAIT_SYNCH_ALL) {
+        if (thread->status == ThreadStatus::WaitSynchAll) {
             ready_to_run = std::none_of(thread->wait_objects.begin(), thread->wait_objects.end(),
                                         [&thread](const SharedPtr<WaitObject>& object) {
                                             return object->ShouldWait(thread.get());

src/core/hle/service/acc/acc.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <array>
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/acc/acc.h"
@@ -24,18 +25,17 @@ struct UserData {
 static_assert(sizeof(UserData) == 0x80, "UserData structure has incorrect size");
 
 struct ProfileBase {
-    u8 user_id[0x10];
+    u128 user_id;
     u64 timestamp;
-    u8 username[0x20];
+    std::array<u8, 0x20> username;
 };
 static_assert(sizeof(ProfileBase) == 0x38, "ProfileBase structure has incorrect size");
 
-using Uid = std::array<u64, 2>;
-static constexpr Uid DEFAULT_USER_ID{0x10ull, 0x20ull};
+static constexpr u128 DEFAULT_USER_ID{1ull, 0ull};
 
 class IProfile final : public ServiceFramework<IProfile> {
 public:
-    IProfile() : ServiceFramework("IProfile") {
+    IProfile(u128 user_id) : ServiceFramework("IProfile"), user_id(user_id) {
         static const FunctionInfo functions[] = {
             {0, nullptr, "Get"},
             {1, &IProfile::GetBase, "GetBase"},
@@ -48,11 +48,18 @@ public:
 private:
     void GetBase(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_ACC, "(STUBBED) called");
+
+        // TODO(Subv): Retrieve this information from somewhere.
         ProfileBase profile_base{};
+        profile_base.user_id = user_id;
+        profile_base.username = {'y', 'u', 'z', 'u'};
+
         IPC::ResponseBuilder rb{ctx, 16};
         rb.Push(RESULT_SUCCESS);
         rb.PushRaw(profile_base);
     }
+
+    u128 user_id; ///< The user id this profile refers to.
 };
 
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
@@ -75,14 +82,16 @@ private:
         LOG_WARNING(Service_ACC, "(STUBBED) called");
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push(true); // TODO: Check when this is supposed to return true and when not
+        rb.Push(false); // TODO: Check when this is supposed to return true and when not
     }
 
     void GetAccountId(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_ACC, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(0x12345678ABCDEF);
+        // TODO(Subv): Find out what this actually does and implement it. Stub it as an error for
+        // now since we do not implement NNID. Returning a bogus id here will cause games to send
+        // invalid IPC requests after ListOpenUsers is called.
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultCode(-1));
     }
 };
 
@@ -95,25 +104,29 @@ void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
 
 void Module::Interface::ListAllUsers(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_ACC, "(STUBBED) called");
-    constexpr std::array<u128, 10> user_ids{DEFAULT_USER_ID};
-    ctx.WriteBuffer(user_ids.data(), user_ids.size());
+    // TODO(Subv): There is only one user for now.
+    const std::vector<u128> user_ids = {DEFAULT_USER_ID};
+    ctx.WriteBuffer(user_ids);
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
 void Module::Interface::ListOpenUsers(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_ACC, "(STUBBED) called");
-    constexpr std::array<u128, 10> user_ids{DEFAULT_USER_ID};
-    ctx.WriteBuffer(user_ids.data(), user_ids.size());
+    // TODO(Subv): There is only one user for now.
+    const std::vector<u128> user_ids = {DEFAULT_USER_ID};
+    ctx.WriteBuffer(user_ids);
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
 void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    u128 user_id = rp.PopRaw<u128>();
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IProfile>();
-    LOG_DEBUG(Service_ACC, "called");
+    rb.PushIpcInterface<IProfile>(user_id);
+    LOG_DEBUG(Service_ACC, "called user_id=0x{:016X}{:016X}", user_id[1], user_id[0]);
 }
 
 void Module::Interface::InitializeApplicationInfo(Kernel::HLERequestContext& ctx) {

src/core/hle/service/acc/acc.h

@@ -12,7 +12,7 @@ class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {
     public:
-        Interface(std::shared_ptr<Module> module, const char* name);
+        explicit Interface(std::shared_ptr<Module> module, const char* name);
 
         void GetUserExistence(Kernel::HLERequestContext& ctx);
         void ListAllUsers(Kernel::HLERequestContext& ctx);

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

@@ -4,9 +4,10 @@
 
 #include <cinttypes>
 #include <stack>
-#include "core/file_sys/filesystem.h"
+#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
+#include "core/hle/kernel/process.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
@@ -614,25 +615,14 @@ void IApplicationFunctions::CreateApplicationAndRequestToStartForQuest(
 
 void IApplicationFunctions::EnsureSaveData(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    u128 uid = rp.PopRaw<u128>();
+    u128 uid = rp.PopRaw<u128>(); // What does this do?
 
     LOG_WARNING(Service, "(STUBBED) called uid = {:016X}{:016X}", uid[1], uid[0]);
 
     IPC::ResponseBuilder rb{ctx, 4};
-
-    FileSys::Path unused;
-    auto savedata = FileSystem::OpenFileSystem(FileSystem::Type::SaveData);
-    if (savedata.Failed()) {
-        // Create the save data and return an error indicating that the operation was performed.
-        FileSystem::FormatFileSystem(FileSystem::Type::SaveData);
-        // TODO(Subv): Find out the correct error code for this.
-        rb.Push(ResultCode(ErrorModule::FS, 40));
-    } else {
-        rb.Push(RESULT_SUCCESS);
-    }
-
+    rb.Push(RESULT_SUCCESS);
     rb.Push<u64>(0);
-}
+} // namespace Service::AM
 
 void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {
     // Takes an input u32 Result, no output.

src/core/hle/service/am/am.h

@@ -72,7 +72,7 @@ public:
 
 class ISelfController final : public ServiceFramework<ISelfController> {
 public:
-    ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger);
+    explicit ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger);
 
 private:
     void SetFocusHandlingMode(Kernel::HLERequestContext& ctx);

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

@@ -12,7 +12,7 @@ namespace Service::AM {
 
 class ILibraryAppletProxy final : public ServiceFramework<ILibraryAppletProxy> {
 public:
-    ILibraryAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
+    explicit ILibraryAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
         : ServiceFramework("ILibraryAppletProxy"), nvflinger(std::move(nvflinger)) {
         static const FunctionInfo functions[] = {
             {0, &ILibraryAppletProxy::GetCommonStateGetter, "GetCommonStateGetter"},

src/core/hle/service/am/applet_ae.h

@@ -17,7 +17,7 @@ namespace AM {
 
 class AppletAE final : public ServiceFramework<AppletAE> {
 public:
-    AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger);
+    explicit AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger);
     ~AppletAE() = default;
 
 private:

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

@@ -12,7 +12,7 @@ namespace Service::AM {
 
 class IApplicationProxy final : public ServiceFramework<IApplicationProxy> {
 public:
-    IApplicationProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
+    explicit IApplicationProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
         : ServiceFramework("IApplicationProxy"), nvflinger(std::move(nvflinger)) {
         static const FunctionInfo functions[] = {
             {0, &IApplicationProxy::GetCommonStateGetter, "GetCommonStateGetter"},

src/core/hle/service/am/applet_oe.h

@@ -17,7 +17,7 @@ namespace AM {
 
 class AppletOE final : public ServiceFramework<AppletOE> {
 public:
-    AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger);
+    explicit AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger);
     ~AppletOE() = default;
 
 private:

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

@@ -20,6 +20,21 @@ public:
     }
 
 private:
+    enum class PerformanceConfiguration : u32 {
+        Config1 = 0x00010000,
+        Config2 = 0x00010001,
+        Config3 = 0x00010002,
+        Config4 = 0x00020000,
+        Config5 = 0x00020001,
+        Config6 = 0x00020002,
+        Config7 = 0x00020003,
+        Config8 = 0x00020004,
+        Config9 = 0x00020005,
+        Config10 = 0x00020006,
+        Config11 = 0x92220007,
+        Config12 = 0x92220008,
+    };
+
     void SetPerformanceConfiguration(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 
@@ -40,7 +55,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(0); // Performance configuration
+        rb.Push<u32>(static_cast<u32>(PerformanceConfiguration::Config1));
 
         LOG_WARNING(Service_APM, "(STUBBED) called mode={}", static_cast<u32>(mode));
     }

src/core/hle/service/apm/interface.h

@@ -10,7 +10,7 @@ namespace Service::APM {
 
 class APM final : public ServiceFramework<APM> {
 public:
-    APM(std::shared_ptr<Module> apm, const char* name);
+    explicit APM(std::shared_ptr<Module> apm, const char* name);
     ~APM() = default;
 
 private:

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

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <array>
 #include <vector>
 #include "common/logging/log.h"
 #include "core/core_timing.h"
@@ -27,12 +28,12 @@ public:
             {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
             {1, &IAudioOut::StartAudioOut, "StartAudioOut"},
             {2, &IAudioOut::StopAudioOut, "StopAudioOut"},
-            {3, &IAudioOut::AppendAudioOutBuffer, "AppendAudioOutBuffer"},
+            {3, &IAudioOut::AppendAudioOutBufferImpl, "AppendAudioOutBuffer"},
             {4, &IAudioOut::RegisterBufferEvent, "RegisterBufferEvent"},
-            {5, &IAudioOut::GetReleasedAudioOutBuffer, "GetReleasedAudioOutBuffer"},
+            {5, &IAudioOut::GetReleasedAudioOutBufferImpl, "GetReleasedAudioOutBuffer"},
             {6, nullptr, "ContainsAudioOutBuffer"},
-            {7, nullptr, "AppendAudioOutBufferAuto"},
-            {8, nullptr, "GetReleasedAudioOutBufferAuto"},
+            {7, &IAudioOut::AppendAudioOutBufferImpl, "AppendAudioOutBufferAuto"},
+            {8, &IAudioOut::GetReleasedAudioOutBufferImpl, "GetReleasedAudioOutBufferAuto"},
             {9, nullptr, "GetAudioOutBufferCount"},
             {10, nullptr, "GetAudioOutPlayedSampleCount"},
             {11, nullptr, "FlushAudioOutBuffers"},
@@ -96,7 +97,7 @@ private:
         rb.PushCopyObjects(buffer_event);
     }
 
-    void AppendAudioOutBuffer(Kernel::HLERequestContext& ctx) {
+    void AppendAudioOutBufferImpl(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
 
@@ -107,7 +108,7 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
-    void GetReleasedAudioOutBuffer(Kernel::HLERequestContext& ctx) {
+    void GetReleasedAudioOutBufferImpl(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
 
         // TODO(st4rk): This is how libtransistor currently implements the
@@ -163,12 +164,12 @@ private:
     AudioState audio_out_state;
 };
 
-void AudOutU::ListAudioOuts(Kernel::HLERequestContext& ctx) {
+void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_Audio, "(STUBBED) called");
     IPC::RequestParser rp{ctx};
 
-    const std::string audio_interface = "AudioInterface";
-    ctx.WriteBuffer(audio_interface.c_str(), audio_interface.size());
+    constexpr std::array<char, 15> audio_interface{{"AudioInterface"}};
+    ctx.WriteBuffer(audio_interface);
 
     IPC::ResponseBuilder rb = rp.MakeBuilder(3, 0, 0);
 
@@ -179,7 +180,7 @@ void AudOutU::ListAudioOuts(Kernel::HLERequestContext& ctx) {
     rb.Push<u32>(1);
 }
 
-void AudOutU::OpenAudioOut(Kernel::HLERequestContext& ctx) {
+void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_Audio, "(STUBBED) called");
 
     if (!audio_out_interface) {
@@ -196,10 +197,10 @@ void AudOutU::OpenAudioOut(Kernel::HLERequestContext& ctx) {
 }
 
 AudOutU::AudOutU() : ServiceFramework("audout:u") {
-    static const FunctionInfo functions[] = {{0, &AudOutU::ListAudioOuts, "ListAudioOuts"},
-                                             {1, &AudOutU::OpenAudioOut, "OpenAudioOut"},
-                                             {2, nullptr, "ListAudioOutsAuto"},
-                                             {3, nullptr, "OpenAudioOutAuto"}};
+    static const FunctionInfo functions[] = {{0, &AudOutU::ListAudioOutsImpl, "ListAudioOuts"},
+                                             {1, &AudOutU::OpenAudioOutImpl, "OpenAudioOut"},
+                                             {2, &AudOutU::ListAudioOutsImpl, "ListAudioOutsAuto"},
+                                             {3, &AudOutU::OpenAudioOutImpl, "OpenAudioOutAuto"}};
     RegisterHandlers(functions);
 }
 

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

@@ -22,8 +22,8 @@ public:
 private:
     std::shared_ptr<IAudioOut> audio_out_interface;
 
-    void ListAudioOuts(Kernel::HLERequestContext& ctx);
-    void OpenAudioOut(Kernel::HLERequestContext& ctx);
+    void ListAudioOutsImpl(Kernel::HLERequestContext& ctx);
+    void OpenAudioOutImpl(Kernel::HLERequestContext& ctx);
 
     enum class PcmFormat : u32 {
         Invalid = 0,

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

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <array>
+
 #include "common/alignment.h"
 #include "common/logging/log.h"
 #include "core/core_timing.h"
@@ -17,7 +19,7 @@ constexpr u64 audio_ticks{static_cast<u64>(CoreTiming::BASE_CLOCK_RATE / 200)};
 
 class IAudioRenderer final : public ServiceFramework<IAudioRenderer> {
 public:
-    IAudioRenderer(AudioRendererParameter audren_params)
+    explicit IAudioRenderer(AudioRendererParameter audren_params)
         : ServiceFramework("IAudioRenderer"), worker_params(audren_params) {
         static const FunctionInfo functions[] = {
             {0, nullptr, "GetAudioRendererSampleRate"},
@@ -47,7 +49,7 @@ public:
 
         // Start the audio event
         CoreTiming::ScheduleEvent(audio_ticks, audio_event);
-        voice_status_list.reserve(worker_params.voice_count);
+        voice_status_list.resize(worker_params.voice_count);
     }
     ~IAudioRenderer() {
         CoreTiming::UnscheduleEvent(audio_event, 0);
@@ -87,8 +89,6 @@ private:
                 memory_pool[i].state = MemoryPoolStates::Attached;
             else if (mem_pool_info[i].pool_state == MemoryPoolStates::RequestDetach)
                 memory_pool[i].state = MemoryPoolStates::Detached;
-            else
-                memory_pool[i].state = mem_pool_info[i].pool_state;
         }
         std::memcpy(output.data() + sizeof(UpdateDataHeader), memory_pool.data(),
                     response_data.memory_pools_size);
@@ -178,12 +178,14 @@ private:
     struct UpdateDataHeader {
         UpdateDataHeader() {}
 
-        UpdateDataHeader(const AudioRendererParameter& config) {
+        explicit UpdateDataHeader(const AudioRendererParameter& config) {
             revision = Common::MakeMagic('R', 'E', 'V', '4'); // 5.1.0 Revision
             behavior_size = 0xb0;
             memory_pools_size = (config.effect_count + (config.voice_count * 4)) * 0x10;
             voices_size = config.voice_count * 0x10;
+            voice_resource_size = 0x0;
             effects_size = config.effect_count * 0x10;
+            mixes_size = 0x0;
             sinks_size = config.sink_count * 0x20;
             performance_manager_size = 0x10;
             total_size = sizeof(UpdateDataHeader) + behavior_size + memory_pools_size +
@@ -298,8 +300,8 @@ private:
         LOG_WARNING(Service_Audio, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
 
-        const std::string audio_interface = "AudioInterface";
-        ctx.WriteBuffer(audio_interface.c_str(), audio_interface.size());
+        constexpr std::array<char, 15> audio_interface{{"AudioInterface"}};
+        ctx.WriteBuffer(audio_interface);
 
         IPC::ResponseBuilder rb = rp.MakeBuilder(3, 0, 0);
         rb.Push(RESULT_SUCCESS);
@@ -323,8 +325,8 @@ private:
         LOG_WARNING(Service_Audio, "(STUBBED) called");
         IPC::RequestParser rp{ctx};
 
-        const std::string audio_interface = "AudioDevice";
-        ctx.WriteBuffer(audio_interface.c_str(), audio_interface.size());
+        constexpr std::array<char, 12> audio_interface{{"AudioDevice"}};
+        ctx.WriteBuffer(audio_interface);
 
         IPC::ResponseBuilder rb = rp.MakeBuilder(3, 0, 0);
         rb.Push(RESULT_SUCCESS);

src/core/hle/service/bcat/module.h

@@ -12,7 +12,7 @@ class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {
     public:
-        Interface(std::shared_ptr<Module> module, const char* name);
+        explicit Interface(std::shared_ptr<Module> module, const char* name);
 
         void CreateBcatService(Kernel::HLERequestContext& ctx);
 

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

@@ -12,7 +12,7 @@ class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {
     public:
-        Interface(std::shared_ptr<Module> module, const char* name);
+        explicit Interface(std::shared_ptr<Module> module, const char* name);
 
         void ThrowFatalWithPolicy(Kernel::HLERequestContext& ctx);
         void ThrowFatalWithCpuContext(Kernel::HLERequestContext& ctx);

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

@@ -2,17 +2,17 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "boost/container/flat_map.hpp"
+#include <utility>
+
 #include "common/assert.h"
-#include "common/common_paths.h"
 #include "common/file_util.h"
 #include "core/core.h"
 #include "core/file_sys/errors.h"
-#include "core/file_sys/filesystem.h"
+#include "core/file_sys/savedata_factory.h"
+#include "core/file_sys/sdmc_factory.h"
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/file_sys/vfs_real.h"
-#include "core/hle/kernel/process.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_srv.h"
 
@@ -25,14 +25,14 @@ constexpr u64 EMULATED_SD_REPORTED_SIZE = 32000000000;
 
 static FileSys::VirtualDir GetDirectoryRelativeWrapped(FileSys::VirtualDir base,
                                                        const std::string& dir_name) {
-    if (dir_name == "." || dir_name == "" || dir_name == "/" || dir_name == "\\")
+    if (dir_name.empty() || dir_name == "." || dir_name == "/" || dir_name == "\\")
         return base;
 
     return base->GetDirectoryRelative(dir_name);
 }
 
 VfsDirectoryServiceWrapper::VfsDirectoryServiceWrapper(FileSys::VirtualDir backing_)
-    : backing(backing_) {}
+    : backing(std::move(backing_)) {}
 
 std::string VfsDirectoryServiceWrapper::GetName() const {
     return backing->GetName();
@@ -41,17 +41,29 @@ std::string VfsDirectoryServiceWrapper::GetName() const {
 ResultCode VfsDirectoryServiceWrapper::CreateFile(const std::string& path, u64 size) const {
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
     auto file = dir->CreateFile(FileUtil::GetFilename(path));
-    if (file == nullptr)
+    if (file == nullptr) {
+        // TODO(DarkLordZach): Find a better error code for this
         return ResultCode(-1);
-    if (!file->Resize(size))
+    }
+    if (!file->Resize(size)) {
+        // TODO(DarkLordZach): Find a better error code for this
         return ResultCode(-1);
+    }
     return RESULT_SUCCESS;
 }
 
 ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path) const {
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
-    if (!backing->DeleteFile(FileUtil::GetFilename(path)))
+    if (path == "/" || path == "\\") {
+        // TODO(DarkLordZach): Why do games call this and what should it do? Works as is but...
+        return RESULT_SUCCESS;
+    }
+    if (dir->GetFile(FileUtil::GetFilename(path)) == nullptr)
+        return FileSys::ERROR_PATH_NOT_FOUND;
+    if (!backing->DeleteFile(FileUtil::GetFilename(path))) {
+        // TODO(DarkLordZach): Find a better error code for this
         return ResultCode(-1);
+    }
     return RESULT_SUCCESS;
 }
 
@@ -60,22 +72,28 @@ ResultCode VfsDirectoryServiceWrapper::CreateDirectory(const std::string& path)
     if (dir == nullptr && FileUtil::GetFilename(FileUtil::GetParentPath(path)).empty())
         dir = backing;
     auto new_dir = dir->CreateSubdirectory(FileUtil::GetFilename(path));
-    if (new_dir == nullptr)
+    if (new_dir == nullptr) {
+        // TODO(DarkLordZach): Find a better error code for this
         return ResultCode(-1);
+    }
     return RESULT_SUCCESS;
 }
 
 ResultCode VfsDirectoryServiceWrapper::DeleteDirectory(const std::string& path) const {
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
-    if (!dir->DeleteSubdirectory(FileUtil::GetFilename(path)))
+    if (!dir->DeleteSubdirectory(FileUtil::GetFilename(path))) {
+        // TODO(DarkLordZach): Find a better error code for this
         return ResultCode(-1);
+    }
     return RESULT_SUCCESS;
 }
 
 ResultCode VfsDirectoryServiceWrapper::DeleteDirectoryRecursively(const std::string& path) const {
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
-    if (!dir->DeleteSubdirectoryRecursive(FileUtil::GetFilename(path)))
+    if (!dir->DeleteSubdirectoryRecursive(FileUtil::GetFilename(path))) {
+        // TODO(DarkLordZach): Find a better error code for this
         return ResultCode(-1);
+    }
     return RESULT_SUCCESS;
 }
 
@@ -86,8 +104,10 @@ ResultCode VfsDirectoryServiceWrapper::RenameFile(const std::string& src_path,
         // Use more-optimized vfs implementation rename.
         if (src == nullptr)
             return FileSys::ERROR_PATH_NOT_FOUND;
-        if (!src->Rename(FileUtil::GetFilename(dest_path)))
+        if (!src->Rename(FileUtil::GetFilename(dest_path))) {
+            // TODO(DarkLordZach): Find a better error code for this
             return ResultCode(-1);
+        }
         return RESULT_SUCCESS;
     }
 
@@ -102,8 +122,10 @@ ResultCode VfsDirectoryServiceWrapper::RenameFile(const std::string& src_path,
     ASSERT_MSG(dest->WriteBytes(src->ReadAllBytes()) == src->GetSize(),
                "Could not write all of the bytes but everything else has succeded.");
 
-    if (!src->GetContainingDirectory()->DeleteFile(FileUtil::GetFilename(src_path)))
+    if (!src->GetContainingDirectory()->DeleteFile(FileUtil::GetFilename(src_path))) {
+        // TODO(DarkLordZach): Find a better error code for this
         return ResultCode(-1);
+    }
 
     return RESULT_SUCCESS;
 }
@@ -115,8 +137,10 @@ ResultCode VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_pa
         // Use more-optimized vfs implementation rename.
         if (src == nullptr)
             return FileSys::ERROR_PATH_NOT_FOUND;
-        if (!src->Rename(FileUtil::GetFilename(dest_path)))
+        if (!src->Rename(FileUtil::GetFilename(dest_path))) {
+            // TODO(DarkLordZach): Find a better error code for this
             return ResultCode(-1);
+        }
         return RESULT_SUCCESS;
     }
 
@@ -126,16 +150,20 @@ ResultCode VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_pa
                "don't match -- UNIMPLEMENTED",
                src_path, dest_path);
 
+    // TODO(DarkLordZach): Find a better error code for this
     return ResultCode(-1);
 }
 
 ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::string& path,
                                                                      FileSys::Mode mode) const {
-    auto file = backing->GetFileRelative(path);
+    auto npath = path;
+    while (npath.size() > 0 && (npath[0] == '/' || npath[0] == '\\'))
+        npath = npath.substr(1);
+    auto file = backing->GetFileRelative(npath);
     if (file == nullptr)
         return FileSys::ERROR_PATH_NOT_FOUND;
 
-    if ((static_cast<u32>(mode) & static_cast<u32>(FileSys::Mode::Append)) != 0) {
+    if (mode == FileSys::Mode::Append) {
         return MakeResult<FileSys::VirtualFile>(
             std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize()));
     }
@@ -145,8 +173,10 @@ ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::
 
 ResultVal<FileSys::VirtualDir> VfsDirectoryServiceWrapper::OpenDirectory(const std::string& path) {
     auto dir = GetDirectoryRelativeWrapped(backing, path);
-    if (dir == nullptr)
+    if (dir == nullptr) {
+        // TODO(DarkLordZach): Find a better error code for this
         return ResultCode(-1);
+    }
     return MakeResult(dir);
 }
 
@@ -161,103 +191,96 @@ ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
     const std::string& path) const {
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
     if (dir == nullptr)
-        return ResultCode(-1);
+        return FileSys::ERROR_PATH_NOT_FOUND;
     auto filename = FileUtil::GetFilename(path);
+    // TODO(Subv): Some games use the '/' path, find out what this means.
+    if (filename.empty())
+        return MakeResult(FileSys::EntryType::Directory);
+
     if (dir->GetFile(filename) != nullptr)
         return MakeResult(FileSys::EntryType::File);
     if (dir->GetSubdirectory(filename) != nullptr)
         return MakeResult(FileSys::EntryType::Directory);
-    return ResultCode(-1);
+    return FileSys::ERROR_PATH_NOT_FOUND;
 }
 
-// A deferred filesystem for nand save data.
-// This must be deferred because the directory is dependent on title id, which is not set at
-// registration time.
-struct SaveDataDeferredFilesystem : DeferredFilesystem {
-protected:
-    FileSys::VirtualDir CreateFilesystem() override {
-        u64 title_id = Core::CurrentProcess()->program_id;
-        // TODO(DarkLordZach): Users
-        u32 user_id = 0;
-        std::string nand_directory = fmt::format(
-            "{}save/{:016X}/{:08X}/", FileUtil::GetUserPath(D_NAND_IDX), title_id, user_id);
-
-        auto savedata =
-            std::make_shared<FileSys::RealVfsDirectory>(nand_directory, FileSys::Mode::Write);
-        return savedata;
-    }
-};
-
 /**
  * Map of registered file systems, identified by type. Once an file system is registered here, it
  * is never removed until UnregisterFileSystems is called.
  */
-static boost::container::flat_map<Type, std::unique_ptr<DeferredFilesystem>> filesystem_map;
-static FileSys::VirtualFile filesystem_romfs = nullptr;
+static std::unique_ptr<FileSys::RomFSFactory> romfs_factory;
+static std::unique_ptr<FileSys::SaveDataFactory> save_data_factory;
+static std::unique_ptr<FileSys::SDMCFactory> sdmc_factory;
 
-ResultCode RegisterFileSystem(std::unique_ptr<DeferredFilesystem>&& factory, Type type) {
-    auto result = filesystem_map.emplace(type, std::move(factory));
-
-    bool inserted = result.second;
-    ASSERT_MSG(inserted, "Tried to register more than one system with same id code");
-
-    auto& filesystem = result.first->second;
-    LOG_DEBUG(Service_FS, "Registered file system with id code 0x{:08X}", static_cast<u32>(type));
+ResultCode RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory) {
+    ASSERT_MSG(romfs_factory == nullptr, "Tried to register a second RomFS");
+    romfs_factory = std::move(factory);
+    LOG_DEBUG(Service_FS, "Registered RomFS");
     return RESULT_SUCCESS;
 }
 
-ResultCode RegisterRomFS(FileSys::VirtualFile filesystem) {
-    ASSERT_MSG(filesystem_romfs == nullptr,
-               "Tried to register more than one system with same id code");
-
-    filesystem_romfs = filesystem;
-    LOG_DEBUG(Service_FS, "Registered file system {} with id code 0x{:08X}", filesystem->GetName(),
-              static_cast<u32>(Type::RomFS));
+ResultCode RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory) {
+    ASSERT_MSG(romfs_factory == nullptr, "Tried to register a second save data");
+    save_data_factory = std::move(factory);
+    LOG_DEBUG(Service_FS, "Registered save data");
     return RESULT_SUCCESS;
 }
 
-ResultVal<FileSys::VirtualDir> OpenFileSystem(Type type) {
-    LOG_TRACE(Service_FS, "Opening FileSystem with type={}", static_cast<u32>(type));
+ResultCode RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory) {
+    ASSERT_MSG(sdmc_factory == nullptr, "Tried to register a second SDMC");
+    sdmc_factory = std::move(factory);
+    LOG_DEBUG(Service_FS, "Registered SDMC");
+    return RESULT_SUCCESS;
+}
 
-    auto itr = filesystem_map.find(type);
-    if (itr == filesystem_map.end()) {
+ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id) {
+    LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}", title_id);
+
+    if (romfs_factory == nullptr) {
         // TODO(bunnei): Find a better error code for this
         return ResultCode(-1);
     }
 
-    return MakeResult(itr->second->Get());
+    return romfs_factory->Open(title_id);
 }
 
-ResultVal<FileSys::VirtualFile> OpenRomFS() {
-    if (filesystem_romfs == nullptr)
-        return ResultCode(-1);
-    return MakeResult(filesystem_romfs);
-}
+ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
+                                            FileSys::SaveDataDescriptor save_struct) {
+    LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}",
+              static_cast<u8>(space), save_struct.DebugInfo());
 
-ResultCode FormatFileSystem(Type type) {
-    LOG_TRACE(Service_FS, "Formatting FileSystem with type={}", static_cast<u32>(type));
-
-    auto itr = filesystem_map.find(type);
-    if (itr == filesystem_map.end()) {
-        // TODO(bunnei): Find a better error code for this
-        return ResultCode(-1);
+    if (save_data_factory == nullptr) {
+        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound);
     }
 
-    return itr->second->Get()->GetParentDirectory()->DeleteSubdirectory(
-               itr->second->Get()->GetName())
-               ? RESULT_SUCCESS
-               : ResultCode(-1);
+    return save_data_factory->Open(space, save_struct);
+}
+
+ResultVal<FileSys::VirtualDir> OpenSDMC() {
+    LOG_TRACE(Service_FS, "Opening SDMC");
+
+    if (sdmc_factory == nullptr) {
+        return ResultCode(ErrorModule::FS, FileSys::ErrCodes::SdCardNotFound);
+    }
+
+    return sdmc_factory->Open();
 }
 
 void RegisterFileSystems() {
-    filesystem_map.clear();
-    filesystem_romfs = nullptr;
+    romfs_factory = nullptr;
+    save_data_factory = nullptr;
+    sdmc_factory = nullptr;
 
-    std::string sd_directory = FileUtil::GetUserPath(D_SDMC_IDX);
-    auto sdcard = std::make_shared<FileSys::RealVfsDirectory>(sd_directory, FileSys::Mode::Write);
-    RegisterFileSystem(std::make_unique<DeferredFilesystem>(sdcard), Type::SDMC);
+    auto nand_directory = std::make_shared<FileSys::RealVfsDirectory>(
+        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir), FileSys::Mode::Write);
+    auto sd_directory = std::make_shared<FileSys::RealVfsDirectory>(
+        FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir), FileSys::Mode::Write);
 
-    RegisterFileSystem(std::make_unique<SaveDataDeferredFilesystem>(), Type::SaveData);
+    auto savedata = std::make_unique<FileSys::SaveDataFactory>(std::move(nand_directory));
+    save_data_factory = std::move(savedata);
+
+    auto sdcard = std::make_unique<FileSys::SDMCFactory>(std::move(sd_directory));
+    sdmc_factory = std::move(sdcard);
 }
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {

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

@@ -6,16 +6,13 @@
 
 #include <memory>
 #include "common/common_types.h"
-#include "core/file_sys/filesystem.h"
-#include "core/file_sys/vfs.h"
+#include "core/file_sys/directory.h"
+#include "core/file_sys/mode.h"
+#include "core/file_sys/romfs_factory.h"
+#include "core/file_sys/savedata_factory.h"
+#include "core/file_sys/sdmc_factory.h"
 #include "core/hle/result.h"
 
-namespace FileSys {
-class FileSystemBackend;
-class FileSystemFactory;
-class Path;
-} // namespace FileSys
-
 namespace Service {
 
 namespace SM {
@@ -24,12 +21,22 @@ class ServiceManager;
 
 namespace FileSystem {
 
-/// Supported FileSystem types
-enum class Type {
-    RomFS = 1,
-    SaveData = 2,
-    SDMC = 3,
-};
+ResultCode RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory);
+ResultCode RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory);
+ResultCode RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory);
+
+// TODO(DarkLordZach): BIS Filesystem
+// ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
+ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id);
+ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
+                                            FileSys::SaveDataDescriptor save_struct);
+ResultVal<FileSys::VirtualDir> OpenSDMC();
+
+// TODO(DarkLordZach): BIS Filesystem
+// ResultVal<std::unique_ptr<FileSys::FileSystemBackend>> OpenBIS();
+
+/// Registers all Filesystem services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& service_manager);
 
 // A class that wraps a VfsDirectory with methods that return ResultVal and ResultCode instead of
 // pointers and booleans. This makes using a VfsDirectory with switch services much easier and
@@ -126,61 +133,5 @@ private:
     FileSys::VirtualDir backing;
 };
 
-// A class that deferres the creation of a filesystem until a later time.
-// This is useful if construction depends on a variable not known when the filesystem is registered.
-// Construct this with a filesystem (VirtualDir) to avoid the deferrence feature or override the
-//     CreateFilesystem method which will be called on first use.
-struct DeferredFilesystem {
-    DeferredFilesystem() = default;
-
-    explicit DeferredFilesystem(FileSys::VirtualDir vfs_directory) : fs(std::move(vfs_directory)) {}
-
-    FileSys::VirtualDir Get() {
-        if (fs == nullptr)
-            fs = CreateFilesystem();
-
-        return fs;
-    }
-
-    virtual ~DeferredFilesystem() = default;
-
-protected:
-    virtual FileSys::VirtualDir CreateFilesystem() {
-        return fs;
-    }
-
-private:
-    FileSys::VirtualDir fs;
-};
-
-/**
- * Registers a FileSystem, instances of which can later be opened using its IdCode.
- * @param factory FileSystem backend interface to use
- * @param type Type used to access this type of FileSystem
- */
-ResultCode RegisterFileSystem(std::unique_ptr<DeferredFilesystem>&& fs, Type type);
-
-ResultCode RegisterRomFS(FileSys::VirtualFile fs);
-
-/**
- * Opens a file system
- * @param type Type of the file system to open
- * @param path Path to the file system, used with Binary paths
- * @return FileSys::FileSystemBackend interface to the file system
- */
-ResultVal<FileSys::VirtualDir> OpenFileSystem(Type type);
-
-ResultVal<FileSys::VirtualFile> OpenRomFS();
-
-/**
- * Formats a file system
- * @param type Type of the file system to format
- * @return ResultCode of the operation
- */
-ResultCode FormatFileSystem(Type type);
-
-/// Registers all Filesystem services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager);
-
 } // namespace FileSystem
 } // namespace Service

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

@@ -3,23 +3,38 @@
 // Refer to the license.txt file included.
 
 #include <cinttypes>
+#include <cstring>
+#include <iterator>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "common/assert.h"
+#include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/file_sys/directory.h"
-#include "core/file_sys/filesystem.h"
-#include "core/file_sys/storage.h"
+#include "core/file_sys/errors.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/client_port.h"
-#include "core/hle/kernel/client_session.h"
+#include "core/hle/kernel/process.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_srv.h"
 
 namespace Service::FileSystem {
 
+enum class StorageId : u8 {
+    None = 0,
+    Host = 1,
+    GameCard = 2,
+    NandSystem = 3,
+    NandUser = 4,
+    SdCard = 5,
+};
+
 class IStorage final : public ServiceFramework<IStorage> {
 public:
-    IStorage(FileSys::VirtualFile backend_)
+    explicit IStorage(FileSys::VirtualFile backend_)
         : ServiceFramework("IStorage"), backend(std::move(backend_)) {
         static const FunctionInfo functions[] = {
             {0, &IStorage::Read, "Read"}, {1, nullptr, "Write"},   {2, nullptr, "Flush"},
@@ -52,13 +67,6 @@ private:
 
         // Read the data from the Storage backend
         std::vector<u8> output = backend->ReadBytes(length, offset);
-        auto res = MakeResult<size_t>(output.size());
-        if (res.Failed()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(res.Code());
-            return;
-        }
-
         // Write the data to memory
         ctx.WriteBuffer(output);
 
@@ -104,19 +112,13 @@ private:
 
         // Read the data from the Storage backend
         std::vector<u8> output = backend->ReadBytes(length, offset);
-        auto res = MakeResult<size_t>(output.size());
-        if (res.Failed()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(res.Code());
-            return;
-        }
 
         // Write the data to memory
         ctx.WriteBuffer(output);
 
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(RESULT_SUCCESS);
-        rb.Push(static_cast<u64>(*res));
+        rb.Push(static_cast<u64>(output.size()));
     }
 
     void Write(Kernel::HLERequestContext& ctx) {
@@ -139,15 +141,21 @@ private:
             return;
         }
 
-        std::vector<u8> data = ctx.ReadBuffer();
-        data.resize(length);
+        const std::vector<u8> data = ctx.ReadBuffer();
+
+        ASSERT_MSG(
+            static_cast<s64>(data.size()) <= length,
+            "Attempting to write more data than requested (requested={:016X}, actual={:016X}).",
+            length, data.size());
+
         // Write the data to the Storage backend
-        auto res = MakeResult<size_t>(backend->WriteBytes(data, offset));
-        if (res.Failed()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(res.Code());
-            return;
-        }
+        const auto write_size =
+            static_cast<std::size_t>(std::distance(data.begin(), data.begin() + length));
+        const std::size_t written = backend->Write(data.data(), write_size, offset);
+
+        ASSERT_MSG(static_cast<s64>(written) == length,
+                   "Could not write all bytes to file (requested={:016X}, actual={:016X}).", length,
+                   written);
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -205,6 +213,7 @@ public:
         };
         RegisterHandlers(functions);
 
+        // TODO(DarkLordZach): Verify that this is the correct behavior.
         // Build entry index now to save time later.
         BuildEntryIndex(entries, backend->GetFiles(), FileSys::File);
         BuildEntryIndex(entries, backend->GetSubdirectories(), FileSys::Directory);
@@ -222,23 +231,20 @@ private:
         LOG_DEBUG(Service_FS, "called, unk=0x{:X}", unk);
 
         // Calculate how many entries we can fit in the output buffer
-        u64 count_entries = ctx.GetWriteBufferSize() / sizeof(FileSys::Entry);
+        const u64 count_entries = ctx.GetWriteBufferSize() / sizeof(FileSys::Entry);
 
         // Cap at total number of entries.
-        u64 actual_entries = std::min(count_entries, entries.size() - next_entry_index);
+        const u64 actual_entries = std::min(count_entries, entries.size() - next_entry_index);
 
-        // Read the data from the Directory backend
-        std::vector<FileSys::Entry> entry_data(entries.begin() + next_entry_index,
-                                               entries.begin() + next_entry_index + actual_entries);
+        // Determine data start and end
+        const auto* begin = reinterpret_cast<u8*>(entries.data() + next_entry_index);
+        const auto* end = reinterpret_cast<u8*>(entries.data() + next_entry_index + actual_entries);
+        const auto range_size = static_cast<std::size_t>(std::distance(begin, end));
 
         next_entry_index += actual_entries;
 
-        // Convert the data into a byte array
-        std::vector<u8> output(entry_data.size() * sizeof(FileSys::Entry));
-        std::memcpy(output.data(), entry_data.data(), output.size());
-
         // Write the data to memory
-        ctx.WriteBuffer(output);
+        ctx.WriteBuffer(begin, range_size);
 
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(RESULT_SUCCESS);
@@ -512,16 +518,6 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
     RegisterHandlers(functions);
 }
 
-void FSP_SRV::TryLoadRomFS() {
-    if (romfs) {
-        return;
-    }
-    auto res = OpenRomFS();
-    if (res.Succeeded()) {
-        romfs = std::move(res.Unwrap());
-    }
-}
-
 void FSP_SRV::Initialize(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_FS, "(STUBBED) called");
 
@@ -532,7 +528,7 @@ void FSP_SRV::Initialize(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::MountSdCard(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_FS, "called");
 
-    IFileSystem filesystem(OpenFileSystem(Type::SDMC).Unwrap());
+    IFileSystem filesystem(OpenSDMC().Unwrap());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
@@ -542,20 +538,34 @@ void FSP_SRV::MountSdCard(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::CreateSaveData(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
-    auto save_struct = rp.PopRaw<std::array<u8, 0x40>>();
+    auto save_struct = rp.PopRaw<FileSys::SaveDataDescriptor>();
     auto save_create_struct = rp.PopRaw<std::array<u8, 0x40>>();
     u128 uid = rp.PopRaw<u128>();
 
-    LOG_WARNING(Service_FS, "(STUBBED) called uid = {:016X}{:016X}", uid[1], uid[0]);
+    LOG_WARNING(Service_FS, "(STUBBED) called save_struct = {}, uid = {:016X}{:016X}",
+                save_struct.DebugInfo(), uid[1], uid[0]);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
 void FSP_SRV::MountSaveData(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
+    IPC::RequestParser rp{ctx};
 
-    IFileSystem filesystem(OpenFileSystem(Type::SaveData).Unwrap());
+    auto space_id = rp.PopRaw<FileSys::SaveDataSpaceId>();
+    auto unk = rp.Pop<u32>();
+    LOG_INFO(Service_FS, "called with unknown={:08X}", unk);
+    auto save_struct = rp.PopRaw<FileSys::SaveDataDescriptor>();
+
+    auto dir = OpenSaveData(space_id, save_struct);
+
+    if (dir.Failed()) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 0};
+        rb.Push(ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound));
+        return;
+    }
+
+    IFileSystem filesystem(std::move(dir.Unwrap()));
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
@@ -573,8 +583,8 @@ void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_FS, "called");
 
-    TryLoadRomFS();
-    if (!romfs) {
+    auto romfs = OpenRomFS(Core::System::GetInstance().CurrentProcess()->program_id);
+    if (romfs.Failed()) {
         // TODO (bunnei): Find the right error code to use here
         LOG_CRITICAL(Service_FS, "no file system interface available!");
         IPC::ResponseBuilder rb{ctx, 2};
@@ -582,7 +592,7 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
         return;
     }
 
-    IStorage storage(romfs);
+    IStorage storage(std::move(romfs.Unwrap()));
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
@@ -590,8 +600,16 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
 }
 
 void FSP_SRV::OpenRomStorage(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_FS, "(STUBBED) called, using OpenDataStorageByCurrentProcess");
-    OpenDataStorageByCurrentProcess(ctx);
+    IPC::RequestParser rp{ctx};
+
+    auto storage_id = rp.PopRaw<StorageId>();
+    auto title_id = rp.PopRaw<u64>();
+
+    LOG_DEBUG(Service_FS, "called with storage_id={:02X}, title_id={:016X}",
+              static_cast<u8>(storage_id), title_id);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultCode(ErrorModule::FS, FileSys::ErrCodes::TitleNotFound));
 }
 
 } // namespace Service::FileSystem

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

@@ -19,8 +19,6 @@ public:
     ~FSP_SRV() = default;
 
 private:
-    void TryLoadRomFS();
-
     void Initialize(Kernel::HLERequestContext& ctx);
     void MountSdCard(Kernel::HLERequestContext& ctx);
     void CreateSaveData(Kernel::HLERequestContext& ctx);

src/core/hle/service/friend/friend.h

@@ -12,7 +12,7 @@ class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {
     public:
-        Interface(std::shared_ptr<Module> module, const char* name);
+        explicit Interface(std::shared_ptr<Module> module, const char* name);
 
         void CreateFriendService(Kernel::HLERequestContext& ctx);
 

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

@@ -5,6 +5,7 @@
 #include <atomic>
 #include "common/logging/log.h"
 #include "core/core_timing.h"
+#include "core/frontend/emu_window.h"
 #include "core/frontend/input.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
@@ -18,9 +19,9 @@ namespace Service::HID {
 
 // Updating period for each HID device.
 // TODO(shinyquagsire23): These need better values.
-constexpr u64 pad_update_ticks = CoreTiming::BASE_CLOCK_RATE / 10000;
-constexpr u64 accelerometer_update_ticks = CoreTiming::BASE_CLOCK_RATE / 10000;
-constexpr u64 gyroscope_update_ticks = CoreTiming::BASE_CLOCK_RATE / 10000;
+constexpr u64 pad_update_ticks = CoreTiming::BASE_CLOCK_RATE / 100;
+constexpr u64 accelerometer_update_ticks = CoreTiming::BASE_CLOCK_RATE / 100;
+constexpr u64 gyroscope_update_ticks = CoreTiming::BASE_CLOCK_RATE / 100;
 
 class IAppletResource final : public ServiceFramework<IAppletResource> {
 public:
@@ -63,7 +64,8 @@ private:
         std::transform(Settings::values.analogs.begin() + Settings::NativeAnalog::STICK_HID_BEGIN,
                        Settings::values.analogs.begin() + Settings::NativeAnalog::STICK_HID_END,
                        sticks.begin(), Input::CreateDevice<Input::AnalogDevice>);
-        // TODO(shinyquagsire23): gyro, touch, mouse, keyboard
+        touch_device = Input::CreateDevice<Input::TouchDevice>(Settings::values.touch_device);
+        // TODO(shinyquagsire23): gyro, mouse, keyboard
     }
 
     void UpdatePadCallback(u64 userdata, int cycles_late) {
@@ -75,7 +77,7 @@ private:
 
         // Set up controllers as neon red+blue Joy-Con attached to console
         ControllerHeader& controller_header = mem.controllers[Controller_Handheld].header;
-        controller_header.type = ControllerType_Handheld | ControllerType_JoyconPair;
+        controller_header.type = ControllerType_Handheld;
         controller_header.single_colors_descriptor = ColorDesc_ColorsNonexistent;
         controller_header.right_color_body = JOYCON_BODY_NEON_RED;
         controller_header.right_color_buttons = JOYCON_BUTTONS_NEON_RED;
@@ -83,24 +85,21 @@ private:
         controller_header.left_color_buttons = JOYCON_BUTTONS_NEON_BLUE;
 
         for (size_t controller = 0; controller < mem.controllers.size(); controller++) {
-            for (int index = 0; index < HID_NUM_LAYOUTS; index++) {
-                // TODO(DarkLordZach): Is this layout/controller config actually invalid?
-                if (controller == Controller_Handheld && index == Layout_Single)
-                    continue;
-
-                ControllerLayout& layout = mem.controllers[controller].layouts[index];
+            for (auto& layout : mem.controllers[controller].layouts) {
                 layout.header.num_entries = HID_NUM_ENTRIES;
                 layout.header.max_entry_index = HID_NUM_ENTRIES - 1;
 
                 // HID shared memory stores the state of the past 17 samples in a circlular buffer,
                 // each with a timestamp in number of samples since boot.
+                const ControllerInputEntry& last_entry = layout.entries[layout.header.latest_entry];
+
                 layout.header.timestamp_ticks = CoreTiming::GetTicks();
                 layout.header.latest_entry = (layout.header.latest_entry + 1) % HID_NUM_ENTRIES;
 
                 ControllerInputEntry& entry = layout.entries[layout.header.latest_entry];
-                entry.timestamp++;
+                entry.timestamp = last_entry.timestamp + 1;
                 // TODO(shinyquagsire23): Is this always identical to timestamp?
-                entry.timestamp_2++;
+                entry.timestamp_2 = entry.timestamp;
 
                 // TODO(shinyquagsire23): More than just handheld input
                 if (controller != Controller_Handheld)
@@ -153,8 +152,6 @@ private:
             }
         }
 
-        // TODO(bunnei): Properly implement the touch screen, the below will just write empty data
-
         TouchScreen& touchscreen = mem.touchscreen;
         const u64 last_entry = touchscreen.header.latest_entry;
         const u64 curr_entry = (last_entry + 1) % touchscreen.entries.size();
@@ -166,7 +163,26 @@ private:
         touchscreen.header.max_entry_index = touchscreen.entries.size();
         touchscreen.header.timestamp = timestamp;
         touchscreen.entries[curr_entry].header.timestamp = sample_counter;
-        touchscreen.entries[curr_entry].header.num_touches = 0;
+
+        TouchScreenEntryTouch touch_entry{};
+        auto [x, y, pressed] = touch_device->GetStatus();
+        touch_entry.timestamp = timestamp;
+        touch_entry.x = static_cast<u16>(x * Layout::ScreenUndocked::Width);
+        touch_entry.y = static_cast<u16>(y * Layout::ScreenUndocked::Height);
+        touch_entry.touch_index = 0;
+
+        // TODO(DarkLordZach): Maybe try to derive these from EmuWindow?
+        touch_entry.diameter_x = 15;
+        touch_entry.diameter_y = 15;
+        touch_entry.angle = 0;
+
+        // TODO(DarkLordZach): Implement multi-touch support
+        if (pressed) {
+            touchscreen.entries[curr_entry].header.num_touches = 1;
+            touchscreen.entries[curr_entry].touches[0] = touch_entry;
+        } else {
+            touchscreen.entries[curr_entry].header.num_touches = 0;
+        }
 
         // TODO(shinyquagsire23): Properly implement mouse
         Mouse& mouse = mem.mouse;
@@ -196,8 +212,7 @@ private:
         keyboard.entries[curr_keyboard_entry].timestamp_2 = keyboard_sample_counter;
 
         // TODO(shinyquagsire23): Figure out what any of these are
-        for (size_t i = 0; i < mem.unk_input_1.size(); i++) {
-            UnkInput1& input = mem.unk_input_1[i];
+        for (auto& input : mem.unk_input_1) {
             const u64 last_input_entry = input.header.latest_entry;
             const u64 curr_input_entry = (input.header.latest_entry + 1) % input.entries.size();
             const u64 input_sample_counter = input.entries[last_input_entry].timestamp + 1;
@@ -211,9 +226,7 @@ private:
             input.entries[curr_input_entry].timestamp_2 = input_sample_counter;
         }
 
-        for (size_t i = 0; i < mem.unk_input_2.size(); i++) {
-            UnkInput2& input = mem.unk_input_2[i];
-
+        for (auto& input : mem.unk_input_2) {
             input.header.timestamp_ticks = timestamp;
             input.header.num_entries = 17;
             input.header.latest_entry = 0;
@@ -252,6 +265,7 @@ private:
     std::array<std::unique_ptr<Input::ButtonDevice>, Settings::NativeButton::NUM_BUTTONS_HID>
         buttons;
     std::array<std::unique_ptr<Input::AnalogDevice>, Settings::NativeAnalog::NUM_STICKS_HID> sticks;
+    std::unique_ptr<Input::TouchDevice> touch_device;
 };
 
 class IActiveVibrationDeviceList final : public ServiceFramework<IActiveVibrationDeviceList> {

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

@@ -380,7 +380,7 @@ static_assert(sizeof(ControllerLayout) == 0x350,
 
 struct Controller {
     ControllerHeader header;
-    std::array<ControllerLayout, 7> layouts;
+    std::array<ControllerLayout, HID_NUM_LAYOUTS> layouts;
     std::array<u8, 0x2a70> unk_1;
     ControllerMAC mac_left;
     ControllerMAC mac_right;

src/core/hle/service/nfp/nfp.h

@@ -12,7 +12,7 @@ class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {
     public:
-        Interface(std::shared_ptr<Module> module, const char* name);
+        explicit Interface(std::shared_ptr<Module> module, const char* name);
 
         void CreateUserInterface(Kernel::HLERequestContext& ctx);