service/nfc: Implement Create[x]Interface functions

These simply return the respective interface.

.gitignore

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

src/common/logging/backend.cpp

@@ -173,8 +173,10 @@ void FileBackend::Write(const Entry& entry) {
     SUB(Service, Friend)                                                                           \
     SUB(Service, FS)                                                                               \
     SUB(Service, HID)                                                                              \
+    SUB(Service, LDN)                                                                              \
     SUB(Service, LM)                                                                               \
     SUB(Service, MM)                                                                               \
+    SUB(Service, NFC)                                                                              \
     SUB(Service, NFP)                                                                              \
     SUB(Service, NIFM)                                                                             \
     SUB(Service, NS)                                                                               \

src/common/logging/log.h

@@ -60,8 +60,10 @@ enum class Class : ClassType {
     Service_Friend,    ///< The friend service
     Service_FS,        ///< The FS (Filesystem) service
     Service_HID,       ///< The HID (Human interface device) service
+    Service_LDN,       ///< The LDN (Local domain network) service
     Service_LM,        ///< The LM (Logger) service
     Service_MM,        ///< The MM (Multimedia) service
+    Service_NFC,       ///< The NFC (Near-field communication) service
     Service_NFP,       ///< The NFP service
     Service_NIFM,      ///< The NIFM (Network interface) service
     Service_NS,        ///< The NS services

src/common/string_util.cpp

@@ -162,21 +162,21 @@ void SplitString(const std::string& str, const char delim, std::vector<std::stri
     std::istringstream iss(str);
     output.resize(1);
 
-    while (std::getline(iss, *output.rbegin(), delim))
-        output.push_back("");
+    while (std::getline(iss, *output.rbegin(), delim)) {
+        output.emplace_back();
+    }
 
     output.pop_back();
 }
 
-std::string TabsToSpaces(int tab_size, const std::string& in) {
-    const std::string spaces(tab_size, ' ');
-    std::string out(in);
-
+std::string TabsToSpaces(int tab_size, std::string in) {
     size_t i = 0;
-    while (out.npos != (i = out.find('\t')))
-        out.replace(i, 1, spaces);
 
-    return out;
+    while ((i = in.find('\t')) != std::string::npos) {
+        in.replace(i, 1, tab_size, ' ');
+    }
+
+    return in;
 }
 
 std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest) {
@@ -220,31 +220,37 @@ std::u16string UTF8ToUTF16(const std::string& input) {
 }
 
 static std::wstring CPToUTF16(u32 code_page, const std::string& input) {
-    auto const size =
+    const auto size =
         MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);
 
-    std::wstring output;
-    output.resize(size);
+    if (size == 0) {
+        return L"";
+    }
 
-    if (size == 0 ||
-        size != MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()),
-                                    &output[0], static_cast<int>(output.size())))
+    std::wstring output(size, L'\0');
+
+    if (size != MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()),
+                                    &output[0], static_cast<int>(output.size()))) {
         output.clear();
+    }
 
     return output;
 }
 
 std::string UTF16ToUTF8(const std::wstring& input) {
-    auto const size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
+    const auto size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
                                           nullptr, 0, nullptr, nullptr);
+    if (size == 0) {
+        return "";
+    }
 
-    std::string output;
-    output.resize(size);
+    std::string output(size, '\0');
 
-    if (size == 0 ||
-        size != WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
-                                    &output[0], static_cast<int>(output.size()), nullptr, nullptr))
+    if (size != WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
+                                    &output[0], static_cast<int>(output.size()), nullptr,
+                                    nullptr)) {
         output.clear();
+    }
 
     return output;
 }
@@ -265,8 +271,6 @@ std::string CP1252ToUTF8(const std::string& input) {
 
 template <typename T>
 static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>& input) {
-    std::string result;
-
     iconv_t const conv_desc = iconv_open("UTF-8", fromcode);
     if ((iconv_t)(-1) == conv_desc) {
         LOG_ERROR(Common, "Iconv initialization failure [{}]: {}", fromcode, strerror(errno));
@@ -278,8 +282,7 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
     // Multiply by 4, which is the max number of bytes to encode a codepoint
     const size_t out_buffer_size = 4 * in_bytes;
 
-    std::string out_buffer;
-    out_buffer.resize(out_buffer_size);
+    std::string out_buffer(out_buffer_size, '\0');
 
     auto src_buffer = &input[0];
     size_t src_bytes = in_bytes;
@@ -304,6 +307,7 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
         }
     }
 
+    std::string result;
     out_buffer.resize(out_buffer_size - dst_bytes);
     out_buffer.swap(result);
 
@@ -313,8 +317,6 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
 }
 
 std::u16string UTF8ToUTF16(const std::string& input) {
-    std::u16string result;
-
     iconv_t const conv_desc = iconv_open("UTF-16LE", "UTF-8");
     if ((iconv_t)(-1) == conv_desc) {
         LOG_ERROR(Common, "Iconv initialization failure [UTF-8]: {}", strerror(errno));
@@ -326,8 +328,7 @@ std::u16string UTF8ToUTF16(const std::string& input) {
     // Multiply by 4, which is the max number of bytes to encode a codepoint
     const size_t out_buffer_size = 4 * sizeof(char16_t) * in_bytes;
 
-    std::u16string out_buffer;
-    out_buffer.resize(out_buffer_size);
+    std::u16string out_buffer(out_buffer_size, char16_t{});
 
     char* src_buffer = const_cast<char*>(&input[0]);
     size_t src_bytes = in_bytes;
@@ -352,6 +353,7 @@ std::u16string UTF8ToUTF16(const std::string& input) {
         }
     }
 
+    std::u16string result;
     out_buffer.resize(out_buffer_size - dst_bytes);
     out_buffer.swap(result);
 

src/common/string_util.h

@@ -57,7 +57,7 @@ static bool TryParse(const std::string& str, N* const output) {
         return false;
 }
 
-std::string TabsToSpaces(int tab_size, const std::string& in);
+std::string TabsToSpaces(int tab_size, std::string in);
 
 void SplitString(const std::string& str, char delim, std::vector<std::string>& output);
 

src/core/CMakeLists.txt

@@ -10,8 +10,12 @@ add_library(core STATIC
     core_cpu.h
     core_timing.cpp
     core_timing.h
+    core_timing_util.cpp
+    core_timing_util.h
     file_sys/content_archive.cpp
     file_sys/content_archive.h
+    file_sys/control_metadata.cpp
+    file_sys/control_metadata.h
     file_sys/directory.h
     file_sys/errors.h
     file_sys/mode.h
@@ -38,8 +42,6 @@ add_library(core STATIC
     frontend/input.h
     gdbstub/gdbstub.cpp
     gdbstub/gdbstub.h
-    hle/config_mem.cpp
-    hle/config_mem.h
     hle/ipc.h
     hle/ipc_helpers.h
     hle/kernel/address_arbiter.cpp
@@ -114,26 +116,32 @@ add_library(core STATIC
     hle/service/apm/apm.h
     hle/service/apm/interface.cpp
     hle/service/apm/interface.h
-    hle/service/audio/audio.cpp
-    hle/service/audio/audio.h
     hle/service/audio/audin_u.cpp
     hle/service/audio/audin_u.h
+    hle/service/audio/audio.cpp
+    hle/service/audio/audio.h
     hle/service/audio/audout_u.cpp
     hle/service/audio/audout_u.h
     hle/service/audio/audrec_u.cpp
     hle/service/audio/audrec_u.h
     hle/service/audio/audren_u.cpp
-    hle/service/audio/audren_u.h
     hle/service/audio/audren_u.cpp
     hle/service/audio/audren_u.h
+    hle/service/audio/audren_u.h
     hle/service/audio/codecctl.cpp
     hle/service/audio/codecctl.h
     hle/service/audio/hwopus.cpp
     hle/service/audio/hwopus.h
-    hle/service/bcat/module.cpp
-    hle/service/bcat/module.h
     hle/service/bcat/bcat.cpp
     hle/service/bcat/bcat.h
+    hle/service/bcat/module.cpp
+    hle/service/bcat/module.h
+    hle/service/erpt/erpt.cpp
+    hle/service/erpt/erpt.h
+    hle/service/es/es.cpp
+    hle/service/es/es.h
+    hle/service/eupld/eupld.cpp
+    hle/service/eupld/eupld.h
     hle/service/fatal/fatal.cpp
     hle/service/fatal/fatal.h
     hle/service/fatal/fatal_p.cpp
@@ -146,28 +154,34 @@ add_library(core STATIC
     hle/service/filesystem/fsp_srv.h
     hle/service/friend/friend.cpp
     hle/service/friend/friend.h
-    hle/service/friend/friend_a.cpp
-    hle/service/friend/friend_a.h
-    hle/service/friend/friend_u.cpp
-    hle/service/friend/friend_u.h
+    hle/service/friend/interface.cpp
+    hle/service/friend/interface.h
+    hle/service/grc/grc.cpp
+    hle/service/grc/grc.h
     hle/service/hid/hid.cpp
     hle/service/hid/hid.h
+    hle/service/hid/irs.cpp
+    hle/service/hid/irs.h
+    hle/service/hid/xcd.cpp
+    hle/service/hid/xcd.h
+    hle/service/ldn/ldn.cpp
+    hle/service/ldn/ldn.h
+    hle/service/ldr/ldr.cpp
+    hle/service/ldr/ldr.h
     hle/service/lm/lm.cpp
     hle/service/lm/lm.h
     hle/service/mm/mm_u.cpp
     hle/service/mm/mm_u.h
-    hle/service/nifm/nifm.cpp
-    hle/service/nifm/nifm.h
-    hle/service/nifm/nifm_a.cpp
-    hle/service/nifm/nifm_a.h
-    hle/service/nifm/nifm_s.cpp
-    hle/service/nifm/nifm_s.h
-    hle/service/nifm/nifm_u.cpp
-    hle/service/nifm/nifm_u.h
+    hle/service/nfc/nfc.cpp
+    hle/service/nfc/nfc.h
     hle/service/nfp/nfp.cpp
     hle/service/nfp/nfp.h
     hle/service/nfp/nfp_user.cpp
     hle/service/nfp/nfp_user.h
+    hle/service/nifm/nifm.cpp
+    hle/service/nifm/nifm.h
+    hle/service/nim/nim.cpp
+    hle/service/nim/nim.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp
@@ -201,6 +215,8 @@ add_library(core STATIC
     hle/service/pctl/module.h
     hle/service/pctl/pctl.cpp
     hle/service/pctl/pctl.h
+    hle/service/pm/pm.cpp
+    hle/service/pm/pm.h
     hle/service/prepo/prepo.cpp
     hle/service/prepo/prepo.h
     hle/service/service.cpp
@@ -221,6 +237,8 @@ add_library(core STATIC
     hle/service/sm/sm.h
     hle/service/sockets/bsd.cpp
     hle/service/sockets/bsd.h
+    hle/service/sockets/ethc.cpp
+    hle/service/sockets/ethc.h
     hle/service/sockets/nsd.cpp
     hle/service/sockets/nsd.h
     hle/service/sockets/sfdnsres.cpp
@@ -235,12 +253,10 @@ add_library(core STATIC
     hle/service/spl/spl.h
     hle/service/ssl/ssl.cpp
     hle/service/ssl/ssl.h
+    hle/service/time/interface.cpp
+    hle/service/time/interface.h
     hle/service/time/time.cpp
     hle/service/time/time.h
-    hle/service/time/time_s.cpp
-    hle/service/time/time_s.h
-    hle/service/time/time_u.cpp
-    hle/service/time/time_u.h
     hle/service/vi/vi.cpp
     hle/service/vi/vi.h
     hle/service/vi/vi_m.cpp
@@ -249,8 +265,6 @@ add_library(core STATIC
     hle/service/vi/vi_s.h
     hle/service/vi/vi_u.cpp
     hle/service/vi/vi_u.h
-    hle/shared_page.cpp
-    hle/shared_page.h
     hw/hw.cpp
     hw/hw.h
     hw/lcd.cpp

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -102,8 +102,8 @@ public:
     u64 tpidr_el0 = 0;
 };
 
-std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() {
-    const auto page_table = Core::CurrentProcess()->vm_manager.page_table.pointers.data();
+std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
+    auto** const page_table = Core::CurrentProcess()->vm_manager.page_table.pointers.data();
 
     Dynarmic::A64::UserConfig config;
 
@@ -257,7 +257,7 @@ void ARM_Dynarmic::PageTableChanged() {
 DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(size_t core_count) : monitor(core_count) {}
 DynarmicExclusiveMonitor::~DynarmicExclusiveMonitor() = default;
 
-void DynarmicExclusiveMonitor::SetExclusive(size_t core_index, u64 addr) {
+void DynarmicExclusiveMonitor::SetExclusive(size_t core_index, VAddr addr) {
     // Size doesn't actually matter.
     monitor.Mark(core_index, addr, 16);
 }
@@ -266,28 +266,27 @@ void DynarmicExclusiveMonitor::ClearExclusive() {
     monitor.Clear();
 }
 
-bool DynarmicExclusiveMonitor::ExclusiveWrite8(size_t core_index, u64 vaddr, u8 value) {
+bool DynarmicExclusiveMonitor::ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) {
     return monitor.DoExclusiveOperation(core_index, vaddr, 1,
                                         [&] { Memory::Write8(vaddr, value); });
 }
 
-bool DynarmicExclusiveMonitor::ExclusiveWrite16(size_t core_index, u64 vaddr, u16 value) {
+bool DynarmicExclusiveMonitor::ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) {
     return monitor.DoExclusiveOperation(core_index, vaddr, 2,
                                         [&] { Memory::Write16(vaddr, value); });
 }
 
-bool DynarmicExclusiveMonitor::ExclusiveWrite32(size_t core_index, u64 vaddr, u32 value) {
+bool DynarmicExclusiveMonitor::ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) {
     return monitor.DoExclusiveOperation(core_index, vaddr, 4,
                                         [&] { Memory::Write32(vaddr, value); });
 }
 
-bool DynarmicExclusiveMonitor::ExclusiveWrite64(size_t core_index, u64 vaddr, u64 value) {
+bool DynarmicExclusiveMonitor::ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) {
     return monitor.DoExclusiveOperation(core_index, vaddr, 8,
                                         [&] { Memory::Write64(vaddr, value); });
 }
 
-bool DynarmicExclusiveMonitor::ExclusiveWrite128(size_t core_index, u64 vaddr,
-                                                 std::array<std::uint64_t, 2> value) {
+bool DynarmicExclusiveMonitor::ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) {
     return monitor.DoExclusiveOperation(core_index, vaddr, 16, [&] {
         Memory::Write64(vaddr, value[0]);
         Memory::Write64(vaddr, value[1]);

src/core/arm/dynarmic/arm_dynarmic.h

@@ -50,7 +50,7 @@ public:
     void PageTableChanged() override;
 
 private:
-    std::unique_ptr<Dynarmic::A64::Jit> MakeJit();
+    std::unique_ptr<Dynarmic::A64::Jit> MakeJit() const;
 
     friend class ARM_Dynarmic_Callbacks;
     std::unique_ptr<ARM_Dynarmic_Callbacks> cb;
@@ -68,15 +68,14 @@ public:
     explicit DynarmicExclusiveMonitor(size_t core_count);
     ~DynarmicExclusiveMonitor();
 
-    void SetExclusive(size_t core_index, u64 addr) override;
+    void SetExclusive(size_t core_index, VAddr addr) override;
     void ClearExclusive() override;
 
-    bool ExclusiveWrite8(size_t core_index, u64 vaddr, u8 value) override;
-    bool ExclusiveWrite16(size_t core_index, u64 vaddr, u16 value) override;
-    bool ExclusiveWrite32(size_t core_index, u64 vaddr, u32 value) override;
-    bool ExclusiveWrite64(size_t core_index, u64 vaddr, u64 value) override;
-    bool ExclusiveWrite128(size_t core_index, u64 vaddr,
-                           std::array<std::uint64_t, 2> value) override;
+    bool ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) override;
+    bool ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) override;
+    bool ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) override;
+    bool ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) override;
+    bool ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) override;
 
 private:
     friend class ARM_Dynarmic;

src/core/arm/exclusive_monitor.h

@@ -4,20 +4,18 @@
 
 #pragma once
 
-#include <array>
 #include "common/common_types.h"
 
 class ExclusiveMonitor {
 public:
     virtual ~ExclusiveMonitor();
 
-    virtual void SetExclusive(size_t core_index, u64 addr) = 0;
+    virtual void SetExclusive(size_t core_index, VAddr addr) = 0;
     virtual void ClearExclusive() = 0;
 
-    virtual bool ExclusiveWrite8(size_t core_index, u64 vaddr, u8 value) = 0;
-    virtual bool ExclusiveWrite16(size_t core_index, u64 vaddr, u16 value) = 0;
-    virtual bool ExclusiveWrite32(size_t core_index, u64 vaddr, u32 value) = 0;
-    virtual bool ExclusiveWrite64(size_t core_index, u64 vaddr, u64 value) = 0;
-    virtual bool ExclusiveWrite128(size_t core_index, u64 vaddr,
-                                   std::array<std::uint64_t, 2> value) = 0;
+    virtual bool ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) = 0;
+    virtual bool ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) = 0;
+    virtual bool ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) = 0;
+    virtual bool ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) = 0;
+    virtual bool ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) = 0;
 };

src/core/core_timing.cpp

@@ -5,17 +5,15 @@
 #include "core/core_timing.h"
 
 #include <algorithm>
-#include <cinttypes>
-#include <limits>
 #include <mutex>
 #include <string>
 #include <tuple>
 #include <unordered_map>
 #include <vector>
 #include "common/assert.h"
-#include "common/logging/log.h"
 #include "common/thread.h"
 #include "common/threadsafe_queue.h"
+#include "core/core_timing_util.h"
 
 namespace CoreTiming {
 
@@ -59,7 +57,6 @@ static u64 event_fifo_id;
 static Common::MPSCQueue<Event, false> ts_queue;
 
 constexpr int MAX_SLICE_LENGTH = 20000;
-constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
 
 static s64 idled_cycles;
 
@@ -72,54 +69,6 @@ static EventType* ev_lost = nullptr;
 
 static void EmptyTimedCallback(u64 userdata, s64 cyclesLate) {}
 
-s64 usToCycles(s64 us) {
-    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
-        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (us > MAX_VALUE_TO_MULTIPLY) {
-        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (us / 1000000);
-    }
-    return (BASE_CLOCK_RATE * us) / 1000000;
-}
-
-s64 usToCycles(u64 us) {
-    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
-        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (us > MAX_VALUE_TO_MULTIPLY) {
-        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * static_cast<s64>(us / 1000000);
-    }
-    return (BASE_CLOCK_RATE * static_cast<s64>(us)) / 1000000;
-}
-
-s64 nsToCycles(s64 ns) {
-    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
-        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (ns > MAX_VALUE_TO_MULTIPLY) {
-        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (ns / 1000000000);
-    }
-    return (BASE_CLOCK_RATE * ns) / 1000000000;
-}
-
-s64 nsToCycles(u64 ns) {
-    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
-        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
-        return std::numeric_limits<s64>::max();
-    }
-    if (ns > MAX_VALUE_TO_MULTIPLY) {
-        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (static_cast<s64>(ns) / 1000000000);
-    }
-    return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
-}
-
 EventType* RegisterEvent(const std::string& name, TimedCallback callback) {
     // check for existing type with same name.
     // we want event type names to remain unique so that we can use them for serialization.

src/core/core_timing.h

@@ -23,59 +23,6 @@
 
 namespace CoreTiming {
 
-// The below clock rate is based on Switch's clockspeed being widely known as 1.020GHz
-// The exact value used is of course unverified.
-constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
-
-inline s64 msToCycles(int ms) {
-    // since ms is int there is no way to overflow
-    return BASE_CLOCK_RATE * static_cast<s64>(ms) / 1000;
-}
-
-inline s64 msToCycles(float ms) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.001f) * ms);
-}
-
-inline s64 msToCycles(double ms) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.001) * ms);
-}
-
-inline s64 usToCycles(float us) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.000001f) * us);
-}
-
-inline s64 usToCycles(int us) {
-    return (BASE_CLOCK_RATE * static_cast<s64>(us) / 1000000);
-}
-
-s64 usToCycles(s64 us);
-
-s64 usToCycles(u64 us);
-
-inline s64 nsToCycles(float ns) {
-    return static_cast<s64>(BASE_CLOCK_RATE * (0.000000001f) * ns);
-}
-
-inline s64 nsToCycles(int ns) {
-    return BASE_CLOCK_RATE * static_cast<s64>(ns) / 1000000000;
-}
-
-s64 nsToCycles(s64 ns);
-
-s64 nsToCycles(u64 ns);
-
-inline u64 cyclesToNs(s64 cycles) {
-    return cycles * 1000000000 / BASE_CLOCK_RATE;
-}
-
-inline s64 cyclesToUs(s64 cycles) {
-    return cycles * 1000000 / BASE_CLOCK_RATE;
-}
-
-inline u64 cyclesToMs(s64 cycles) {
-    return cycles * 1000 / BASE_CLOCK_RATE;
-}
-
 /**
  * CoreTiming begins at the boundary of timing slice -1. An initial call to Advance() is
  * required to end slice -1 and start slice 0 before the first cycle of code is executed.

src/core/core_timing_util.cpp

@@ -0,0 +1,63 @@
+// Copyright 2008 Dolphin Emulator Project / 2017 Citra Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "core/core_timing_util.h"
+
+#include <cinttypes>
+#include <limits>
+#include "common/logging/log.h"
+
+namespace CoreTiming {
+
+constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
+
+s64 usToCycles(s64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (us > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (us / 1000000);
+    }
+    return (BASE_CLOCK_RATE * us) / 1000000;
+}
+
+s64 usToCycles(u64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (us > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * static_cast<s64>(us / 1000000);
+    }
+    return (BASE_CLOCK_RATE * static_cast<s64>(us)) / 1000000;
+}
+
+s64 nsToCycles(s64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (ns / 1000000000);
+    }
+    return (BASE_CLOCK_RATE * ns) / 1000000000;
+}
+
+s64 nsToCycles(u64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (static_cast<s64>(ns) / 1000000000);
+    }
+    return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
+}
+
+} // namespace CoreTiming

src/core/core_timing_util.h

@@ -0,0 +1,64 @@
+// Copyright 2008 Dolphin Emulator Project / 2017 Citra Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace CoreTiming {
+
+// The below clock rate is based on Switch's clockspeed being widely known as 1.020GHz
+// The exact value used is of course unverified.
+constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
+
+inline s64 msToCycles(int ms) {
+    // since ms is int there is no way to overflow
+    return BASE_CLOCK_RATE * static_cast<s64>(ms) / 1000;
+}
+
+inline s64 msToCycles(float ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001f) * ms);
+}
+
+inline s64 msToCycles(double ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001) * ms);
+}
+
+inline s64 usToCycles(float us) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000001f) * us);
+}
+
+inline s64 usToCycles(int us) {
+    return (BASE_CLOCK_RATE * static_cast<s64>(us) / 1000000);
+}
+
+s64 usToCycles(s64 us);
+
+s64 usToCycles(u64 us);
+
+inline s64 nsToCycles(float ns) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000000001f) * ns);
+}
+
+inline s64 nsToCycles(int ns) {
+    return BASE_CLOCK_RATE * static_cast<s64>(ns) / 1000000000;
+}
+
+s64 nsToCycles(s64 ns);
+
+s64 nsToCycles(u64 ns);
+
+inline u64 cyclesToNs(s64 cycles) {
+    return cycles * 1000000000 / BASE_CLOCK_RATE;
+}
+
+inline s64 cyclesToUs(s64 cycles) {
+    return cycles * 1000000 / BASE_CLOCK_RATE;
+}
+
+inline u64 cyclesToMs(s64 cycles) {
+    return cycles * 1000 / BASE_CLOCK_RATE;
+}
+
+} // namespace CoreTiming

src/core/file_sys/control_metadata.cpp

@@ -0,0 +1,42 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/string_util.h"
+#include "common/swap.h"
+#include "core/file_sys/control_metadata.h"
+
+namespace FileSys {
+
+std::string LanguageEntry::GetApplicationName() const {
+    return Common::StringFromFixedZeroTerminatedBuffer(application_name.data(), 0x200);
+}
+
+std::string LanguageEntry::GetDeveloperName() const {
+    return Common::StringFromFixedZeroTerminatedBuffer(developer_name.data(), 0x100);
+}
+
+NACP::NACP(VirtualFile file_) : file(std::move(file_)), raw(std::make_unique<RawNACP>()) {
+    file->ReadObject(raw.get());
+}
+
+const LanguageEntry& NACP::GetLanguageEntry(Language language) const {
+    return raw->language_entries.at(static_cast<u8>(language));
+}
+
+std::string NACP::GetApplicationName(Language language) const {
+    return GetLanguageEntry(language).GetApplicationName();
+}
+
+std::string NACP::GetDeveloperName(Language language) const {
+    return GetLanguageEntry(language).GetDeveloperName();
+}
+
+u64 NACP::GetTitleId() const {
+    return raw->title_id;
+}
+
+std::string NACP::GetVersionString() const {
+    return Common::StringFromFixedZeroTerminatedBuffer(raw->version_string.data(), 0x10);
+}
+} // namespace FileSys

src/core/file_sys/control_metadata.h

@@ -0,0 +1,81 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <string>
+#include "common/common_funcs.h"
+#include "core/file_sys/vfs.h"
+
+namespace FileSys {
+
+// A localized entry containing strings within the NACP.
+// One for each language of type Language.
+struct LanguageEntry {
+    std::array<char, 0x200> application_name;
+    std::array<char, 0x100> developer_name;
+
+    std::string GetApplicationName() const;
+    std::string GetDeveloperName() const;
+};
+static_assert(sizeof(LanguageEntry) == 0x300, "LanguageEntry has incorrect size.");
+
+// The raw file format of a NACP file.
+struct RawNACP {
+    std::array<LanguageEntry, 16> language_entries;
+    INSERT_PADDING_BYTES(0x38);
+    u64_le title_id;
+    INSERT_PADDING_BYTES(0x20);
+    std::array<char, 0x10> version_string;
+    u64_le dlc_base_title_id;
+    u64_le title_id_2;
+    INSERT_PADDING_BYTES(0x28);
+    u64_le product_code;
+    u64_le title_id_3;
+    std::array<u64_le, 0x7> title_id_array;
+    INSERT_PADDING_BYTES(0x8);
+    u64_le title_id_update;
+    std::array<u8, 0x40> bcat_passphrase;
+    INSERT_PADDING_BYTES(0xEC0);
+};
+static_assert(sizeof(RawNACP) == 0x4000, "RawNACP has incorrect size.");
+
+// A language on the NX. These are for names and icons.
+enum class Language : u8 {
+    AmericanEnglish = 0,
+    BritishEnglish = 1,
+    Japanese = 2,
+    French = 3,
+    German = 4,
+    LatinAmericanSpanish = 5,
+    Spanish = 6,
+    Italian = 7,
+    Dutch = 8,
+    CanadianFrench = 9,
+    Portugese = 10,
+    Russian = 11,
+    Korean = 12,
+    Taiwanese = 13,
+    Chinese = 14,
+};
+
+// A class representing the format used by NX metadata files, typically named Control.nacp.
+// These store application name, dev name, title id, and other miscellaneous data.
+class NACP {
+public:
+    explicit NACP(VirtualFile file);
+    const LanguageEntry& GetLanguageEntry(Language language = Language::AmericanEnglish) const;
+    std::string GetApplicationName(Language language = Language::AmericanEnglish) const;
+    std::string GetDeveloperName(Language language = Language::AmericanEnglish) const;
+    u64 GetTitleId() const;
+    std::string GetVersionString() const;
+
+private:
+    VirtualFile file;
+    std::unique_ptr<RawNACP> raw;
+};
+
+} // namespace FileSys

src/core/file_sys/partition_filesystem.cpp

@@ -65,8 +65,8 @@ PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
         std::string name(
             reinterpret_cast<const char*>(&file_data[strtab_offset + entry.strtab_offset]));
 
-        pfs_files.emplace_back(
-            std::make_shared<OffsetVfsFile>(file, entry.size, content_offset + entry.offset, name));
+        pfs_files.emplace_back(std::make_shared<OffsetVfsFile>(
+            file, entry.size, content_offset + entry.offset, std::move(name)));
     }
 
     status = Loader::ResultStatus::Success;
@@ -109,7 +109,7 @@ bool PartitionFilesystem::ReplaceFileWithSubdirectory(VirtualFile file, VirtualD
         return false;
 
     const std::ptrdiff_t offset = std::distance(pfs_files.begin(), iter);
-    pfs_files[offset] = pfs_files.back();
+    pfs_files[offset] = std::move(pfs_files.back());
     pfs_files.pop_back();
 
     pfs_dirs.emplace_back(std::move(dir));

src/core/hle/config_mem.cpp

@@ -1,31 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include "core/hle/config_mem.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace ConfigMem {
-
-ConfigMemDef config_mem;
-
-void Init() {
-    std::memset(&config_mem, 0, sizeof(config_mem));
-
-    // Values extracted from firmware 11.2.0-35E
-    config_mem.kernel_version_min = 0x34;
-    config_mem.kernel_version_maj = 0x2;
-    config_mem.ns_tid = 0x0004013000008002;
-    config_mem.sys_core_ver = 0x2;
-    config_mem.unit_info = 0x1; // Bit 0 set for Retail
-    config_mem.prev_firm = 0x1;
-    config_mem.ctr_sdk_ver = 0x0000F297;
-    config_mem.firm_version_min = 0x34;
-    config_mem.firm_version_maj = 0x2;
-    config_mem.firm_sys_core_ver = 0x2;
-    config_mem.firm_ctr_sdk_ver = 0x0000F297;
-}
-
-} // namespace ConfigMem

src/core/hle/config_mem.h

@@ -1,56 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-// Configuration memory stores various hardware/kernel configuration settings. This memory page is
-// read-only for ARM11 processes. I'm guessing this would normally be written to by the firmware/
-// bootrom. Because we're not emulating this, and essentially just "stubbing" the functionality, I'm
-// putting this as a subset of HLE for now.
-
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/memory.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace ConfigMem {
-
-struct ConfigMemDef {
-    u8 kernel_unk;                       // 0
-    u8 kernel_version_rev;               // 1
-    u8 kernel_version_min;               // 2
-    u8 kernel_version_maj;               // 3
-    u32_le update_flag;                  // 4
-    u64_le ns_tid;                       // 8
-    u32_le sys_core_ver;                 // 10
-    u8 unit_info;                        // 14
-    u8 boot_firm;                        // 15
-    u8 prev_firm;                        // 16
-    INSERT_PADDING_BYTES(0x1);           // 17
-    u32_le ctr_sdk_ver;                  // 18
-    INSERT_PADDING_BYTES(0x30 - 0x1C);   // 1C
-    u32_le app_mem_type;                 // 30
-    INSERT_PADDING_BYTES(0x40 - 0x34);   // 34
-    u32_le app_mem_alloc;                // 40
-    u32_le sys_mem_alloc;                // 44
-    u32_le base_mem_alloc;               // 48
-    INSERT_PADDING_BYTES(0x60 - 0x4C);   // 4C
-    u8 firm_unk;                         // 60
-    u8 firm_version_rev;                 // 61
-    u8 firm_version_min;                 // 62
-    u8 firm_version_maj;                 // 63
-    u32_le firm_sys_core_ver;            // 64
-    u32_le firm_ctr_sdk_ver;             // 68
-    INSERT_PADDING_BYTES(0x1000 - 0x6C); // 6C
-};
-static_assert(sizeof(ConfigMemDef) == Memory::CONFIG_MEMORY_SIZE,
-              "Config Memory structure size is wrong");
-
-extern ConfigMemDef config_mem;
-
-void Init();
-
-} // namespace ConfigMem

src/core/hle/ipc_helpers.h

@@ -25,9 +25,9 @@ protected:
     ptrdiff_t index = 0;
 
 public:
-    RequestHelperBase(u32* command_buffer) : cmdbuf(command_buffer) {}
+    explicit RequestHelperBase(u32* command_buffer) : cmdbuf(command_buffer) {}
 
-    RequestHelperBase(Kernel::HLERequestContext& context)
+    explicit RequestHelperBase(Kernel::HLERequestContext& context)
         : context(&context), cmdbuf(context.CommandBuffer()) {}
 
     void Skip(unsigned size_in_words, bool set_to_null) {
@@ -56,13 +56,6 @@ public:
 
 class ResponseBuilder : public RequestHelperBase {
 public:
-    ResponseBuilder(u32* command_buffer) : RequestHelperBase(command_buffer) {}
-
-    u32 normal_params_size{};
-    u32 num_handles_to_copy{};
-    u32 num_objects_to_move{}; ///< Domain objects or move handles, context dependent
-    std::ptrdiff_t datapayload_index{};
-
     /// Flags used for customizing the behavior of ResponseBuilder
     enum class Flags : u32 {
         None = 0,
@@ -71,9 +64,11 @@ public:
         AlwaysMoveHandles = 1,
     };
 
-    ResponseBuilder(Kernel::HLERequestContext& context, u32 normal_params_size,
-                    u32 num_handles_to_copy = 0, u32 num_objects_to_move = 0,
-                    Flags flags = Flags::None)
+    explicit ResponseBuilder(u32* command_buffer) : RequestHelperBase(command_buffer) {}
+
+    explicit ResponseBuilder(Kernel::HLERequestContext& context, u32 normal_params_size,
+                             u32 num_handles_to_copy = 0, u32 num_objects_to_move = 0,
+                             Flags flags = Flags::None)
 
         : RequestHelperBase(context), normal_params_size(normal_params_size),
           num_handles_to_copy(num_handles_to_copy), num_objects_to_move(num_objects_to_move) {
@@ -206,6 +201,12 @@ public:
 
     template <typename... O>
     void PushCopyObjects(Kernel::SharedPtr<O>... pointers);
+
+private:
+    u32 normal_params_size{};
+    u32 num_handles_to_copy{};
+    u32 num_objects_to_move{}; ///< Domain objects or move handles, context dependent
+    std::ptrdiff_t datapayload_index{};
 };
 
 /// Push ///
@@ -273,9 +274,9 @@ inline void ResponseBuilder::PushMoveObjects(Kernel::SharedPtr<O>... pointers) {
 
 class RequestParser : public RequestHelperBase {
 public:
-    RequestParser(u32* command_buffer) : RequestHelperBase(command_buffer) {}
+    explicit RequestParser(u32* command_buffer) : RequestHelperBase(command_buffer) {}
 
-    RequestParser(Kernel::HLERequestContext& context) : RequestHelperBase(context) {
+    explicit RequestParser(Kernel::HLERequestContext& context) : RequestHelperBase(context) {
         ASSERT_MSG(context.GetDataPayloadOffset(), "context is incomplete");
         Skip(context.GetDataPayloadOffset(), false);
         // Skip the u64 command id, it's already stored in the context
@@ -285,8 +286,9 @@ public:
 
     ResponseBuilder MakeBuilder(u32 normal_params_size, u32 num_handles_to_copy,
                                 u32 num_handles_to_move,
-                                ResponseBuilder::Flags flags = ResponseBuilder::Flags::None) {
-        return {*context, normal_params_size, num_handles_to_copy, num_handles_to_move, flags};
+                                ResponseBuilder::Flags flags = ResponseBuilder::Flags::None) const {
+        return ResponseBuilder{*context, normal_params_size, num_handles_to_copy,
+                               num_handles_to_move, flags};
     }
 
     template <typename T>
@@ -298,6 +300,14 @@ public:
     template <typename First, typename... Other>
     void Pop(First& first_value, Other&... other_values);
 
+    template <typename T>
+    T PopEnum() {
+        static_assert(std::is_enum_v<T>, "T must be an enum type within a PopEnum call.");
+        static_assert(!std::is_convertible_v<T, int>,
+                      "enum type in PopEnum must be a strongly typed enum.");
+        return static_cast<T>(Pop<std::underlying_type_t<T>>());
+    }
+
     /**
      * @brief Reads the next normal parameters as a struct, by copying it
      * @note: The output class must be correctly packed/padded to fit hardware layout.

src/core/hle/kernel/hle_ipc.h

@@ -91,7 +91,7 @@ protected:
  */
 class HLERequestContext {
 public:
-    HLERequestContext(SharedPtr<Kernel::ServerSession> session);
+    explicit HLERequestContext(SharedPtr<ServerSession> session);
     ~HLERequestContext();
 
     /// Returns a pointer to the IPC command buffer for this request.

src/core/hle/kernel/kernel.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "core/hle/config_mem.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory.h"
@@ -11,7 +10,6 @@
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
-#include "core/hle/shared_page.h"
 
 namespace Kernel {
 
@@ -19,9 +17,6 @@ unsigned int Object::next_object_id;
 
 /// Initialize the kernel
 void Init(u32 system_mode) {
-    ConfigMem::Init();
-    SharedPage::Init();
-
     Kernel::MemoryInit(system_mode);
 
     Kernel::ResourceLimitsInit();

src/core/hle/kernel/memory.cpp

@@ -11,11 +11,9 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "core/hle/config_mem.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/hle/result.h"
-#include "core/hle/shared_page.h"
 #include "core/memory.h"
 #include "core/memory_setup.h"
 
@@ -63,14 +61,6 @@ void MemoryInit(u32 mem_type) {
 
     // We must've allocated the entire FCRAM by the end
     ASSERT(base == Memory::FCRAM_SIZE);
-
-    using ConfigMem::config_mem;
-    config_mem.app_mem_type = mem_type;
-    // app_mem_malloc does not always match the configured size for memory_region[0]: in case the
-    // n3DS type override is in effect it reports the size the game expects, not the real one.
-    config_mem.app_mem_alloc = memory_region_sizes[mem_type][0];
-    config_mem.sys_mem_alloc = static_cast<u32_le>(memory_regions[1].size);
-    config_mem.base_mem_alloc = static_cast<u32_le>(memory_regions[2].size);
 }
 
 void MemoryShutdown() {

src/core/hle/kernel/mutex.cpp

@@ -19,7 +19,7 @@ namespace Kernel {
 /// Returns the number of threads that are waiting for a mutex, and the highest priority one among
 /// those.
 static std::pair<SharedPtr<Thread>, u32> GetHighestPriorityMutexWaitingThread(
-    SharedPtr<Thread> current_thread, VAddr mutex_addr) {
+    const SharedPtr<Thread>& current_thread, VAddr mutex_addr) {
 
     SharedPtr<Thread> highest_priority_thread;
     u32 num_waiters = 0;

src/core/hle/kernel/svc.cpp

@@ -40,7 +40,9 @@ static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
 }
 
 static ResultCode SetMemoryAttribute(VAddr addr, u64 size, u32 state0, u32 state1) {
-    LOG_WARNING(Kernel_SVC, "(STUBBED) called, addr=0x{:X}", addr);
+    LOG_WARNING(Kernel_SVC,
+                "(STUBBED) called, addr=0x{:X}, size=0x{:X}, state0=0x{:X}, state1=0x{:X}", addr,
+                size, state0, state1);
     return RESULT_SUCCESS;
 }
 
@@ -165,11 +167,14 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
     using ObjectPtr = SharedPtr<WaitObject>;
     std::vector<ObjectPtr> objects(handle_count);
 
-    for (int i = 0; i < handle_count; ++i) {
-        Handle handle = Memory::Read32(handles_address + i * sizeof(Handle));
-        auto object = g_handle_table.Get<WaitObject>(handle);
-        if (object == nullptr)
+    for (u64 i = 0; i < handle_count; ++i) {
+        const Handle handle = Memory::Read32(handles_address + i * sizeof(Handle));
+        const auto object = g_handle_table.Get<WaitObject>(handle);
+
+        if (object == nullptr) {
             return ERR_INVALID_HANDLE;
+        }
+
         objects[i] = object;
     }
 

src/core/hle/kernel/thread.cpp

@@ -14,6 +14,7 @@
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"

src/core/hle/kernel/timer.cpp

@@ -6,6 +6,7 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/thread.h"

src/core/hle/kernel/timer.h

@@ -32,13 +32,17 @@ public:
         return HANDLE_TYPE;
     }
 
-    ResetType reset_type; ///< The ResetType of this timer
+    ResetType GetResetType() const {
+        return reset_type;
+    }
 
-    bool signaled;    ///< Whether the timer has been signaled or not
-    std::string name; ///< Name of timer (optional)
+    u64 GetInitialDelay() const {
+        return initial_delay;
+    }
 
-    u64 initial_delay;  ///< The delay until the timer fires for the first time
-    u64 interval_delay; ///< The delay until the timer fires after the first time
+    u64 GetIntervalDelay() const {
+        return interval_delay;
+    }
 
     bool ShouldWait(Thread* thread) const override;
     void Acquire(Thread* thread) override;
@@ -67,6 +71,14 @@ private:
     Timer();
     ~Timer() override;
 
+    ResetType reset_type; ///< The ResetType of this timer
+
+    u64 initial_delay;  ///< The delay until the timer fires for the first time
+    u64 interval_delay; ///< The delay until the timer fires after the first time
+
+    bool signaled;    ///< Whether the timer has been signaled or not
+    std::string name; ///< Name of timer (optional)
+
     /// Handle used as userdata to reference this object when inserting into the CoreTiming queue.
     Handle callback_handle;
 };

src/core/hle/kernel/wait_object.cpp

@@ -5,7 +5,6 @@
 #include <algorithm>
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/hle/config_mem.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory.h"
@@ -13,7 +12,6 @@
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
-#include "core/hle/shared_page.h"
 
 namespace Kernel {
 

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

@@ -35,7 +35,7 @@ static constexpr u128 DEFAULT_USER_ID{1ull, 0ull};
 
 class IProfile final : public ServiceFramework<IProfile> {
 public:
-    IProfile(u128 user_id) : ServiceFramework("IProfile"), user_id(user_id) {
+    explicit IProfile(u128 user_id) : ServiceFramework("IProfile"), user_id(user_id) {
         static const FunctionInfo functions[] = {
             {0, nullptr, "Get"},
             {1, &IProfile::GetBase, "GetBase"},

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

@@ -19,7 +19,4 @@ private:
     std::shared_ptr<Module> apm;
 };
 
-/// Registers all AM services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager);
-
 } // namespace Service::APM

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

@@ -6,6 +6,7 @@
 #include <vector>
 #include "common/logging/log.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/hle_ipc.h"

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

@@ -7,6 +7,7 @@
 #include "common/alignment.h"
 #include "common/logging/log.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/hle_ipc.h"

src/core/hle/service/erpt/erpt.cpp

@@ -0,0 +1,51 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/hle/service/erpt/erpt.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::ERPT {
+
+class ErrorReportContext final : public ServiceFramework<ErrorReportContext> {
+public:
+    explicit ErrorReportContext() : ServiceFramework{"erpt:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "SubmitContext"},
+            {1, nullptr, "CreateReport"},
+            {2, nullptr, "Unknown1"},
+            {3, nullptr, "Unknown2"},
+            {4, nullptr, "Unknown3"},
+            {5, nullptr, "Unknown4"},
+            {6, nullptr, "Unknown5"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class ErrorReportSession final : public ServiceFramework<ErrorReportSession> {
+public:
+    explicit ErrorReportSession() : ServiceFramework{"erpt:r"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "OpenReport"},
+            {1, nullptr, "OpenManager"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<ErrorReportContext>()->InstallAsService(sm);
+    std::make_shared<ErrorReportSession>()->InstallAsService(sm);
+}
+
+} // namespace Service::ERPT

src/core/hle/service/erpt/erpt.h

@@ -0,0 +1,16 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::ERPT {
+
+/// Registers all ERPT services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& sm);
+
+} // namespace Service::ERPT

src/core/hle/service/es/es.cpp

@@ -0,0 +1,57 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/service.h"
+
+namespace Service::ES {
+
+class ETicket final : public ServiceFramework<ETicket> {
+public:
+    explicit ETicket() : ServiceFramework{"es"} {
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "ImportTicket"},
+            {2, nullptr, "ImportTicketCertificateSet"},
+            {3, nullptr, "DeleteTicket"},
+            {4, nullptr, "DeletePersonalizedTicket"},
+            {5, nullptr, "DeleteAllCommonTicket"},
+            {6, nullptr, "DeleteAllPersonalizedTicket"},
+            {7, nullptr, "DeleteAllPersonalizedTicketEx"},
+            {8, nullptr, "GetTitleKey"},
+            {9, nullptr, "CountCommonTicket"},
+            {10, nullptr, "CountPersonalizedTicket"},
+            {11, nullptr, "ListCommonTicket"},
+            {12, nullptr, "ListPersonalizedTicket"},
+            {13, nullptr, "ListMissingPersonalizedTicket"},
+            {14, nullptr, "GetCommonTicketSize"},
+            {15, nullptr, "GetPersonalizedTicketSize"},
+            {16, nullptr, "GetCommonTicketData"},
+            {17, nullptr, "GetPersonalizedTicketData"},
+            {18, nullptr, "OwnTicket"},
+            {19, nullptr, "GetTicketInfo"},
+            {20, nullptr, "ListLightTicketInfo"},
+            {21, nullptr, "SignData"},
+            {22, nullptr, "GetCommonTicketAndCertificateSize"},
+            {23, nullptr, "GetCommonTicketAndCertificateData"},
+            {24, nullptr, "ImportPrepurchaseRecord"},
+            {25, nullptr, "DeletePrepurchaseRecord"},
+            {26, nullptr, "DeleteAllPrepurchaseRecord"},
+            {27, nullptr, "CountPrepurchaseRecord"},
+            {28, nullptr, "ListPrepurchaseRecord"},
+            {29, nullptr, "ListPrepurchaseRecordInfo"},
+            {30, nullptr, "Unknown1"},
+            {31, nullptr, "Unknown2"},
+            {32, nullptr, "Unknown3"},
+            {33, nullptr, "Unknown4"},
+            {34, nullptr, "Unknown5"},
+            {35, nullptr, "Unknown6"},
+        };
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& service_manager) {
+    std::make_shared<ETicket>()->InstallAsService(service_manager);
+}
+
+} // namespace Service::ES

src/core/hle/service/es/es.h

@@ -0,0 +1,16 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::ES {
+
+/// Registers all ES services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& service_manager);
+
+} // namespace Service::ES

src/core/hle/service/eupld/eupld.cpp

@@ -0,0 +1,52 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/hle/service/eupld/eupld.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::EUPLD {
+
+class ErrorUploadContext final : public ServiceFramework<ErrorUploadContext> {
+public:
+    explicit ErrorUploadContext() : ServiceFramework{"eupld:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "SetUrl"},
+            {1, nullptr, "ImportCrt"},
+            {2, nullptr, "ImportPki"},
+            {3, nullptr, "SetAutoUpload"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class ErrorUploadRequest final : public ServiceFramework<ErrorUploadRequest> {
+public:
+    explicit ErrorUploadRequest() : ServiceFramework{"eupld:r"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "UploadAll"},
+            {2, nullptr, "UploadSelected"},
+            {3, nullptr, "GetUploadStatus"},
+            {4, nullptr, "CancelUpload"},
+            {5, nullptr, "GetResult"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<ErrorUploadContext>()->InstallAsService(sm);
+    std::make_shared<ErrorUploadRequest>()->InstallAsService(sm);
+}
+
+} // namespace Service::EUPLD

src/core/hle/service/eupld/eupld.h

@@ -0,0 +1,16 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::EUPLD {
+
+/// Registers all EUPLD services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& sm);
+
+} // namespace Service::EUPLD

src/core/hle/service/friend/friend.cpp

@@ -5,8 +5,7 @@
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/friend/friend.h"
-#include "core/hle/service/friend/friend_a.h"
-#include "core/hle/service/friend/friend_u.h"
+#include "core/hle/service/friend/interface.h"
 
 namespace Service::Friend {
 
@@ -21,8 +20,11 @@ Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module = std::make_shared<Module>();
-    std::make_shared<Friend_A>(module)->InstallAsService(service_manager);
-    std::make_shared<Friend_U>(module)->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:a")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:m")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:s")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:u")->InstallAsService(service_manager);
+    std::make_shared<Friend>(module, "friend:v")->InstallAsService(service_manager);
 }
 
 } // namespace Service::Friend

src/core/hle/service/friend/friend_a.cpp

@@ -1,18 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/friend/friend_a.h"
-
-namespace Service::Friend {
-
-Friend_A::Friend_A(std::shared_ptr<Module> module)
-    : Module::Interface(std::move(module), "friend:a") {
-    static const FunctionInfo functions[] = {
-        {0, &Friend_A::CreateFriendService, "CreateFriendService"},
-        {1, nullptr, "CreateNotificationService"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Service::Friend

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

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/friend/friend.h"
-
-namespace Service::Friend {
-
-class Friend_A final : public Module::Interface {
-public:
-    explicit Friend_A(std::shared_ptr<Module> module);
-};
-
-} // namespace Service::Friend

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

@@ -2,15 +2,16 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "core/hle/service/friend/friend_u.h"
+#include "core/hle/service/friend/interface.h"
 
 namespace Service::Friend {
 
-Friend_U::Friend_U(std::shared_ptr<Module> module)
-    : Module::Interface(std::move(module), "friend:u") {
+Friend::Friend(std::shared_ptr<Module> module, const char* name)
+    : Interface(std::move(module), name) {
     static const FunctionInfo functions[] = {
-        {0, &Friend_U::CreateFriendService, "CreateFriendService"},
+        {0, &Friend::CreateFriendService, "CreateFriendService"},
         {1, nullptr, "CreateNotificationService"},
+        {2, nullptr, "CreateDaemonSuspendSessionService"},
     };
     RegisterHandlers(functions);
 }

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

@@ -8,9 +8,9 @@
 
 namespace Service::Friend {
 
-class Friend_U final : public Module::Interface {
+class Friend final : public Module::Interface {
 public:
-    explicit Friend_U(std::shared_ptr<Module> module);
+    explicit Friend(std::shared_ptr<Module> module, const char* name);
 };
 
 } // namespace Service::Friend

src/core/hle/service/grc/grc.cpp

@@ -0,0 +1,31 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/hle/service/grc/grc.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::GRC {
+
+class GRC final : public ServiceFramework<GRC> {
+public:
+    explicit GRC() : ServiceFramework{"grc:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "OpenContinuousRecorder"},
+            {2, nullptr, "OpenGameMovieTrimmer"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<GRC>()->InstallAsService(sm);
+}
+
+} // namespace Service::GRC

src/core/hle/service/grc/grc.h

@@ -0,0 +1,15 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::GRC {
+
+void InstallInterfaces(SM::ServiceManager& sm);
+
+} // namespace Service::GRC

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/core_timing_util.h"
 #include "core/frontend/emu_window.h"
 #include "core/frontend/input.h"
 #include "core/hle/ipc_helpers.h"
@@ -13,6 +14,8 @@
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/service/hid/hid.h"
+#include "core/hle/service/hid/irs.h"
+#include "core/hle/service/hid/xcd.h"
 #include "core/hle/service/service.h"
 
 namespace Service::HID {
@@ -554,10 +557,233 @@ private:
     }
 };
 
+class HidDbg final : public ServiceFramework<HidDbg> {
+public:
+    explicit HidDbg() : ServiceFramework{"hid:dbg"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "DeactivateDebugPad"},
+            {1, nullptr, "SetDebugPadAutoPilotState"},
+            {2, nullptr, "UnsetDebugPadAutoPilotState"},
+            {10, nullptr, "DeactivateTouchScreen"},
+            {11, nullptr, "SetTouchScreenAutoPilotState"},
+            {12, nullptr, "UnsetTouchScreenAutoPilotState"},
+            {20, nullptr, "DeactivateMouse"},
+            {21, nullptr, "SetMouseAutoPilotState"},
+            {22, nullptr, "UnsetMouseAutoPilotState"},
+            {30, nullptr, "DeactivateKeyboard"},
+            {31, nullptr, "SetKeyboardAutoPilotState"},
+            {32, nullptr, "UnsetKeyboardAutoPilotState"},
+            {50, nullptr, "DeactivateXpad"},
+            {51, nullptr, "SetXpadAutoPilotState"},
+            {52, nullptr, "UnsetXpadAutoPilotState"},
+            {60, nullptr, "DeactivateJoyXpad"},
+            {91, nullptr, "DeactivateGesture"},
+            {110, nullptr, "DeactivateHomeButton"},
+            {111, nullptr, "SetHomeButtonAutoPilotState"},
+            {112, nullptr, "UnsetHomeButtonAutoPilotState"},
+            {120, nullptr, "DeactivateSleepButton"},
+            {121, nullptr, "SetSleepButtonAutoPilotState"},
+            {122, nullptr, "UnsetSleepButtonAutoPilotState"},
+            {123, nullptr, "DeactivateInputDetector"},
+            {130, nullptr, "DeactivateCaptureButton"},
+            {131, nullptr, "SetCaptureButtonAutoPilotState"},
+            {132, nullptr, "UnsetCaptureButtonAutoPilotState"},
+            {133, nullptr, "SetShiftAccelerometerCalibrationValue"},
+            {134, nullptr, "GetShiftAccelerometerCalibrationValue"},
+            {135, nullptr, "SetShiftGyroscopeCalibrationValue"},
+            {136, nullptr, "GetShiftGyroscopeCalibrationValue"},
+            {140, nullptr, "DeactivateConsoleSixAxisSensor"},
+            {141, nullptr, "GetConsoleSixAxisSensorSamplingFrequency"},
+            {142, nullptr, "DeactivateSevenSixAxisSensor"},
+            {201, nullptr, "ActivateFirmwareUpdate"},
+            {202, nullptr, "DeactivateFirmwareUpdate"},
+            {203, nullptr, "StartFirmwareUpdate"},
+            {204, nullptr, "GetFirmwareUpdateStage"},
+            {205, nullptr, "GetFirmwareVersion"},
+            {206, nullptr, "GetDestinationFirmwareVersion"},
+            {207, nullptr, "DiscardFirmwareInfoCacheForRevert"},
+            {208, nullptr, "StartFirmwareUpdateForRevert"},
+            {209, nullptr, "GetAvailableFirmwareVersionForRevert"},
+            {210, nullptr, "IsFirmwareUpdatingDevice"},
+            {221, nullptr, "UpdateControllerColor"},
+            {222, nullptr, "ConnectUsbPadsAsync"},
+            {223, nullptr, "DisconnectUsbPadsAsync"},
+            {224, nullptr, "UpdateDesignInfo"},
+            {225, nullptr, "GetUniquePadDriverState"},
+            {226, nullptr, "GetSixAxisSensorDriverStates"},
+            {301, nullptr, "GetAbstractedPadHandles"},
+            {302, nullptr, "GetAbstractedPadState"},
+            {303, nullptr, "GetAbstractedPadsState"},
+            {321, nullptr, "SetAutoPilotVirtualPadState"},
+            {322, nullptr, "UnsetAutoPilotVirtualPadState"},
+            {323, nullptr, "UnsetAllAutoPilotVirtualPadState"},
+            {350, nullptr, "AddRegisteredDevice"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class HidSys final : public ServiceFramework<HidSys> {
+public:
+    explicit HidSys() : ServiceFramework{"hid:sys"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {31, nullptr, "SendKeyboardLockKeyEvent"},
+            {101, nullptr, "AcquireHomeButtonEventHandle"},
+            {111, nullptr, "ActivateHomeButton"},
+            {121, nullptr, "AcquireSleepButtonEventHandle"},
+            {131, nullptr, "ActivateSleepButton"},
+            {141, nullptr, "AcquireCaptureButtonEventHandle"},
+            {151, nullptr, "ActivateCaptureButton"},
+            {210, nullptr, "AcquireNfcDeviceUpdateEventHandle"},
+            {211, nullptr, "GetNpadsWithNfc"},
+            {212, nullptr, "AcquireNfcActivateEventHandle"},
+            {213, nullptr, "ActivateNfc"},
+            {214, nullptr, "GetXcdHandleForNpadWithNfc"},
+            {215, nullptr, "IsNfcActivated"},
+            {230, nullptr, "AcquireIrSensorEventHandle"},
+            {231, nullptr, "ActivateIrSensor"},
+            {301, nullptr, "ActivateNpadSystem"},
+            {303, nullptr, "ApplyNpadSystemCommonPolicy"},
+            {304, nullptr, "EnableAssigningSingleOnSlSrPress"},
+            {305, nullptr, "DisableAssigningSingleOnSlSrPress"},
+            {306, nullptr, "GetLastActiveNpad"},
+            {307, nullptr, "GetNpadSystemExtStyle"},
+            {308, nullptr, "ApplyNpadSystemCommonPolicyFull"},
+            {309, nullptr, "GetNpadFullKeyGripColor"},
+            {311, nullptr, "SetNpadPlayerLedBlinkingDevice"},
+            {321, nullptr, "GetUniquePadsFromNpad"},
+            {322, nullptr, "GetIrSensorState"},
+            {323, nullptr, "GetXcdHandleForNpadWithIrSensor"},
+            {500, nullptr, "SetAppletResourceUserId"},
+            {501, nullptr, "RegisterAppletResourceUserId"},
+            {502, nullptr, "UnregisterAppletResourceUserId"},
+            {503, nullptr, "EnableAppletToGetInput"},
+            {504, nullptr, "SetAruidValidForVibration"},
+            {505, nullptr, "EnableAppletToGetSixAxisSensor"},
+            {510, nullptr, "SetVibrationMasterVolume"},
+            {511, nullptr, "GetVibrationMasterVolume"},
+            {512, nullptr, "BeginPermitVibrationSession"},
+            {513, nullptr, "EndPermitVibrationSession"},
+            {520, nullptr, "EnableHandheldHids"},
+            {521, nullptr, "DisableHandheldHids"},
+            {540, nullptr, "AcquirePlayReportControllerUsageUpdateEvent"},
+            {541, nullptr, "GetPlayReportControllerUsages"},
+            {542, nullptr, "AcquirePlayReportRegisteredDeviceUpdateEvent"},
+            {543, nullptr, "GetRegisteredDevicesOld"},
+            {544, nullptr, "AcquireConnectionTriggerTimeoutEvent"},
+            {545, nullptr, "SendConnectionTrigger"},
+            {546, nullptr, "AcquireDeviceRegisteredEventForControllerSupport"},
+            {547, nullptr, "GetAllowedBluetoothLinksCount"},
+            {548, nullptr, "GetRegisteredDevices"},
+            {700, nullptr, "ActivateUniquePad"},
+            {702, nullptr, "AcquireUniquePadConnectionEventHandle"},
+            {703, nullptr, "GetUniquePadIds"},
+            {751, nullptr, "AcquireJoyDetachOnBluetoothOffEventHandle"},
+            {800, nullptr, "ListSixAxisSensorHandles"},
+            {801, nullptr, "IsSixAxisSensorUserCalibrationSupported"},
+            {802, nullptr, "ResetSixAxisSensorCalibrationValues"},
+            {803, nullptr, "StartSixAxisSensorUserCalibration"},
+            {804, nullptr, "CancelSixAxisSensorUserCalibration"},
+            {805, nullptr, "GetUniquePadBluetoothAddress"},
+            {806, nullptr, "DisconnectUniquePad"},
+            {807, nullptr, "GetUniquePadType"},
+            {808, nullptr, "GetUniquePadInterface"},
+            {809, nullptr, "GetUniquePadSerialNumber"},
+            {810, nullptr, "GetUniquePadControllerNumber"},
+            {811, nullptr, "GetSixAxisSensorUserCalibrationStage"},
+            {821, nullptr, "StartAnalogStickManualCalibration"},
+            {822, nullptr, "RetryCurrentAnalogStickManualCalibrationStage"},
+            {823, nullptr, "CancelAnalogStickManualCalibration"},
+            {824, nullptr, "ResetAnalogStickManualCalibration"},
+            {825, nullptr, "GetAnalogStickState"},
+            {826, nullptr, "GetAnalogStickManualCalibrationStage"},
+            {827, nullptr, "IsAnalogStickButtonPressed"},
+            {828, nullptr, "IsAnalogStickInReleasePosition"},
+            {829, nullptr, "IsAnalogStickInCircumference"},
+            {850, nullptr, "IsUsbFullKeyControllerEnabled"},
+            {851, nullptr, "EnableUsbFullKeyController"},
+            {852, nullptr, "IsUsbConnected"},
+            {900, nullptr, "ActivateInputDetector"},
+            {901, nullptr, "NotifyInputDetector"},
+            {1000, nullptr, "InitializeFirmwareUpdate"},
+            {1001, nullptr, "GetFirmwareVersion"},
+            {1002, nullptr, "GetAvailableFirmwareVersion"},
+            {1003, nullptr, "IsFirmwareUpdateAvailable"},
+            {1004, nullptr, "CheckFirmwareUpdateRequired"},
+            {1005, nullptr, "StartFirmwareUpdate"},
+            {1006, nullptr, "AbortFirmwareUpdate"},
+            {1007, nullptr, "GetFirmwareUpdateState"},
+            {1008, nullptr, "ActivateAudioControl"},
+            {1009, nullptr, "AcquireAudioControlEventHandle"},
+            {1010, nullptr, "GetAudioControlStates"},
+            {1011, nullptr, "DeactivateAudioControl"},
+            {1050, nullptr, "IsSixAxisSensorAccurateUserCalibrationSupported"},
+            {1051, nullptr, "StartSixAxisSensorAccurateUserCalibration"},
+            {1052, nullptr, "CancelSixAxisSensorAccurateUserCalibration"},
+            {1053, nullptr, "GetSixAxisSensorAccurateUserCalibrationState"},
+            {1100, nullptr, "GetHidbusSystemServiceObject"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class HidTmp final : public ServiceFramework<HidTmp> {
+public:
+    explicit HidTmp() : ServiceFramework{"hid:tmp"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetConsoleSixAxisSensorCalibrationValues"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class HidBus final : public ServiceFramework<HidBus> {
+public:
+    explicit HidBus() : ServiceFramework{"hidbus"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "GetBusHandle"},
+            {2, nullptr, "IsExternalDeviceConnected"},
+            {3, nullptr, "Initialize"},
+            {4, nullptr, "Finalize"},
+            {5, nullptr, "EnableExternalDevice"},
+            {6, nullptr, "GetExternalDeviceId"},
+            {7, nullptr, "SendCommandAsync"},
+            {8, nullptr, "GetSendCommandAsynceResult"},
+            {9, nullptr, "SetEventForSendCommandAsycResult"},
+            {10, nullptr, "GetSharedMemoryHandle"},
+            {11, nullptr, "EnableJoyPollingReceiveMode"},
+            {12, nullptr, "DisableJoyPollingReceiveMode"},
+            {13, nullptr, "GetPollingData"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
 void ReloadInputDevices() {}
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<Hid>()->InstallAsService(service_manager);
+    std::make_shared<HidBus>()->InstallAsService(service_manager);
+    std::make_shared<HidDbg>()->InstallAsService(service_manager);
+    std::make_shared<HidSys>()->InstallAsService(service_manager);
+    std::make_shared<HidTmp>()->InstallAsService(service_manager);
+
+    std::make_shared<IRS>()->InstallAsService(service_manager);
+    std::make_shared<IRS_SYS>()->InstallAsService(service_manager);
+
+    std::make_shared<XCD_SYS>()->InstallAsService(service_manager);
 }
 
 } // namespace Service::HID

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

@@ -0,0 +1,49 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/hid/irs.h"
+
+namespace Service::HID {
+
+IRS::IRS() : ServiceFramework{"irs"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {302, nullptr, "ActivateIrsensor"},
+        {303, nullptr, "DeactivateIrsensor"},
+        {304, nullptr, "GetIrsensorSharedMemoryHandle"},
+        {305, nullptr, "StopImageProcessor"},
+        {306, nullptr, "RunMomentProcessor"},
+        {307, nullptr, "RunClusteringProcessor"},
+        {308, nullptr, "RunImageTransferProcessor"},
+        {309, nullptr, "GetImageTransferProcessorState"},
+        {310, nullptr, "RunTeraPluginProcessor"},
+        {311, nullptr, "GetNpadIrCameraHandle"},
+        {312, nullptr, "RunPointingProcessor"},
+        {313, nullptr, "SuspendImageProcessor"},
+        {314, nullptr, "CheckFirmwareVersion"},
+        {315, nullptr, "SetFunctionLevel"},
+        {316, nullptr, "RunImageTransferExProcessor"},
+        {317, nullptr, "RunIrLedProcessor"},
+        {318, nullptr, "StopImageProcessorAsync"},
+        {319, nullptr, "ActivateIrsensorWithFunctionLevel"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IRS_SYS::IRS_SYS() : ServiceFramework{"irs:sys"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {500, nullptr, "SetAppletResourceUserId"},
+        {501, nullptr, "RegisterAppletResourceUserId"},
+        {502, nullptr, "UnregisterAppletResourceUserId"},
+        {503, nullptr, "EnableAppletToGetInput"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+} // namespace Service::HID

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

@@ -0,0 +1,21 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+namespace Service::HID {
+
+class IRS final : public ServiceFramework<IRS> {
+public:
+    explicit IRS();
+};
+
+class IRS_SYS final : public ServiceFramework<IRS_SYS> {
+public:
+    explicit IRS_SYS();
+};
+
+} // namespace Service::HID

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

@@ -0,0 +1,37 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/hid/xcd.h"
+
+namespace Service::HID {
+
+XCD_SYS::XCD_SYS() : ServiceFramework{"xcd:sys"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetDataFormat"},
+        {1, nullptr, "SetDataFormat"},
+        {2, nullptr, "GetMcuState"},
+        {3, nullptr, "SetMcuState"},
+        {4, nullptr, "GetMcuVersionForNfc"},
+        {5, nullptr, "CheckNfcDevicePower"},
+        {10, nullptr, "SetNfcEvent"},
+        {11, nullptr, "GetNfcInfo"},
+        {12, nullptr, "StartNfcDiscovery"},
+        {13, nullptr, "StopNfcDiscovery"},
+        {14, nullptr, "StartNtagRead"},
+        {15, nullptr, "StartNtagWrite"},
+        {16, nullptr, "SendNfcRawData"},
+        {17, nullptr, "RegisterMifareKey"},
+        {18, nullptr, "ClearMifareKey"},
+        {19, nullptr, "StartMifareRead"},
+        {20, nullptr, "StartMifareWrite"},
+        {101, nullptr, "GetAwakeTriggerReasonForLeftRail"},
+        {102, nullptr, "GetAwakeTriggerReasonForRightRail"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+} // namespace Service::HID

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

@@ -0,0 +1,16 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+namespace Service::HID {
+
+class XCD_SYS final : public ServiceFramework<XCD_SYS> {
+public:
+    explicit XCD_SYS();
+};
+
+} // namespace Service::HID

src/core/hle/service/ldn/ldn.cpp

@@ -0,0 +1,142 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/result.h"
+#include "core/hle/service/ldn/ldn.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::LDN {
+
+class IMonitorService final : public ServiceFramework<IMonitorService> {
+public:
+    explicit IMonitorService() : ServiceFramework{"IMonitorService"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetStateForMonitor"},
+            {1, nullptr, "GetNetworkInfoForMonitor"},
+            {2, nullptr, "GetIpv4AddressForMonitor"},
+            {3, nullptr, "GetDisconnectReasonForMonitor"},
+            {4, nullptr, "GetSecurityParameterForMonitor"},
+            {5, nullptr, "GetNetworkConfigForMonitor"},
+            {100, nullptr, "InitializeMonitor"},
+            {101, nullptr, "FinalizeMonitor"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class LDNM final : public ServiceFramework<LDNM> {
+public:
+    explicit LDNM() : ServiceFramework{"ldn:m"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &LDNM::CreateMonitorService, "CreateMonitorService"}
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+    void CreateMonitorService(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IMonitorService>();
+
+        LOG_DEBUG(Service_LDN, "called");
+    }
+};
+
+class ILocalCommunicationService final : public ServiceFramework<ILocalCommunicationService> {
+public:
+    explicit ILocalCommunicationService(const char* name) : ServiceFramework{name} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetState"},
+            {1, nullptr, "GetNetworkInfo"},
+            {2, nullptr, "GetIpv4Address"},
+            {3, nullptr, "GetDisconnectReason"},
+            {4, nullptr, "GetSecurityParameter"},
+            {5, nullptr, "GetNetworkConfig"},
+            {100, nullptr, "AttachStateChangeEvent"},
+            {101, nullptr, "GetNetworkInfoLatestUpdate"},
+            {102, nullptr, "Scan"},
+            {103, nullptr, "ScanPrivate"},
+            {200, nullptr, "OpenAccessPoint"},
+            {201, nullptr, "CloseAccessPoint"},
+            {202, nullptr, "CreateNetwork"},
+            {203, nullptr, "CreateNetworkPrivate"},
+            {204, nullptr, "DestroyNetwork"},
+            {205, nullptr, "Reject"},
+            {206, nullptr, "SetAdvertiseData"},
+            {207, nullptr, "SetStationAcceptPolicy"},
+            {208, nullptr, "AddAcceptFilterEntry"},
+            {209, nullptr, "ClearAcceptFilter"},
+            {300, nullptr, "OpenStation"},
+            {301, nullptr, "CloseStation"},
+            {302, nullptr, "Connect"},
+            {303, nullptr, "ConnectPrivate"},
+            {304, nullptr, "Disconnect"},
+            {400, nullptr, "InitializeSystem"},
+            {401, nullptr, "FinalizeSystem"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class LDNS final : public ServiceFramework<LDNS> {
+public:
+    explicit LDNS() : ServiceFramework{"ldn:s"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &LDNS::CreateSystemLocalCommunicationService, "CreateSystemLocalCommunicationService"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+    void CreateSystemLocalCommunicationService(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<ILocalCommunicationService>("ISystemLocalCommunicationService");
+
+        LOG_DEBUG(Service_LDN, "called");
+    }
+};
+
+class LDNU final : public ServiceFramework<LDNU> {
+public:
+    explicit LDNU() : ServiceFramework{"ldn:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &LDNU::CreateUserLocalCommunicationService, "CreateUserLocalCommunicationService"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+    void CreateUserLocalCommunicationService(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<ILocalCommunicationService>("IUserLocalCommunicationService");
+
+        LOG_DEBUG(Service_LDN, "called");
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<LDNM>()->InstallAsService(sm);
+    std::make_shared<LDNS>()->InstallAsService(sm);
+    std::make_shared<LDNU>()->InstallAsService(sm);
+}
+
+} // namespace Service::LDN

src/core/hle/service/ldn/ldn.h

@@ -0,0 +1,16 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::LDN {
+
+/// Registers all LDN services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& sm);
+
+} // namespace Service::LDN

src/core/hle/service/ldr/ldr.cpp

@@ -0,0 +1,81 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/hle/service/ldr/ldr.h"
+#include "core/hle/service/service.h"
+
+namespace Service::LDR {
+
+class DebugMonitor final : public ServiceFramework<DebugMonitor> {
+public:
+    explicit DebugMonitor() : ServiceFramework{"ldr:dmnt"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "AddProcessToDebugLaunchQueue"},
+            {1, nullptr, "ClearDebugLaunchQueue"},
+            {2, nullptr, "GetNsoInfos"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class ProcessManager final : public ServiceFramework<ProcessManager> {
+public:
+    explicit ProcessManager() : ServiceFramework{"ldr:pm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateProcess"},
+            {1, nullptr, "GetProgramInfo"},
+            {2, nullptr, "RegisterTitle"},
+            {3, nullptr, "UnregisterTitle"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class Shell final : public ServiceFramework<Shell> {
+public:
+    explicit Shell() : ServiceFramework{"ldr:shel"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "AddProcessToLaunchQueue"},
+            {1, nullptr, "ClearLaunchQueue"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class RelocatableObject final : public ServiceFramework<RelocatableObject> {
+public:
+    explicit RelocatableObject() : ServiceFramework{"ldr:ro"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "LoadNro"},
+            {1, nullptr, "UnloadNro"},
+            {2, nullptr, "LoadNrr"},
+            {3, nullptr, "UnloadNrr"},
+            {4, nullptr, "Initialize"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<DebugMonitor>()->InstallAsService(sm);
+    std::make_shared<ProcessManager>()->InstallAsService(sm);
+    std::make_shared<Shell>()->InstallAsService(sm);
+    std::make_shared<RelocatableObject>()->InstallAsService(sm);
+}
+
+} // namespace Service::LDR

src/core/hle/service/ldr/ldr.h

@@ -0,0 +1,16 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::LDR {
+
+/// Registers all LDR services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& sm);
+
+} // namespace Service::LDR

src/core/hle/service/lm/lm.cpp

@@ -4,10 +4,12 @@
 
 #include <sstream>
 #include <string>
+
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/client_session.h"
 #include "core/hle/service/lm/lm.h"
+#include "core/hle/service/service.h"
+#include "core/memory.h"
 
 namespace Service::LM {
 
@@ -15,13 +17,12 @@ class Logger final : public ServiceFramework<Logger> {
 public:
     Logger() : ServiceFramework("Logger") {
         static const FunctionInfo functions[] = {
-            {0x00000000, &Logger::Log, "Log"},
+            {0x00000000, &Logger::Initialize, "Initialize"},
+            {0x00000001, nullptr, "SetDestination"},
         };
         RegisterHandlers(functions);
     }
 
-    ~Logger() = default;
-
 private:
     struct MessageHeader {
         enum Flags : u32_le {
@@ -66,13 +67,13 @@ private:
     };
 
     /**
-     * LM::Log service function
+     * ILogger::Initialize service function
      *  Inputs:
      *      0: 0x00000000
      *  Outputs:
      *      0: ResultCode
      */
-    void Log(Kernel::HLERequestContext& ctx) {
+    void Initialize(Kernel::HLERequestContext& ctx) {
         // This function only succeeds - Get that out of the way
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -162,30 +163,33 @@ private:
     std::ostringstream log_stream;
 };
 
+class LM final : public ServiceFramework<LM> {
+public:
+    explicit LM() : ServiceFramework{"lm"} {
+        static const FunctionInfo functions[] = {
+            {0x00000000, &LM::OpenLogger, "OpenLogger"},
+        };
+        RegisterHandlers(functions);
+    }
+
+    /**
+     * LM::OpenLogger service function
+     *  Inputs:
+     *      0: 0x00000000
+     *  Outputs:
+     *      0: ResultCode
+     */
+    void OpenLogger(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<Logger>();
+
+        LOG_DEBUG(Service_LM, "called");
+    }
+};
+
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<LM>()->InstallAsService(service_manager);
 }
 
-/**
- * LM::Initialize service function
- *  Inputs:
- *      0: 0x00000000
- *  Outputs:
- *      0: ResultCode
- */
-void LM::Initialize(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<Logger>();
-
-    LOG_DEBUG(Service_LM, "called");
-}
-
-LM::LM() : ServiceFramework("lm") {
-    static const FunctionInfo functions[] = {
-        {0x00000000, &LM::Initialize, "Initialize"},
-    };
-    RegisterHandlers(functions);
-}
-
 } // namespace Service::LM

src/core/hle/service/lm/lm.h

@@ -4,21 +4,12 @@
 
 #pragma once
 
-#include <vector>
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/service/service.h"
+namespace Service::SM {
+class ServiceManager;
+}
 
 namespace Service::LM {
 
-class LM final : public ServiceFramework<LM> {
-public:
-    LM();
-    ~LM() = default;
-
-private:
-    void Initialize(Kernel::HLERequestContext& ctx);
-};
-
 /// Registers all LM services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 

src/core/hle/service/nfc/nfc.cpp

@@ -0,0 +1,222 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/hle_ipc.h"
+#include "core/hle/service/nfc/nfc.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::NFC {
+
+class IAm final : public ServiceFramework<IAm> {
+public:
+    explicit IAm() : ServiceFramework{"IAm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "Finalize"},
+            {2, nullptr, "NotifyForegroundApplet"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class NFC_AM final : public ServiceFramework<NFC_AM> {
+public:
+    explicit NFC_AM() : ServiceFramework{"nfc:am"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &NFC_AM::CreateAmInterface, "CreateAmInterface"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void CreateAmInterface(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IAm>();
+
+        LOG_DEBUG(Service_NFC, "called");
+    }
+};
+
+class MFIUser final : public ServiceFramework<MFIUser> {
+public:
+    explicit MFIUser() : ServiceFramework{"IUser"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "Finalize"},
+            {2, nullptr, "ListDevices"},
+            {3, nullptr, "StartDetection"},
+            {4, nullptr, "StopDetection"},
+            {5, nullptr, "Read"},
+            {6, nullptr, "Write"},
+            {7, nullptr, "GetTagInfo"},
+            {8, nullptr, "GetActivateEventHandle"},
+            {9, nullptr, "GetDeactivateEventHandle"},
+            {10, nullptr, "GetState"},
+            {11, nullptr, "GetDeviceState"},
+            {12, nullptr, "GetNpadId"},
+            {13, nullptr, "GetAvailabilityChangeEventHandle"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class NFC_MF_U final : public ServiceFramework<NFC_MF_U> {
+public:
+    explicit NFC_MF_U() : ServiceFramework{"nfc:mf:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &NFC_MF_U::CreateUserInterface, "CreateUserInterface"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void CreateUserInterface(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<MFIUser>();
+
+        LOG_DEBUG(Service_NFC, "called");
+    }
+};
+
+class IUser final : public ServiceFramework<IUser> {
+public:
+    explicit IUser() : ServiceFramework{"IUser"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "Finalize"},
+            {2, nullptr, "GetState"},
+            {3, nullptr, "IsNfcEnabled"},
+            {400, nullptr, "Initialize"},
+            {401, nullptr, "Finalize"},
+            {402, nullptr, "GetState"},
+            {403, nullptr, "IsNfcEnabled"},
+            {404, nullptr, "ListDevices"},
+            {405, nullptr, "GetDeviceState"},
+            {406, nullptr, "GetNpadId"},
+            {407, nullptr, "AttachAvailabilityChangeEvent"},
+            {408, nullptr, "StartDetection"},
+            {409, nullptr, "StopDetection"},
+            {410, nullptr, "GetTagInfo"},
+            {411, nullptr, "AttachActivateEvent"},
+            {412, nullptr, "AttachDeactivateEvent"},
+            {1000, nullptr, "ReadMifare"},
+            {1001, nullptr, "WriteMifare"},
+            {1300, nullptr, "SendCommandByPassThrough"},
+            {1301, nullptr, "KeepPassThroughSession"},
+            {1302, nullptr, "ReleasePassThroughSession"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class NFC_U final : public ServiceFramework<NFC_U> {
+public:
+    explicit NFC_U() : ServiceFramework{"nfc:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &NFC_U::CreateUserInterface, "CreateUserInterface"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void CreateUserInterface(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IUser>();
+
+        LOG_DEBUG(Service_NFC, "called");
+    }
+};
+
+class ISystem final : public ServiceFramework<ISystem> {
+public:
+    explicit ISystem() : ServiceFramework{"ISystem"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "Finalize"},
+            {2, nullptr, "GetState"},
+            {3, nullptr, "IsNfcEnabled"},
+            {100, nullptr, "SetNfcEnabled"},
+            {400, nullptr, "InitializeSystem"},
+            {401, nullptr, "FinalizeSystem"},
+            {402, nullptr, "GetState"},
+            {403, nullptr, "IsNfcEnabled"},
+            {404, nullptr, "ListDevices"},
+            {405, nullptr, "GetDeviceState"},
+            {406, nullptr, "GetNpadId"},
+            {407, nullptr, "AttachAvailabilityChangeEvent"},
+            {408, nullptr, "StartDetection"},
+            {409, nullptr, "StopDetection"},
+            {410, nullptr, "GetTagInfo"},
+            {411, nullptr, "AttachActivateEvent"},
+            {412, nullptr, "AttachDeactivateEvent"},
+            {500, nullptr, "SetNfcEnabled"},
+            {1000, nullptr, "ReadMifare"},
+            {1001, nullptr, "WriteMifare"},
+            {1300, nullptr, "SendCommandByPassThrough"},
+            {1301, nullptr, "KeepPassThroughSession"},
+            {1302, nullptr, "ReleasePassThroughSession"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class NFC_SYS final : public ServiceFramework<NFC_SYS> {
+public:
+    explicit NFC_SYS() : ServiceFramework{"nfc:sys"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &NFC_SYS::CreateSystemInterface, "CreateSystemInterface"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void CreateSystemInterface(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<ISystem>();
+
+        LOG_DEBUG(Service_NFC, "called");
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<NFC_AM>()->InstallAsService(sm);
+    std::make_shared<NFC_MF_U>()->InstallAsService(sm);
+    std::make_shared<NFC_U>()->InstallAsService(sm);
+    std::make_shared<NFC_SYS>()->InstallAsService(sm);
+}
+
+} // namespace Service::NFC

src/core/hle/service/nfc/nfc.h

@@ -0,0 +1,15 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::NFC {
+
+void InstallInterfaces(SM::ServiceManager& sm);
+
+} // namespace Service::NFC

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

@@ -5,9 +5,7 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/event.h"
 #include "core/hle/service/nifm/nifm.h"
-#include "core/hle/service/nifm/nifm_a.h"
-#include "core/hle/service/nifm/nifm_s.h"
-#include "core/hle/service/nifm/nifm_u.h"
+#include "core/hle/service/service.h"
 
 namespace Service::NIFM {
 
@@ -210,28 +208,35 @@ IGeneralService::IGeneralService() : ServiceFramework("IGeneralService") {
     RegisterHandlers(functions);
 }
 
-void Module::Interface::CreateGeneralServiceOld(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IGeneralService>();
-    LOG_DEBUG(Service_NIFM, "called");
-}
+class NetworkInterface final : public ServiceFramework<NetworkInterface> {
+public:
+    explicit NetworkInterface(const char* name) : ServiceFramework{name} {
+        static const FunctionInfo functions[] = {
+            {4, &NetworkInterface::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
+            {5, &NetworkInterface::CreateGeneralService, "CreateGeneralService"},
+        };
+        RegisterHandlers(functions);
+    }
 
-void Module::Interface::CreateGeneralService(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IGeneralService>();
-    LOG_DEBUG(Service_NIFM, "called");
-}
+    void CreateGeneralServiceOld(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IGeneralService>();
+        LOG_DEBUG(Service_NIFM, "called");
+    }
 
-Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
-    : ServiceFramework(name), module(std::move(module)) {}
+    void CreateGeneralService(Kernel::HLERequestContext& ctx) {
+        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushIpcInterface<IGeneralService>();
+        LOG_DEBUG(Service_NIFM, "called");
+    }
+};
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
-    auto module = std::make_shared<Module>();
-    std::make_shared<NIFM_A>(module)->InstallAsService(service_manager);
-    std::make_shared<NIFM_S>(module)->InstallAsService(service_manager);
-    std::make_shared<NIFM_U>(module)->InstallAsService(service_manager);
+    std::make_shared<NetworkInterface>("nifm:a")->InstallAsService(service_manager);
+    std::make_shared<NetworkInterface>("nifm:s")->InstallAsService(service_manager);
+    std::make_shared<NetworkInterface>("nifm:u")->InstallAsService(service_manager);
 }
 
 } // namespace Service::NIFM

src/core/hle/service/nifm/nifm.h

@@ -4,24 +4,13 @@
 
 #pragma once
 
-#include "core/hle/service/service.h"
+namespace Service::SM {
+class ServiceManager;
+}
 
 namespace Service::NIFM {
 
-class Module final {
-public:
-    class Interface : public ServiceFramework<Interface> {
-    public:
-        explicit Interface(std::shared_ptr<Module> module, const char* name);
-
-        void CreateGeneralServiceOld(Kernel::HLERequestContext& ctx);
-        void CreateGeneralService(Kernel::HLERequestContext& ctx);
-
-    protected:
-        std::shared_ptr<Module> module;
-    };
-};
-
+/// Registers all NIFM services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager);
 
 } // namespace Service::NIFM

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

@@ -1,17 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/nifm/nifm_a.h"
-
-namespace Service::NIFM {
-
-NIFM_A::NIFM_A(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "nifm:a") {
-    static const FunctionInfo functions[] = {
-        {4, &NIFM_A::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
-        {5, &NIFM_A::CreateGeneralService, "CreateGeneralService"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Service::NIFM

src/core/hle/service/nifm/nifm_a.h

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/nifm/nifm.h"
-
-namespace Service::NIFM {
-
-class NIFM_A final : public Module::Interface {
-public:
-    explicit NIFM_A(std::shared_ptr<Module> module);
-};
-
-} // namespace Service::NIFM

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

@@ -1,17 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/nifm/nifm_s.h"
-
-namespace Service::NIFM {
-
-NIFM_S::NIFM_S(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "nifm:s") {
-    static const FunctionInfo functions[] = {
-        {4, &NIFM_S::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
-        {5, &NIFM_S::CreateGeneralService, "CreateGeneralService"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Service::NIFM

src/core/hle/service/nifm/nifm_s.h

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/nifm/nifm.h"
-
-namespace Service::NIFM {
-
-class NIFM_S final : public Module::Interface {
-public:
-    explicit NIFM_S(std::shared_ptr<Module> module);
-};
-
-} // namespace Service::NIFM

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

@@ -1,17 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/nifm/nifm_u.h"
-
-namespace Service::NIFM {
-
-NIFM_U::NIFM_U(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "nifm:u") {
-    static const FunctionInfo functions[] = {
-        {4, &NIFM_U::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
-        {5, &NIFM_U::CreateGeneralService, "CreateGeneralService"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Service::NIFM

src/core/hle/service/nifm/nifm_u.h

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/nifm/nifm.h"
-
-namespace Service::NIFM {
-
-class NIFM_U final : public Module::Interface {
-public:
-    explicit NIFM_U(std::shared_ptr<Module> module);
-};
-
-} // namespace Service::NIFM

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

@@ -0,0 +1,124 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/nim/nim.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/sm/sm.h"
+
+namespace Service::NIM {
+
+class NIM final : public ServiceFramework<NIM> {
+public:
+    explicit NIM() : ServiceFramework{"nim"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateSystemUpdateTask"},
+            {1, nullptr, "DestroySystemUpdateTask"},
+            {2, nullptr, "ListSystemUpdateTask"},
+            {3, nullptr, "RequestSystemUpdateTaskRun"},
+            {4, nullptr, "GetSystemUpdateTaskInfo"},
+            {5, nullptr, "CommitSystemUpdateTask"},
+            {6, nullptr, "CreateNetworkInstallTask"},
+            {7, nullptr, "DestroyNetworkInstallTask"},
+            {8, nullptr, "ListNetworkInstallTask"},
+            {9, nullptr, "RequestNetworkInstallTaskRun"},
+            {10, nullptr, "GetNetworkInstallTaskInfo"},
+            {11, nullptr, "CommitNetworkInstallTask"},
+            {12, nullptr, "RequestLatestSystemUpdateMeta"},
+            {14, nullptr, "ListApplicationNetworkInstallTask"},
+            {15, nullptr, "ListNetworkInstallTaskContentMeta"},
+            {16, nullptr, "RequestLatestVersion"},
+            {17, nullptr, "SetNetworkInstallTaskAttribute"},
+            {18, nullptr, "AddNetworkInstallTaskContentMeta"},
+            {19, nullptr, "GetDownloadedSystemDataPath"},
+            {20, nullptr, "CalculateNetworkInstallTaskRequiredSize"},
+            {21, nullptr, "IsExFatDriverIncluded"},
+            {22, nullptr, "GetBackgroundDownloadStressTaskInfo"},
+            {23, nullptr, "RequestDeviceAuthenticationToken"},
+            {24, nullptr, "RequestGameCardRegistrationStatus"},
+            {25, nullptr, "RequestRegisterGameCard"},
+            {26, nullptr, "RequestRegisterNotificationToken"},
+            {27, nullptr, "RequestDownloadTaskList"},
+            {28, nullptr, "RequestApplicationControl"},
+            {29, nullptr, "RequestLatestApplicationControl"},
+            {30, nullptr, "RequestVersionList"},
+            {31, nullptr, "CreateApplyDeltaTask"},
+            {32, nullptr, "DestroyApplyDeltaTask"},
+            {33, nullptr, "ListApplicationApplyDeltaTask"},
+            {34, nullptr, "RequestApplyDeltaTaskRun"},
+            {35, nullptr, "GetApplyDeltaTaskInfo"},
+            {36, nullptr, "ListApplyDeltaTask"},
+            {37, nullptr, "CommitApplyDeltaTask"},
+            {38, nullptr, "CalculateApplyDeltaTaskRequiredSize"},
+            {39, nullptr, "PrepareShutdown"},
+            {40, nullptr, "ListApplyDeltaTask"},
+            {41, nullptr, "ClearNotEnoughSpaceStateOfApplyDeltaTask"},
+            {42, nullptr, "Unknown1"},
+            {43, nullptr, "Unknown2"},
+            {44, nullptr, "Unknown3"},
+            {45, nullptr, "Unknown4"},
+            {46, nullptr, "Unknown5"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class NIM_SHP final : public ServiceFramework<NIM_SHP> {
+public:
+    explicit NIM_SHP() : ServiceFramework{"nim:shp"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestDeviceAuthenticationToken"},
+            {1, nullptr, "RequestCachedDeviceAuthenticationToken"},
+            {100, nullptr, "RequestRegisterDeviceAccount"},
+            {101, nullptr, "RequestUnregisterDeviceAccount"},
+            {102, nullptr, "RequestDeviceAccountStatus"},
+            {103, nullptr, "GetDeviceAccountInfo"},
+            {104, nullptr, "RequestDeviceRegistrationInfo"},
+            {105, nullptr, "RequestTransferDeviceAccount"},
+            {106, nullptr, "RequestSyncRegistration"},
+            {107, nullptr, "IsOwnDeviceId"},
+            {200, nullptr, "RequestRegisterNotificationToken"},
+            {300, nullptr, "RequestUnlinkDevice"},
+            {301, nullptr, "RequestUnlinkDeviceIntegrated"},
+            {302, nullptr, "RequestLinkDevice"},
+            {303, nullptr, "HasDeviceLink"},
+            {304, nullptr, "RequestUnlinkDeviceAll"},
+            {305, nullptr, "RequestCreateVirtualAccount"},
+            {306, nullptr, "RequestDeviceLinkStatus"},
+            {400, nullptr, "GetAccountByVirtualAccount"},
+            {500, nullptr, "RequestSyncTicket"},
+            {501, nullptr, "RequestDownloadTicket"},
+            {502, nullptr, "RequestDownloadTicketForPrepurchasedContents"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+class NTC final : public ServiceFramework<NTC> {
+public:
+    explicit NTC() : ServiceFramework{"ntc"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "OpenEnsureNetworkClockAvailabilityService"},
+            {100, nullptr, "SuspendAutonomicTimeCorrection"},
+            {101, nullptr, "ResumeAutonomicTimeCorrection"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<NIM>()->InstallAsService(sm);
+    std::make_shared<NIM_SHP>()->InstallAsService(sm);
+    std::make_shared<NTC>()->InstallAsService(sm);
+}
+
+} // namespace Service::NIM

src/core/hle/service/nim/nim.h

@@ -0,0 +1,15 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::NIM {
+
+void InstallInterfaces(SM::ServiceManager& sm);
+
+} // namespace Service::NIM

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

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <utility>
+
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
@@ -40,14 +42,14 @@ Module::Module() {
     devices["/dev/nvhost-nvdec"] = std::make_shared<Devices::nvhost_nvdec>();
 }
 
-u32 Module::Open(std::string device_name) {
+u32 Module::Open(const std::string& device_name) {
     ASSERT_MSG(devices.find(device_name) != devices.end(), "Trying to open unknown device {}",
                device_name);
 
     auto device = devices[device_name];
-    u32 fd = next_fd++;
+    const u32 fd = next_fd++;
 
-    open_files[fd] = device;
+    open_files[fd] = std::move(device);
 
     return fd;
 }
@@ -56,7 +58,7 @@ u32 Module::Ioctl(u32 fd, u32_le command, const std::vector<u8>& input, std::vec
     auto itr = open_files.find(fd);
     ASSERT_MSG(itr != open_files.end(), "Tried to talk to an invalid device");
 
-    auto device = itr->second;
+    auto& device = itr->second;
     return device->ioctl({command}, input, output);
 }
 

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

@@ -38,7 +38,7 @@ public:
     }
 
     /// Opens a device node and returns a file descriptor to it.
-    u32 Open(std::string device_name);
+    u32 Open(const std::string& device_name);
     /// Sends an ioctl command to the specified file descriptor.
     u32 Ioctl(u32 fd, u32 command, const std::vector<u8>& input, std::vector<u8>& output);
     /// Closes a device file descriptor and returns operation success.

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

@@ -9,6 +9,7 @@
 #include "common/scope_exit.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/service/nvdrv/devices/nvdisp_disp0.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"

src/core/hle/service/pm/pm.cpp

@@ -0,0 +1,70 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/service.h"
+
+namespace Service::PM {
+
+class BootMode final : public ServiceFramework<BootMode> {
+public:
+    explicit BootMode() : ServiceFramework{"pm:bm"} {
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetBootMode"},
+            {1, nullptr, "SetMaintenanceBoot"},
+        };
+        RegisterHandlers(functions);
+    }
+};
+
+class DebugMonitor final : public ServiceFramework<DebugMonitor> {
+public:
+    explicit DebugMonitor() : ServiceFramework{"pm:dmnt"} {
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "IsDebugMode"},
+            {1, nullptr, "GetDebugProcesses"},
+            {2, nullptr, "StartDebugProcess"},
+            {3, nullptr, "GetTitlePid"},
+            {4, nullptr, "EnableDebugForTitleId"},
+            {5, nullptr, "GetApplicationPid"},
+            {6, nullptr, "EnableDebugForApplication"},
+        };
+        RegisterHandlers(functions);
+    }
+};
+
+class Info final : public ServiceFramework<Info> {
+public:
+    explicit Info() : ServiceFramework{"pm:info"} {
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetTitleId"},
+        };
+        RegisterHandlers(functions);
+    }
+};
+
+class Shell final : public ServiceFramework<Shell> {
+public:
+    explicit Shell() : ServiceFramework{"pm:shell"} {
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "LaunchProcess"},
+            {1, nullptr, "TerminateProcessByPid"},
+            {2, nullptr, "TerminateProcessByTitleId"},
+            {3, nullptr, "GetProcessEventWaiter"},
+            {4, nullptr, "GetProcessEventType"},
+            {5, nullptr, "NotifyBootFinished"},
+            {6, nullptr, "GetApplicationPid"},
+            {7, nullptr, "BoostSystemMemoryResourceLimit"},
+        };
+        RegisterHandlers(functions);
+    }
+};
+
+void InstallInterfaces(SM::ServiceManager& sm) {
+    std::make_shared<BootMode>()->InstallAsService(sm);
+    std::make_shared<DebugMonitor>()->InstallAsService(sm);
+    std::make_shared<Info>()->InstallAsService(sm);
+    std::make_shared<Shell>()->InstallAsService(sm);
+}
+
+} // namespace Service::PM

src/core/hle/service/pm/pm.h

@@ -0,0 +1,16 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace Service::SM {
+class ServiceManager;
+}
+
+namespace Service::PM {
+
+/// Registers all PM services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& service_manager);
+
+} // namespace Service::PM

src/core/hle/service/service.cpp

@@ -21,17 +21,26 @@
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/audio/audio.h"
 #include "core/hle/service/bcat/bcat.h"
+#include "core/hle/service/erpt/erpt.h"
+#include "core/hle/service/es/es.h"
+#include "core/hle/service/eupld/eupld.h"
 #include "core/hle/service/fatal/fatal.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/friend/friend.h"
+#include "core/hle/service/grc/grc.h"
 #include "core/hle/service/hid/hid.h"
+#include "core/hle/service/ldn/ldn.h"
+#include "core/hle/service/ldr/ldr.h"
 #include "core/hle/service/lm/lm.h"
 #include "core/hle/service/mm/mm_u.h"
+#include "core/hle/service/nfc/nfc.h"
 #include "core/hle/service/nfp/nfp.h"
 #include "core/hle/service/nifm/nifm.h"
+#include "core/hle/service/nim/nim.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvdrv/nvdrv.h"
 #include "core/hle/service/pctl/pctl.h"
+#include "core/hle/service/pm/pm.h"
 #include "core/hle/service/prepo/prepo.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/set/settings.h"
@@ -187,18 +196,27 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm) {
     APM::InstallInterfaces(*sm);
     BCAT::InstallInterfaces(*sm);
     Audio::InstallInterfaces(*sm);
+    ERPT::InstallInterfaces(*sm);
+    ES::InstallInterfaces(*sm);
+    EUPLD::InstallInterfaces(*sm);
     Fatal::InstallInterfaces(*sm);
     FileSystem::InstallInterfaces(*sm);
     Friend::InstallInterfaces(*sm);
+    GRC::InstallInterfaces(*sm);
     HID::InstallInterfaces(*sm);
+    LDN::InstallInterfaces(*sm);
+    LDR::InstallInterfaces(*sm);
     LM::InstallInterfaces(*sm);
     MM::InstallInterfaces(*sm);
+    NFC::InstallInterfaces(*sm);
     NFP::InstallInterfaces(*sm);
     NIFM::InstallInterfaces(*sm);
+    NIM::InstallInterfaces(*sm);
     NS::InstallInterfaces(*sm);
     Nvidia::InstallInterfaces(*sm);
     PCTL::InstallInterfaces(*sm);
     PlayReport::InstallInterfaces(*sm);
+    PM::InstallInterfaces(*sm);
     Sockets::InstallInterfaces(*sm);
     SPL::InstallInterfaces(*sm);
     SSL::InstallInterfaces(*sm);

src/core/hle/service/service.h

@@ -146,7 +146,7 @@ protected:
      * @param max_sessions Maximum number of sessions that can be
      * connected to this service at the same time.
      */
-    ServiceFramework(const char* service_name, u32 max_sessions = DefaultMaxSessions)
+    explicit ServiceFramework(const char* service_name, u32 max_sessions = DefaultMaxSessions)
         : ServiceFrameworkBase(service_name, max_sessions, Invoker) {}
 
     /// Registers handlers in the service.

src/core/hle/service/set/set.cpp

@@ -11,31 +11,40 @@
 
 namespace Service::Set {
 
+constexpr std::array<LanguageCode, 17> available_language_codes = {{
+    LanguageCode::JA,
+    LanguageCode::EN_US,
+    LanguageCode::FR,
+    LanguageCode::DE,
+    LanguageCode::IT,
+    LanguageCode::ES,
+    LanguageCode::ZH_CN,
+    LanguageCode::KO,
+    LanguageCode::NL,
+    LanguageCode::PT,
+    LanguageCode::RU,
+    LanguageCode::ZH_TW,
+    LanguageCode::EN_GB,
+    LanguageCode::FR_CA,
+    LanguageCode::ES_419,
+    LanguageCode::ZH_HANS,
+    LanguageCode::ZH_HANT,
+}};
+
 void SET::GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx) {
-    static constexpr std::array<LanguageCode, 17> available_language_codes = {{
-        LanguageCode::JA,
-        LanguageCode::EN_US,
-        LanguageCode::FR,
-        LanguageCode::DE,
-        LanguageCode::IT,
-        LanguageCode::ES,
-        LanguageCode::ZH_CN,
-        LanguageCode::KO,
-        LanguageCode::NL,
-        LanguageCode::PT,
-        LanguageCode::RU,
-        LanguageCode::ZH_TW,
-        LanguageCode::EN_GB,
-        LanguageCode::FR_CA,
-        LanguageCode::ES_419,
-        LanguageCode::ZH_HANS,
-        LanguageCode::ZH_HANT,
-    }};
     ctx.WriteBuffer(available_language_codes);
 
-    IPC::ResponseBuilder rb{ctx, 4};
+    IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(static_cast<u64>(available_language_codes.size()));
+    rb.Push(static_cast<u32>(available_language_codes.size()));
+
+    LOG_DEBUG(Service_SET, "called");
+}
+
+void SET::GetAvailableLanguageCodeCount(Kernel::HLERequestContext& ctx) {
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(static_cast<u32>(available_language_codes.size()));
 
     LOG_DEBUG(Service_SET, "called");
 }
@@ -45,10 +54,10 @@ SET::SET() : ServiceFramework("set") {
         {0, nullptr, "GetLanguageCode"},
         {1, &SET::GetAvailableLanguageCodes, "GetAvailableLanguageCodes"},
         {2, nullptr, "MakeLanguageCode"},
-        {3, nullptr, "GetAvailableLanguageCodeCount"},
+        {3, &SET::GetAvailableLanguageCodeCount, "GetAvailableLanguageCodeCount"},
         {4, nullptr, "GetRegionCode"},
         {5, &SET::GetAvailableLanguageCodes, "GetAvailableLanguageCodes2"},
-        {6, nullptr, "GetAvailableLanguageCodeCount2"},
+        {6, &SET::GetAvailableLanguageCodeCount, "GetAvailableLanguageCodeCount2"},
         {7, nullptr, "GetKeyCodeMap"},
         {8, nullptr, "GetQuestFlag"},
     };

src/core/hle/service/set/set.h

@@ -36,6 +36,7 @@ public:
 
 private:
     void GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx);
+    void GetAvailableLanguageCodeCount(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Set

src/core/hle/service/set/set_sys.cpp

@@ -10,13 +10,22 @@
 namespace Service::Set {
 
 void SET_SYS::GetColorSetId(Kernel::HLERequestContext& ctx) {
-
     IPC::ResponseBuilder rb{ctx, 3};
 
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(0);
+    rb.PushEnum(color_set);
 
-    LOG_WARNING(Service_SET, "(STUBBED) called");
+    LOG_DEBUG(Service_SET, "called");
+}
+
+void SET_SYS::SetColorSetId(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    color_set = rp.PopEnum<ColorSet>();
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+
+    LOG_DEBUG(Service_SET, "called");
 }
 
 SET_SYS::SET_SYS() : ServiceFramework("set:sys") {
@@ -44,7 +53,7 @@ SET_SYS::SET_SYS() : ServiceFramework("set:sys") {
         {21, nullptr, "GetEulaVersions"},
         {22, nullptr, "SetEulaVersions"},
         {23, &SET_SYS::GetColorSetId, "GetColorSetId"},
-        {24, nullptr, "SetColorSetId"},
+        {24, &SET_SYS::SetColorSetId, "SetColorSetId"},
         {25, nullptr, "GetConsoleInformationUploadFlag"},
         {26, nullptr, "SetConsoleInformationUploadFlag"},
         {27, nullptr, "GetAutomaticApplicationDownloadFlag"},
@@ -172,4 +181,6 @@ SET_SYS::SET_SYS() : ServiceFramework("set:sys") {
     RegisterHandlers(functions);
 }
 
+SET_SYS::~SET_SYS() = default;
+
 } // namespace Service::Set

src/core/hle/service/set/set_sys.h

@@ -11,10 +11,19 @@ namespace Service::Set {
 class SET_SYS final : public ServiceFramework<SET_SYS> {
 public:
     explicit SET_SYS();
-    ~SET_SYS() = default;
+    ~SET_SYS() override;
 
 private:
+    /// Indicates the current theme set by the system settings
+    enum class ColorSet : u32 {
+        BasicWhite = 0,
+        BasicBlack = 1,
+    };
+
     void GetColorSetId(Kernel::HLERequestContext& ctx);
+    void SetColorSetId(Kernel::HLERequestContext& ctx);
+
+    ColorSet color_set = ColorSet::BasicWhite;
 };
 
 } // namespace Service::Set

src/core/hle/service/sockets/bsd.cpp

@@ -109,4 +109,26 @@ BSD::BSD(const char* name) : ServiceFramework(name) {
     RegisterHandlers(functions);
 }
 
+BSDCFG::BSDCFG() : ServiceFramework{"bsdcfg"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "SetIfUp"},
+        {1, nullptr, "SetIfUpWithEvent"},
+        {2, nullptr, "CancelIf"},
+        {3, nullptr, "SetIfDown"},
+        {4, nullptr, "GetIfState"},
+        {5, nullptr, "DhcpRenew"},
+        {6, nullptr, "AddStaticArpEntry"},
+        {7, nullptr, "RemoveArpEntry"},
+        {8, nullptr, "LookupArpEntry"},
+        {9, nullptr, "LookupArpEntry2"},
+        {10, nullptr, "ClearArpEntries"},
+        {11, nullptr, "ClearArpEntries2"},
+        {12, nullptr, "PrintArpEntries"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
 } // namespace Service::Sockets

src/core/hle/service/sockets/bsd.h

@@ -26,4 +26,9 @@ private:
     u32 next_fd = 1;
 };
 
+class BSDCFG final : public ServiceFramework<BSDCFG> {
+public:
+    explicit BSDCFG();
+};
+
 } // namespace Service::Sockets

src/core/hle/service/sockets/ethc.cpp

@@ -0,0 +1,38 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/hle/service/sockets/ethc.h"
+
+namespace Service::Sockets {
+
+ETHC_C::ETHC_C() : ServiceFramework{"ethc:c"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "Initialize"},
+        {1, nullptr, "Cancel"},
+        {2, nullptr, "GetResult"},
+        {3, nullptr, "GetMediaList"},
+        {4, nullptr, "SetMediaType"},
+        {5, nullptr, "GetMediaType"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+ETHC_I::ETHC_I() : ServiceFramework{"ethc:i"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, nullptr, "GetReadableHandle"},
+        {1, nullptr, "Cancel"},
+        {2, nullptr, "GetResult"},
+        {3, nullptr, "GetInterfaceList"},
+        {4, nullptr, "GetInterfaceCount"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+} // namespace Service::Sockets

src/core/hle/service/sockets/ethc.h

@@ -0,0 +1,21 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+namespace Service::Sockets {
+
+class ETHC_C final : public ServiceFramework<ETHC_C> {
+public:
+    explicit ETHC_C();
+};
+
+class ETHC_I final : public ServiceFramework<ETHC_I> {
+public:
+    explicit ETHC_I();
+};
+
+} // namespace Service::Sockets

src/core/hle/service/sockets/sockets.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include "core/hle/service/sockets/bsd.h"
+#include "core/hle/service/sockets/ethc.h"
 #include "core/hle/service/sockets/nsd.h"
 #include "core/hle/service/sockets/sfdnsres.h"
 #include "core/hle/service/sockets/sockets.h"
@@ -12,8 +13,14 @@ namespace Service::Sockets {
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     std::make_shared<BSD>("bsd:s")->InstallAsService(service_manager);
     std::make_shared<BSD>("bsd:u")->InstallAsService(service_manager);
+    std::make_shared<BSDCFG>()->InstallAsService(service_manager);
+
+    std::make_shared<ETHC_C>()->InstallAsService(service_manager);
+    std::make_shared<ETHC_I>()->InstallAsService(service_manager);
+
     std::make_shared<NSD>("nsd:a")->InstallAsService(service_manager);
     std::make_shared<NSD>("nsd:u")->InstallAsService(service_manager);
+
     std::make_shared<SFDNSRES>()->InstallAsService(service_manager);
 }
 

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

@@ -2,17 +2,18 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "core/hle/service/time/time_s.h"
+#include "core/hle/service/time/interface.h"
 
 namespace Service::Time {
 
-TIME_S::TIME_S(std::shared_ptr<Module> time) : Module::Interface(std::move(time), "time:s") {
+Time::Time(std::shared_ptr<Module> time, const char* name)
+    : Module::Interface(std::move(time), name) {
     static const FunctionInfo functions[] = {
-        {0, &TIME_S::GetStandardUserSystemClock, "GetStandardUserSystemClock"},
-        {1, &TIME_S::GetStandardNetworkSystemClock, "GetStandardNetworkSystemClock"},
-        {2, &TIME_S::GetStandardSteadyClock, "GetStandardSteadyClock"},
-        {3, &TIME_S::GetTimeZoneService, "GetTimeZoneService"},
-        {4, &TIME_S::GetStandardLocalSystemClock, "GetStandardLocalSystemClock"},
+        {0, &Time::GetStandardUserSystemClock, "GetStandardUserSystemClock"},
+        {1, &Time::GetStandardNetworkSystemClock, "GetStandardNetworkSystemClock"},
+        {2, &Time::GetStandardSteadyClock, "GetStandardSteadyClock"},
+        {3, &Time::GetTimeZoneService, "GetTimeZoneService"},
+        {4, &Time::GetStandardLocalSystemClock, "GetStandardLocalSystemClock"},
         {5, nullptr, "GetEphemeralNetworkSystemClock"},
         {50, nullptr, "SetStandardSteadyClockInternalOffset"},
         {100, nullptr, "IsStandardUserSystemClockAutomaticCorrectionEnabled"},

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

@@ -8,9 +8,9 @@
 
 namespace Service::Time {
 
-class TIME_S final : public Module::Interface {
+class Time final : public Module::Interface {
 public:
-    explicit TIME_S(std::shared_ptr<Module> time);
+    explicit Time(std::shared_ptr<Module> time, const char* name);
 };
 
 } // namespace Service::Time

src/core/hle/service/time/time.cpp

@@ -6,12 +6,12 @@
 #include <ctime>
 #include "common/logging/log.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
+#include "core/hle/service/time/interface.h"
 #include "core/hle/service/time/time.h"
-#include "core/hle/service/time/time_s.h"
-#include "core/hle/service/time/time_u.h"
 
 namespace Service::Time {
 
@@ -212,8 +212,9 @@ Module::Interface::Interface(std::shared_ptr<Module> time, const char* name)
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto time = std::make_shared<Module>();
-    std::make_shared<TIME_S>(time)->InstallAsService(service_manager);
-    std::make_shared<TIME_U>(time)->InstallAsService(service_manager);
+    std::make_shared<Time>(time, "time:a")->InstallAsService(service_manager);
+    std::make_shared<Time>(time, "time:s")->InstallAsService(service_manager);
+    std::make_shared<Time>(time, "time:u")->InstallAsService(service_manager);
 }
 
 } // namespace Service::Time

src/core/hle/service/time/time_u.cpp

@@ -1,31 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/service/time/time_u.h"
-
-namespace Service::Time {
-
-TIME_U::TIME_U(std::shared_ptr<Module> time) : Module::Interface(std::move(time), "time:u") {
-    static const FunctionInfo functions[] = {
-        {0, &TIME_U::GetStandardUserSystemClock, "GetStandardUserSystemClock"},
-        {1, &TIME_U::GetStandardNetworkSystemClock, "GetStandardNetworkSystemClock"},
-        {2, &TIME_U::GetStandardSteadyClock, "GetStandardSteadyClock"},
-        {3, &TIME_U::GetTimeZoneService, "GetTimeZoneService"},
-        {4, &TIME_U::GetStandardLocalSystemClock, "GetStandardLocalSystemClock"},
-        {5, nullptr, "GetEphemeralNetworkSystemClock"},
-        {50, nullptr, "SetStandardSteadyClockInternalOffset"},
-        {100, nullptr, "IsStandardUserSystemClockAutomaticCorrectionEnabled"},
-        {101, nullptr, "SetStandardUserSystemClockAutomaticCorrectionEnabled"},
-        {102, nullptr, "GetStandardUserSystemClockInitialYear"},
-        {200, nullptr, "IsStandardNetworkSystemClockAccuracySufficient"},
-        {300, nullptr, "CalculateMonotonicSystemClockBaseTimePoint"},
-        {400, nullptr, "GetClockSnapshot"},
-        {401, nullptr, "GetClockSnapshotFromSystemClockContext"},
-        {500, nullptr, "CalculateStandardUserSystemClockDifferenceByUser"},
-        {501, nullptr, "CalculateSpanBetween"},
-    };
-    RegisterHandlers(functions);
-}
-
-} // namespace Service::Time

src/core/hle/service/time/time_u.h

@@ -1,16 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/time/time.h"
-
-namespace Service::Time {
-
-class TIME_U final : public Module::Interface {
-public:
-    explicit TIME_U(std::shared_ptr<Module> time);
-};
-
-} // namespace Service::Time

src/core/hle/service/vi/vi.cpp

@@ -5,6 +5,8 @@
 #include <algorithm>
 #include <array>
 #include <memory>
+#include <type_traits>
+#include <utility>
 #include <boost/optional.hpp>
 #include "common/alignment.h"
 #include "common/math_util.h"
@@ -43,7 +45,9 @@ public:
 
     template <typename T>
     T Read() {
+        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
         ASSERT(read_index + sizeof(T) <= buffer.size());
+
         T val;
         std::memcpy(&val, buffer.data() + read_index, sizeof(T));
         read_index += sizeof(T);
@@ -53,7 +57,9 @@ public:
 
     template <typename T>
     T ReadUnaligned() {
+        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
         ASSERT(read_index + sizeof(T) <= buffer.size());
+
         T val;
         std::memcpy(&val, buffer.data() + read_index, sizeof(T));
         read_index += sizeof(T);
@@ -87,8 +93,12 @@ public:
 
     template <typename T>
     void Write(const T& val) {
-        if (buffer.size() < write_index + sizeof(T))
+        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
+
+        if (buffer.size() < write_index + sizeof(T)) {
             buffer.resize(buffer.size() + sizeof(T) + DefaultBufferSize);
+        }
+
         std::memcpy(buffer.data() + write_index, &val, sizeof(T));
         write_index += sizeof(T);
         write_index = Common::AlignUp(write_index, 4);
@@ -96,7 +106,9 @@ public:
 
     template <typename T>
     void WriteObject(const T& val) {
-        u32_le size = static_cast<u32>(sizeof(val));
+        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
+
+        const u32_le size = static_cast<u32>(sizeof(val));
         Write(size);
         // TODO(Subv): Support file descriptors.
         Write<u32_le>(0); // Fd count.
@@ -176,7 +188,7 @@ private:
 
 class IGBPConnectRequestParcel : public Parcel {
 public:
-    explicit IGBPConnectRequestParcel(const std::vector<u8>& buffer) : Parcel(buffer) {
+    explicit IGBPConnectRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
         Deserialize();
     }
     ~IGBPConnectRequestParcel() override = default;
@@ -223,8 +235,8 @@ private:
 
 class IGBPSetPreallocatedBufferRequestParcel : public Parcel {
 public:
-    explicit IGBPSetPreallocatedBufferRequestParcel(const std::vector<u8>& buffer)
-        : Parcel(buffer) {
+    explicit IGBPSetPreallocatedBufferRequestParcel(std::vector<u8> buffer)
+        : Parcel(std::move(buffer)) {
         Deserialize();
     }
     ~IGBPSetPreallocatedBufferRequestParcel() override = default;
@@ -256,7 +268,7 @@ protected:
 
 class IGBPDequeueBufferRequestParcel : public Parcel {
 public:
-    explicit IGBPDequeueBufferRequestParcel(const std::vector<u8>& buffer) : Parcel(buffer) {
+    explicit IGBPDequeueBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
         Deserialize();
     }
     ~IGBPDequeueBufferRequestParcel() override = default;
@@ -307,7 +319,7 @@ protected:
 
 class IGBPRequestBufferRequestParcel : public Parcel {
 public:
-    explicit IGBPRequestBufferRequestParcel(const std::vector<u8>& buffer) : Parcel(buffer) {
+    explicit IGBPRequestBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
         Deserialize();
     }
     ~IGBPRequestBufferRequestParcel() override = default;
@@ -322,8 +334,7 @@ public:
 
 class IGBPRequestBufferResponseParcel : public Parcel {
 public:
-    explicit IGBPRequestBufferResponseParcel(NVFlinger::IGBPBuffer buffer)
-        : Parcel(), buffer(buffer) {}
+    explicit IGBPRequestBufferResponseParcel(NVFlinger::IGBPBuffer buffer) : buffer(buffer) {}
     ~IGBPRequestBufferResponseParcel() override = default;
 
 protected:
@@ -340,7 +351,7 @@ protected:
 
 class IGBPQueueBufferRequestParcel : public Parcel {
 public:
-    explicit IGBPQueueBufferRequestParcel(const std::vector<u8>& buffer) : Parcel(buffer) {
+    explicit IGBPQueueBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
         Deserialize();
     }
     ~IGBPQueueBufferRequestParcel() override = default;
@@ -409,7 +420,7 @@ private:
 
 class IGBPQueryRequestParcel : public Parcel {
 public:
-    explicit IGBPQueryRequestParcel(const std::vector<u8>& buffer) : Parcel(buffer) {
+    explicit IGBPQueryRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
         Deserialize();
     }
     ~IGBPQueryRequestParcel() override = default;

src/core/hle/shared_page.cpp

@@ -1,86 +0,0 @@
-// Copyright 2015 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <chrono>
-#include <cstring>
-#include <ctime>
-#include "core/core_timing.h"
-#include "core/hle/shared_page.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace SharedPage {
-
-SharedPageDef shared_page;
-
-static CoreTiming::EventType* update_time_event;
-
-/// Gets system time in 3DS format. The epoch is Jan 1900, and the unit is millisecond.
-static u64 GetSystemTime() {
-    auto now = std::chrono::system_clock::now();
-
-    // 3DS system does't allow user to set a time before Jan 1 2000,
-    // so we use it as an auxiliary epoch to calculate the console time.
-    std::tm epoch_tm;
-    epoch_tm.tm_sec = 0;
-    epoch_tm.tm_min = 0;
-    epoch_tm.tm_hour = 0;
-    epoch_tm.tm_mday = 1;
-    epoch_tm.tm_mon = 0;
-    epoch_tm.tm_year = 100;
-    epoch_tm.tm_isdst = 0;
-    auto epoch = std::chrono::system_clock::from_time_t(std::mktime(&epoch_tm));
-
-    // 3DS console time uses Jan 1 1900 as internal epoch,
-    // so we use the milliseconds between 1900 and 2000 as base console time
-    u64 console_time = 3155673600000ULL;
-
-    // Only when system time is after 2000, we set it as 3DS system time
-    if (now > epoch) {
-        console_time += std::chrono::duration_cast<std::chrono::milliseconds>(now - epoch).count();
-    }
-
-    // If the system time is in daylight saving, we give an additional hour to console time
-    std::time_t now_time_t = std::chrono::system_clock::to_time_t(now);
-    std::tm* now_tm = std::localtime(&now_time_t);
-    if (now_tm && now_tm->tm_isdst > 0)
-        console_time += 60 * 60 * 1000;
-
-    return console_time;
-}
-
-static void UpdateTimeCallback(u64 userdata, int cycles_late) {
-    DateTime& date_time =
-        shared_page.date_time_counter % 2 ? shared_page.date_time_0 : shared_page.date_time_1;
-
-    date_time.date_time = GetSystemTime();
-    date_time.update_tick = CoreTiming::GetTicks();
-    date_time.tick_to_second_coefficient = CoreTiming::BASE_CLOCK_RATE;
-    date_time.tick_offset = 0;
-
-    ++shared_page.date_time_counter;
-
-    // system time is updated hourly
-    CoreTiming::ScheduleEvent(CoreTiming::msToCycles(60 * 60 * 1000) - cycles_late,
-                              update_time_event);
-}
-
-void Init() {
-    std::memset(&shared_page, 0, sizeof(shared_page));
-
-    shared_page.running_hw = 0x1; // product
-
-    // Some games wait until this value becomes 0x1, before asking running_hw
-    shared_page.unknown_value = 0x1;
-
-    // Set to a completely full battery
-    shared_page.battery_state.is_adapter_connected.Assign(1);
-    shared_page.battery_state.is_charging.Assign(1);
-
-    update_time_event =
-        CoreTiming::RegisterEvent("SharedPage::UpdateTimeCallback", UpdateTimeCallback);
-    CoreTiming::ScheduleEvent(0, update_time_event);
-}
-
-} // namespace SharedPage

src/core/hle/shared_page.h

@@ -1,69 +0,0 @@
-// Copyright 2015 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-/**
- * The shared page stores various runtime configuration settings. This memory page is
- * read-only for user processes (there is a bit in the header that grants the process
- * write access, according to 3dbrew; this is not emulated)
- */
-
-#include "common/bit_field.h"
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "core/memory.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace SharedPage {
-
-// See http://3dbrew.org/wiki/Configuration_Memory#Shared_Memory_Page_For_ARM11_Processes
-
-struct DateTime {
-    u64_le date_time;                  // 0
-    u64_le update_tick;                // 8
-    u64_le tick_to_second_coefficient; // 10
-    u64_le tick_offset;                // 18
-};
-static_assert(sizeof(DateTime) == 0x20, "Datetime size is wrong");
-
-union BatteryState {
-    u8 raw;
-    BitField<0, 1, u8> is_adapter_connected;
-    BitField<1, 1, u8> is_charging;
-    BitField<2, 3, u8> charge_level;
-};
-
-struct SharedPageDef {
-    // Most of these names are taken from the 3dbrew page linked above.
-    u32_le date_time_counter; // 0
-    u8 running_hw;            // 4
-    /// "Microcontroller hardware info"
-    u8 mcu_hw_info;                      // 5
-    INSERT_PADDING_BYTES(0x20 - 0x6);    // 6
-    DateTime date_time_0;                // 20
-    DateTime date_time_1;                // 40
-    u8 wifi_macaddr[6];                  // 60
-    u8 wifi_link_level;                  // 66
-    u8 wifi_unknown2;                    // 67
-    INSERT_PADDING_BYTES(0x80 - 0x68);   // 68
-    float_le sliderstate_3d;             // 80
-    u8 ledstate_3d;                      // 84
-    BatteryState battery_state;          // 85
-    u8 unknown_value;                    // 86
-    INSERT_PADDING_BYTES(0xA0 - 0x87);   // 87
-    u64_le menu_title_id;                // A0
-    u64_le active_menu_title_id;         // A8
-    INSERT_PADDING_BYTES(0x1000 - 0xB0); // B0
-};
-static_assert(sizeof(SharedPageDef) == Memory::SHARED_PAGE_SIZE,
-              "Shared page structure size is wrong");
-
-extern SharedPageDef shared_page;
-
-void Init();
-
-} // namespace SharedPage

src/core/loader/deconstructed_rom_directory.cpp

@@ -6,7 +6,6 @@
 #include "common/common_funcs.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
-#include "common/string_util.h"
 #include "core/file_sys/content_archive.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
@@ -18,34 +17,6 @@
 
 namespace Loader {
 
-static std::string FindRomFS(const std::string& directory) {
-    std::string filepath_romfs;
-    const auto callback = [&filepath_romfs](u64*, const std::string& directory,
-                                            const std::string& virtual_name) -> bool {
-        const std::string physical_name = directory + virtual_name;
-        if (FileUtil::IsDirectory(physical_name)) {
-            // Skip directories
-            return true;
-        }
-
-        // Verify extension
-        const std::string extension = physical_name.substr(physical_name.find_last_of(".") + 1);
-        if (Common::ToLower(extension) != "romfs") {
-            return true;
-        }
-
-        // Found it - we are done
-        filepath_romfs = std::move(physical_name);
-        return false;
-    };
-
-    // Search the specified directory recursively, looking for the first .romfs file, which will
-    // be used for the RomFS
-    FileUtil::ForeachDirectoryEntry(nullptr, directory, callback);
-
-    return filepath_romfs;
-}
-
 AppLoader_DeconstructedRomDirectory::AppLoader_DeconstructedRomDirectory(FileSys::VirtualFile file)
     : AppLoader(std::move(file)) {}
 

src/core/loader/elf.cpp

@@ -190,7 +190,7 @@ private:
     u32 entryPoint;
 
 public:
-    ElfReader(void* ptr);
+    explicit ElfReader(void* ptr);
 
     u32 Read32(int off) const {
         return base32[off >> 2];

src/core/loader/linker.cpp

@@ -49,8 +49,7 @@ struct Elf64_Sym {
 static_assert(sizeof(Elf64_Sym) == 0x18, "Elf64_Sym has incorrect size.");
 
 void Linker::WriteRelocations(std::vector<u8>& program_image, const std::vector<Symbol>& symbols,
-                              u64 relocation_offset, u64 size, bool is_jump_relocation,
-                              VAddr load_base) {
+                              u64 relocation_offset, u64 size, VAddr load_base) {
     for (u64 i = 0; i < size; i += sizeof(Elf64_Rela)) {
         Elf64_Rela rela;
         std::memcpy(&rela, &program_image[relocation_offset + i], sizeof(Elf64_Rela));
@@ -124,12 +123,11 @@ void Linker::Relocate(std::vector<u8>& program_image, u32 dynamic_section_offset
     }
 
     if (dynamic.find(DT_RELA) != dynamic.end()) {
-        WriteRelocations(program_image, symbols, dynamic[DT_RELA], dynamic[DT_RELASZ], false,
-                         load_base);
+        WriteRelocations(program_image, symbols, dynamic[DT_RELA], dynamic[DT_RELASZ], load_base);
     }
 
     if (dynamic.find(DT_JMPREL) != dynamic.end()) {
-        WriteRelocations(program_image, symbols, dynamic[DT_JMPREL], dynamic[DT_PLTRELSZ], true,
+        WriteRelocations(program_image, symbols, dynamic[DT_JMPREL], dynamic[DT_PLTRELSZ],
                          load_base);
     }
 }

src/core/loader/linker.h

@@ -24,8 +24,7 @@ protected:
     };
 
     void WriteRelocations(std::vector<u8>& program_image, const std::vector<Symbol>& symbols,
-                          u64 relocation_offset, u64 size, bool is_jump_relocation,
-                          VAddr load_base);
+                          u64 relocation_offset, u64 size, VAddr load_base);
     void Relocate(std::vector<u8>& program_image, u32 dynamic_section_offset, VAddr load_base);
 
     void ResolveImports();

src/core/loader/loader.cpp

@@ -42,7 +42,7 @@ FileType IdentifyFile(FileSys::VirtualFile file) {
 }
 
 FileType IdentifyFile(const std::string& file_name) {
-    return IdentifyFile(FileSys::VirtualFile(std::make_shared<FileSys::RealVfsFile>(file_name)));
+    return IdentifyFile(std::make_shared<FileSys::RealVfsFile>(file_name));
 }
 
 FileType GuessFromFilename(const std::string& name) {

src/core/loader/loader.h

@@ -79,7 +79,7 @@ enum class ResultStatus {
 /// Interface for loading an application
 class AppLoader : NonCopyable {
 public:
-    AppLoader(FileSys::VirtualFile file) : file(std::move(file)) {}
+    explicit AppLoader(FileSys::VirtualFile file) : file(std::move(file)) {}
     virtual ~AppLoader() {}
 
     /**

src/core/loader/nro.cpp

@@ -6,10 +6,13 @@
 #include <vector>
 
 #include "common/common_funcs.h"
+#include "common/common_types.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/swap.h"
 #include "core/core.h"
+#include "core/file_sys/control_metadata.h"
+#include "core/file_sys/vfs_offset.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
@@ -49,7 +52,62 @@ struct ModHeader {
 };
 static_assert(sizeof(ModHeader) == 0x1c, "ModHeader has incorrect size.");
 
-AppLoader_NRO::AppLoader_NRO(FileSys::VirtualFile file) : AppLoader(std::move(file)) {}
+struct AssetSection {
+    u64_le offset;
+    u64_le size;
+};
+static_assert(sizeof(AssetSection) == 0x10, "AssetSection has incorrect size.");
+
+struct AssetHeader {
+    u32_le magic;
+    u32_le format_version;
+    AssetSection icon;
+    AssetSection nacp;
+    AssetSection romfs;
+};
+static_assert(sizeof(AssetHeader) == 0x38, "AssetHeader has incorrect size.");
+
+AppLoader_NRO::AppLoader_NRO(FileSys::VirtualFile file) : AppLoader(file) {
+    NroHeader nro_header{};
+    if (file->ReadObject(&nro_header) != sizeof(NroHeader)) {
+        return;
+    }
+
+    if (file->GetSize() >= nro_header.file_size + sizeof(AssetHeader)) {
+        const u64 offset = nro_header.file_size;
+        AssetHeader asset_header{};
+        if (file->ReadObject(&asset_header, offset) != sizeof(AssetHeader)) {
+            return;
+        }
+
+        if (asset_header.format_version != 0) {
+            LOG_WARNING(Loader,
+                        "NRO Asset Header has format {}, currently supported format is 0. If "
+                        "strange glitches occur with metadata, check NRO assets.",
+                        asset_header.format_version);
+        }
+
+        if (asset_header.magic != Common::MakeMagic('A', 'S', 'E', 'T')) {
+            return;
+        }
+
+        if (asset_header.nacp.size > 0) {
+            nacp = std::make_unique<FileSys::NACP>(std::make_shared<FileSys::OffsetVfsFile>(
+                file, asset_header.nacp.size, offset + asset_header.nacp.offset, "Control.nacp"));
+        }
+
+        if (asset_header.romfs.size > 0) {
+            romfs = std::make_shared<FileSys::OffsetVfsFile>(
+                file, asset_header.romfs.size, offset + asset_header.romfs.offset, "game.romfs");
+        }
+
+        if (asset_header.icon.size > 0) {
+            icon_data = file->ReadBytes(asset_header.icon.size, offset + asset_header.icon.offset);
+        }
+    }
+}
+
+AppLoader_NRO::~AppLoader_NRO() = default;
 
 FileType AppLoader_NRO::IdentifyType(const FileSys::VirtualFile& file) {
     // Read NSO header
@@ -80,8 +138,9 @@ bool AppLoader_NRO::LoadNro(FileSys::VirtualFile file, VAddr load_base) {
     // Build program image
     Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("");
     std::vector<u8> program_image = file->ReadBytes(PageAlignSize(nro_header.file_size));
-    if (program_image.size() != PageAlignSize(nro_header.file_size))
+    if (program_image.size() != PageAlignSize(nro_header.file_size)) {
         return {};
+    }
 
     for (std::size_t i = 0; i < nro_header.segments.size(); ++i) {
         codeset->segments[i].addr = nro_header.segments[i].offset;
@@ -136,4 +195,39 @@ ResultStatus AppLoader_NRO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     return ResultStatus::Success;
 }
 
+ResultStatus AppLoader_NRO::ReadIcon(std::vector<u8>& buffer) {
+    if (icon_data.empty()) {
+        return ResultStatus::ErrorNotUsed;
+    }
+
+    buffer = icon_data;
+    return ResultStatus::Success;
+}
+
+ResultStatus AppLoader_NRO::ReadProgramId(u64& out_program_id) {
+    if (nacp == nullptr) {
+        return ResultStatus::ErrorNotUsed;
+    }
+
+    out_program_id = nacp->GetTitleId();
+    return ResultStatus::Success;
+}
+
+ResultStatus AppLoader_NRO::ReadRomFS(FileSys::VirtualFile& dir) {
+    if (romfs == nullptr) {
+        return ResultStatus::ErrorNotUsed;
+    }
+
+    dir = romfs;
+    return ResultStatus::Success;
+}
+
+ResultStatus AppLoader_NRO::ReadTitle(std::string& title) {
+    if (nacp == nullptr) {
+        return ResultStatus::ErrorNotUsed;
+    }
+
+    title = nacp->GetApplicationName();
+    return ResultStatus::Success;
+}
 } // namespace Loader