14 files changed, 255 insertions, 67 deletions

diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index f71232c1a..3381524e3 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -20,6 +20,7 @@ set(SRCS
             file_sys/archive_romfs.cpp
             file_sys/archive_savedata.cpp
             file_sys/archive_sdmc.cpp
+            file_sys/archive_systemsavedata.cpp
             file_sys/disk_archive.cpp
             file_sys/file_romfs.cpp
             file_sys/directory_romfs.cpp
@@ -101,6 +102,7 @@ set(HEADERS
             file_sys/archive_romfs.h
             file_sys/archive_savedata.h
             file_sys/archive_sdmc.h
+            file_sys/archive_systemsavedata.h
             file_sys/disk_archive.h
             file_sys/file_backend.h
             file_sys/file_romfs.h
diff --git a/src/core/arm/interpreter/armemu.cpp b/src/core/arm/interpreter/armemu.cpp
index 399ee0886..7408b6f08 100644
--- a/src/core/arm/interpreter/armemu.cpp
+++ b/src/core/arm/interpreter/armemu.cpp
@@ -5681,11 +5681,8 @@ L_stm_s_takeabort:
     /* Attempt to emulate an ARMv6 instruction.
        Returns non-zero upon success.  */
 
-    static int
-    handle_v6_insn (ARMul_State * state, ARMword instr) {
-                ARMword lhs, temp;
-
-        switch (BITS (20, 27)) {
+    static int handle_v6_insn(ARMul_State* state, ARMword instr) {
+        switch (BITS(20, 27)) {
         case 0x03:
             printf ("Unhandled v6 insn: ldr\n");
             break;
@@ -5719,7 +5716,7 @@ L_stm_s_takeabort:
                                 /* strex */
                                 u32 l = LHSReg;
                                 u32 r = RHSReg;
-                                lhs = LHS;
+                                u32 lhs = LHS;
 
                                 bool enter = false;
 
@@ -5744,7 +5741,7 @@ L_stm_s_takeabort:
         case 0x19:
                         /* ldrex */
                         if (BITS(4, 7) == 0x9) {
-                                lhs = LHS;
+                                u32 lhs = LHS;
 
                                 state->currentexaddr = lhs;
                                 state->currentexval = ARMul_ReadWord(state, lhs);
@@ -5763,7 +5760,7 @@ L_stm_s_takeabort:
         case 0x1c:
                         if (BITS(4, 7) == 0x9) {
                                 /* strexb */
-                                lhs = LHS;
+                                u32 lhs = LHS;
 
                                 bool enter = false;
 
@@ -5793,11 +5790,11 @@ L_stm_s_takeabort:
         case 0x1d:
                         if ((BITS(4, 7)) == 0x9) {
                                 /* ldrexb */
-                                temp = LHS;
-                                LoadByte(state, instr, temp, LUNSIGNED);
+                                u32 lhs = LHS;
+                                LoadByte(state, instr, lhs, LUNSIGNED);
 
-                                state->currentexaddr = temp;
-                                state->currentexval = (u32)ARMul_ReadByte(state, temp);
+                                state->currentexaddr = lhs;
+                                state->currentexval = (u32)ARMul_ReadByte(state, lhs);
 
                                 //state->Reg[BITS(12, 15)] = ARMul_LoadByte(state, state->Reg[BITS(16, 19)]);
                                 //printf("ldrexb\n");
@@ -5839,29 +5836,56 @@ L_stm_s_takeabort:
                 const s16 rm_lo = (state->Reg[rm_idx] & 0xFFFF);
                 const s16 rm_hi = ((state->Reg[rm_idx] >> 16) & 0xFFFF);
 
+                s32 lo_result;
+                s32 hi_result;
+
                 // SSUB16
                 if ((instr & 0xFF0) == 0xf70) {
-                    state->Reg[rd_idx] = ((rn_lo - rm_lo) & 0xFFFF) | (((rn_hi - rm_hi) & 0xFFFF) << 16);
+                    lo_result = (rn_lo - rm_lo);
+                    hi_result = (rn_hi - rm_hi);
                 }
                 // SADD16
                 else if ((instr & 0xFF0) == 0xf10) {
-                    state->Reg[rd_idx] = ((rn_lo + rm_lo) & 0xFFFF) | (((rn_hi + rm_hi) & 0xFFFF) << 16);
+                    lo_result = (rn_lo + rm_lo);
+                    hi_result = (rn_hi + rm_hi);
                 }
                 // SSAX
                 else if ((instr & 0xFF0) == 0xf50) {
-                    state->Reg[rd_idx] = ((rn_lo + rm_hi) & 0xFFFF) | (((rn_hi - rm_lo) & 0xFFFF) << 16);
+                    lo_result = (rn_lo + rm_hi);
+                    hi_result = (rn_hi - rm_lo);
                 }
                 // SASX
                 else {
-                    state->Reg[rd_idx] = ((rn_lo - rm_hi) & 0xFFFF) | (((rn_hi + rm_lo) & 0xFFFF) << 16);
+                    lo_result = (rn_lo - rm_hi);
+                    hi_result = (rn_hi + rm_lo);
+                }
+
+                state->Reg[rd_idx] = (lo_result & 0xFFFF) | ((hi_result & 0xFFFF) << 16);
+
+                if (lo_result >= 0) {
+                    state->Cpsr |= (1 << 16);
+                    state->Cpsr |= (1 << 17);
+                } else {
+                    state->Cpsr &= ~(1 << 16);
+                    state->Cpsr &= ~(1 << 17);
+                }
+
+                if (hi_result >= 0) {
+                    state->Cpsr |= (1 << 18);
+                    state->Cpsr |= (1 << 19);
+                } else {
+                    state->Cpsr &= ~(1 << 18);
+                    state->Cpsr &= ~(1 << 19);
                 }
                 return 1;
             } else {
                 printf("Unhandled v6 insn: %08x", BITS(20, 27));
             }
             break;
-        case 0x62: // QSUB16 and QADD16
-            if ((instr & 0xFF0) == 0xf70 || (instr & 0xFF0) == 0xf10) {
+        case 0x62: // QADD16, QASX, QSAX, and QSUB16
+            if ((instr & 0xFF0) == 0xf10 || (instr & 0xFF0) == 0xf30 ||
+                (instr & 0xFF0) == 0xf50 || (instr & 0xFF0) == 0xf70)
+            {
                 const u8 rd_idx = BITS(12, 15);
                 const u8 rn_idx = BITS(16, 19);
                 const u8 rm_idx = BITS(0, 3);
@@ -5873,15 +5897,26 @@ L_stm_s_takeabort:
                 s32 lo_result;
                 s32 hi_result;
 
+                // QADD16
+                if ((instr & 0xFF0) == 0xf10) {
+                    lo_result = (rn_lo + rm_lo);
+                    hi_result = (rn_hi + rm_hi);
+                }
+                // QASX
+                else if ((instr & 0xFF0) == 0xf30) {
+                    lo_result = (rn_lo - rm_hi);
+                    hi_result = (rn_hi + rm_lo);
+                }
+                // QSAX
+                else if ((instr & 0xFF0) == 0xf50) {
+                    lo_result = (rn_lo + rm_hi);
+                    hi_result = (rn_hi - rm_lo);
+                }
                 // QSUB16
-                if ((instr & 0xFF0) == 0xf70) {
+                else {
                     lo_result = (rn_lo - rm_lo);
                     hi_result = (rn_hi - rm_hi);
                 }
-                else { // QADD16
-                    lo_result = (rn_lo + rm_lo);
-                    hi_result = (rn_hi + rm_hi);
-                }
 
                 if (lo_result > 0x7FFF)
                     lo_result = 0x7FFF;
@@ -6084,7 +6119,7 @@ L_stm_s_takeabort:
                                 break;
                         }
 
-                        Rm = ((state->Reg[BITS(0, 3)] >> ror) & 0xFF) | ((state->Reg[BITS(0, 3)] << (32 - ror)) & 0xFF) & 0xFF;
+                        Rm = ((state->Reg[BITS(0, 3)] >> ror) & 0xFF) | (((state->Reg[BITS(0, 3)] << (32 - ror)) & 0xFF) & 0xFF);
                         if (Rm & 0x80)
                                 Rm |= 0xffffff00;
 
@@ -6129,7 +6164,7 @@ L_stm_s_takeabort:
                         if (ror == -1)
                                 break;
 
-                        Rm = ((state->Reg[BITS(0, 3)] >> ror) & 0xFFFF) | ((state->Reg[BITS(0, 3)] << (32 - ror)) & 0xFFFF) & 0xFFFF;
+                        Rm = ((state->Reg[BITS(0, 3)] >> ror) & 0xFFFF) | (((state->Reg[BITS(0, 3)] << (32 - ror)) & 0xFFFF) & 0xFFFF);
                         if (Rm & 0x8000)
                                 Rm |= 0xffff0000;
 
@@ -6192,18 +6227,27 @@ L_stm_s_takeabort:
                                         //ichfly
                                         //USAT16
                                 {
-                                        u8 tar = BITS(12, 15);
-                                        u8 src = BITS(0, 3);
-                                        u8 val = BITS(16, 19);
-                                        s16 a1 = (state->Reg[src]);
-                                        s16 a2 = (state->Reg[src] >> 0x10);
-                                        s16 max = 0xFFFF >> (16 - val);
-                                        if (max < a1) a1 = max;
-                                        if (max < a2) a2 = max;
-                                        u32 temp2 = ((u32)(a2)) << 0x10;
-                                        state->Reg[tar] = (a1 & 0xFFFF) | (temp2);
+                                        const u8 rd_idx = BITS(12, 15);
+                                        const u8 rn_idx = BITS(0, 3);
+                                        const u8 num_bits = BITS(16, 19);
+                                        const s16 max = 0xFFFF >> (16 - num_bits);
+                                        s16 rn_lo = (state->Reg[rn_idx]);
+                                        s16 rn_hi = (state->Reg[rn_idx] >> 16);
+                                        
+                                        if (max < rn_lo)
+                                                rn_lo = max;
+                                        else if (rn_lo < 0)
+                                                rn_lo = 0;
+
+                                        if (max < rn_hi)
+                                                rn_hi = max;
+                                        else if (rn_hi < 0)
+                                                rn_hi = 0;
+                                        
+                                        state->Reg[rd_idx] = (rn_lo & 0xFFFF) | ((rn_hi << 16) & 0xFFFF);
+                                        return 1;
                                 }
-                                return 1;
+
                                 default:
                                         break;
                         }
@@ -6216,7 +6260,7 @@ L_stm_s_takeabort:
                                 break;
                         }
 
-                        Rm = ((state->Reg[BITS(0, 3)] >> ror) & 0xFF) | ((state->Reg[BITS(0, 3)] << (32 - ror)) & 0xFF) & 0xFF;
+                        Rm = ((state->Reg[BITS(0, 3)] >> ror) & 0xFF) | (((state->Reg[BITS(0, 3)] << (32 - ror)) & 0xFF) & 0xFF);
 
                         if (BITS(16, 19) == 0xf)
                                 /* UXTB */
@@ -6260,7 +6304,7 @@ L_stm_s_takeabort:
                         if (ror == -1)
                                 break;
 
-                        Rm = ((state->Reg[BITS(0, 3)] >> ror) & 0xFFFF) | ((state->Reg[BITS(0, 3)] << (32 - ror)) & 0xFFFF) & 0xFFFF;
+                        Rm = ((state->Reg[BITS(0, 3)] >> ror) & 0xFFFF) | (((state->Reg[BITS(0, 3)] << (32 - ror)) & 0xFFFF) & 0xFFFF);
 
                         /* UXT */
                         /* state->Reg[BITS (12, 15)] = Rm; */
@@ -6283,11 +6327,14 @@ L_stm_s_takeabort:
                 }
         case 0x70:
             // ichfly
-            // SMUAD, SMUSD, SMLAD
-            if ((instr & 0xf0d0) == 0xf010 || (instr & 0xf0d0) == 0xf050 || (instr & 0xd0) == 0x10) {
+            // SMUAD, SMUSD, SMLAD, and SMLSD
+            if ((instr & 0xf0d0) == 0xf010 || (instr & 0xf0d0) == 0xf050 ||
+                (instr & 0xd0) == 0x10     || (instr & 0xd0) == 0x50)
+            {
                 const u8 rd_idx = BITS(16, 19);
                 const u8 rn_idx = BITS(0, 3);
                 const u8 rm_idx = BITS(8, 11);
+                const u8 ra_idx = BITS(12, 15);
                 const bool do_swap = (BIT(5) == 1);
 
                 u32 rm_val = state->Reg[rm_idx];
@@ -6310,13 +6357,14 @@ L_stm_s_takeabort:
                     state->Reg[rd_idx] = (rn_lo * rm_lo) - (rn_hi * rm_hi);
                 }
                 // SMLAD
-                else {
-                    const u8 ra_idx = BITS(12, 15);
+                else if ((instr & 0xd0) == 0x10) {
                     state->Reg[rd_idx] = (rn_lo * rm_lo) + (rn_hi * rm_hi) + (s32)state->Reg[ra_idx];
                 }
+                // SMLSD
+                else {
+                    state->Reg[rd_idx] = ((rn_lo * rm_lo) - (rn_hi * rm_hi)) + (s32)state->Reg[ra_idx];
+                }
                 return 1;
-            } else {
-                printf ("Unhandled v6 insn: smlsd\n");
             }
             break;
         case 0x74:
diff --git a/src/core/file_sys/archive_backend.h b/src/core/file_sys/archive_backend.h
index 18c314884..d7959b2ca 100644
--- a/src/core/file_sys/archive_backend.h
+++ b/src/core/file_sys/archive_backend.h
@@ -143,7 +143,16 @@ public:
             case Char:
                 return std::vector<u8>(string.begin(), string.end());
             case Wchar:
-                return std::vector<u8>(u16str.begin(), u16str.end());
+            {
+                // use two u8 for each character of u16str
+                std::vector<u8> to_return(u16str.size() * 2);
+                for (size_t i = 0; i < u16str.size(); ++i) {
+                    u16 tmp_char = u16str.at(i);
+                    to_return[i*2] = (tmp_char & 0xFF00) >> 8;
+                    to_return[i*2 + 1] = (tmp_char & 0x00FF);
+                }
+                return to_return;
+            }
             case Empty:
                 return {};
             default:
diff --git a/src/core/file_sys/archive_romfs.cpp b/src/core/file_sys/archive_romfs.cpp
index 0709b62a1..1e3e9dc60 100644
--- a/src/core/file_sys/archive_romfs.cpp
+++ b/src/core/file_sys/archive_romfs.cpp
@@ -5,6 +5,7 @@
 #include <memory>
 
 #include "common/common_types.h"
+#include "common/make_unique.h"
 
 #include "core/file_sys/archive_romfs.h"
 #include "core/file_sys/directory_romfs.h"
@@ -29,7 +30,7 @@ Archive_RomFS::Archive_RomFS(const Loader::AppLoader& app_loader) {
  * @return Opened file, or nullptr
  */
 std::unique_ptr<FileBackend> Archive_RomFS::OpenFile(const Path& path, const Mode mode) const {
-    return std::make_unique<File_RomFS>(this);
+    return Common::make_unique<File_RomFS>(this);
 }
 
 /**
@@ -78,7 +79,7 @@ bool Archive_RomFS::RenameDirectory(const FileSys::Path& src_path, const FileSys
  * @return Opened directory, or nullptr
  */
 std::unique_ptr<DirectoryBackend> Archive_RomFS::OpenDirectory(const Path& path) const {
-    return std::make_unique<Directory_RomFS>();
+    return Common::make_unique<Directory_RomFS>();
 }
 
 } // namespace FileSys
diff --git a/src/core/file_sys/archive_savedata.h b/src/core/file_sys/archive_savedata.h
index b3e561130..d394ad37e 100644
--- a/src/core/file_sys/archive_savedata.h
+++ b/src/core/file_sys/archive_savedata.h
@@ -21,8 +21,7 @@ public:
 
     /**
      * Initialize the archive.
-     * @return CreateSaveDataResult AlreadyExists if the SaveData folder already exists,
-     * Success if it was created properly and Failure if there was any error
+     * @return true if it initialized successfully
      */
     bool Initialize();
 
diff --git a/src/core/file_sys/archive_systemsavedata.cpp b/src/core/file_sys/archive_systemsavedata.cpp
new file mode 100644
index 000000000..dc2c23b41
--- /dev/null
+++ b/src/core/file_sys/archive_systemsavedata.cpp
@@ -0,0 +1,33 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <sys/stat.h>
+
+#include "common/common_types.h"
+#include "common/file_util.h"
+
+#include "core/file_sys/archive_systemsavedata.h"
+#include "core/file_sys/disk_archive.h"
+#include "core/settings.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// FileSys namespace
+
+namespace FileSys {
+
+Archive_SystemSaveData::Archive_SystemSaveData(const std::string& mount_point)
+        : DiskArchive(mount_point) {
+    LOG_INFO(Service_FS, "Directory %s set as SystemSaveData.", this->mount_point.c_str());
+}
+
+bool Archive_SystemSaveData::Initialize() {
+    if (!FileUtil::CreateFullPath(mount_point)) {
+        LOG_ERROR(Service_FS, "Unable to create SystemSaveData path.");
+        return false;
+    }
+
+    return true;
+}
+
+} // namespace FileSys
diff --git a/src/core/file_sys/archive_systemsavedata.h b/src/core/file_sys/archive_systemsavedata.h
new file mode 100644
index 000000000..360ed1e13
--- /dev/null
+++ b/src/core/file_sys/archive_systemsavedata.h
@@ -0,0 +1,33 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+#include "core/file_sys/disk_archive.h"
+#include "core/loader/loader.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// FileSys namespace
+
+namespace FileSys {
+
+/// File system interface to the SystemSaveData archive
+/// TODO(Subv): This archive should point to a location in the NAND, 
+/// specifically nand:/data/<ID0>/sysdata/<SaveID-Low>/<SaveID-High>
+class Archive_SystemSaveData final : public DiskArchive {
+public:
+    Archive_SystemSaveData(const std::string& mount_point);
+
+    /**
+     * Initialize the archive.
+     * @return true if it initialized successfully
+     */
+    bool Initialize();
+
+    std::string GetName() const override { return "SystemSaveData"; }
+};
+
+} // namespace FileSys
diff --git a/src/core/hle/kernel/semaphore.cpp b/src/core/hle/kernel/semaphore.cpp
index 6f56da8a9..f955d1957 100644
--- a/src/core/hle/kernel/semaphore.cpp
+++ b/src/core/hle/kernel/semaphore.cpp
@@ -20,8 +20,8 @@ public:
     static Kernel::HandleType GetStaticHandleType() { return Kernel::HandleType::Semaphore; }
     Kernel::HandleType GetHandleType() const override { return Kernel::HandleType::Semaphore; }
 
-    u32 max_count;                              ///< Maximum number of simultaneous holders the semaphore can have
-    u32 available_count;                        ///< Number of free slots left in the semaphore
+    s32 max_count;                              ///< Maximum number of simultaneous holders the semaphore can have
+    s32 available_count;                        ///< Number of free slots left in the semaphore
     std::queue<Handle> waiting_threads;         ///< Threads that are waiting for the semaphore
     std::string name;                           ///< Name of semaphore (optional)
 
@@ -49,8 +49,8 @@ public:
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ResultCode CreateSemaphore(Handle* handle, u32 initial_count, 
-    u32 max_count, const std::string& name) {
+ResultCode CreateSemaphore(Handle* handle, s32 initial_count, 
+    s32 max_count, const std::string& name) {
 
     if (initial_count > max_count)
         return ResultCode(ErrorDescription::InvalidCombination, ErrorModule::Kernel,
diff --git a/src/core/hle/kernel/semaphore.h b/src/core/hle/kernel/semaphore.h
index f0075fdb8..ad474b875 100644
--- a/src/core/hle/kernel/semaphore.h
+++ b/src/core/hle/kernel/semaphore.h
@@ -18,7 +18,7 @@ namespace Kernel {
  * @param name Optional name of semaphore
  * @return ResultCode of the error
  */
-ResultCode CreateSemaphore(Handle* handle, u32 initial_count, u32 max_count, const std::string& name = "Unknown");
+ResultCode CreateSemaphore(Handle* handle, s32 initial_count, s32 max_count, const std::string& name = "Unknown");
 
 /**
  * Releases a certain number of slots from a semaphore.
diff --git a/src/core/hle/service/fs/archive.cpp b/src/core/hle/service/fs/archive.cpp
index 9c3834733..510d7320c 100644
--- a/src/core/hle/service/fs/archive.cpp
+++ b/src/core/hle/service/fs/archive.cpp
@@ -7,6 +7,7 @@
 
 #include "common/common_types.h"
 #include "common/file_util.h"
+#include "common/make_unique.h"
 #include "common/math_util.h"
 
 #include "core/file_sys/archive_savedata.h"
@@ -260,7 +261,7 @@ ResultCode CloseArchive(ArchiveHandle handle) {
 // TODO(yuriks): This might be what the fs:REG service is for. See the Register/Unregister calls in
 // http://3dbrew.org/wiki/Filesystem_services#ProgramRegistry_service_.22fs:REG.22
 ResultCode CreateArchive(std::unique_ptr<FileSys::ArchiveBackend>&& backend, ArchiveIdCode id_code) {
-    auto result = id_code_map.emplace(id_code, std::make_unique<Archive>(std::move(backend), id_code));
+    auto result = id_code_map.emplace(id_code, Common::make_unique<Archive>(std::move(backend), id_code));
 
     bool inserted = result.second;
     _dbg_assert_msg_(Service_FS, inserted, "Tried to register more than one archive with same id code");
@@ -281,7 +282,7 @@ ResultVal<Handle> OpenFileFromArchive(ArchiveHandle archive_handle, const FileSy
                           ErrorSummary::NotFound, ErrorLevel::Status);
     }
 
-    auto file = std::make_unique<File>(std::move(backend), path);
+    auto file = Common::make_unique<File>(std::move(backend), path);
     Handle handle = Kernel::g_object_pool.Create(file.release());
     return MakeResult<Handle>(handle);
 }
@@ -378,7 +379,7 @@ ResultVal<Handle> OpenDirectoryFromArchive(ArchiveHandle archive_handle, const F
                           ErrorSummary::NotFound, ErrorLevel::Permanent);
     }
 
-    auto directory = std::make_unique<Directory>(std::move(backend), path);
+    auto directory = Common::make_unique<Directory>(std::move(backend), path);
     Handle handle = Kernel::g_object_pool.Create(directory.release());
     return MakeResult<Handle>(handle);
 }
@@ -392,7 +393,7 @@ ResultCode FormatSaveData() {
 
     // Create the SaveData archive
     std::string savedata_directory = FileUtil::GetUserPath(D_SAVEDATA_IDX);
-    auto savedata_archive = std::make_unique<FileSys::Archive_SaveData>(savedata_directory,
+    auto savedata_archive = Common::make_unique<FileSys::Archive_SaveData>(savedata_directory,
         Kernel::g_program_id);
 
     if (savedata_archive->Initialize()) {
@@ -414,11 +415,20 @@ void ArchiveInit() {
     // archive type is SDMC, so it is the only one getting exposed.
 
     std::string sdmc_directory = FileUtil::GetUserPath(D_SDMC_IDX);
-    auto sdmc_archive = std::make_unique<FileSys::Archive_SDMC>(sdmc_directory);
+    auto sdmc_archive = Common::make_unique<FileSys::Archive_SDMC>(sdmc_directory);
     if (sdmc_archive->Initialize())
         CreateArchive(std::move(sdmc_archive), ArchiveIdCode::SDMC);
     else
         LOG_ERROR(Service_FS, "Can't instantiate SDMC archive with path %s", sdmc_directory.c_str());
+
+    std::string systemsavedata_directory = FileUtil::GetUserPath(D_SYSSAVEDATA_IDX);
+    auto systemsavedata_archive = Common::make_unique<FileSys::Archive_SDMC>(systemsavedata_directory);
+    if (systemsavedata_archive->Initialize()) {
+        CreateArchive(std::move(systemsavedata_archive), ArchiveIdCode::SystemSaveData);
+    } else {
+        LOG_ERROR(Service_FS, "Can't instantiate SystemSaveData archive with path %s",
+            systemsavedata_directory.c_str());
+    }
 }
 
 /// Shutdown archives
diff --git a/src/core/hle/service/fs/fs_user.cpp b/src/core/hle/service/fs/fs_user.cpp
index f99d84b2f..8b908d691 100644
--- a/src/core/hle/service/fs/fs_user.cpp
+++ b/src/core/hle/service/fs/fs_user.cpp
@@ -397,16 +397,44 @@ static void IsSdmcDetected(Service::Interface* self) {
 }
 
 /**
- * FS_User::FormatSaveData service function
+ * FS_User::FormatSaveData service function, 
+ * formats the SaveData specified by the input path.
  *  Inputs:
+ *      0  : 0x084C0242
+ *      1  : Archive ID
+ *      2  : Archive low path type
+ *      3  : Archive low path size
+ *      10 : (LowPathSize << 14) | 2
+ *      11 : Archive low path
  *  Outputs:
  *      1 : Result of function, 0 on success, otherwise error code
  */
 static void FormatSaveData(Service::Interface* self) {
+    // TODO(Subv): Find out what the other inputs and outputs of this function are
     u32* cmd_buff = Kernel::GetCommandBuffer();
     LOG_DEBUG(Service_FS, "(STUBBED)");
 
-    // TODO(Subv): Find out what the inputs and outputs of this function are
+    auto archive_id = static_cast<FS::ArchiveIdCode>(cmd_buff[1]);
+    auto archivename_type = static_cast<FileSys::LowPathType>(cmd_buff[2]);
+    u32 archivename_size = cmd_buff[3];
+    u32 archivename_ptr = cmd_buff[11];
+    FileSys::Path archive_path(archivename_type, archivename_size, archivename_ptr);
+
+    LOG_DEBUG(Service_FS, "archive_path=%s", archive_path.DebugStr().c_str());
+
+    if (archive_id != FS::ArchiveIdCode::SaveData) {
+        // TODO(Subv): What should happen if somebody attempts to format a different archive?
+        LOG_ERROR(Service_FS, "tried to format an archive different than SaveData, %u", cmd_buff[1]);
+        cmd_buff[1] = UnimplementedFunction(ErrorModule::FS).raw;
+        return;
+    }
+
+    if (archive_path.GetType() != FileSys::LowPathType::Empty) {
+        // TODO(Subv): Implement formatting the SaveData of other games
+        LOG_ERROR(Service_FS, "archive LowPath type other than empty is currently unsupported");
+        cmd_buff[1] = UnimplementedFunction(ErrorModule::FS).raw;
+        return;
+    }
 
     cmd_buff[1] = FormatSaveData().raw;
 }
@@ -414,6 +442,7 @@ static void FormatSaveData(Service::Interface* self) {
 /**
  * FS_User::FormatThisUserSaveData service function
  *  Inputs:
+ *      0: 0x080F0180
  *  Outputs:
  *      1 : Result of function, 0 on success, otherwise error code
  */
diff --git a/src/core/hle/service/gsp_gpu.cpp b/src/core/hle/service/gsp_gpu.cpp
index db8027142..8c9ad2712 100644
--- a/src/core/hle/service/gsp_gpu.cpp
+++ b/src/core/hle/service/gsp_gpu.cpp
@@ -145,6 +145,30 @@ static void SetBufferSwap(Service::Interface* self) {
 }
 
 /**
+ * GSP_GPU::FlushDataCache service function
+ *
+ * This Function is a no-op, We aren't emulating the CPU cache any time soon.
+ *
+ *  Inputs:
+ *      1 : Address
+ *      2 : Size
+ *      3 : Value 0, some descriptor for the KProcess Handle
+ *      4 : KProcess handle
+ *  Outputs:
+ *      1 : Result of function, 0 on success, otherwise error code
+ */
+static void FlushDataCache(Service::Interface* self) {
+    u32* cmd_buff = Kernel::GetCommandBuffer();
+    u32 address = cmd_buff[1];
+    u32 size    = cmd_buff[2];
+    u32 process = cmd_buff[4];
+
+    // TODO(purpasmart96): Verify return header on HW
+
+    cmd_buff[1] = RESULT_SUCCESS.raw; // No error
+}
+
+/**
  * GSP_GPU::RegisterInterruptRelayQueue service function
  *  Inputs:
  *      1 : "Flags" field, purpose is unknown
@@ -335,7 +359,7 @@ const Interface::FunctionInfo FunctionTable[] = {
     {0x00050200, SetBufferSwap,                 "SetBufferSwap"},
     {0x00060082, nullptr,                       "SetCommandList"},
     {0x000700C2, nullptr,                       "RequestDma"},
-    {0x00080082, nullptr,                       "FlushDataCache"},
+    {0x00080082, FlushDataCache,                "FlushDataCache"},
     {0x00090082, nullptr,                       "InvalidateDataCache"},
     {0x000A0044, nullptr,                       "RegisterInterruptEvents"},
     {0x000B0040, nullptr,                       "SetLcdForceBlack"},
diff --git a/src/core/loader/3dsx.cpp b/src/core/loader/3dsx.cpp
index 0437e5374..3d84fc5da 100644
--- a/src/core/loader/3dsx.cpp
+++ b/src/core/loader/3dsx.cpp
@@ -223,9 +223,7 @@ int THREEDSXReader::Load3DSXFile(const std::string& filename, u32 base_addr)
         LOG_INFO(Loader, "Loading 3DSX file %s...", filename.c_str());
         FileUtil::IOFile file(filename, "rb");
         if (file.IsOpen()) {
-
-            THREEDSXReader reader;
-            reader.Load3DSXFile(filename, 0x00100000);
+            THREEDSXReader::Load3DSXFile(filename, 0x00100000);
             Kernel::LoadExec(0x00100000);
         } else {
             return ResultStatus::Error;
diff --git a/src/core/loader/loader.cpp b/src/core/loader/loader.cpp
index 480274d23..b3b58da72 100644
--- a/src/core/loader/loader.cpp
+++ b/src/core/loader/loader.cpp
@@ -2,7 +2,9 @@
 // Licensed under GPLv2
 // Refer to the license.txt file included.
 
-#include <memory>
+#include <string>
+
+#include "common/make_unique.h"
 
 #include "core/file_sys/archive_romfs.h"
 #include "core/loader/3dsx.h"
@@ -75,7 +77,7 @@ ResultStatus LoadFile(const std::string& filename) {
         // Load application and RomFS
         if (ResultStatus::Success == app_loader.Load()) {
             Kernel::g_program_id = app_loader.GetProgramId();
-            Service::FS::CreateArchive(std::make_unique<FileSys::Archive_RomFS>(app_loader), Service::FS::ArchiveIdCode::RomFS);
+            Service::FS::CreateArchive(Common::make_unique<FileSys::Archive_RomFS>(app_loader), Service::FS::ArchiveIdCode::RomFS);
             return ResultStatus::Success;
         }
         break;