Merge b196a263fa into 46fc7d8502

merge

.appveyor/UtilityFunctions.ps1

@@ -1,39 +0,0 @@
-# Set-up Visual Studio Command Prompt environment for PowerShell
-pushd "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\Tools\"
-cmd /c "VsDevCmd.bat -arch=x64 & set" | foreach {
-    if ($_ -match "=") {
-        $v = $_.split("="); Set-Item -Force -Path "ENV:\$($v[0])" -Value "$($v[1])"
-    }
-}
-popd
-
-function Which ($search_path, $name) {
-    ($search_path).Split(";") | Get-ChildItem -Filter $name | Select -First 1 -Exp FullName
-}
-
-function GetDeps ($search_path, $binary) {
-    ((dumpbin /dependents $binary).Where({ $_ -match "dependencies:"}, "SkipUntil") | Select-String "[^ ]*\.dll").Matches | foreach {
-        Which $search_path $_.Value
-    }
-}
-
-function RecursivelyGetDeps ($search_path, $binary) {
-    $final_deps = @()
-    $deps_to_process = GetDeps $search_path $binary
-    while ($deps_to_process.Count -gt 0) {
-        $current, $deps_to_process = $deps_to_process
-        if ($final_deps -contains $current) { continue }
-
-        # Is this a system dll file?
-        # We use the same algorithm that cmake uses to determine this.
-        if ($current -match "$([regex]::Escape($env:SystemRoot))\\sys") { continue }
-        if ($current -match "$([regex]::Escape($env:WinDir))\\sys") { continue }
-        if ($current -match "\\msvc[^\\]+dll") { continue }
-        if ($current -match "\\api-ms-win-[^\\]+dll") { continue }
-
-        $final_deps += $current
-        $new_deps = GetDeps $search_path $current
-        $deps_to_process += ($new_deps | ?{-not ($final_deps -contains $_)})
-    }
-    return $final_deps
-}

.gitmodules

@@ -18,7 +18,7 @@
     url = https://github.com/fmtlib/fmt.git
 [submodule "lz4"]
     path = externals/lz4
-    url = https://github.com/lz4/lz4.git
+    url = http://github.com/lz4/lz4.git
 [submodule "unicorn"]
     path = externals/unicorn
     url = https://github.com/yuzu-emu/unicorn

CMakeLists.txt

@@ -160,9 +160,6 @@ set_property(DIRECTORY APPEND PROPERTY
     COMPILE_DEFINITIONS $<$<CONFIG:Debug>:_DEBUG> $<$<NOT:$<CONFIG:Debug>>:NDEBUG>)
 
 
-math(EXPR EMU_ARCH_BITS ${CMAKE_SIZEOF_VOID_P}*8)
-add_definitions(-DEMU_ARCH_BITS=${EMU_ARCH_BITS})
-
 # System imported libraries
 # ======================
 
@@ -278,7 +275,7 @@ endif()
 if (ENABLE_QT)
     if (YUZU_USE_BUNDLED_QT)
         if (MSVC14 AND ARCHITECTURE_x86_64)
-            set(QT_VER qt-5.10.0-msvc2015_64)
+            set(QT_VER qt-5.7-msvc2015_64)
         else()
             message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
         endif()

appveyor.yml

@@ -121,16 +121,23 @@ after_build:
           Get-ChildItem "$CMAKE_BINARY_DIR" -Filter "yuzu*.exe" | Copy-Item -destination $RELEASE_DIST
           Copy-Item -path "$CMAKE_SOURCE_DIR/license.txt" -destination $RELEASE_DIST
           Copy-Item -path "$CMAKE_SOURCE_DIR/README.md" -destination $RELEASE_DIST
-
           # copy all the dll dependencies to the release folder
-          . "./.appveyor/UtilityFunctions.ps1"
-          $DLLSearchPath = "C:\msys64\mingw64\bin;$env:PATH"
-          $MingwDLLs = RecursivelyGetDeps $DLLSearchPath "$RELEASE_DIST\yuzu.exe"
-          $MingwDLLs += RecursivelyGetDeps $DLLSearchPath  "$RELEASE_DIST\yuzu_cmd.exe"
-          Write-Host "Detected the following dependencies:"
-          Write-Host $MingwDLLs
+          # hardcoded list because we don't build static and determining the list of dlls from the binary is a pain.
+          $MingwDLLs = "Qt5Core.dll","Qt5Widgets.dll","Qt5Gui.dll","Qt5OpenGL.dll",
+                       # QT dll dependencies
+                       "libbz2-*.dll","libicudt*.dll","libicuin*.dll","libicuuc*.dll","libffi-*.dll",
+                       "libfreetype-*.dll","libglib-*.dll","libgobject-*.dll","libgraphite2.dll","libiconv-*.dll",
+                       "libharfbuzz-*.dll","libintl-*.dll","libpcre-*.dll","libpcre2-16-*.dll","libpcre16-*.dll","libpng16-*.dll",
+                       # Runtime/Other dependencies
+                       "libgcc_s_seh-*.dll","libstdc++-*.dll","libwinpthread-*.dll","SDL2.dll","zlib1.dll"
           foreach ($file in $MingwDLLs) {
-            Copy-Item -path "$file" -force -destination "$RELEASE_DIST"
+            Copy-Item -path "C:/msys64/mingw64/bin/$file" -force -destination "$RELEASE_DIST"
+          }
+          # the above list copies a few extra debug dlls that aren't needed (thanks globbing patterns!)
+          # so we can remove them by hardcoding another list of extra dlls to remove
+          $DebugDLLs = "libicudtd*.dll","libicuind*.dll","libicuucd*.dll"
+          foreach ($file in $DebugDLLs) {
+            Remove-Item -path "$RELEASE_DIST/$file"
           }
 
           # copy the qt windows plugin dll to platforms

dist/icons/icons.qrc

@@ -0,0 +1,5 @@
+<RCC>
+  <qresource prefix="icons">
+    <file>yuzu.png</file>
+  </qresource>
+</RCC>

dist/qt_themes/default/default.qrc

@@ -1,11 +0,0 @@
-<RCC>
-    <qresource prefix="icons/default">
-        <file alias="index.theme">icons/index.theme</file>
-      
-        <file alias="16x16/checked.png">icons/16x16/checked.png</file>
-
-        <file alias="16x16/failed.png">icons/16x16/failed.png</file>
-      
-        <file alias="256x256/yuzu.png">icons/256x256/yuzu.png</file>
-    </qresource>
-</RCC>

dist/qt_themes/default/icons/index.theme

@@ -1,10 +0,0 @@
-[Icon Theme]
-Name=default
-Comment=default theme
-Directories=16x16,256x256
- 
-[16x16]
-Size=16
- 
-[256x256]
-Size=256

dist/qt_themes/qdarkstyle/icons/index.theme

@@ -1,11 +0,0 @@
-[Icon Theme]
-Name=qdarkstyle
-Comment=dark theme
-Inherits=default
-Directories=16x16,256x256
- 
-[16x16]
-Size=16
- 
-[256x256]
-Size=256

dist/qt_themes/qdarkstyle/style.qrc

@@ -1,49 +0,0 @@
-<RCC>
-  <qresource prefix="icons/qdarkstyle">
-    <file alias="index.theme">icons/index.theme</file>
-  </qresource>
-  <qresource prefix="qss_icons">
-    <file>rc/up_arrow_disabled.png</file>
-    <file>rc/Hmovetoolbar.png</file>
-    <file>rc/stylesheet-branch-end.png</file>
-    <file>rc/branch_closed-on.png</file>
-    <file>rc/stylesheet-vline.png</file>
-    <file>rc/branch_closed.png</file>
-    <file>rc/branch_open-on.png</file>
-    <file>rc/transparent.png</file>
-    <file>rc/right_arrow_disabled.png</file>
-    <file>rc/sizegrip.png</file>
-    <file>rc/close.png</file>
-    <file>rc/close-hover.png</file>
-    <file>rc/close-pressed.png</file>
-    <file>rc/down_arrow.png</file>
-    <file>rc/Vmovetoolbar.png</file>
-    <file>rc/left_arrow.png</file>
-    <file>rc/stylesheet-branch-more.png</file>
-    <file>rc/up_arrow.png</file>
-    <file>rc/right_arrow.png</file>
-    <file>rc/left_arrow_disabled.png</file>
-    <file>rc/Hsepartoolbar.png</file>
-    <file>rc/branch_open.png</file>
-    <file>rc/Vsepartoolbar.png</file>
-    <file>rc/down_arrow_disabled.png</file>
-    <file>rc/undock.png</file>
-    <file>rc/checkbox_checked_disabled.png</file>
-    <file>rc/checkbox_checked_focus.png</file>
-    <file>rc/checkbox_checked.png</file>
-    <file>rc/checkbox_indeterminate.png</file>
-    <file>rc/checkbox_indeterminate_focus.png</file>
-    <file>rc/checkbox_unchecked_disabled.png</file>
-    <file>rc/checkbox_unchecked_focus.png</file>
-    <file>rc/checkbox_unchecked.png</file>
-    <file>rc/radio_checked_disabled.png</file>
-    <file>rc/radio_checked_focus.png</file>
-    <file>rc/radio_checked.png</file>
-    <file>rc/radio_unchecked_disabled.png</file>
-    <file>rc/radio_unchecked_focus.png</file>
-    <file>rc/radio_unchecked.png</file>
-  </qresource>
-  <qresource prefix="qdarkstyle">
-      <file>style.qss</file>
-  </qresource>
-</RCC>

externals/glad/Readme.md

@@ -1,5 +1,5 @@
 These files were generated by the [glad](https://github.com/Dav1dde/glad) OpenGL loader generator and have been checked in as-is. You can re-generate them using glad with the following command:
 
 ```
-python -m glad --profile core --out-path glad/ --api gl=3.3 --generator=c
+python -m glad --profile core --out-path glad/ --api gl=3.3,gles=3.0
 ```

externals/glad/include/KHR/khrplatform.h

@@ -26,7 +26,7 @@
 
 /* Khronos platform-specific types and definitions.
  *
- * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $
+ * $Revision: 23298 $ on $Date: 2013-09-30 17:07:13 -0700 (Mon, 30 Sep 2013) $
  *
  * Adopters may modify this file to suit their platform. Adopters are
  * encouraged to submit platform specific modifications to the Khronos
@@ -101,8 +101,6 @@
 #   define KHRONOS_APICALL __declspec(dllimport)
 #elif defined (__SYMBIAN32__)
 #   define KHRONOS_APICALL IMPORT_C
-#elif defined(__ANDROID__)
-#   define KHRONOS_APICALL __attribute__((visibility("default")))
 #else
 #   define KHRONOS_APICALL
 #endif
@@ -225,7 +223,7 @@ typedef signed   short int     khronos_int16_t;
 typedef unsigned short int     khronos_uint16_t;
 
 /*
- * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * Types that differ between LLP64 and LP64 architectures - in LLP64, 
  * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
  * to be the only LLP64 architecture in current use.
  */

hooks/pre-commit

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-# Enforce yuzu's whitespace policy
+# Enforce citra's whitespace policy
 git config --local core.whitespace tab-in-indent,trailing-space
 
 paths_to_check="src/ CMakeLists.txt"

src/common/CMakeLists.txt

@@ -58,6 +58,7 @@ add_library(common STATIC
     misc.cpp
     param_package.cpp
     param_package.h
+    platform.h
     quaternion.h
     scm_rev.cpp
     scm_rev.h

src/common/file_util.h

@@ -121,7 +121,7 @@ void CopyDir(const std::string& source_path, const std::string& dest_path);
 // Set the current directory to given directory
 bool SetCurrentDir(const std::string& directory);
 
-// Returns a pointer to a string with a yuzu data dir in the user's home
+// Returns a pointer to a string with a Citra data dir in the user's home
 // directory. To be used in "multi-user" mode (that is, installed).
 const std::string& GetUserPath(const unsigned int DirIDX, const std::string& newPath = "");
 

src/common/logging/backend.cpp

@@ -37,20 +37,16 @@ namespace Log {
     SUB(Service, AM)                                                                               \
     SUB(Service, AOC)                                                                              \
     SUB(Service, APM)                                                                              \
-    SUB(Service, Fatal)                                                                            \
     SUB(Service, Friend)                                                                           \
     SUB(Service, FS)                                                                               \
     SUB(Service, HID)                                                                              \
     SUB(Service, LM)                                                                               \
-    SUB(Service, NFP)                                                                              \
     SUB(Service, NIFM)                                                                             \
     SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \
     SUB(Service, PCTL)                                                                             \
     SUB(Service, SET)                                                                              \
     SUB(Service, SM)                                                                               \
-    SUB(Service, SPL)                                                                              \
-    SUB(Service, SSL)                                                                              \
     SUB(Service, Time)                                                                             \
     SUB(Service, VI)                                                                               \
     CLS(HW)                                                                                        \

src/common/logging/log.h

@@ -54,20 +54,16 @@ enum class Class : ClassType {
     Service_AOC,       ///< The AOC (AddOn Content) service
     Service_APM,       ///< The APM (Performance) service
     Service_Audio,     ///< The Audio (Audio control) service
-    Service_Fatal,     ///< The Fatal service
     Service_Friend,    ///< The friend service
     Service_FS,        ///< The FS (Filesystem) service
     Service_HID,       ///< The HID (Human interface device) service
     Service_LM,        ///< The LM (Logger) service
-    Service_NFP,       ///< The NFP service
     Service_NIFM,      ///< The NIFM (Network interface) service
     Service_NS,        ///< The NS services
     Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
     Service_PCTL,      ///< The PCTL (Parental control) service
     Service_SET,       ///< The SET (Settings) service
     Service_SM,        ///< The SM (Service manager) service
-    Service_SPL,       ///< The SPL service
-    Service_SSL,       ///< The SSL service
     Service_Time,      ///< The time service
     Service_VI,        ///< The VI (Video interface) service
     HW,                ///< Low-level hardware emulation
@@ -86,7 +82,7 @@ enum class Class : ClassType {
     Loader,            ///< ROM loader
     Input,             ///< Input emulation
     Network,           ///< Network emulation
-    WebService,        ///< Interface to yuzu Web Services
+    WebService,        ///< Interface to Citra Web Services
     Count              ///< Total number of logging classes
 };
 

src/common/platform.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright (C) 2005-2012 Gekko Emulator
+ *
+ * @file    platform.h
+ * @author  ShizZy <shizzy247@gmail.com>
+ * @date    2012-02-11
+ * @brief   Platform detection macros for portable compilation
+ *
+ * @section LICENSE
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details at
+ * http://www.gnu.org/copyleft/gpl.html
+ *
+ * Official project repository can be found at:
+ * http://code.google.com/p/gekko-gc-emu/
+ */
+
+#pragma once
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Platform detection
+
+#if defined(ARCHITECTURE_x86_64) || defined(__aarch64__)
+#define EMU_ARCH_BITS 64
+#elif defined(__i386) || defined(_M_IX86) || defined(__arm__) || defined(_M_ARM)
+#define EMU_ARCH_BITS 32
+#endif

src/common/x64/cpu_detect.cpp

@@ -54,7 +54,7 @@ static CPUCaps Detect() {
     caps.num_cores = std::thread::hardware_concurrency();
 
     // Assumes the CPU supports the CPUID instruction. Those that don't would likely not support
-    // yuzu at all anyway
+    // Citra at all anyway
 
     int cpu_id[4];
     memset(caps.brand_string, 0, sizeof(caps.brand_string));

src/core/CMakeLists.txt

@@ -22,8 +22,6 @@ add_library(core STATIC
     file_sys/romfs_filesystem.h
     file_sys/savedata_factory.cpp
     file_sys/savedata_factory.h
-    file_sys/sdmc_factory.cpp
-    file_sys/sdmc_factory.h
     file_sys/storage.h
     frontend/emu_window.cpp
     frontend/emu_window.h
@@ -116,12 +114,6 @@ add_library(core STATIC
     hle/service/audio/audren_u.h
     hle/service/audio/codecctl.cpp
     hle/service/audio/codecctl.h
-    hle/service/fatal/fatal.cpp
-    hle/service/fatal/fatal.h
-    hle/service/fatal/fatal_p.cpp
-    hle/service/fatal/fatal_p.h
-    hle/service/fatal/fatal_u.cpp
-    hle/service/fatal/fatal_u.h
     hle/service/filesystem/filesystem.cpp
     hle/service/filesystem/filesystem.h
     hle/service/filesystem/fsp_srv.cpp
@@ -142,10 +134,6 @@ add_library(core STATIC
     hle/service/nifm/nifm_s.h
     hle/service/nifm/nifm_u.cpp
     hle/service/nifm/nifm_u.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/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp
@@ -181,34 +169,16 @@ add_library(core STATIC
     hle/service/service.h
     hle/service/set/set.cpp
     hle/service/set/set.h
-    hle/service/set/set_cal.cpp
-    hle/service/set/set_cal.h
-    hle/service/set/set_fd.cpp
-    hle/service/set/set_fd.h
-    hle/service/set/set_sys.cpp
-    hle/service/set/set_sys.h
-    hle/service/set/settings.cpp
-    hle/service/set/settings.h
     hle/service/sm/controller.cpp
     hle/service/sm/controller.h
     hle/service/sm/sm.cpp
     hle/service/sm/sm.h
-    hle/service/sockets/bsd.cpp
-    hle/service/sockets/bsd.h
-    hle/service/sockets/nsd.cpp
-    hle/service/sockets/nsd.h
+    hle/service/sockets/bsd_u.cpp
+    hle/service/sockets/bsd_u.h
     hle/service/sockets/sfdnsres.cpp
     hle/service/sockets/sfdnsres.h
     hle/service/sockets/sockets.cpp
     hle/service/sockets/sockets.h
-    hle/service/spl/csrng.cpp
-    hle/service/spl/csrng.h
-    hle/service/spl/module.cpp
-    hle/service/spl/module.h
-    hle/service/spl/spl.cpp
-    hle/service/spl/spl.h
-    hle/service/ssl/ssl.cpp
-    hle/service/ssl/ssl.h
     hle/service/time/time.cpp
     hle/service/time/time.h
     hle/service/time/time_s.cpp

src/core/arm/arm_interface.h

@@ -25,18 +25,22 @@ public:
         VAddr tls_address;
     };
 
-    /// Runs the CPU until an event happens
-    virtual void Run() = 0;
+    /**
+     * Runs the CPU for the given number of instructions
+     * @param num_instructions Number of instructions to run
+     */
+    void Run(int num_instructions) {
+        ExecuteInstructions(num_instructions);
+        this->num_instructions += num_instructions;
+    }
 
     /// Step CPU by one instruction
-    virtual void Step() = 0;
+    void Step() {
+        Run(1);
+    }
 
-    /// Maps a backing memory region for the CPU
     virtual void MapBackingMemory(VAddr address, size_t size, u8* memory,
-                                  Kernel::VMAPermission perms) = 0;
-
-    /// Unmaps a region of memory that was previously mapped using MapBackingMemory
-    virtual void UnmapMemory(VAddr address, size_t size) = 0;
+                                  Kernel::VMAPermission perms) {}
 
     /// Clear all instruction cache
     virtual void ClearInstructionCache() = 0;
@@ -118,4 +122,19 @@ public:
 
     /// Prepare core for thread reschedule (if needed to correctly handle state)
     virtual void PrepareReschedule() = 0;
+
+    /// Getter for num_instructions
+    u64 GetNumInstructions() const {
+        return num_instructions;
+    }
+
+protected:
+    /**
+     * Executes the given number of instructions
+     * @param num_instructions Number of instructions to executes
+     */
+    virtual void ExecuteInstructions(int num_instructions) = 0;
+
+private:
+    u64 num_instructions = 0; ///< Number of instructions executed
 };

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -8,7 +8,6 @@
 #include <dynarmic/A64/config.h>
 #include "common/logging/log.h"
 #include "core/arm/dynarmic/arm_dynarmic.h"
-#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/svc.h"
@@ -86,24 +85,28 @@ public:
     }
 
     void AddTicks(u64 ticks) override {
-        CoreTiming::AddTicks(ticks - num_interpreted_instructions);
-        num_interpreted_instructions = 0;
+        if (ticks > ticks_remaining) {
+            ticks_remaining = 0;
+            return;
+        }
+        ticks -= ticks_remaining;
     }
     u64 GetTicksRemaining() override {
-        return std::max(CoreTiming::GetDowncount(), 0);
+        return ticks_remaining;
     }
     u64 GetCNTPCT() override {
         return CoreTiming::GetTicks();
     }
 
     ARM_Dynarmic& parent;
+    size_t ticks_remaining = 0;
     size_t num_interpreted_instructions = 0;
     u64 tpidrro_el0 = 0;
     u64 tpidr_el0 = 0;
 };
 
 std::unique_ptr<Dynarmic::A64::Jit> MakeJit(const std::unique_ptr<ARM_Dynarmic_Callbacks>& cb) {
-    const auto page_table = Core::CurrentProcess()->vm_manager.page_table.pointers.data();
+    const auto page_table = Kernel::g_current_process->vm_manager.page_table.pointers.data();
 
     Dynarmic::A64::UserConfig config;
     config.callbacks = cb.get();
@@ -118,22 +121,11 @@ std::unique_ptr<Dynarmic::A64::Jit> MakeJit(const std::unique_ptr<ARM_Dynarmic_C
     return std::make_unique<Dynarmic::A64::Jit>(config);
 }
 
-void ARM_Dynarmic::Run() {
-    ASSERT(Memory::GetCurrentPageTable() == current_page_table);
-
-    jit->Run();
-}
-
-void ARM_Dynarmic::Step() {
-    cb->InterpreterFallback(jit->GetPC(), 1);
-}
-
 ARM_Dynarmic::ARM_Dynarmic()
     : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), jit(MakeJit(cb)) {
     ARM_Interface::ThreadContext ctx;
     inner_unicorn.SaveContext(ctx);
     LoadContext(ctx);
-    PageTableChanged();
 }
 
 ARM_Dynarmic::~ARM_Dynarmic() = default;
@@ -143,10 +135,6 @@ void ARM_Dynarmic::MapBackingMemory(u64 address, size_t size, u8* memory,
     inner_unicorn.MapBackingMemory(address, size, memory, perms);
 }
 
-void ARM_Dynarmic::UnmapMemory(u64 address, size_t size) {
-    inner_unicorn.UnmapMemory(address, size);
-}
-
 void ARM_Dynarmic::SetPC(u64 pc) {
     jit->SetPC(pc);
 }
@@ -196,6 +184,13 @@ void ARM_Dynarmic::SetTlsAddress(u64 address) {
     cb->tpidrro_el0 = address;
 }
 
+void ARM_Dynarmic::ExecuteInstructions(int num_instructions) {
+    cb->ticks_remaining = num_instructions;
+    jit->Run();
+    CoreTiming::AddTicks(num_instructions - cb->num_interpreted_instructions);
+    cb->num_interpreted_instructions = 0;
+}
+
 void ARM_Dynarmic::SaveContext(ARM_Interface::ThreadContext& ctx) {
     ctx.cpu_registers = jit->GetRegisters();
     ctx.sp = jit->GetSP();
@@ -228,5 +223,4 @@ void ARM_Dynarmic::ClearInstructionCache() {
 
 void ARM_Dynarmic::PageTableChanged() {
     jit = MakeJit(cb);
-    current_page_table = Memory::GetCurrentPageTable();
 }

src/core/arm/dynarmic/arm_dynarmic.h

@@ -19,7 +19,7 @@ public:
 
     void MapBackingMemory(VAddr address, size_t size, u8* memory,
                           Kernel::VMAPermission perms) override;
-    void UnmapMemory(u64 address, size_t size) override;
+
     void SetPC(u64 pc) override;
     u64 GetPC() const override;
     u64 GetReg(int index) const override;
@@ -29,8 +29,6 @@ public:
     u32 GetVFPReg(int index) const override;
     void SetVFPReg(int index, u32 value) override;
     u32 GetCPSR() const override;
-    void Run() override;
-    void Step() override;
     void SetCPSR(u32 cpsr) override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
@@ -39,6 +37,7 @@ public:
     void LoadContext(const ThreadContext& ctx) override;
 
     void PrepareReschedule() override;
+    void ExecuteInstructions(int num_instructions) override;
 
     void ClearInstructionCache() override;
     void PageTableChanged() override;
@@ -48,6 +47,4 @@ private:
     std::unique_ptr<ARM_Dynarmic_Callbacks> cb;
     std::unique_ptr<Dynarmic::A64::Jit> jit;
     ARM_Unicorn inner_unicorn;
-
-    Memory::PageTable* current_page_table = nullptr;
 };

src/core/arm/unicorn/arm_unicorn.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <algorithm>
 #include <unicorn/arm64.h>
 #include "common/assert.h"
 #include "common/microprofile.h"
@@ -53,7 +52,7 @@ static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int si
                                void* user_data) {
     ARM_Interface::ThreadContext ctx{};
     Core::CPU().SaveContext(ctx);
-    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x%lx, pc=0x%lx, lr=0x%lx", addr,
+    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x%llx, pc=0x%llx, lr=0x%llx", addr,
                ctx.pc, ctx.cpu_registers[30]);
     return {};
 }
@@ -78,10 +77,6 @@ void ARM_Unicorn::MapBackingMemory(VAddr address, size_t size, u8* memory,
     CHECKED(uc_mem_map_ptr(uc, address, size, static_cast<u32>(perms), memory));
 }
 
-void ARM_Unicorn::UnmapMemory(VAddr address, size_t size) {
-    CHECKED(uc_mem_unmap(uc, address, size));
-}
-
 void ARM_Unicorn::SetPC(u64 pc) {
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_PC, &pc));
 }
@@ -154,14 +149,6 @@ void ARM_Unicorn::SetTlsAddress(VAddr base) {
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDRRO_EL0, &base));
 }
 
-void ARM_Unicorn::Run() {
-    ExecuteInstructions(std::max(CoreTiming::GetDowncount(), 0));
-}
-
-void ARM_Unicorn::Step() {
-    ExecuteInstructions(1);
-}
-
 MICROPROFILE_DEFINE(ARM_Jit, "ARM JIT", "ARM JIT", MP_RGB(255, 64, 64));
 
 void ARM_Unicorn::ExecuteInstructions(int num_instructions) {

src/core/arm/unicorn/arm_unicorn.h

@@ -14,7 +14,6 @@ public:
     ~ARM_Unicorn();
     void MapBackingMemory(VAddr address, size_t size, u8* memory,
                           Kernel::VMAPermission perms) override;
-    void UnmapMemory(VAddr address, size_t size) override;
     void SetPC(u64 pc) override;
     u64 GetPC() const override;
     u64 GetReg(int index) const override;
@@ -30,9 +29,7 @@ public:
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;
     void PrepareReschedule() override;
-    void ExecuteInstructions(int num_instructions);
-    void Run() override;
-    void Step() override;
+    void ExecuteInstructions(int num_instructions) override;
     void ClearInstructionCache() override;
     void PageTableChanged() override{};
 

src/core/core.cpp

@@ -26,7 +26,7 @@ namespace Core {
 
 /*static*/ System System::s_instance;
 
-System::ResultStatus System::RunLoop(bool tight_loop) {
+System::ResultStatus System::RunLoop(int tight_loop) {
     status = ResultStatus::Success;
     if (!cpu_core) {
         return ResultStatus::ErrorNotInitialized;
@@ -40,7 +40,7 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
         if (GDBStub::GetCpuHaltFlag()) {
             if (GDBStub::GetCpuStepFlag()) {
                 GDBStub::SetCpuStepFlag(false);
-                tight_loop = false;
+                tight_loop = 1;
             } else {
                 return ResultStatus::Success;
             }
@@ -56,11 +56,7 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
         PrepareReschedule();
     } else {
         CoreTiming::Advance();
-        if (tight_loop) {
-            cpu_core->Run();
-        } else {
-            cpu_core->Step();
-        }
+        cpu_core->Run(tight_loop);
     }
 
     HW::Update();
@@ -70,7 +66,7 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
 }
 
 System::ResultStatus System::SingleStep() {
-    return RunLoop(false);
+    return RunLoop(1);
 }
 
 System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& filepath) {
@@ -99,15 +95,14 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
 
     ResultStatus init_result{Init(emu_window, system_mode.first.get())};
     if (init_result != ResultStatus::Success) {
-        LOG_CRITICAL(Core, "Failed to initialize system (Error %i)!",
-                     static_cast<int>(init_result));
+        LOG_CRITICAL(Core, "Failed to initialize system (Error %i)!", init_result);
         System::Shutdown();
         return init_result;
     }
 
-    const Loader::ResultStatus load_result{app_loader->Load(current_process)};
+    const Loader::ResultStatus load_result{app_loader->Load(Kernel::g_current_process)};
     if (Loader::ResultStatus::Success != load_result) {
-        LOG_CRITICAL(Core, "Failed to load ROM (Error %i)!", static_cast<int>(load_result));
+        LOG_CRITICAL(Core, "Failed to load ROM (Error %i)!", load_result);
         System::Shutdown();
 
         switch (load_result) {
@@ -146,17 +141,19 @@ System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
 
     CoreTiming::Init();
 
-    current_process = Kernel::Process::Create("main");
-
-    if (Settings::values.use_cpu_jit) {
+    switch (Settings::values.cpu_core) {
+    case Settings::CpuCore::Unicorn:
+        cpu_core = std::make_shared<ARM_Unicorn>();
+        break;
+    case Settings::CpuCore::Dynarmic:
+    default:
 #ifdef ARCHITECTURE_x86_64
         cpu_core = std::make_shared<ARM_Dynarmic>();
 #else
         cpu_core = std::make_shared<ARM_Unicorn>();
         LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
-    } else {
-        cpu_core = std::make_shared<ARM_Unicorn>();
+        break;
     }
 
     gpu_core = std::make_unique<Tegra::GPU>();

src/core/core.h

@@ -7,13 +7,11 @@
 #include <memory>
 #include <string>
 #include "common/common_types.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
 #include "core/perf_stats.h"
 #include "core/telemetry_session.h"
-#include "video_core/debug_utils/debug_utils.h"
 #include "video_core/gpu.h"
 
 class EmuWindow;
@@ -54,10 +52,10 @@ public:
      * is not required to do a full dispatch with each instruction. NOTE: the number of instructions
      * requested is not guaranteed to run, as this will be interrupted preemptively if a hardware
      * update is requested (e.g. on a thread switch).
-     * @param tight_loop If false, the CPU single-steps.
+     * @param tight_loop Number of instructions to execute.
      * @return Result status, indicating whether or not the operation succeeded.
      */
-    ResultStatus RunLoop(bool tight_loop = true);
+    ResultStatus RunLoop(int tight_loop = 100000);
 
     /**
      * Step the CPU one instruction
@@ -114,10 +112,6 @@ public:
         return *scheduler;
     }
 
-    Kernel::SharedPtr<Kernel::Process>& CurrentProcess() {
-        return current_process;
-    }
-
     PerfStats perf_stats;
     FrameLimiter frame_limiter;
 
@@ -136,14 +130,6 @@ public:
         return *app_loader;
     }
 
-    void SetGPUDebugContext(std::shared_ptr<Tegra::DebugContext> context) {
-        debug_context = std::move(context);
-    }
-
-    std::shared_ptr<Tegra::DebugContext> GetGPUDebugContext() const {
-        return debug_context;
-    }
-
 private:
     /**
      * Initialize the emulated system.
@@ -163,10 +149,6 @@ private:
     std::unique_ptr<Kernel::Scheduler> scheduler;
     std::unique_ptr<Tegra::GPU> gpu_core;
 
-    std::shared_ptr<Tegra::DebugContext> debug_context;
-
-    Kernel::SharedPtr<Kernel::Process> current_process;
-
     /// When true, signals that a reschedule should happen
     bool reschedule_pending{};
 
@@ -187,8 +169,4 @@ inline TelemetrySession& Telemetry() {
     return System::GetInstance().TelemetrySession();
 }
 
-inline Kernel::SharedPtr<Kernel::Process>& CurrentProcess() {
-    return System::GetInstance().CurrentProcess();
-}
-
 } // namespace Core

src/core/file_sys/directory.h

@@ -6,28 +6,34 @@
 
 #include <array>
 #include <cstddef>
-#include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "core/file_sys/filesystem.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // FileSys namespace
 
 namespace FileSys {
 
-// Structure of a directory entry, from
-// http://switchbrew.org/index.php?title=Filesystem_services#DirectoryEntry
-const size_t FILENAME_LENGTH = 0x300;
+// Structure of a directory entry, from http://3dbrew.org/wiki/FSDir:Read#Entry_format
+const size_t FILENAME_LENGTH = 0x20C / 2;
 struct Entry {
-    char filename[FILENAME_LENGTH];
-    INSERT_PADDING_BYTES(4);
-    EntryType type;
-    INSERT_PADDING_BYTES(3);
-    u64 file_size;
+    char16_t filename[FILENAME_LENGTH]; // Entry name (UTF-16, null-terminated)
+    std::array<char, 9> short_name; // 8.3 file name ('longfilename' -> 'LONGFI~1', null-terminated)
+    char unknown1;                  // unknown (observed values: 0x0A, 0x70, 0xFD)
+    std::array<char, 4>
+        extension;     // 8.3 file extension (set to spaces for directories, null-terminated)
+    char unknown2;     // unknown (always 0x01)
+    char unknown3;     // unknown (0x00 or 0x08)
+    char is_directory; // directory flag
+    char is_hidden;    // hidden flag
+    char is_archive;   // archive flag
+    char is_read_only; // read-only flag
+    u64 file_size;     // file size (for files only)
 };
-static_assert(sizeof(Entry) == 0x310, "Directory Entry struct isn't exactly 0x310 bytes long!");
-static_assert(offsetof(Entry, type) == 0x304, "Wrong offset for type in Entry.");
-static_assert(offsetof(Entry, file_size) == 0x308, "Wrong offset for file_size in Entry.");
+static_assert(sizeof(Entry) == 0x228, "Directory Entry struct isn't exactly 0x228 bytes long!");
+static_assert(offsetof(Entry, short_name) == 0x20C, "Wrong offset for short_name in Entry.");
+static_assert(offsetof(Entry, extension) == 0x216, "Wrong offset for extension in Entry.");
+static_assert(offsetof(Entry, is_archive) == 0x21E, "Wrong offset for is_archive in Entry.");
+static_assert(offsetof(Entry, file_size) == 0x220, "Wrong offset for file_size in Entry.");
 
 class DirectoryBackend : NonCopyable {
 public:
@@ -40,10 +46,7 @@ public:
      * @param entries Buffer to read data into
      * @return Number of entries listed
      */
-    virtual u64 Read(const u64 count, Entry* entries) = 0;
-
-    /// Returns the number of entries still left to read.
-    virtual u64 GetEntryCount() const = 0;
+    virtual u32 Read(const u32 count, Entry* entries) = 0;
 
     /**
      * Close the directory

src/core/file_sys/disk_filesystem.cpp

@@ -7,50 +7,23 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/file_sys/disk_filesystem.h"
-#include "core/file_sys/errors.h"
 
 namespace FileSys {
 
-static std::string ModeFlagsToString(Mode mode) {
-    std::string mode_str;
-    u32 mode_flags = static_cast<u32>(mode);
-
-    // Calculate the correct open mode for the file.
-    if ((mode_flags & static_cast<u32>(Mode::Read)) &&
-        (mode_flags & static_cast<u32>(Mode::Write))) {
-        if (mode_flags & static_cast<u32>(Mode::Append))
-            mode_str = "a+";
-        else
-            mode_str = "r+";
-    } else {
-        if (mode_flags & static_cast<u32>(Mode::Read))
-            mode_str = "r";
-        else if (mode_flags & static_cast<u32>(Mode::Append))
-            mode_str = "a";
-        else if (mode_flags & static_cast<u32>(Mode::Write))
-            mode_str = "w";
-    }
-
-    mode_str += "b";
-
-    return mode_str;
-}
-
 std::string Disk_FileSystem::GetName() const {
     return "Disk";
 }
 
 ResultVal<std::unique_ptr<StorageBackend>> Disk_FileSystem::OpenFile(const std::string& path,
                                                                      Mode mode) const {
-
-    // Calculate the correct open mode for the file.
-    std::string mode_str = ModeFlagsToString(mode);
+    ASSERT_MSG(mode == Mode::Read || mode == Mode::Write, "Other file modes are not supported");
 
     std::string full_path = base_directory + path;
-    auto file = std::make_shared<FileUtil::IOFile>(full_path, mode_str.c_str());
+    auto file = std::make_shared<FileUtil::IOFile>(full_path, mode == Mode::Read ? "rb" : "wb");
 
     if (!file->IsOpen()) {
-        return ERROR_PATH_NOT_FOUND;
+        // TODO(Subv): Find out the correct error code.
+        return ResultCode(-1);
     }
 
     return MakeResult<std::unique_ptr<StorageBackend>>(
@@ -102,15 +75,8 @@ ResultCode Disk_FileSystem::CreateFile(const std::string& path, u64 size) const
     return ResultCode(-1);
 }
 
-ResultCode Disk_FileSystem::CreateDirectory(const std::string& path) const {
-    // TODO(Subv): Perform path validation to prevent escaping the emulator sandbox.
-    std::string full_path = base_directory + path;
-
-    if (FileUtil::CreateDir(full_path)) {
-        return RESULT_SUCCESS;
-    }
-
-    LOG_CRITICAL(Service_FS, "(unreachable) Unknown error creating %s", full_path.c_str());
+ResultCode Disk_FileSystem::CreateDirectory(const Path& path) const {
+    LOG_WARNING(Service_FS, "(STUBBED) called");
     // TODO(wwylele): Use correct error code
     return ResultCode(-1);
 }
@@ -122,17 +88,8 @@ ResultCode Disk_FileSystem::RenameDirectory(const Path& src_path, const Path& de
 }
 
 ResultVal<std::unique_ptr<DirectoryBackend>> Disk_FileSystem::OpenDirectory(
-    const std::string& path) const {
-
-    std::string full_path = base_directory + path;
-
-    if (!FileUtil::IsDirectory(full_path)) {
-        // TODO(Subv): Find the correct error code for this.
-        return ResultCode(-1);
-    }
-
-    auto directory = std::make_unique<Disk_Directory>(full_path);
-    return MakeResult<std::unique_ptr<DirectoryBackend>>(std::move(directory));
+    const Path& path) const {
+    return MakeResult<std::unique_ptr<DirectoryBackend>>(std::make_unique<Disk_Directory>());
 }
 
 u64 Disk_FileSystem::GetFreeSpaceSize() const {
@@ -143,13 +100,12 @@ u64 Disk_FileSystem::GetFreeSpaceSize() const {
 ResultVal<FileSys::EntryType> Disk_FileSystem::GetEntryType(const std::string& path) const {
     std::string full_path = base_directory + path;
     if (!FileUtil::Exists(full_path)) {
-        return ERROR_PATH_NOT_FOUND;
+        // TODO(Subv): Find out what this actually means
+        return ResultCode(ErrorModule::FS, 1);
     }
 
-    if (FileUtil::IsDirectory(full_path))
-        return MakeResult(EntryType::Directory);
-
-    return MakeResult(EntryType::File);
+    // TODO(Subv): Find out the EntryType values
+    UNIMPLEMENTED_MSG("Unimplemented GetEntryType");
 }
 
 ResultVal<size_t> Disk_Storage::Read(const u64 offset, const size_t length, u8* buffer) const {
@@ -174,55 +130,18 @@ u64 Disk_Storage::GetSize() const {
 }
 
 bool Disk_Storage::SetSize(const u64 size) const {
-    file->Resize(size);
-    file->Flush();
+    LOG_WARNING(Service_FS, "(STUBBED) called");
+    return false;
+}
+
+u32 Disk_Directory::Read(const u32 count, Entry* entries) {
+    LOG_WARNING(Service_FS, "(STUBBED) called");
+    return 0;
+}
+
+bool Disk_Directory::Close() const {
+    LOG_WARNING(Service_FS, "(STUBBED) called");
     return true;
 }
 
-Disk_Directory::Disk_Directory(const std::string& path) : directory() {
-    unsigned size = FileUtil::ScanDirectoryTree(path, directory);
-    directory.size = size;
-    directory.isDirectory = true;
-    children_iterator = directory.children.begin();
-}
-
-u64 Disk_Directory::Read(const u64 count, Entry* entries) {
-    u64 entries_read = 0;
-
-    while (entries_read < count && children_iterator != directory.children.cend()) {
-        const FileUtil::FSTEntry& file = *children_iterator;
-        const std::string& filename = file.virtualName;
-        Entry& entry = entries[entries_read];
-
-        LOG_TRACE(Service_FS, "File %s: size=%llu dir=%d", filename.c_str(), file.size,
-                  file.isDirectory);
-
-        // TODO(Link Mauve): use a proper conversion to UTF-16.
-        for (size_t j = 0; j < FILENAME_LENGTH; ++j) {
-            entry.filename[j] = filename[j];
-            if (!filename[j])
-                break;
-        }
-
-        if (file.isDirectory) {
-            entry.file_size = 0;
-            entry.type = EntryType::Directory;
-        } else {
-            entry.file_size = file.size;
-            entry.type = EntryType::File;
-        }
-
-        ++entries_read;
-        ++children_iterator;
-    }
-    return entries_read;
-}
-
-u64 Disk_Directory::GetEntryCount() const {
-    // We convert the children iterator into a const_iterator to allow template argument deduction
-    // in std::distance.
-    std::vector<FileUtil::FSTEntry>::const_iterator current = children_iterator;
-    return std::distance(current, directory.children.end());
-}
-
 } // namespace FileSys

src/core/file_sys/disk_filesystem.h

@@ -30,10 +30,9 @@ public:
     ResultCode DeleteDirectory(const Path& path) const override;
     ResultCode DeleteDirectoryRecursively(const Path& path) const override;
     ResultCode CreateFile(const std::string& path, u64 size) const override;
-    ResultCode CreateDirectory(const std::string& path) const override;
+    ResultCode CreateDirectory(const Path& path) const override;
     ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
-    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(
-        const std::string& path) const override;
+    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const override;
     u64 GetFreeSpaceSize() const override;
     ResultVal<EntryType> GetEntryType(const std::string& path) const override;
 
@@ -60,26 +59,8 @@ private:
 
 class Disk_Directory : public DirectoryBackend {
 public:
-    Disk_Directory(const std::string& path);
-
-    ~Disk_Directory() override {
-        Close();
-    }
-
-    u64 Read(const u64 count, Entry* entries) override;
-    u64 GetEntryCount() const override;
-
-    bool Close() const override {
-        return true;
-    }
-
-protected:
-    u32 total_entries_in_directory;
-    FileUtil::FSTEntry directory;
-
-    // We need to remember the last entry we returned, so a subsequent call to Read will continue
-    // from the next one. This iterator will always point to the next unread entry.
-    std::vector<FileUtil::FSTEntry>::iterator children_iterator;
+    u32 Read(const u32 count, Entry* entries) override;
+    bool Close() const override;
 };
 
 } // namespace FileSys

src/core/file_sys/errors.h

@@ -10,17 +10,36 @@ namespace FileSys {
 
 namespace ErrCodes {
 enum {
-    NotFound = 1,
+    RomFSNotFound = 100,
+    ArchiveNotMounted = 101,
+    FileNotFound = 112,
+    PathNotFound = 113,
+    GameCardNotInserted = 141,
+    NotFound = 120,
+    FileAlreadyExists = 180,
+    DirectoryAlreadyExists = 185,
+    AlreadyExists = 190,
+    InvalidOpenFlags = 230,
+    DirectoryNotEmpty = 240,
+    NotAFile = 250,
+    NotFormatted = 340, ///< This is used by the FS service when creating a SaveData archive
+    ExeFSSectionNotFound = 567,
+    CommandNotAllowed = 630,
+    InvalidReadFlag = 700,
+    InvalidPath = 702,
+    WriteBeyondEnd = 705,
+    UnsupportedOpenFlags = 760,
+    IncorrectExeFSReadSize = 761,
+    UnexpectedFileOrDirectory = 770,
 };
 }
 
-constexpr ResultCode ERROR_PATH_NOT_FOUND(ErrorModule::FS, ErrCodes::NotFound);
-
 // TODO(bunnei): Replace these with correct errors for Switch OS
 constexpr ResultCode ERROR_INVALID_PATH(ResultCode(-1));
 constexpr ResultCode ERROR_UNSUPPORTED_OPEN_FLAGS(ResultCode(-1));
 constexpr ResultCode ERROR_INVALID_OPEN_FLAGS(ResultCode(-1));
 constexpr ResultCode ERROR_FILE_NOT_FOUND(ResultCode(-1));
+constexpr ResultCode ERROR_PATH_NOT_FOUND(ResultCode(-1));
 constexpr ResultCode ERROR_UNEXPECTED_FILE_OR_DIRECTORY(ResultCode(-1));
 constexpr ResultCode ERROR_DIRECTORY_ALREADY_EXISTS(ResultCode(-1));
 constexpr ResultCode ERROR_FILE_ALREADY_EXISTS(ResultCode(-1));

src/core/file_sys/filesystem.h

@@ -27,7 +27,7 @@ enum LowPathType : u32 {
     Wchar = 4,
 };
 
-enum EntryType : u8 {
+enum EntryType : u32 {
     Directory = 0,
     File = 1,
 };
@@ -35,7 +35,6 @@ enum EntryType : u8 {
 enum class Mode : u32 {
     Read = 1,
     Write = 2,
-    Append = 4,
 };
 
 class Path {
@@ -104,7 +103,7 @@ public:
      * @param path Path relative to the archive
      * @return Result of the operation
      */
-    virtual ResultCode CreateDirectory(const std::string& path) const = 0;
+    virtual ResultCode CreateDirectory(const Path& path) const = 0;
 
     /**
      * Delete a directory specified by its path
@@ -150,8 +149,7 @@ public:
      * @param path Path relative to the archive
      * @return Opened directory, or error code
      */
-    virtual ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(
-        const std::string& path) const = 0;
+    virtual ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const = 0;
 
     /**
      * Get the free space
@@ -185,9 +183,10 @@ public:
     /**
      * Deletes the archive contents and then re-creates the base folder
      * @param path Path to the archive
+     * @param format_info Format information for the new archive
      * @return ResultCode of the operation, 0 on success
      */
-    virtual ResultCode Format(const Path& path) = 0;
+    virtual ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) = 0;
 
     /**
      * Retrieves the format info about the archive with the specified path

src/core/file_sys/romfs_factory.cpp

@@ -23,7 +23,7 @@ ResultVal<std::unique_ptr<FileSystemBackend>> RomFS_Factory::Open(const Path& pa
     return MakeResult<std::unique_ptr<FileSystemBackend>>(std::move(archive));
 }
 
-ResultCode RomFS_Factory::Format(const Path& path) {
+ResultCode RomFS_Factory::Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) {
     LOG_ERROR(Service_FS, "Unimplemented Format archive %s", GetName().c_str());
     // TODO(bunnei): Find the right error code for this
     return ResultCode(-1);

src/core/file_sys/romfs_factory.h

@@ -23,7 +23,7 @@ public:
         return "ArchiveFactory_RomFS";
     }
     ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) override;
-    ResultCode Format(const Path& path) override;
+    ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) override;
     ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
 
 private:

src/core/file_sys/romfs_filesystem.cpp

@@ -55,7 +55,7 @@ ResultCode RomFS_FileSystem::CreateFile(const std::string& path, u64 size) const
     return ResultCode(-1);
 }
 
-ResultCode RomFS_FileSystem::CreateDirectory(const std::string& path) const {
+ResultCode RomFS_FileSystem::CreateDirectory(const Path& path) const {
     LOG_CRITICAL(Service_FS, "Attempted to create a directory in an ROMFS archive (%s).",
                  GetName().c_str());
     // TODO(wwylele): Use correct error code
@@ -70,8 +70,7 @@ ResultCode RomFS_FileSystem::RenameDirectory(const Path& src_path, const Path& d
 }
 
 ResultVal<std::unique_ptr<DirectoryBackend>> RomFS_FileSystem::OpenDirectory(
-    const std::string& path) const {
-    LOG_WARNING(Service_FS, "Opening Directory in a ROMFS archive");
+    const Path& path) const {
     return MakeResult<std::unique_ptr<DirectoryBackend>>(std::make_unique<ROMFSDirectory>());
 }
 

src/core/file_sys/romfs_filesystem.h

@@ -36,10 +36,9 @@ public:
     ResultCode DeleteDirectory(const Path& path) const override;
     ResultCode DeleteDirectoryRecursively(const Path& path) const override;
     ResultCode CreateFile(const std::string& path, u64 size) const override;
-    ResultCode CreateDirectory(const std::string& path) const override;
+    ResultCode CreateDirectory(const Path& path) const override;
     ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const override;
-    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(
-        const std::string& path) const override;
+    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const override;
     u64 GetFreeSpaceSize() const override;
     ResultVal<EntryType> GetEntryType(const std::string& path) const override;
 
@@ -71,10 +70,7 @@ private:
 
 class ROMFSDirectory : public DirectoryBackend {
 public:
-    u64 Read(const u64 count, Entry* entries) override {
-        return 0;
-    }
-    u64 GetEntryCount() const override {
+    u32 Read(const u32 count, Entry* entries) override {
         return 0;
     }
     bool Close() const override {

src/core/file_sys/savedata_factory.cpp

@@ -7,7 +7,6 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
-#include "core/core.h"
 #include "core/file_sys/disk_filesystem.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/hle/kernel/process.h"
@@ -18,26 +17,20 @@ SaveData_Factory::SaveData_Factory(std::string nand_directory)
     : nand_directory(std::move(nand_directory)) {}
 
 ResultVal<std::unique_ptr<FileSystemBackend>> SaveData_Factory::Open(const Path& path) {
-    std::string save_directory = GetFullPath();
-    // Return an error if the save data doesn't actually exist.
-    if (!FileUtil::IsDirectory(save_directory)) {
-        // TODO(Subv): Find out correct error code.
-        return ResultCode(-1);
-    }
-
+    u64 title_id = Kernel::g_current_process->program_id;
+    // TODO(Subv): Somehow obtain this value.
+    u32 user = 0;
+    std::string save_directory = Common::StringFromFormat("%ssave/%016" PRIX64 "/%08X",
+                                                          nand_directory.c_str(), title_id, user);
     auto archive = std::make_unique<Disk_FileSystem>(save_directory);
     return MakeResult<std::unique_ptr<FileSystemBackend>>(std::move(archive));
 }
 
-ResultCode SaveData_Factory::Format(const Path& path) {
-    LOG_WARNING(Service_FS, "Format archive %s", GetName().c_str());
-    // Create the save data directory.
-    if (!FileUtil::CreateFullPath(GetFullPath())) {
-        // TODO(Subv): Find the correct error code.
-        return ResultCode(-1);
-    }
-
-    return RESULT_SUCCESS;
+ResultCode SaveData_Factory::Format(const Path& path,
+                                    const FileSys::ArchiveFormatInfo& format_info) {
+    LOG_ERROR(Service_FS, "Unimplemented Format archive %s", GetName().c_str());
+    // TODO(bunnei): Find the right error code for this
+    return ResultCode(-1);
 }
 
 ResultVal<ArchiveFormatInfo> SaveData_Factory::GetFormatInfo(const Path& path) const {
@@ -46,12 +39,4 @@ ResultVal<ArchiveFormatInfo> SaveData_Factory::GetFormatInfo(const Path& path) c
     return ResultCode(-1);
 }
 
-std::string SaveData_Factory::GetFullPath() const {
-    u64 title_id = Core::CurrentProcess()->program_id;
-    // TODO(Subv): Somehow obtain this value.
-    u32 user = 0;
-    return Common::StringFromFormat("%ssave/%016" PRIX64 "/%08X/", nand_directory.c_str(), title_id,
-                                    user);
-}
-
 } // namespace FileSys

src/core/file_sys/savedata_factory.h

@@ -21,13 +21,11 @@ public:
         return "SaveData_Factory";
     }
     ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) override;
-    ResultCode Format(const Path& path) override;
+    ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) override;
     ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
 
 private:
     std::string nand_directory;
-
-    std::string GetFullPath() const;
 };
 
 } // namespace FileSys

src/core/file_sys/sdmc_factory.cpp

@@ -1,40 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cinttypes>
-#include <memory>
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "common/string_util.h"
-#include "core/core.h"
-#include "core/file_sys/disk_filesystem.h"
-#include "core/file_sys/sdmc_factory.h"
-
-namespace FileSys {
-
-SDMC_Factory::SDMC_Factory(std::string sd_directory) : sd_directory(std::move(sd_directory)) {}
-
-ResultVal<std::unique_ptr<FileSystemBackend>> SDMC_Factory::Open(const Path& path) {
-    // Create the SD Card directory if it doesn't already exist.
-    if (!FileUtil::IsDirectory(sd_directory)) {
-        FileUtil::CreateFullPath(sd_directory);
-    }
-
-    auto archive = std::make_unique<Disk_FileSystem>(sd_directory);
-    return MakeResult<std::unique_ptr<FileSystemBackend>>(std::move(archive));
-}
-
-ResultCode SDMC_Factory::Format(const Path& path) {
-    LOG_ERROR(Service_FS, "Unimplemented Format archive %s", GetName().c_str());
-    // TODO(Subv): Find the right error code for this
-    return ResultCode(-1);
-}
-
-ResultVal<ArchiveFormatInfo> SDMC_Factory::GetFormatInfo(const Path& path) const {
-    LOG_ERROR(Service_FS, "Unimplemented GetFormatInfo archive %s", GetName().c_str());
-    // TODO(bunnei): Find the right error code for this
-    return ResultCode(-1);
-}
-
-} // namespace FileSys

src/core/file_sys/sdmc_factory.h

@@ -1,31 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <string>
-#include "common/common_types.h"
-#include "core/file_sys/filesystem.h"
-#include "core/hle/result.h"
-
-namespace FileSys {
-
-/// File system interface to the SDCard archive
-class SDMC_Factory final : public FileSystemFactory {
-public:
-    explicit SDMC_Factory(std::string sd_directory);
-
-    std::string GetName() const override {
-        return "SDMC_Factory";
-    }
-    ResultVal<std::unique_ptr<FileSystemBackend>> Open(const Path& path) override;
-    ResultCode Format(const Path& path) override;
-    ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path) const override;
-
-private:
-    std::string sd_directory;
-};
-
-} // namespace FileSys

src/core/gdbstub/gdbstub.cpp

@@ -693,7 +693,7 @@ static void ReadMemory() {
     u64 len =
         HexToLong(start_offset, static_cast<u64>((command_buffer + command_length) - start_offset));
 
-    LOG_DEBUG(Debug_GDBStub, "gdb: addr: %016lx len: %016lx\n", addr, len);
+    LOG_DEBUG(Debug_GDBStub, "gdb: addr: %016llx len: %016llx\n", addr, len);
 
     if (len * 2 > sizeof(reply)) {
         SendReply("E01");

src/core/hle/kernel/handle_table.cpp

@@ -5,7 +5,6 @@
 #include <utility>
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
@@ -78,7 +77,7 @@ SharedPtr<Object> HandleTable::GetGeneric(Handle handle) const {
     if (handle == CurrentThread) {
         return GetCurrentThread();
     } else if (handle == CurrentProcess) {
-        return Core::CurrentProcess();
+        return g_current_process;
     }
 
     if (!IsValid(handle)) {

src/core/hle/kernel/hle_ipc.cpp

@@ -7,7 +7,6 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/kernel/kernel.h"
@@ -27,32 +26,6 @@ void SessionRequestHandler::ClientDisconnected(SharedPtr<ServerSession> server_s
     boost::range::remove_erase(connected_sessions, server_session);
 }
 
-SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> thread,
-                                                      const std::string& reason, u64 timeout,
-                                                      WakeupCallback&& callback) {
-
-    // Put the client thread to sleep until the wait event is signaled or the timeout expires.
-    thread->wakeup_callback =
-        [context = *this, callback](ThreadWakeupReason reason, SharedPtr<Thread> thread,
-                                    SharedPtr<WaitObject> object, size_t index) mutable -> bool {
-        ASSERT(thread->status == THREADSTATUS_WAIT_HLE_EVENT);
-        callback(thread, context, reason);
-        context.WriteToOutgoingCommandBuffer(*thread);
-        return true;
-    };
-
-    auto event = Kernel::Event::Create(Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
-    thread->status = THREADSTATUS_WAIT_HLE_EVENT;
-    thread->wait_objects = {event};
-    event->AddWaitingThread(thread);
-
-    if (timeout > 0) {
-        thread->WakeAfterDelay(timeout);
-    }
-
-    return event;
-}
-
 HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_session)
     : server_session(std::move(server_session)) {
     cmd_buf[0] = 0;
@@ -62,7 +35,7 @@ HLERequestContext::~HLERequestContext() = default;
 
 void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
     IPC::RequestParser rp(src_cmdbuf);
-    command_header = std::make_shared<IPC::CommandHeader>(rp.PopRaw<IPC::CommandHeader>());
+    command_header = std::make_unique<IPC::CommandHeader>(rp.PopRaw<IPC::CommandHeader>());
 
     if (command_header->type == IPC::CommandType::Close) {
         // Close does not populate the rest of the IPC header
@@ -72,7 +45,7 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
     // If handle descriptor is present, add size of it
     if (command_header->enable_handle_descriptor) {
         handle_descriptor_header =
-            std::make_shared<IPC::HandleDescriptorHeader>(rp.PopRaw<IPC::HandleDescriptorHeader>());
+            std::make_unique<IPC::HandleDescriptorHeader>(rp.PopRaw<IPC::HandleDescriptorHeader>());
         if (handle_descriptor_header->send_current_pid) {
             rp.Skip(2, false);
         }
@@ -115,7 +88,7 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
         // All outgoing domain messages have the domain header, if only incoming has it
         if (incoming || domain_message_header) {
             domain_message_header =
-                std::make_shared<IPC::DomainMessageHeader>(rp.PopRaw<IPC::DomainMessageHeader>());
+                std::make_unique<IPC::DomainMessageHeader>(rp.PopRaw<IPC::DomainMessageHeader>());
         } else {
             if (Session()->IsDomain())
                 LOG_WARNING(IPC, "Domain request has no DomainMessageHeader!");
@@ -123,7 +96,7 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
     }
 
     data_payload_header =
-        std::make_shared<IPC::DataPayloadHeader>(rp.PopRaw<IPC::DataPayloadHeader>());
+        std::make_unique<IPC::DataPayloadHeader>(rp.PopRaw<IPC::DataPayloadHeader>());
 
     data_payload_offset = rp.GetCurrentOffset();
 
@@ -186,11 +159,8 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(u32_le* src_cmdb
     return RESULT_SUCCESS;
 }
 
-ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
-    std::array<u32, IPC::COMMAND_BUFFER_LENGTH> dst_cmdbuf;
-    Memory::ReadBlock(*thread.owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
-                      dst_cmdbuf.size() * sizeof(u32));
-
+ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(u32_le* dst_cmdbuf, Process& dst_process,
+                                                           HandleTable& dst_table) {
     // The header was already built in the internal command buffer. Attempt to parse it to verify
     // the integrity and then copy it over to the target command buffer.
     ParseCommandBuffer(cmd_buf.data(), false);
@@ -201,7 +171,7 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
     if (domain_message_header)
         size -= sizeof(IPC::DomainMessageHeader) / sizeof(u32);
 
-    std::copy_n(cmd_buf.begin(), size, dst_cmdbuf.data());
+    std::copy_n(cmd_buf.begin(), size, dst_cmdbuf);
 
     if (command_header->enable_handle_descriptor) {
         ASSERT_MSG(!move_objects.empty() || !copy_objects.empty(),
@@ -243,11 +213,6 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(Thread& thread) {
             dst_cmdbuf[domain_offset++] = static_cast<u32_le>(request_handlers.size());
         }
     }
-
-    // Copy the translated command buffer back into the thread's command buffer area.
-    Memory::WriteBlock(*thread.owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
-                       dst_cmdbuf.size() * sizeof(u32));
-
     return RESULT_SUCCESS;
 }
 
@@ -268,11 +233,8 @@ std::vector<u8> HLERequestContext::ReadBuffer() const {
 
 size_t HLERequestContext::WriteBuffer(const void* buffer, size_t size) const {
     const bool is_buffer_b{BufferDescriptorB().size() && BufferDescriptorB()[0].Size()};
-    const size_t buffer_size{GetWriteBufferSize()};
-    if (size > buffer_size) {
-        LOG_CRITICAL(Core, "size (%016zx) is greater than buffer_size (%016zx)", size, buffer_size);
-        size = buffer_size; // TODO(bunnei): This needs to be HW tested
-    }
+
+    ASSERT_MSG(size <= GetWriteBufferSize(), "Size %d is too big", size);
 
     if (is_buffer_b) {
         Memory::WriteBlock(BufferDescriptorB()[0].Address(), buffer, size);

src/core/hle/kernel/hle_ipc.h

@@ -6,7 +6,6 @@
 
 #include <array>
 #include <memory>
-#include <string>
 #include <vector>
 #include <boost/container/small_vector.hpp>
 #include "common/common_types.h"
@@ -14,7 +13,6 @@
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/server_session.h"
-#include "core/hle/kernel/thread.h"
 
 namespace Service {
 class ServiceFrameworkBase;
@@ -26,7 +24,6 @@ class Domain;
 class HandleTable;
 class HLERequestContext;
 class Process;
-class Event;
 
 /**
  * Interface implemented by HLE Session handlers.
@@ -105,31 +102,14 @@ public:
         return server_session;
     }
 
-    using WakeupCallback = std::function<void(SharedPtr<Thread> thread, HLERequestContext& context,
-                                              ThreadWakeupReason reason)>;
-
-    /**
-     * Puts the specified guest thread to sleep until the returned event is signaled or until the
-     * specified timeout expires.
-     * @param thread Thread to be put to sleep.
-     * @param reason Reason for pausing the thread, to be used for debugging purposes.
-     * @param timeout Timeout in nanoseconds after which the thread will be awoken and the callback
-     * invoked with a Timeout reason.
-     * @param callback Callback to be invoked when the thread is resumed. This callback must write
-     * the entire command response once again, regardless of the state of it before this function
-     * was called.
-     * @returns Event that when signaled will resume the thread and call the callback function.
-     */
-    SharedPtr<Event> SleepClientThread(SharedPtr<Thread> thread, const std::string& reason,
-                                       u64 timeout, WakeupCallback&& callback);
-
     void ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming);
 
     /// Populates this context with data from the requesting process/thread.
     ResultCode PopulateFromIncomingCommandBuffer(u32_le* src_cmdbuf, Process& src_process,
                                                  HandleTable& src_table);
     /// Writes data from this context back to the requesting process/thread.
-    ResultCode WriteToOutgoingCommandBuffer(Thread& thread);
+    ResultCode WriteToOutgoingCommandBuffer(u32_le* dst_cmdbuf, Process& dst_process,
+                                            HandleTable& dst_table);
 
     u32_le GetCommand() const {
         return command;
@@ -159,7 +139,7 @@ public:
         return buffer_c_desciptors;
     }
 
-    const std::shared_ptr<IPC::DomainMessageHeader>& GetDomainMessageHeader() const {
+    const std::unique_ptr<IPC::DomainMessageHeader>& GetDomainMessageHeader() const {
         return domain_message_header;
     }
 
@@ -232,10 +212,10 @@ private:
     boost::container::small_vector<SharedPtr<Object>, 8> copy_objects;
     boost::container::small_vector<std::shared_ptr<SessionRequestHandler>, 8> domain_objects;
 
-    std::shared_ptr<IPC::CommandHeader> command_header;
-    std::shared_ptr<IPC::HandleDescriptorHeader> handle_descriptor_header;
-    std::shared_ptr<IPC::DataPayloadHeader> data_payload_header;
-    std::shared_ptr<IPC::DomainMessageHeader> domain_message_header;
+    std::unique_ptr<IPC::CommandHeader> command_header;
+    std::unique_ptr<IPC::HandleDescriptorHeader> handle_descriptor_header;
+    std::unique_ptr<IPC::DataPayloadHeader> data_payload_header;
+    std::unique_ptr<IPC::DomainMessageHeader> domain_message_header;
     std::vector<IPC::BufferDescriptorX> buffer_x_desciptors;
     std::vector<IPC::BufferDescriptorABW> buffer_a_desciptors;
     std::vector<IPC::BufferDescriptorABW> buffer_b_desciptors;

src/core/hle/kernel/kernel.cpp

@@ -41,6 +41,7 @@ void Shutdown() {
     g_object_address_table.Clear();
 
     Kernel::ThreadingShutdown();
+    g_current_process = nullptr;
 
     Kernel::TimersShutdown();
     Kernel::ResourceLimitsShutdown();

src/core/hle/kernel/kernel.h

@@ -33,6 +33,10 @@ enum class HandleType : u32 {
     ServerSession,
 };
 
+enum {
+    DEFAULT_STACK_SIZE = 0x10000,
+};
+
 enum class ResetType {
     OneShot,
     Sticky,

src/core/hle/kernel/object_address_table.cpp

@@ -10,12 +10,12 @@ namespace Kernel {
 ObjectAddressTable g_object_address_table;
 
 void ObjectAddressTable::Insert(VAddr addr, SharedPtr<Object> obj) {
-    ASSERT_MSG(objects.find(addr) == objects.end(), "Object already exists with addr=0x%lx", addr);
+    ASSERT_MSG(objects.find(addr) == objects.end(), "Object already exists with addr=0x%llx", addr);
     objects[addr] = obj;
 }
 
 void ObjectAddressTable::Close(VAddr addr) {
-    ASSERT_MSG(objects.find(addr) != objects.end(), "Object does not exist with addr=0x%lx", addr);
+    ASSERT_MSG(objects.find(addr) != objects.end(), "Object does not exist with addr=0x%llx", addr);
     objects.erase(addr);
 }
 

src/core/hle/kernel/process.cpp

@@ -31,14 +31,14 @@ CodeSet::~CodeSet() {}
 
 u32 Process::next_process_id;
 
-SharedPtr<Process> Process::Create(std::string&& name) {
+SharedPtr<Process> Process::Create(std::string&& name, u64 program_id) {
     SharedPtr<Process> process(new Process);
 
     process->name = std::move(name);
     process->flags.raw = 0;
     process->flags.memory_region.Assign(MemoryRegion::APPLICATION);
     process->status = ProcessStatus::Created;
-    process->program_id = 0;
+    process->program_id = program_id;
 
     process_list.push_back(process);
     return process;
@@ -117,13 +117,11 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
 }
 
 void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) {
-    // Allocate and map the main thread stack
-    // TODO(bunnei): This is heap area that should be allocated by the kernel and not mapped as part
-    // of the user address space.
+    // Allocate and map stack
     vm_manager
-        .MapMemoryBlock(Memory::STACK_AREA_VADDR_END - stack_size,
+        .MapMemoryBlock(Memory::HEAP_VADDR_END - stack_size,
                         std::make_shared<std::vector<u8>>(stack_size, 0), 0, stack_size,
-                        MemoryState::Mapped)
+                        MemoryState::Heap)
         .Unwrap();
     misc_memory_used += stack_size;
     memory_region->used += stack_size;
@@ -155,9 +153,9 @@ void Process::LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr) {
     };
 
     // Map CodeSet segments
-    MapSegment(module_->code, VMAPermission::ReadExecute, MemoryState::CodeStatic);
-    MapSegment(module_->rodata, VMAPermission::Read, MemoryState::CodeMutable);
-    MapSegment(module_->data, VMAPermission::ReadWrite, MemoryState::CodeMutable);
+    MapSegment(module_->code, VMAPermission::ReadExecute, MemoryState::Code);
+    MapSegment(module_->rodata, VMAPermission::Read, MemoryState::Static);
+    MapSegment(module_->data, VMAPermission::ReadWrite, MemoryState::Static);
 }
 
 VAddr Process::GetLinearHeapAreaAddress() const {
@@ -184,8 +182,6 @@ ResultVal<VAddr> Process::HeapAllocate(VAddr target, u64 size, VMAPermission per
         // Initialize heap
         heap_memory = std::make_shared<std::vector<u8>>();
         heap_start = heap_end = target;
-    } else {
-        vm_manager.UnmapRange(heap_start, heap_end - heap_start);
     }
 
     // If necessary, expand backing vector to cover new heap extents.
@@ -205,7 +201,7 @@ ResultVal<VAddr> Process::HeapAllocate(VAddr target, u64 size, VMAPermission per
                                                        size, MemoryState::Heap));
     vm_manager.Reprotect(vma, perms);
 
-    heap_used = size;
+    heap_used += size;
     memory_region->used += size;
 
     return MakeResult<VAddr>(heap_end - size);
@@ -292,7 +288,7 @@ ResultCode Process::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
 
     CASCADE_RESULT(auto new_vma,
                    vm_manager.MapMemoryBlock(dst_addr, backing_block, backing_block_offset, size,
-                                             MemoryState::Mapped));
+                                             vma->second.meminfo_state));
     // Protect mirror with permissions from old region
     vm_manager.Reprotect(new_vma, vma->second.permissions);
     // Remove permissions from old region
@@ -323,4 +319,5 @@ SharedPtr<Process> GetProcessById(u32 process_id) {
     return *itr;
 }
 
+SharedPtr<Process> g_current_process;
 } // namespace Kernel

src/core/hle/kernel/process.h

@@ -95,7 +95,7 @@ private:
 
 class Process final : public Object {
 public:
-    static SharedPtr<Process> Create(std::string&& name);
+    static SharedPtr<Process> Create(std::string&& name, u64 program_id);
 
     std::string GetTypeName() const override {
         return "Process";
@@ -203,4 +203,5 @@ void ClearProcessList();
 /// Retrieves a process from the current list of processes.
 SharedPtr<Process> GetProcessById(u32 process_id);
 
+extern SharedPtr<Process> g_current_process;
 } // namespace Kernel

src/core/hle/kernel/scheduler.cpp

@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
@@ -68,7 +67,7 @@ void Scheduler::SwitchContext(Thread* new_thread) {
         // Cancel any outstanding wakeup events for this thread
         new_thread->CancelWakeupTimer();
 
-        auto previous_process = Core::CurrentProcess();
+        auto previous_process = Kernel::g_current_process;
 
         current_thread = new_thread;
 
@@ -76,8 +75,8 @@ void Scheduler::SwitchContext(Thread* new_thread) {
         new_thread->status = THREADSTATUS_RUNNING;
 
         if (previous_process != current_thread->owner_process) {
-            Core::CurrentProcess() = current_thread->owner_process;
-            SetCurrentPageTable(&Core::CurrentProcess()->vm_manager.page_table);
+            Kernel::g_current_process = current_thread->owner_process;
+            SetCurrentPageTable(&Kernel::g_current_process->vm_manager.page_table);
         }
 
         cpu_core->LoadContext(new_thread->context);

src/core/hle/kernel/server_session.cpp

@@ -4,7 +4,6 @@
 
 #include <tuple>
 
-#include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
@@ -78,8 +77,7 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
         }
         }
 
-        LOG_CRITICAL(IPC, "Unknown domain command=%d",
-                     static_cast<int>(domain_message_header->command.Value()));
+        LOG_CRITICAL(IPC, "Unknown domain command=%d", domain_message_header->command.Value());
         ASSERT(false);
     }
 
@@ -93,7 +91,7 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
 
     Kernel::HLERequestContext context(this);
     u32* cmd_buf = (u32*)Memory::GetPointer(thread->GetTLSAddress());
-    context.PopulateFromIncomingCommandBuffer(cmd_buf, *Core::CurrentProcess(),
+    context.PopulateFromIncomingCommandBuffer(cmd_buf, *Kernel::g_current_process,
                                               Kernel::g_handle_table);
 
     ResultCode result = RESULT_SUCCESS;

src/core/hle/kernel/shared_memory.cpp

@@ -4,7 +4,6 @@
 
 #include <cstring>
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/shared_memory.h"
@@ -52,8 +51,8 @@ SharedPtr<SharedMemory> SharedMemory::Create(SharedPtr<Process> owner_process, u
         }
 
         // Refresh the address mappings for the current process.
-        if (Core::CurrentProcess() != nullptr) {
-            Core::CurrentProcess()->vm_manager.RefreshMemoryBlockMappings(linheap_memory.get());
+        if (Kernel::g_current_process != nullptr) {
+            Kernel::g_current_process->vm_manager.RefreshMemoryBlockMappings(linheap_memory.get());
         }
     } else {
         auto& vm_manager = shared_memory->owner_process->vm_manager;
@@ -107,7 +106,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
 
     // Error out if the requested permissions don't match what the creator process allows.
     if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
-        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%lx name=%s, permissions don't match",
+        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%llx name=%s, permissions don't match",
                   GetObjectId(), address, name.c_str());
         return ERR_INVALID_COMBINATION;
     }
@@ -115,7 +114,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
     // Error out if the provided permissions are not compatible with what the creator process needs.
     if (other_permissions != MemoryPermission::DontCare &&
         static_cast<u32>(this->permissions) & ~static_cast<u32>(other_permissions)) {
-        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%lx name=%s, permissions don't match",
+        LOG_ERROR(Kernel, "cannot map id=%u, address=0x%llx name=%s, permissions don't match",
                   GetObjectId(), address, name.c_str());
         return ERR_WRONG_PERMISSION;
     }
@@ -126,7 +125,7 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
     if (address != 0) {
         // TODO(shinyquagsire23): Check for virtual/mappable memory here too?
         if (address >= Memory::HEAP_VADDR && address < Memory::HEAP_VADDR_END) {
-            LOG_ERROR(Kernel, "cannot map id=%u, address=0x%lx name=%s, invalid address",
+            LOG_ERROR(Kernel, "cannot map id=%u, address=0x%llx name=%s, invalid address",
                       GetObjectId(), address, name.c_str());
             return ERR_INVALID_ADDRESS;
         }
@@ -143,9 +142,10 @@ ResultCode SharedMemory::Map(Process* target_process, VAddr address, MemoryPermi
     auto result = target_process->vm_manager.MapMemoryBlock(
         target_address, backing_block, backing_block_offset, size, MemoryState::Shared);
     if (result.Failed()) {
-        LOG_ERROR(Kernel,
-                  "cannot map id=%u, target_address=0x%lx name=%s, error mapping to virtual memory",
-                  GetObjectId(), target_address, name.c_str());
+        LOG_ERROR(
+            Kernel,
+            "cannot map id=%u, target_address=0x%llx name=%s, error mapping to virtual memory",
+            GetObjectId(), target_address, name.c_str());
         return result.Code();
     }
 

src/core/hle/kernel/svc.cpp

@@ -8,7 +8,6 @@
 #include "common/logging/log.h"
 #include "common/microprofile.h"
 #include "common/string_util.h"
-#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
@@ -32,14 +31,14 @@ namespace Kernel {
 /// Set the process heap to a given Size. It can both extend and shrink the heap.
 static ResultCode SetHeapSize(VAddr* heap_addr, u64 heap_size) {
     LOG_TRACE(Kernel_SVC, "called, heap_size=0x%llx", heap_size);
-    auto& process = *Core::CurrentProcess();
+    auto& process = *g_current_process;
     CASCADE_RESULT(*heap_addr,
                    process.HeapAllocate(Memory::HEAP_VADDR, heap_size, VMAPermission::ReadWrite));
     return RESULT_SUCCESS;
 }
 
 static ResultCode SetMemoryAttribute(VAddr addr, u64 size, u32 state0, u32 state1) {
-    LOG_WARNING(Kernel_SVC, "(STUBBED) called, addr=0x%lx", addr);
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called, addr=0x%llx", addr);
     return RESULT_SUCCESS;
 }
 
@@ -47,14 +46,14 @@ static ResultCode SetMemoryAttribute(VAddr addr, u64 size, u32 state0, u32 state
 static ResultCode MapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
     LOG_TRACE(Kernel_SVC, "called, dst_addr=0x%llx, src_addr=0x%llx, size=0x%llx", dst_addr,
               src_addr, size);
-    return Core::CurrentProcess()->MirrorMemory(dst_addr, src_addr, size);
+    return g_current_process->MirrorMemory(dst_addr, src_addr, size);
 }
 
 /// Unmaps a region that was previously mapped with svcMapMemory
 static ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size) {
     LOG_TRACE(Kernel_SVC, "called, dst_addr=0x%llx, src_addr=0x%llx, size=0x%llx", dst_addr,
               src_addr, size);
-    return Core::CurrentProcess()->UnmapMemory(dst_addr, src_addr, size);
+    return g_current_process->UnmapMemory(dst_addr, src_addr, size);
 }
 
 /// Connect to an OS service given the port name, returns the handle to the port to out
@@ -307,23 +306,23 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
     LOG_TRACE(Kernel_SVC, "called info_id=0x%X, info_sub_id=0x%X, handle=0x%08X", info_id,
               info_sub_id, handle);
 
-    auto& vm_manager = Core::CurrentProcess()->vm_manager;
+    auto& vm_manager = g_current_process->vm_manager;
 
     switch (static_cast<GetInfoType>(info_id)) {
     case GetInfoType::AllowedCpuIdBitmask:
-        *result = Core::CurrentProcess()->allowed_processor_mask;
+        *result = g_current_process->allowed_processor_mask;
         break;
     case GetInfoType::AllowedThreadPrioBitmask:
-        *result = Core::CurrentProcess()->allowed_thread_priority_mask;
+        *result = g_current_process->allowed_thread_priority_mask;
         break;
     case GetInfoType::MapRegionBaseAddr:
-        *result = Memory::MAP_REGION_VADDR;
+        *result = vm_manager.GetMapRegionBaseAddr();
         break;
     case GetInfoType::MapRegionSize:
-        *result = Memory::MAP_REGION_SIZE;
+        *result = vm_manager.GetAddressSpaceSize();
         break;
     case GetInfoType::HeapRegionBaseAddr:
-        *result = Memory::HEAP_VADDR;
+        *result = vm_manager.GetNewMapRegionBaseAddr() + vm_manager.GetNewMapRegionSize();
         break;
     case GetInfoType::HeapRegionSize:
         *result = Memory::HEAP_SIZE;
@@ -347,13 +346,13 @@ static ResultCode GetInfo(u64* result, u64 info_id, u64 handle, u64 info_sub_id)
         *result = vm_manager.GetAddressSpaceSize();
         break;
     case GetInfoType::NewMapRegionBaseAddr:
-        *result = Memory::NEW_MAP_REGION_VADDR;
+        *result = vm_manager.GetNewMapRegionBaseAddr();
         break;
     case GetInfoType::NewMapRegionSize:
-        *result = Memory::NEW_MAP_REGION_SIZE;
+        *result = vm_manager.GetNewMapRegionSize();
         break;
     case GetInfoType::IsVirtualAddressMemoryEnabled:
-        *result = Core::CurrentProcess()->is_virtual_address_memory_enabled;
+        *result = g_current_process->is_virtual_address_memory_enabled;
         break;
     case GetInfoType::TitleId:
         LOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query titleid, returned 0");
@@ -393,7 +392,7 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
 
     // Note: The kernel uses the current process's resource limit instead of
     // the one from the thread owner's resource limit.
-    SharedPtr<ResourceLimit>& resource_limit = Core::CurrentProcess()->resource_limit;
+    SharedPtr<ResourceLimit>& resource_limit = g_current_process->resource_limit;
     if (resource_limit->GetMaxResourceValue(ResourceTypes::PRIORITY) > priority) {
         return ERR_NOT_AUTHORIZED;
     }
@@ -436,7 +435,7 @@ static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 s
     case MemoryPermission::WriteExecute:
     case MemoryPermission::ReadWriteExecute:
     case MemoryPermission::DontCare:
-        return shared_memory->Map(Core::CurrentProcess().get(), addr, permissions_type,
+        return shared_memory->Map(g_current_process.get(), addr, permissions_type,
                                   MemoryPermission::DontCare);
     default:
         LOG_ERROR(Kernel_SVC, "unknown permissions=0x%08X", permissions);
@@ -452,7 +451,7 @@ static ResultCode UnmapSharedMemory(Handle shared_memory_handle, VAddr addr, u64
 
     SharedPtr<SharedMemory> shared_memory = g_handle_table.Get<SharedMemory>(shared_memory_handle);
 
-    return shared_memory->Unmap(Core::CurrentProcess().get(), addr);
+    return shared_memory->Unmap(g_current_process.get(), addr);
 }
 
 /// Query process memory
@@ -464,11 +463,11 @@ static ResultCode QueryProcessMemory(MemoryInfo* memory_info, PageInfo* /*page_i
     }
     auto vma = process->vm_manager.FindVMA(addr);
     memory_info->attributes = 0;
-    if (vma == Core::CurrentProcess()->vm_manager.vma_map.end()) {
+    if (vma == g_current_process->vm_manager.vma_map.end()) {
         memory_info->base_address = 0;
         memory_info->permission = static_cast<u32>(VMAPermission::None);
         memory_info->size = 0;
-        memory_info->type = static_cast<u32>(MemoryState::Unmapped);
+        memory_info->type = static_cast<u32>(MemoryState::Free);
     } else {
         memory_info->base_address = vma->second.base;
         memory_info->permission = static_cast<u32>(vma->second.permissions);
@@ -488,17 +487,16 @@ static ResultCode QueryMemory(MemoryInfo* memory_info, PageInfo* page_info, VAdd
 
 /// Exits the current process
 static void ExitProcess() {
-    LOG_INFO(Kernel_SVC, "Process %u exiting", Core::CurrentProcess()->process_id);
+    LOG_INFO(Kernel_SVC, "Process %u exiting", g_current_process->process_id);
 
-    ASSERT_MSG(Core::CurrentProcess()->status == ProcessStatus::Running,
-               "Process has already exited");
+    ASSERT_MSG(g_current_process->status == ProcessStatus::Running, "Process has already exited");
 
-    Core::CurrentProcess()->status = ProcessStatus::Exited;
+    g_current_process->status = ProcessStatus::Exited;
 
     // Stop all the process threads that are currently waiting for objects.
     auto& thread_list = Core::System::GetInstance().Scheduler().GetThreadList();
     for (auto& thread : thread_list) {
-        if (thread->owner_process != Core::CurrentProcess())
+        if (thread->owner_process != g_current_process)
             continue;
 
         if (thread == GetCurrentThread())
@@ -527,14 +525,14 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
         return ERR_OUT_OF_RANGE;
     }
 
-    SharedPtr<ResourceLimit>& resource_limit = Core::CurrentProcess()->resource_limit;
+    SharedPtr<ResourceLimit>& resource_limit = g_current_process->resource_limit;
     if (resource_limit->GetMaxResourceValue(ResourceTypes::PRIORITY) > priority) {
         return ERR_NOT_AUTHORIZED;
     }
 
     if (processor_id == THREADPROCESSORID_DEFAULT) {
         // Set the target CPU to the one specified in the process' exheader.
-        processor_id = Core::CurrentProcess()->ideal_processor;
+        processor_id = g_current_process->ideal_processor;
         ASSERT(processor_id != THREADPROCESSORID_DEFAULT);
     }
 
@@ -556,7 +554,7 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
 
     CASCADE_RESULT(SharedPtr<Thread> thread,
                    Thread::Create(name, entry_point, priority, arg, processor_id, stack_top,
-                                  Core::CurrentProcess()));
+                                  g_current_process));
     CASCADE_RESULT(thread->guest_handle, g_handle_table.Create(thread));
     *out_handle = thread->guest_handle;
 
@@ -750,22 +748,14 @@ static ResultCode ResetSignal(Handle handle) {
 
 /// Creates a TransferMemory object
 static ResultCode CreateTransferMemory(Handle* handle, VAddr addr, u64 size, u32 permissions) {
-    LOG_WARNING(Kernel_SVC, "(STUBBED) called addr=0x%lx, size=0x%lx, perms=%08X", addr, size,
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called addr=0x%llx, size=0x%llx, perms=%08X", addr, size,
                 permissions);
     *handle = 0;
     return RESULT_SUCCESS;
 }
 
-static ResultCode GetThreadCoreMask(Handle handle, u32* mask, u64* unknown) {
-    LOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x%08X", handle);
-    *mask = 0x0;
-    *unknown = 0xf;
-    return RESULT_SUCCESS;
-}
-
-static ResultCode SetThreadCoreMask(Handle handle, u32 mask, u64 unknown) {
-    LOG_WARNING(Kernel_SVC, "(STUBBED) called, handle=0x%08X, mask=0x%08X, unknown=0x%lx", handle,
-                mask, unknown);
+static ResultCode SetThreadCoreMask(u64, u64, u64) {
+    LOG_WARNING(Kernel_SVC, "(STUBBED) called");
     return RESULT_SUCCESS;
 }
 
@@ -817,7 +807,7 @@ static const FunctionDef SVC_Table[] = {
     {0x0B, SvcWrap<SleepThread>, "SleepThread"},
     {0x0C, SvcWrap<GetThreadPriority>, "GetThreadPriority"},
     {0x0D, SvcWrap<SetThreadPriority>, "SetThreadPriority"},
-    {0x0E, SvcWrap<GetThreadCoreMask>, "GetThreadCoreMask"},
+    {0x0E, nullptr, "GetThreadCoreMask"},
     {0x0F, SvcWrap<SetThreadCoreMask>, "SetThreadCoreMask"},
     {0x10, SvcWrap<GetCurrentProcessorNumber>, "GetCurrentProcessorNumber"},
     {0x11, nullptr, "SignalEvent"},