Fix clang-format

.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

.travis.yml

@@ -3,11 +3,16 @@ matrix:
   include:
     - os: linux
       env: NAME="clang-format"
-      sudo: required
       dist: trusty
-      services: docker
-      install: "./.travis/clang-format/deps.sh"
-      script: "./.travis/clang-format/build.sh"
+      addons:
+        apt:
+          sources:
+            - sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-6.0 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+            - sourceline: 'deb http://ppa.launchpad.net/ubuntu-toolchain-r/test/ubuntu trusty main'
+          packages:
+            - clang-format-6.0
+      script: "./.travis/clang-format/script.sh"
     - os: linux
       env: NAME="linux build"
       sudo: required
@@ -37,8 +42,3 @@ deploy:
   skip_cleanup: true
   on:
     tags: true
-
-notifications:
-  webhooks:
-    urls:
-      - https://api.yuzu-emu.org/code/travis/notify

.travis/clang-format/build.sh

@@ -1,3 +0,0 @@
-#!/bin/bash -ex
-
-docker run -v $(pwd):/yuzu ubuntu:18.04 /bin/bash -ex /yuzu/.travis/clang-format/docker.sh

.travis/clang-format/deps.sh

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

.travis/clang-format/docker.sh

@@ -1,8 +0,0 @@
-#!/bin/bash -ex
-
-apt-get update
-apt-get install -y clang-format-6.0
-
-# Run clang-format
-cd /yuzu
-./.travis/clang-format/script.sh

.travis/macos/build.sh

@@ -2,13 +2,13 @@
 
 set -o pipefail
 
-export MACOSX_DEPLOYMENT_TARGET=10.12
+export MACOSX_DEPLOYMENT_TARGET=10.9
 export Qt5_DIR=$(brew --prefix)/opt/qt5
 export UNICORNDIR=$(pwd)/externals/unicorn
 
 mkdir build && cd build
 cmake --version
-cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release
+cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_OSX_ARCHITECTURES="x86_64;x86_64h" -DCMAKE_BUILD_TYPE=Release
 make -j4
 
 ctest -VV -C Release

CMakeLists.txt

@@ -13,7 +13,7 @@ option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON "ENABLE_SDL2;MSVC" OFF)
 
 option(ENABLE_QT "Enable the Qt frontend" ON)
-CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_QT;MSVC" OFF)
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_SDL2;MSVC" OFF)
 
 option(YUZU_USE_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)
 
@@ -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()
@@ -426,7 +423,7 @@ if(ENABLE_QT AND UNIX AND NOT APPLE)
     install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.desktop"
             DESTINATION "${CMAKE_INSTALL_PREFIX}/share/applications")
     install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.svg"
-            DESTINATION "${CMAKE_INSTALL_PREFIX}/share/icons/hicolor/scalable/apps")
+            DESTINATION "${CMAKE_INSTALL_PREFIX}/share/pixmaps")
     install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.xml"
             DESTINATION "${CMAKE_INSTALL_PREFIX}/share/mime/packages")
 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/CMakeLists.txt

@@ -17,7 +17,6 @@ endif()
 
 # libfmt
 add_subdirectory(fmt)
-add_library(fmt::fmt ALIAS fmt)
 
 # getopt
 if (MSVC)

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

@@ -32,8 +32,6 @@ add_library(common STATIC
     break_points.cpp
     break_points.h
     chunk_file.h
-    cityhash.cpp
-    cityhash.h
     code_block.h
     color.h
     common_funcs.h
@@ -41,6 +39,7 @@ add_library(common STATIC
     common_types.h
     file_util.cpp
     file_util.h
+    hash.cpp
     hash.h
     linear_disk_cache.h
     logging/backend.cpp
@@ -59,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
@@ -90,7 +90,7 @@ endif()
 
 create_target_directory_groups(common)
 
-target_link_libraries(common PUBLIC Boost::boost fmt microprofile)
+target_link_libraries(common PUBLIC Boost::boost microprofile)
 if (ARCHITECTURE_x86_64)
     target_link_libraries(common PRIVATE xbyak)
 endif()

src/common/bit_field.h

@@ -115,7 +115,7 @@ private:
     // assignment would copy the full storage value, rather than just the bits
     // relevant to this particular bit field.
     // We don't delete it because we want BitField to be trivially copyable.
-    constexpr BitField& operator=(const BitField&) = default;
+    BitField& operator=(const BitField&) = default;
 
     // StorageType is T for non-enum types and the underlying type of T if
     // T is an enumeration. Note that T is wrapped within an enable_if in the
@@ -166,20 +166,20 @@ public:
     // so that we can use this within unions
     constexpr BitField() = default;
 
-    constexpr FORCE_INLINE operator T() const {
+    FORCE_INLINE operator T() const {
         return Value();
     }
 
-    constexpr FORCE_INLINE void Assign(const T& value) {
+    FORCE_INLINE void Assign(const T& value) {
         storage = (storage & ~mask) | FormatValue(value);
     }
 
-    constexpr T Value() const {
+    FORCE_INLINE T Value() const {
         return ExtractValue(storage);
     }
 
     // TODO: we may want to change this to explicit operator bool() if it's bug-free in VS2015
-    constexpr FORCE_INLINE bool ToBool() const {
+    FORCE_INLINE bool ToBool() const {
         return Value() != 0;
     }
 
@@ -192,6 +192,11 @@ private:
     static_assert(position < 8 * sizeof(T), "Invalid position");
     static_assert(bits <= 8 * sizeof(T), "Invalid number of bits");
     static_assert(bits > 0, "Invalid number of bits");
-    static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable in a BitField");
+    static_assert(std::is_pod<T>::value, "Invalid base type");
 };
 #pragma pack()
+
+#if (__GNUC__ >= 5) || defined(__clang__) || defined(_MSC_VER)
+static_assert(std::is_trivially_copyable<BitField<0, 1, unsigned>>::value,
+              "BitField must be trivially copyable");
+#endif

src/common/cityhash.cpp

@@ -1,340 +0,0 @@
-// Copyright (c) 2011 Google, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-// CityHash, by Geoff Pike and Jyrki Alakuijala
-//
-// This file provides CityHash64() and related functions.
-//
-// It's probably possible to create even faster hash functions by
-// writing a program that systematically explores some of the space of
-// possible hash functions, by using SIMD instructions, or by
-// compromising on hash quality.
-
-#include <algorithm>
-#include <string.h> // for memcpy and memset
-#include "cityhash.h"
-#include "common/swap.h"
-
-// #include "config.h"
-#ifdef __GNUC__
-#define HAVE_BUILTIN_EXPECT 1
-#endif
-#ifdef COMMON_BIG_ENDIAN
-#define WORDS_BIGENDIAN 1
-#endif
-
-using namespace std;
-
-typedef uint8_t uint8;
-typedef uint32_t uint32;
-typedef uint64_t uint64;
-
-namespace Common {
-
-static uint64 UNALIGNED_LOAD64(const char* p) {
-    uint64 result;
-    memcpy(&result, p, sizeof(result));
-    return result;
-}
-
-static uint32 UNALIGNED_LOAD32(const char* p) {
-    uint32 result;
-    memcpy(&result, p, sizeof(result));
-    return result;
-}
-
-#ifdef WORDS_BIGENDIAN
-#define uint32_in_expected_order(x) (swap32(x))
-#define uint64_in_expected_order(x) (swap64(x))
-#else
-#define uint32_in_expected_order(x) (x)
-#define uint64_in_expected_order(x) (x)
-#endif
-
-#if !defined(LIKELY)
-#if HAVE_BUILTIN_EXPECT
-#define LIKELY(x) (__builtin_expect(!!(x), 1))
-#else
-#define LIKELY(x) (x)
-#endif
-#endif
-
-static uint64 Fetch64(const char* p) {
-    return uint64_in_expected_order(UNALIGNED_LOAD64(p));
-}
-
-static uint32 Fetch32(const char* p) {
-    return uint32_in_expected_order(UNALIGNED_LOAD32(p));
-}
-
-// Some primes between 2^63 and 2^64 for various uses.
-static const uint64 k0 = 0xc3a5c85c97cb3127ULL;
-static const uint64 k1 = 0xb492b66fbe98f273ULL;
-static const uint64 k2 = 0x9ae16a3b2f90404fULL;
-
-// Bitwise right rotate.  Normally this will compile to a single
-// instruction, especially if the shift is a manifest constant.
-static uint64 Rotate(uint64 val, int shift) {
-    // Avoid shifting by 64: doing so yields an undefined result.
-    return shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
-}
-
-static uint64 ShiftMix(uint64 val) {
-    return val ^ (val >> 47);
-}
-
-static uint64 HashLen16(uint64 u, uint64 v) {
-    return Hash128to64(uint128(u, v));
-}
-
-static uint64 HashLen16(uint64 u, uint64 v, uint64 mul) {
-    // Murmur-inspired hashing.
-    uint64 a = (u ^ v) * mul;
-    a ^= (a >> 47);
-    uint64 b = (v ^ a) * mul;
-    b ^= (b >> 47);
-    b *= mul;
-    return b;
-}
-
-static uint64 HashLen0to16(const char* s, size_t len) {
-    if (len >= 8) {
-        uint64 mul = k2 + len * 2;
-        uint64 a = Fetch64(s) + k2;
-        uint64 b = Fetch64(s + len - 8);
-        uint64 c = Rotate(b, 37) * mul + a;
-        uint64 d = (Rotate(a, 25) + b) * mul;
-        return HashLen16(c, d, mul);
-    }
-    if (len >= 4) {
-        uint64 mul = k2 + len * 2;
-        uint64 a = Fetch32(s);
-        return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
-    }
-    if (len > 0) {
-        uint8 a = s[0];
-        uint8 b = s[len >> 1];
-        uint8 c = s[len - 1];
-        uint32 y = static_cast<uint32>(a) + (static_cast<uint32>(b) << 8);
-        uint32 z = static_cast<uint32>(len) + (static_cast<uint32>(c) << 2);
-        return ShiftMix(y * k2 ^ z * k0) * k2;
-    }
-    return k2;
-}
-
-// This probably works well for 16-byte strings as well, but it may be overkill
-// in that case.
-static uint64 HashLen17to32(const char* s, size_t len) {
-    uint64 mul = k2 + len * 2;
-    uint64 a = Fetch64(s) * k1;
-    uint64 b = Fetch64(s + 8);
-    uint64 c = Fetch64(s + len - 8) * mul;
-    uint64 d = Fetch64(s + len - 16) * k2;
-    return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d, a + Rotate(b + k2, 18) + c, mul);
-}
-
-// Return a 16-byte hash for 48 bytes.  Quick and dirty.
-// Callers do best to use "random-looking" values for a and b.
-static pair<uint64, uint64> WeakHashLen32WithSeeds(uint64 w, uint64 x, uint64 y, uint64 z, uint64 a,
-                                                   uint64 b) {
-    a += w;
-    b = Rotate(b + a + z, 21);
-    uint64 c = a;
-    a += x;
-    a += y;
-    b += Rotate(a, 44);
-    return make_pair(a + z, b + c);
-}
-
-// Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
-static pair<uint64, uint64> WeakHashLen32WithSeeds(const char* s, uint64 a, uint64 b) {
-    return WeakHashLen32WithSeeds(Fetch64(s), Fetch64(s + 8), Fetch64(s + 16), Fetch64(s + 24), a,
-                                  b);
-}
-
-// Return an 8-byte hash for 33 to 64 bytes.
-static uint64 HashLen33to64(const char* s, size_t len) {
-    uint64 mul = k2 + len * 2;
-    uint64 a = Fetch64(s) * k2;
-    uint64 b = Fetch64(s + 8);
-    uint64 c = Fetch64(s + len - 24);
-    uint64 d = Fetch64(s + len - 32);
-    uint64 e = Fetch64(s + 16) * k2;
-    uint64 f = Fetch64(s + 24) * 9;
-    uint64 g = Fetch64(s + len - 8);
-    uint64 h = Fetch64(s + len - 16) * mul;
-    uint64 u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
-    uint64 v = ((a + g) ^ d) + f + 1;
-    uint64 w = swap64((u + v) * mul) + h;
-    uint64 x = Rotate(e + f, 42) + c;
-    uint64 y = (swap64((v + w) * mul) + g) * mul;
-    uint64 z = e + f + c;
-    a = swap64((x + z) * mul + y) + b;
-    b = ShiftMix((z + a) * mul + d + h) * mul;
-    return b + x;
-}
-
-uint64 CityHash64(const char* s, size_t len) {
-    if (len <= 32) {
-        if (len <= 16) {
-            return HashLen0to16(s, len);
-        } else {
-            return HashLen17to32(s, len);
-        }
-    } else if (len <= 64) {
-        return HashLen33to64(s, len);
-    }
-
-    // For strings over 64 bytes we hash the end first, and then as we
-    // loop we keep 56 bytes of state: v, w, x, y, and z.
-    uint64 x = Fetch64(s + len - 40);
-    uint64 y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
-    uint64 z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
-    pair<uint64, uint64> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
-    pair<uint64, uint64> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
-    x = x * k1 + Fetch64(s);
-
-    // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
-    len = (len - 1) & ~static_cast<size_t>(63);
-    do {
-        x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
-        y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
-        x ^= w.second;
-        y += v.first + Fetch64(s + 40);
-        z = Rotate(z + w.first, 33) * k1;
-        v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
-        w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-        std::swap(z, x);
-        s += 64;
-        len -= 64;
-    } while (len != 0);
-    return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z,
-                     HashLen16(v.second, w.second) + x);
-}
-
-uint64 CityHash64WithSeed(const char* s, size_t len, uint64 seed) {
-    return CityHash64WithSeeds(s, len, k2, seed);
-}
-
-uint64 CityHash64WithSeeds(const char* s, size_t len, uint64 seed0, uint64 seed1) {
-    return HashLen16(CityHash64(s, len) - seed0, seed1);
-}
-
-// A subroutine for CityHash128().  Returns a decent 128-bit hash for strings
-// of any length representable in signed long.  Based on City and Murmur.
-static uint128 CityMurmur(const char* s, size_t len, uint128 seed) {
-    uint64 a = Uint128Low64(seed);
-    uint64 b = Uint128High64(seed);
-    uint64 c = 0;
-    uint64 d = 0;
-    signed long l = static_cast<long>(len) - 16;
-    if (l <= 0) { // len <= 16
-        a = ShiftMix(a * k1) * k1;
-        c = b * k1 + HashLen0to16(s, len);
-        d = ShiftMix(a + (len >= 8 ? Fetch64(s) : c));
-    } else { // len > 16
-        c = HashLen16(Fetch64(s + len - 8) + k1, a);
-        d = HashLen16(b + len, c + Fetch64(s + len - 16));
-        a += d;
-        do {
-            a ^= ShiftMix(Fetch64(s) * k1) * k1;
-            a *= k1;
-            b ^= a;
-            c ^= ShiftMix(Fetch64(s + 8) * k1) * k1;
-            c *= k1;
-            d ^= c;
-            s += 16;
-            l -= 16;
-        } while (l > 0);
-    }
-    a = HashLen16(a, c);
-    b = HashLen16(d, b);
-    return uint128(a ^ b, HashLen16(b, a));
-}
-
-uint128 CityHash128WithSeed(const char* s, size_t len, uint128 seed) {
-    if (len < 128) {
-        return CityMurmur(s, len, seed);
-    }
-
-    // We expect len >= 128 to be the common case.  Keep 56 bytes of state:
-    // v, w, x, y, and z.
-    pair<uint64, uint64> v, w;
-    uint64 x = Uint128Low64(seed);
-    uint64 y = Uint128High64(seed);
-    uint64 z = len * k1;
-    v.first = Rotate(y ^ k1, 49) * k1 + Fetch64(s);
-    v.second = Rotate(v.first, 42) * k1 + Fetch64(s + 8);
-    w.first = Rotate(y + z, 35) * k1 + x;
-    w.second = Rotate(x + Fetch64(s + 88), 53) * k1;
-
-    // This is the same inner loop as CityHash64(), manually unrolled.
-    do {
-        x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
-        y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
-        x ^= w.second;
-        y += v.first + Fetch64(s + 40);
-        z = Rotate(z + w.first, 33) * k1;
-        v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
-        w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-        std::swap(z, x);
-        s += 64;
-        x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
-        y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
-        x ^= w.second;
-        y += v.first + Fetch64(s + 40);
-        z = Rotate(z + w.first, 33) * k1;
-        v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
-        w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-        std::swap(z, x);
-        s += 64;
-        len -= 128;
-    } while (LIKELY(len >= 128));
-    x += Rotate(v.first + z, 49) * k0;
-    y = y * k0 + Rotate(w.second, 37);
-    z = z * k0 + Rotate(w.first, 27);
-    w.first *= 9;
-    v.first *= k0;
-    // If 0 < len < 128, hash up to 4 chunks of 32 bytes each from the end of s.
-    for (size_t tail_done = 0; tail_done < len;) {
-        tail_done += 32;
-        y = Rotate(x + y, 42) * k0 + v.second;
-        w.first += Fetch64(s + len - tail_done + 16);
-        x = x * k0 + w.first;
-        z += w.second + Fetch64(s + len - tail_done);
-        w.second += v.first;
-        v = WeakHashLen32WithSeeds(s + len - tail_done, v.first + z, v.second);
-        v.first *= k0;
-    }
-    // At this point our 56 bytes of state should contain more than
-    // enough information for a strong 128-bit hash.  We use two
-    // different 56-byte-to-8-byte hashes to get a 16-byte final result.
-    x = HashLen16(x, v.first);
-    y = HashLen16(y + z, w.first);
-    return uint128(HashLen16(x + v.second, w.second) + y, HashLen16(x + w.second, y + v.second));
-}
-
-uint128 CityHash128(const char* s, size_t len) {
-    return len >= 16
-               ? CityHash128WithSeed(s + 16, len - 16, uint128(Fetch64(s), Fetch64(s + 8) + k0))
-               : CityHash128WithSeed(s, len, uint128(k0, k1));
-}
-
-} // namespace Common

src/common/cityhash.h

@@ -1,110 +0,0 @@
-// Copyright (c) 2011 Google, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-// CityHash, by Geoff Pike and Jyrki Alakuijala
-//
-// http://code.google.com/p/cityhash/
-//
-// This file provides a few functions for hashing strings.  All of them are
-// high-quality functions in the sense that they pass standard tests such
-// as Austin Appleby's SMHasher.  They are also fast.
-//
-// For 64-bit x86 code, on short strings, we don't know of anything faster than
-// CityHash64 that is of comparable quality.  We believe our nearest competitor
-// is Murmur3.  For 64-bit x86 code, CityHash64 is an excellent choice for hash
-// tables and most other hashing (excluding cryptography).
-//
-// For 64-bit x86 code, on long strings, the picture is more complicated.
-// On many recent Intel CPUs, such as Nehalem, Westmere, Sandy Bridge, etc.,
-// CityHashCrc128 appears to be faster than all competitors of comparable
-// quality.  CityHash128 is also good but not quite as fast.  We believe our
-// nearest competitor is Bob Jenkins' Spooky.  We don't have great data for
-// other 64-bit CPUs, but for long strings we know that Spooky is slightly
-// faster than CityHash on some relatively recent AMD x86-64 CPUs, for example.
-// Note that CityHashCrc128 is declared in citycrc.h.
-//
-// For 32-bit x86 code, we don't know of anything faster than CityHash32 that
-// is of comparable quality.  We believe our nearest competitor is Murmur3A.
-// (On 64-bit CPUs, it is typically faster to use the other CityHash variants.)
-//
-// Functions in the CityHash family are not suitable for cryptography.
-//
-// Please see CityHash's README file for more details on our performance
-// measurements and so on.
-//
-// WARNING: This code has been only lightly tested on big-endian platforms!
-// It is known to work well on little-endian platforms that have a small penalty
-// for unaligned reads, such as current Intel and AMD moderate-to-high-end CPUs.
-// It should work on all 32-bit and 64-bit platforms that allow unaligned reads;
-// bug reports are welcome.
-//
-// By the way, for some hash functions, given strings a and b, the hash
-// of a+b is easily derived from the hashes of a and b.  This property
-// doesn't hold for any hash functions in this file.
-
-#pragma once
-
-#include <utility>
-#include <stdint.h>
-#include <stdlib.h> // for size_t.
-
-namespace Common {
-
-typedef std::pair<uint64_t, uint64_t> uint128;
-
-inline uint64_t Uint128Low64(const uint128& x) {
-    return x.first;
-}
-inline uint64_t Uint128High64(const uint128& x) {
-    return x.second;
-}
-
-// Hash function for a byte array.
-uint64_t CityHash64(const char* buf, size_t len);
-
-// Hash function for a byte array.  For convenience, a 64-bit seed is also
-// hashed into the result.
-uint64_t CityHash64WithSeed(const char* buf, size_t len, uint64_t seed);
-
-// Hash function for a byte array.  For convenience, two seeds are also
-// hashed into the result.
-uint64_t CityHash64WithSeeds(const char* buf, size_t len, uint64_t seed0, uint64_t seed1);
-
-// Hash function for a byte array.
-uint128 CityHash128(const char* s, size_t len);
-
-// Hash function for a byte array.  For convenience, a 128-bit seed is also
-// hashed into the result.
-uint128 CityHash128WithSeed(const char* s, size_t len, uint128 seed);
-
-// Hash 128 input bits down to 64 bits of output.
-// This is intended to be a reasonably good hash function.
-inline uint64_t Hash128to64(const uint128& x) {
-    // Murmur-inspired hashing.
-    const uint64_t kMul = 0x9ddfea08eb382d69ULL;
-    uint64_t a = (Uint128Low64(x) ^ Uint128High64(x)) * kMul;
-    a ^= (a >> 47);
-    uint64_t b = (Uint128High64(x) ^ a) * kMul;
-    b ^= (b >> 47);
-    b *= kMul;
-    return b;
-}
-
-} // namespace Common

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/hash.cpp

@@ -0,0 +1,141 @@
+// Copyright 2015 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#if defined(_MSC_VER)
+#include <stdlib.h>
+#endif
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/hash.h"
+
+namespace Common {
+
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+
+// Block read - if your platform needs to do endian-swapping or can only handle aligned reads, do
+// the conversion here
+static FORCE_INLINE u64 getblock64(const u64* p, size_t i) {
+    return p[i];
+}
+
+// Finalization mix - force all bits of a hash block to avalanche
+static FORCE_INLINE u64 fmix64(u64 k) {
+    k ^= k >> 33;
+    k *= 0xff51afd7ed558ccdllu;
+    k ^= k >> 33;
+    k *= 0xc4ceb9fe1a85ec53llu;
+    k ^= k >> 33;
+
+    return k;
+}
+
+// This is the 128-bit variant of the MurmurHash3 hash function that is targeted for 64-bit
+// platforms (MurmurHash3_x64_128). It was taken from:
+// https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp
+void MurmurHash3_128(const void* key, size_t len, u32 seed, void* out) {
+    const u8* data = (const u8*)key;
+    const size_t nblocks = len / 16;
+
+    u64 h1 = seed;
+    u64 h2 = seed;
+
+    const u64 c1 = 0x87c37b91114253d5llu;
+    const u64 c2 = 0x4cf5ad432745937fllu;
+
+    // Body
+
+    const u64* blocks = (const u64*)(data);
+
+    for (size_t i = 0; i < nblocks; i++) {
+        u64 k1 = getblock64(blocks, i * 2 + 0);
+        u64 k2 = getblock64(blocks, i * 2 + 1);
+
+        k1 *= c1;
+        k1 = _rotl64(k1, 31);
+        k1 *= c2;
+        h1 ^= k1;
+
+        h1 = _rotl64(h1, 27);
+        h1 += h2;
+        h1 = h1 * 5 + 0x52dce729;
+
+        k2 *= c2;
+        k2 = _rotl64(k2, 33);
+        k2 *= c1;
+        h2 ^= k2;
+
+        h2 = _rotl64(h2, 31);
+        h2 += h1;
+        h2 = h2 * 5 + 0x38495ab5;
+    }
+
+    // Tail
+
+    const u8* tail = (const u8*)(data + nblocks * 16);
+
+    u64 k1 = 0;
+    u64 k2 = 0;
+
+    switch (len & 15) {
+    case 15:
+        k2 ^= ((u64)tail[14]) << 48;
+    case 14:
+        k2 ^= ((u64)tail[13]) << 40;
+    case 13:
+        k2 ^= ((u64)tail[12]) << 32;
+    case 12:
+        k2 ^= ((u64)tail[11]) << 24;
+    case 11:
+        k2 ^= ((u64)tail[10]) << 16;
+    case 10:
+        k2 ^= ((u64)tail[9]) << 8;
+    case 9:
+        k2 ^= ((u64)tail[8]) << 0;
+        k2 *= c2;
+        k2 = _rotl64(k2, 33);
+        k2 *= c1;
+        h2 ^= k2;
+
+    case 8:
+        k1 ^= ((u64)tail[7]) << 56;
+    case 7:
+        k1 ^= ((u64)tail[6]) << 48;
+    case 6:
+        k1 ^= ((u64)tail[5]) << 40;
+    case 5:
+        k1 ^= ((u64)tail[4]) << 32;
+    case 4:
+        k1 ^= ((u64)tail[3]) << 24;
+    case 3:
+        k1 ^= ((u64)tail[2]) << 16;
+    case 2:
+        k1 ^= ((u64)tail[1]) << 8;
+    case 1:
+        k1 ^= ((u64)tail[0]) << 0;
+        k1 *= c1;
+        k1 = _rotl64(k1, 31);
+        k1 *= c2;
+        h1 ^= k1;
+    };
+
+    // Finalization
+
+    h1 ^= len;
+    h2 ^= len;
+
+    h1 += h2;
+    h2 += h1;
+
+    h1 = fmix64(h1);
+    h2 = fmix64(h2);
+
+    h1 += h2;
+    h2 += h1;
+
+    ((u64*)out)[0] = h1;
+    ((u64*)out)[1] = h2;
+}
+
+} // namespace Common

src/common/hash.h

@@ -5,12 +5,12 @@
 #pragma once
 
 #include <cstddef>
-#include <cstring>
-#include "common/cityhash.h"
 #include "common/common_types.h"
 
 namespace Common {
 
+void MurmurHash3_128(const void* key, size_t len, u32 seed, void* out);
+
 /**
  * Computes a 64-bit hash over the specified block of data
  * @param data Block of data to compute hash over
@@ -18,54 +18,9 @@ namespace Common {
  * @returns 64-bit hash value that was computed over the data block
  */
 static inline u64 ComputeHash64(const void* data, size_t len) {
-    return CityHash64(static_cast<const char*>(data), len);
+    u64 res[2];
+    MurmurHash3_128(data, len, 0, res);
+    return res[0];
 }
 
-/**
- * Computes a 64-bit hash of a struct. In addition to being trivially copyable, it is also critical
- * that either the struct includes no padding, or that any padding is initialized to a known value
- * by memsetting the struct to 0 before filling it in.
- */
-template <typename T>
-static inline u64 ComputeStructHash64(const T& data) {
-    static_assert(std::is_trivially_copyable<T>(),
-                  "Type passed to ComputeStructHash64 must be trivially copyable");
-    return ComputeHash64(&data, sizeof(data));
-}
-
-/// A helper template that ensures the padding in a struct is initialized by memsetting to 0.
-template <typename T>
-struct HashableStruct {
-    // In addition to being trivially copyable, T must also have a trivial default constructor,
-    // because any member initialization would be overridden by memset
-    static_assert(std::is_trivial<T>(), "Type passed to HashableStruct must be trivial");
-    /*
-     * We use a union because "implicitly-defined copy/move constructor for a union X copies the
-     * object representation of X." and "implicitly-defined copy assignment operator for a union X
-     * copies the object representation (3.9) of X." = Bytewise copy instead of memberwise copy.
-     * This is important because the padding bytes are included in the hash and comparison between
-     * objects.
-     */
-    union {
-        T state;
-    };
-
-    HashableStruct() {
-        // Memset structure to zero padding bits, so that they will be deterministic when hashing
-        std::memset(&state, 0, sizeof(T));
-    }
-
-    bool operator==(const HashableStruct<T>& o) const {
-        return std::memcmp(&state, &o.state, sizeof(T)) == 0;
-    };
-
-    bool operator!=(const HashableStruct<T>& o) const {
-        return !(*this == o);
-    };
-
-    size_t Hash() const {
-        return Common::ComputeStructHash64(state);
-    }
-};
-
 } // namespace Common

src/common/logging/backend.cpp

@@ -11,7 +11,6 @@
 #include "common/logging/filter.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
-#include "common/string_util.h"
 
 namespace Log {
 
@@ -33,27 +32,14 @@ namespace Log {
     CLS(Kernel)                                                                                    \
     SUB(Kernel, SVC)                                                                               \
     CLS(Service)                                                                                   \
-    SUB(Service, ACC)                                                                              \
-    SUB(Service, Audio)                                                                            \
-    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)                                                                               \
+    SUB(Service, FS)                                                                               \
+    SUB(Service, GSP)                                                                              \
+    SUB(Service, CFG)                                                                              \
+    SUB(Service, DSP)                                                                              \
+    SUB(Service, HID)                                                                              \
+    SUB(Service, NVDRV)                                                                            \
+    SUB(Service, Audio)                                                                            \
     CLS(HW)                                                                                        \
     SUB(HW, Memory)                                                                                \
     SUB(HW, LCD)                                                                                   \
@@ -107,20 +93,25 @@ const char* GetLevelName(Level log_level) {
 }
 
 Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                  const char* function, std::string message) {
+                  const char* function, const char* format, va_list args) {
     using std::chrono::duration_cast;
     using std::chrono::steady_clock;
 
     static steady_clock::time_point time_origin = steady_clock::now();
 
+    std::array<char, 4 * 1024> formatting_buffer;
+
     Entry entry;
     entry.timestamp = duration_cast<std::chrono::microseconds>(steady_clock::now() - time_origin);
     entry.log_class = log_class;
     entry.log_level = log_level;
-    entry.filename = Common::TrimSourcePath(filename);
-    entry.line_num = line_nr;
-    entry.function = function;
-    entry.message = std::move(message);
+
+    snprintf(formatting_buffer.data(), formatting_buffer.size(), "%s:%s:%u", filename, function,
+             line_nr);
+    entry.location = std::string(formatting_buffer.data());
+
+    vsnprintf(formatting_buffer.data(), formatting_buffer.size(), format, args);
+    entry.message = std::string(formatting_buffer.data());
 
     return entry;
 }
@@ -131,28 +122,15 @@ void SetFilter(Filter* new_filter) {
     filter = new_filter;
 }
 
-void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
+void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
                 const char* function, const char* format, ...) {
-    if (filter && !filter->CheckMessage(log_class, log_level))
+    if (filter != nullptr && !filter->CheckMessage(log_class, log_level))
         return;
-    std::array<char, 4 * 1024> formatting_buffer;
+
     va_list args;
     va_start(args, format);
-    vsnprintf(formatting_buffer.data(), formatting_buffer.size(), format, args);
+    Entry entry = CreateEntry(log_class, log_level, filename, line_nr, function, format, args);
     va_end(args);
-    Entry entry = CreateEntry(log_class, log_level, filename, line_num, function,
-                              std::string(formatting_buffer.data()));
-
-    PrintColoredMessage(entry);
-}
-
-void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, const char* format,
-                       const fmt::format_args& args) {
-    if (filter && !filter->CheckMessage(log_class, log_level))
-        return;
-    Entry entry =
-        CreateEntry(log_class, log_level, filename, line_num, function, fmt::vformat(format, args));
 
     PrintColoredMessage(entry);
 }

src/common/logging/backend.h

@@ -22,16 +22,13 @@ struct Entry {
     std::chrono::microseconds timestamp;
     Class log_class;
     Level log_level;
-    std::string filename;
-    unsigned int line_num;
-    std::string function;
+    std::string location;
     std::string message;
 
     Entry() = default;
     Entry(Entry&& o) = default;
 
     Entry& operator=(Entry&& o) = default;
-    Entry& operator=(const Entry& o) = default;
 };
 
 /**
@@ -47,7 +44,7 @@ const char* GetLevelName(Level log_level);
 
 /// Creates a log entry by formatting the given source location, and message.
 Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                  const char* function, std::string message);
+                  const char* function, const char* format, va_list args);
 
 void SetFilter(Filter* filter);
 } // namespace Log

src/common/logging/filter.cpp

@@ -65,14 +65,14 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
                              const std::string::const_iterator end) {
     auto level_separator = std::find(begin, end, ':');
     if (level_separator == end) {
-        NGLOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: %s",
-                    std::string(begin, end).c_str());
+        LOG_ERROR(Log, "Invalid log filter. Must specify a log level after `:`: %s",
+                  std::string(begin, end).c_str());
         return false;
     }
 
     const Level level = GetLevelByName(level_separator + 1, end);
     if (level == Level::Count) {
-        NGLOG_ERROR(Log, "Unknown log level in filter: %s", std::string(begin, end).c_str());
+        LOG_ERROR(Log, "Unknown log level in filter: %s", std::string(begin, end).c_str());
         return false;
     }
 
@@ -83,7 +83,7 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
 
     const Class log_class = GetClassByName(begin, level_separator);
     if (log_class == Class::Count) {
-        NGLOG_ERROR(Log, "Unknown log class in filter: %s", std::string(begin, end).c_str());
+        LOG_ERROR(Log, "Unknown log class in filter: %s", std::string(begin, end).c_str());
         return false;
     }
 

src/common/logging/filter.h

@@ -19,7 +19,7 @@ namespace Log {
 class Filter {
 public:
     /// Initializes the filter with all classes having `default_level` as the minimum level.
-    Filter(Level default_level = Level::Info);
+    Filter(Level default_level);
 
     /// Resets the filter so that all classes have `level` as the minimum displayed level.
     void ResetAll(Level level);

src/common/logging/log.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <fmt/format.h>
 #include "common/common_types.h"
 
 namespace Log {
@@ -50,27 +49,14 @@ enum class Class : ClassType {
     Kernel_SVC,        ///< Kernel system calls
     Service,           ///< HLE implementation of system services. Each major service
                        ///  should have its own subclass.
-    Service_ACC,       ///< The ACC (Accounts) service
-    Service_AM,        ///< The AM (Applet manager) service
-    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_SM,        ///< The SRV (Service Directory) implementation
+    Service_FS,        ///< The FS (Filesystem) service implementation
+    Service_GSP,       ///< The GSP (GPU control) service
+    Service_CFG,       ///< The CFG (Configuration) service
+    Service_DSP,       ///< The DSP (DSP control) 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
+    Service_Audio,     ///< The Audio (Audio control) service
     HW,                ///< Low-level hardware emulation
     HW_Memory,         ///< Memory-map and address translation
     HW_LCD,            ///< LCD register emulation
@@ -87,12 +73,12 @@ 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
 };
 
 /// Logs a message to the global logger.
-void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
+void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
                 const char* function,
 #ifdef _MSC_VER
                 _Printf_format_string_
@@ -104,18 +90,6 @@ void LogMessage(Class log_class, Level log_level, const char* filename, unsigned
 #endif
     ;
 
-/// Logs a message to the global logger, using fmt
-void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, const char* format,
-                       const fmt::format_args& args);
-
-template <typename... Args>
-void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, const char* format, const Args&... args) {
-    FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
-                      fmt::make_args(args...));
-}
-
 } // namespace Log
 
 #define LOG_GENERIC(log_class, log_level, ...)                                                     \
@@ -138,28 +112,3 @@ void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsig
     LOG_GENERIC(::Log::Class::log_class, ::Log::Level::Error, __VA_ARGS__)
 #define LOG_CRITICAL(log_class, ...)                                                               \
     LOG_GENERIC(::Log::Class::log_class, ::Log::Level::Critical, __VA_ARGS__)
-
-// Define the fmt lib macros
-#ifdef _DEBUG
-#define NGLOG_TRACE(log_class, ...)                                                                \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Trace, __FILE__, __LINE__,         \
-                         __func__, __VA_ARGS__)
-#else
-#define NGLOG_TRACE(log_class, fmt, ...) (void(0))
-#endif
-
-#define NGLOG_DEBUG(log_class, ...)                                                                \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Debug, __FILE__, __LINE__,         \
-                         __func__, __VA_ARGS__)
-#define NGLOG_INFO(log_class, ...)                                                                 \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Info, __FILE__, __LINE__,          \
-                         __func__, __VA_ARGS__)
-#define NGLOG_WARNING(log_class, ...)                                                              \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Warning, __FILE__, __LINE__,       \
-                         __func__, __VA_ARGS__)
-#define NGLOG_ERROR(log_class, ...)                                                                \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Error, __FILE__, __LINE__,         \
-                         __func__, __VA_ARGS__)
-#define NGLOG_CRITICAL(log_class, ...)                                                             \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Critical, __FILE__, __LINE__,      \
-                         __func__, __VA_ARGS__)

src/common/logging/text_formatter.cpp

@@ -18,29 +18,50 @@
 
 namespace Log {
 
-std::string FormatLogMessage(const Entry& entry) {
+// TODO(bunnei): This should be moved to a generic path manipulation library
+const char* TrimSourcePath(const char* path, const char* root) {
+    const char* p = path;
+
+    while (*p != '\0') {
+        const char* next_slash = p;
+        while (*next_slash != '\0' && *next_slash != '/' && *next_slash != '\\') {
+            ++next_slash;
+        }
+
+        bool is_src = Common::ComparePartialString(p, next_slash, root);
+        p = next_slash;
+
+        if (*p != '\0') {
+            ++p;
+        }
+        if (is_src) {
+            path = p;
+        }
+    }
+    return path;
+}
+
+void FormatLogMessage(const Entry& entry, char* out_text, size_t text_len) {
     unsigned int time_seconds = static_cast<unsigned int>(entry.timestamp.count() / 1000000);
     unsigned int time_fractional = static_cast<unsigned int>(entry.timestamp.count() % 1000000);
 
     const char* class_name = GetLogClassName(entry.log_class);
     const char* level_name = GetLevelName(entry.log_level);
 
-    return fmt::format("[{:4d}.{:06d}] {} <{}> {}:{}:{}: {}", time_seconds, time_fractional,
-                       class_name, level_name, entry.filename, entry.function, entry.line_num,
-                       entry.message);
+    snprintf(out_text, text_len, "[%4u.%06u] %s <%s> %s: %s", time_seconds, time_fractional,
+             class_name, level_name, TrimSourcePath(entry.location.c_str()), entry.message.c_str());
 }
 
 void PrintMessage(const Entry& entry) {
-    auto str = FormatLogMessage(entry) + '\n';
-    fputs(str.c_str(), stderr);
+    std::array<char, 4 * 1024> format_buffer;
+    FormatLogMessage(entry, format_buffer.data(), format_buffer.size());
+    fputs(format_buffer.data(), stderr);
+    fputc('\n', stderr);
 }
 
 void PrintColoredMessage(const Entry& entry) {
 #ifdef _WIN32
-    HANDLE console_handle = GetStdHandle(STD_ERROR_HANDLE);
-    if (console_handle == INVALID_HANDLE_VALUE) {
-        return;
-    }
+    static HANDLE console_handle = GetStdHandle(STD_ERROR_HANDLE);
 
     CONSOLE_SCREEN_BUFFER_INFO original_info = {0};
     GetConsoleScreenBufferInfo(console_handle, &original_info);

src/common/logging/text_formatter.h

@@ -10,8 +10,20 @@ namespace Log {
 
 struct Entry;
 
+/**
+ * Attempts to trim an arbitrary prefix from `path`, leaving only the part starting at `root`. It's
+ * intended to be used to strip a system-specific build directory from the `__FILE__` macro,
+ * leaving only the path relative to the sources root.
+ *
+ * @param path The input file path as a null-terminated string
+ * @param root The name of the root source directory as a null-terminated string. Path up to and
+ *             including the last occurrence of this name will be stripped
+ * @return A pointer to the same string passed as `path`, but starting at the trimmed portion
+ */
+const char* TrimSourcePath(const char* path, const char* root = "src");
+
 /// Formats a log entry into the provided text buffer.
-std::string FormatLogMessage(const Entry& entry);
+void FormatLogMessage(const Entry& entry, char* out_text, size_t text_len);
 /// Formats and prints a log entry to stderr.
 void PrintMessage(const Entry& entry);
 /// Prints the same message as `PrintMessage`, but colored acoording to the severity level.

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/string_util.cpp

@@ -462,27 +462,4 @@ std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, size_t max_l
 
     return std::string(buffer, len);
 }
-
-const char* TrimSourcePath(const char* path, const char* root) {
-    const char* p = path;
-
-    while (*p != '\0') {
-        const char* next_slash = p;
-        while (*next_slash != '\0' && *next_slash != '/' && *next_slash != '\\') {
-            ++next_slash;
-        }
-
-        bool is_src = Common::ComparePartialString(p, next_slash, root);
-        p = next_slash;
-
-        if (*p != '\0') {
-            ++p;
-        }
-        if (is_src) {
-            path = p;
-        }
-    }
-    return path;
-}
-
 } // namespace Common

src/common/string_util.h

@@ -134,17 +134,4 @@ bool ComparePartialString(InIt begin, InIt end, const char* other) {
  * NUL-terminated then the string ends at max_len characters.
  */
 std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, size_t max_len);
-
-/**
- * Attempts to trim an arbitrary prefix from `path`, leaving only the part starting at `root`. It's
- * intended to be used to strip a system-specific build directory from the `__FILE__` macro,
- * leaving only the path relative to the sources root.
- *
- * @param path The input file path as a null-terminated string
- * @param root The name of the root source directory as a null-terminated string. Path up to and
- *             including the last occurrence of this name will be stripped
- * @return A pointer to the same string passed as `path`, but starting at the trimmed portion
- */
-const char* TrimSourcePath(const char* path, const char* root = "src");
-
 } // namespace Common

src/common/swap.h

@@ -103,19 +103,7 @@ inline __attribute__((always_inline)) u64 swap64(u64 _data) {
     return __builtin_bswap64(_data);
 }
 #elif defined(__Bitrig__) || defined(__OpenBSD__)
-// redefine swap16, swap32, swap64 as inline functions
-#undef swap16
-#undef swap32
-#undef swap64
-inline u16 swap16(u16 _data) {
-    return __swap16(_data);
-}
-inline u32 swap32(u32 _data) {
-    return __swap32(_data);
-}
-inline u64 swap64(u64 _data) {
-    return __swap64(_data);
-}
+// swap16, swap32, swap64 are left as is
 #elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
 inline u16 swap16(u16 _data) {
     return bswap16(_data);

src/common/telemetry.h

@@ -15,7 +15,7 @@ namespace Telemetry {
 /// Field type, used for grouping fields together in the final submitted telemetry log
 enum class FieldType : u8 {
     None = 0,     ///< No specified field group
-    App,          ///< yuzu application fields (e.g. version, branch, etc.)
+    App,          ///< Citra application fields (e.g. version, branch, etc.)
     Session,      ///< Emulated session fields (e.g. title ID, log, etc.)
     Performance,  ///< Emulated performance (e.g. fps, emulated CPU speed, etc.)
     UserFeedback, ///< User submitted feedback (e.g. star rating, user notes, etc.)

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

@@ -7,25 +7,15 @@ add_library(core STATIC
     core_timing.cpp
     core_timing.h
     file_sys/directory.h
-    file_sys/disk_filesystem.cpp
-    file_sys/disk_filesystem.h
     file_sys/errors.h
     file_sys/filesystem.cpp
     file_sys/filesystem.h
-    file_sys/partition_filesystem.cpp
-    file_sys/partition_filesystem.h
     file_sys/path_parser.cpp
     file_sys/path_parser.h
-    file_sys/program_metadata.cpp
-    file_sys/program_metadata.h
     file_sys/romfs_factory.cpp
     file_sys/romfs_factory.h
     file_sys/romfs_filesystem.cpp
     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
@@ -38,6 +28,8 @@ add_library(core STATIC
     hle/config_mem.h
     hle/ipc.h
     hle/ipc_helpers.h
+    hle/kernel/address_arbiter.cpp
+    hle/kernel/address_arbiter.h
     hle/kernel/client_port.cpp
     hle/kernel/client_port.h
     hle/kernel/client_session.cpp
@@ -63,8 +55,6 @@ add_library(core STATIC
     hle/kernel/process.h
     hle/kernel/resource_limit.cpp
     hle/kernel/resource_limit.h
-    hle/kernel/scheduler.cpp
-    hle/kernel/scheduler.h
     hle/kernel/server_port.cpp
     hle/kernel/server_port.h
     hle/kernel/server_session.cpp
@@ -90,26 +80,16 @@ add_library(core STATIC
     hle/romfs.h
     hle/service/acc/acc.cpp
     hle/service/acc/acc.h
-    hle/service/acc/acc_aa.cpp
-    hle/service/acc/acc_aa.h
-    hle/service/acc/acc_su.cpp
-    hle/service/acc/acc_su.h
     hle/service/acc/acc_u0.cpp
     hle/service/acc/acc_u0.h
-    hle/service/acc/acc_u1.cpp
-    hle/service/acc/acc_u1.h
     hle/service/am/am.cpp
     hle/service/am/am.h
-    hle/service/am/applet_ae.cpp
-    hle/service/am/applet_ae.h
     hle/service/am/applet_oe.cpp
     hle/service/am/applet_oe.h
     hle/service/aoc/aoc_u.cpp
     hle/service/aoc/aoc_u.h
     hle/service/apm/apm.cpp
     hle/service/apm/apm.h
-    hle/service/apm/interface.cpp
-    hle/service/apm/interface.h
     hle/service/audio/audio.cpp
     hle/service/audio/audio.h
     hle/service/audio/audin_u.cpp
@@ -124,42 +104,14 @@ 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
     hle/service/filesystem/fsp_srv.h
-    hle/service/friend/friend.cpp
-    hle/service/friend/friend.h
-    hle/service/friend/friend_a.cpp
-    hle/service/friend/friend_a.h
-    hle/service/friend/friend_u.cpp
-    hle/service/friend/friend_u.h
     hle/service/hid/hid.cpp
     hle/service/hid/hid.h
     hle/service/lm/lm.cpp
     hle/service/lm/lm.h
-    hle/service/nifm/nifm.cpp
-    hle/service/nifm/nifm.h
-    hle/service/nifm/nifm_a.cpp
-    hle/service/nifm/nifm_a.h
-    hle/service/nifm/nifm_s.cpp
-    hle/service/nifm/nifm_s.h
-    hle/service/nifm/nifm_u.cpp
-    hle/service/nifm/nifm_u.h
-    hle/service/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
-    hle/service/ns/pl_u.h
     hle/service/nvdrv/devices/nvdevice.h
     hle/service/nvdrv/devices/nvdisp_disp0.cpp
     hle/service/nvdrv/devices/nvdisp_disp0.h
@@ -167,10 +119,6 @@ add_library(core STATIC
     hle/service/nvdrv/devices/nvhost_as_gpu.h
     hle/service/nvdrv/devices/nvhost_ctrl.cpp
     hle/service/nvdrv/devices/nvhost_ctrl.h
-    hle/service/nvdrv/devices/nvhost_ctrl_gpu.cpp
-    hle/service/nvdrv/devices/nvhost_ctrl_gpu.h
-    hle/service/nvdrv/devices/nvhost_gpu.cpp
-    hle/service/nvdrv/devices/nvhost_gpu.h
     hle/service/nvdrv/devices/nvmap.cpp
     hle/service/nvdrv/devices/nvmap.h
     hle/service/nvdrv/interface.cpp
@@ -191,34 +139,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
@@ -229,10 +159,6 @@ add_library(core STATIC
     hle/service/vi/vi.h
     hle/service/vi/vi_m.cpp
     hle/service/vi/vi_m.h
-    hle/service/vi/vi_s.cpp
-    hle/service/vi/vi_s.h
-    hle/service/vi/vi_u.cpp
-    hle/service/vi/vi_u.h
     hle/shared_page.cpp
     hle/shared_page.h
     hw/hw.cpp
@@ -253,8 +179,8 @@ add_library(core STATIC
     loader/nso.h
     memory.cpp
     memory.h
-    memory_hook.h
     memory_setup.h
+    mmio.h
     perf_stats.cpp
     perf_stats.h
     settings.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

@@ -6,16 +6,11 @@
 #include <memory>
 #include <dynarmic/A64/a64.h>
 #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"
 #include "core/memory.h"
 
-using Vector = Dynarmic::A64::Vector;
-
 class ARM_Dynarmic_Callbacks : public Dynarmic::A64::UserCallbacks {
 public:
     explicit ARM_Dynarmic_Callbacks(ARM_Dynarmic& parent) : parent(parent) {}
@@ -33,9 +28,6 @@ public:
     u64 MemoryRead64(u64 vaddr) override {
         return Memory::Read64(vaddr);
     }
-    Vector MemoryRead128(u64 vaddr) override {
-        return {Memory::Read64(vaddr), Memory::Read64(vaddr + 8)};
-    }
 
     void MemoryWrite8(u64 vaddr, u8 value) override {
         Memory::Write8(vaddr, value);
@@ -49,15 +41,8 @@ public:
     void MemoryWrite64(u64 vaddr, u64 value) override {
         Memory::Write64(vaddr, value);
     }
-    void MemoryWrite128(u64 vaddr, Vector value) override {
-        Memory::Write64(vaddr, value[0]);
-        Memory::Write64(vaddr + 8, value[1]);
-    }
 
     void InterpreterFallback(u64 pc, size_t num_instructions) override {
-        LOG_INFO(Core_ARM, "Unicorn fallback @ 0x%" PRIx64 " for %zu instructions (instr = %08x)",
-                 pc, num_instructions, MemoryReadCode(pc));
-
         ARM_Interface::ThreadContext ctx;
         parent.SaveContext(ctx);
         parent.inner_unicorn.LoadContext(ctx);
@@ -67,73 +52,38 @@ public:
         num_interpreted_instructions += num_instructions;
     }
 
-    void ExceptionRaised(u64 pc, Dynarmic::A64::Exception exception) override {
-        switch (exception) {
-        case Dynarmic::A64::Exception::WaitForInterrupt:
-        case Dynarmic::A64::Exception::WaitForEvent:
-        case Dynarmic::A64::Exception::SendEvent:
-        case Dynarmic::A64::Exception::SendEventLocal:
-        case Dynarmic::A64::Exception::Yield:
-            return;
-        default:
-            ASSERT_MSG(false, "ExceptionRaised(exception = %zu, pc = %" PRIx64 ")",
-                       static_cast<size_t>(exception), pc);
-        }
+    void ExceptionRaised(u64 pc, Dynarmic::A64::Exception /*exception*/) override {
+        ASSERT_MSG(false, "ExceptionRaised(%" PRIx64 ")", pc);
     }
 
     void CallSVC(u32 swi) override {
+        printf("svc %x\n", swi);
         Kernel::CallSVC(swi);
     }
 
     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);
-    }
-    u64 GetCNTPCT() override {
-        return CoreTiming::GetTicks();
+        return ticks_remaining;
     }
 
     ARM_Dynarmic& parent;
+    size_t ticks_remaining = 0;
     size_t num_interpreted_instructions = 0;
-    u64 tpidrro_el0 = 0;
-    u64 tpidr_el0 = 0;
+    u64 tpidrr0_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();
-
-    Dynarmic::A64::UserConfig config;
-    config.callbacks = cb.get();
-    config.tpidrro_el0 = &cb->tpidrro_el0;
-    config.tpidr_el0 = &cb->tpidr_el0;
-    config.dczid_el0 = 4;
-    config.ctr_el0 = 0x8444c004;
-    config.page_table = reinterpret_cast<void**>(page_table);
-    config.page_table_address_space_bits = Memory::ADDRESS_SPACE_BITS;
-    config.silently_mirror_page_table = false;
-
-    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)) {
+    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)),
+      jit(Dynarmic::A64::UserConfig{cb.get()}) {
     ARM_Interface::ThreadContext ctx;
     inner_unicorn.SaveContext(ctx);
     LoadContext(ctx);
-    PageTableChanged();
 }
 
 ARM_Dynarmic::~ARM_Dynarmic() = default;
@@ -143,32 +93,28 @@ 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);
+    jit.SetPC(pc);
 }
 
 u64 ARM_Dynarmic::GetPC() const {
-    return jit->GetPC();
+    return jit.GetPC();
 }
 
 u64 ARM_Dynarmic::GetReg(int index) const {
-    return jit->GetRegister(index);
+    return jit.GetRegister(index);
 }
 
 void ARM_Dynarmic::SetReg(int index, u64 value) {
-    jit->SetRegister(index, value);
+    jit.SetRegister(index, value);
 }
 
 u128 ARM_Dynarmic::GetExtReg(int index) const {
-    return jit->GetVector(index);
+    return jit.GetVector(index);
 }
 
 void ARM_Dynarmic::SetExtReg(int index, u128 value) {
-    jit->SetVector(index, value);
+    jit.SetVector(index, value);
 }
 
 u32 ARM_Dynarmic::GetVFPReg(int /*index*/) const {
@@ -181,52 +127,58 @@ void ARM_Dynarmic::SetVFPReg(int /*index*/, u32 /*value*/) {
 }
 
 u32 ARM_Dynarmic::GetCPSR() const {
-    return jit->GetPstate();
+    return jit.GetPstate();
 }
 
 void ARM_Dynarmic::SetCPSR(u32 cpsr) {
-    jit->SetPstate(cpsr);
+    jit.SetPstate(cpsr);
 }
 
 u64 ARM_Dynarmic::GetTlsAddress() const {
-    return cb->tpidrro_el0;
+    return cb->tpidrr0_el0;
 }
 
 void ARM_Dynarmic::SetTlsAddress(u64 address) {
-    cb->tpidrro_el0 = address;
+    cb->tpidrr0_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();
-    ctx.pc = jit->GetPC();
-    ctx.cpsr = jit->GetPstate();
-    ctx.fpu_registers = jit->GetVectors();
-    ctx.fpscr = jit->GetFpcr();
-    ctx.tls_address = cb->tpidrro_el0;
+    ctx.cpu_registers = jit.GetRegisters();
+    ctx.sp = jit.GetSP();
+    ctx.pc = jit.GetPC();
+    ctx.cpsr = jit.GetPstate();
+    ctx.fpu_registers = jit.GetVectors();
+    ctx.fpscr = jit.GetFpcr();
+    ctx.tls_address = cb->tpidrr0_el0;
 }
 
 void ARM_Dynarmic::LoadContext(const ARM_Interface::ThreadContext& ctx) {
-    jit->SetRegisters(ctx.cpu_registers);
-    jit->SetSP(ctx.sp);
-    jit->SetPC(ctx.pc);
-    jit->SetPstate(static_cast<u32>(ctx.cpsr));
-    jit->SetVectors(ctx.fpu_registers);
-    jit->SetFpcr(static_cast<u32>(ctx.fpscr));
-    cb->tpidrro_el0 = ctx.tls_address;
+    jit.SetRegisters(ctx.cpu_registers);
+    jit.SetSP(ctx.sp);
+    jit.SetPC(ctx.pc);
+    jit.SetPstate(static_cast<u32>(ctx.cpsr));
+    jit.SetVectors(ctx.fpu_registers);
+    jit.SetFpcr(static_cast<u32>(ctx.fpscr));
+    cb->tpidrr0_el0 = ctx.tls_address;
 }
 
 void ARM_Dynarmic::PrepareReschedule() {
-    if (jit->IsExecuting()) {
-        jit->HaltExecution();
+    if (jit.IsExecuting()) {
+        jit.HaltExecution();
     }
 }
 
 void ARM_Dynarmic::ClearInstructionCache() {
-    jit->ClearCache();
+    jit.ClearCache();
 }
 
 void ARM_Dynarmic::PageTableChanged() {
-    jit = MakeJit(cb);
-    current_page_table = Memory::GetCurrentPageTable();
+    UNIMPLEMENTED();
 }

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;
@@ -46,8 +45,6 @@ public:
 private:
     friend class ARM_Dynarmic_Callbacks;
     std::unique_ptr<ARM_Dynarmic_Callbacks> cb;
-    std::unique_ptr<Dynarmic::A64::Jit> jit;
+    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,8 +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,
-               ctx.pc, ctx.cpu_registers[30]);
+    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x%llx", addr);
     return {};
 }
 
@@ -78,10 +76,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 +148,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) {
@@ -92,8 +88,6 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
             return ResultStatus::ErrorLoader_ErrorEncrypted;
         case Loader::ResultStatus::ErrorInvalidFormat:
             return ResultStatus::ErrorLoader_ErrorInvalidFormat;
-        case Loader::ResultStatus::ErrorUnsupportedArch:
-            return ResultStatus::ErrorUnsupportedArch;
         default:
             return ResultStatus::ErrorSystemMode;
         }
@@ -101,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) {
@@ -117,8 +110,6 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
             return ResultStatus::ErrorLoader_ErrorEncrypted;
         case Loader::ResultStatus::ErrorInvalidFormat:
             return ResultStatus::ErrorLoader_ErrorInvalidFormat;
-        case Loader::ResultStatus::ErrorUnsupportedArch:
-            return ResultStatus::ErrorUnsupportedArch;
         default:
             return ResultStatus::ErrorLoader;
         }
@@ -142,34 +133,32 @@ void System::Reschedule() {
     }
 
     reschedule_pending = false;
-    Core::System::GetInstance().Scheduler().Reschedule();
+    Kernel::Reschedule();
 }
 
 System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
     LOG_DEBUG(HW_Memory, "initialized OK");
 
-    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_unique<ARM_Unicorn>();
+        break;
+    case Settings::CpuCore::Dynarmic:
+    default:
 #ifdef ARCHITECTURE_x86_64
-        cpu_core = std::make_shared<ARM_Dynarmic>();
+        cpu_core = std::make_unique<ARM_Dynarmic>();
 #else
-        cpu_core = std::make_shared<ARM_Unicorn>();
+        cpu_core = std::make_unique<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>();
-
     telemetry_session = std::make_unique<Core::TelemetrySession>();
 
+    CoreTiming::Init();
     HW::Init();
     Kernel::Init(system_mode);
-    scheduler = std::make_unique<Kernel::Scheduler>(cpu_core.get());
     Service::Init();
     GDBStub::Init();
 
@@ -197,18 +186,15 @@ void System::Shutdown() {
                          perf_results.frametime * 1000.0);
 
     // Shutdown emulation session
-    VideoCore::Shutdown();
     GDBStub::Shutdown();
+    VideoCore::Shutdown();
     Service::Shutdown();
-    scheduler = nullptr;
     Kernel::Shutdown();
     HW::Shutdown();
-    telemetry_session = nullptr;
-    gpu_core = nullptr;
-    cpu_core = nullptr;
     CoreTiming::Shutdown();
-
+    cpu_core = nullptr;
     app_loader = nullptr;
+    telemetry_session = nullptr;
 
     LOG_DEBUG(Core, "Shutdown OK");
 }

src/core/core.h

@@ -7,14 +7,10 @@
 #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;
 class ARM_Interface;
@@ -44,7 +40,6 @@ public:
         ErrorSystemFiles,               ///< Error in finding system files
         ErrorSharedFont,                ///< Error in finding shared font
         ErrorVideoCore,                 ///< Error in the video core
-        ErrorUnsupportedArch,           ///< Unsupported Architecture (32-Bit ROMs)
         ErrorUnknown                    ///< Any other error
     };
 
@@ -55,10 +50,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
@@ -107,18 +102,6 @@ public:
         return *cpu_core;
     }
 
-    Tegra::GPU& GPU() {
-        return *gpu_core;
-    }
-
-    Kernel::Scheduler& Scheduler() {
-        return *scheduler;
-    }
-
-    Kernel::SharedPtr<Kernel::Process>& CurrentProcess() {
-        return current_process;
-    }
-
     PerfStats perf_stats;
     FrameLimiter frame_limiter;
 
@@ -137,14 +120,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.
@@ -160,13 +135,8 @@ private:
     /// AppLoader used to load the current executing application
     std::unique_ptr<Loader::AppLoader> app_loader;
 
-    std::shared_ptr<ARM_Interface> cpu_core;
-    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;
+    ///< ARM11 CPU core
+    std::unique_ptr<ARM_Interface> cpu_core;
 
     /// When true, signals that a reschedule should happen
     bool reschedule_pending{};
@@ -188,8 +158,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

@@ -1,232 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include <memory>
-#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);
-
-    std::string full_path = base_directory + path;
-    auto file = std::make_shared<FileUtil::IOFile>(full_path, mode_str.c_str());
-
-    if (!file->IsOpen()) {
-        return ERROR_PATH_NOT_FOUND;
-    }
-
-    return MakeResult<std::unique_ptr<StorageBackend>>(
-        std::make_unique<Disk_Storage>(std::move(file)));
-}
-
-ResultCode Disk_FileSystem::DeleteFile(const std::string& path) const {
-    if (!FileUtil::Exists(path)) {
-        return ERROR_PATH_NOT_FOUND;
-    }
-
-    FileUtil::Delete(path);
-
-    return RESULT_SUCCESS;
-}
-
-ResultCode Disk_FileSystem::RenameFile(const Path& src_path, const Path& dest_path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::DeleteDirectory(const Path& path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::DeleteDirectoryRecursively(const Path& path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::CreateFile(const std::string& path, u64 size) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-
-    std::string full_path = base_directory + path;
-    if (size == 0) {
-        FileUtil::CreateEmptyFile(full_path);
-        return RESULT_SUCCESS;
-    }
-
-    FileUtil::IOFile file(full_path, "wb");
-    // Creates a sparse file (or a normal file on filesystems without the concept of sparse files)
-    // We do this by seeking to the right size, then writing a single null byte.
-    if (file.Seek(size - 1, SEEK_SET) && file.WriteBytes("", 1) == 1) {
-        return RESULT_SUCCESS;
-    }
-
-    LOG_ERROR(Service_FS, "Too large file");
-    // TODO(Subv): Find out the correct error code
-    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());
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-ResultCode Disk_FileSystem::RenameDirectory(const Path& src_path, const Path& dest_path) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    // TODO(wwylele): Use correct error code
-    return ResultCode(-1);
-}
-
-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));
-}
-
-u64 Disk_FileSystem::GetFreeSpaceSize() const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    return 0;
-}
-
-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;
-    }
-
-    if (FileUtil::IsDirectory(full_path))
-        return MakeResult(EntryType::Directory);
-
-    return MakeResult(EntryType::File);
-}
-
-ResultVal<size_t> Disk_Storage::Read(const u64 offset, const size_t length, u8* buffer) const {
-    LOG_TRACE(Service_FS, "called offset=%llu, length=%zu", offset, length);
-    file->Seek(offset, SEEK_SET);
-    return MakeResult<size_t>(file->ReadBytes(buffer, length));
-}
-
-ResultVal<size_t> Disk_Storage::Write(const u64 offset, const size_t length, const bool flush,
-                                      const u8* buffer) const {
-    LOG_WARNING(Service_FS, "(STUBBED) called");
-    file->Seek(offset, SEEK_SET);
-    size_t written = file->WriteBytes(buffer, length);
-    if (flush) {
-        file->Flush();
-    }
-    return MakeResult<size_t>(written);
-}
-
-u64 Disk_Storage::GetSize() const {
-    return file->GetSize();
-}
-
-bool Disk_Storage::SetSize(const u64 size) const {
-    file->Resize(size);
-    file->Flush();
-    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

@@ -1,85 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-#include <memory>
-#include <string>
-#include "common/common_types.h"
-#include "common/file_util.h"
-#include "core/file_sys/directory.h"
-#include "core/file_sys/filesystem.h"
-#include "core/file_sys/storage.h"
-#include "core/hle/result.h"
-
-namespace FileSys {
-
-class Disk_FileSystem : public FileSystemBackend {
-public:
-    explicit Disk_FileSystem(std::string base_directory)
-        : base_directory(std::move(base_directory)) {}
-
-    std::string GetName() const override;
-
-    ResultVal<std::unique_ptr<StorageBackend>> OpenFile(const std::string& path,
-                                                        Mode mode) const override;
-    ResultCode DeleteFile(const std::string& path) const override;
-    ResultCode RenameFile(const Path& src_path, const Path& dest_path) const override;
-    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 RenameDirectory(const Path& src_path, const Path& dest_path) const override;
-    ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(
-        const std::string& path) const override;
-    u64 GetFreeSpaceSize() const override;
-    ResultVal<EntryType> GetEntryType(const std::string& path) const override;
-
-protected:
-    std::string base_directory;
-};
-
-class Disk_Storage : public StorageBackend {
-public:
-    Disk_Storage(std::shared_ptr<FileUtil::IOFile> file) : file(std::move(file)) {}
-
-    ResultVal<size_t> Read(u64 offset, size_t length, u8* buffer) const override;
-    ResultVal<size_t> Write(u64 offset, size_t length, bool flush, const u8* buffer) const override;
-    u64 GetSize() const override;
-    bool SetSize(u64 size) const override;
-    bool Close() const override {
-        return false;
-    }
-    void Flush() const override {}
-
-private:
-    std::shared_ptr<FileUtil::IOFile> file;
-};
-
-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;
-};
-
-} // 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));