final changes

NVN_THROUGH_OPENGL & NVRM_GPU_PREVENT_USE are a few interesting settings to look at. Carefully choosing settings can help with drawing graphics later on

.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

.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,7 +2,7 @@
 
 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
 

CMakeLists.txt

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

README.md

@@ -7,7 +7,7 @@ yuzu is an experimental open-source emulator for the Nintendo Switch from the cr
 
 It is written in C++ with portability in mind, with builds actively maintained for Windows, Linux and macOS. The emulator is currently only useful for homebrew development and research purposes.
 
-yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. At this time, yuzu cannot play any commercial games without major problems. yuzu can boot some games, to varying degrees of success, but does not implement any of the necessary GPU features to render 3D graphics.
+yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. At this time, yuzu does not run any commercial Switch games. yuzu can boot some games, to varying degrees of success, but does not implement any of the necessary GPU features to render 3D graphics.
 
 yuzu is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.
 

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 {
 
@@ -36,22 +35,15 @@ namespace Log {
     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)                                                                               \
     CLS(HW)                                                                                        \
@@ -107,20 +99,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 +128,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 {
@@ -52,23 +51,16 @@ enum class Class : ClassType {
                        ///  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_HID,       ///< The HID (Human interface device) service
     Service_LM,        ///< The LM (Logger) service
-    Service_NFP,       ///< The NFP service
     Service_NIFM,      ///< The NIFM (Network interface) service
-    Service_NS,        ///< The NS services
     Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
     Service_PCTL,      ///< The PCTL (Parental control) service
     Service_SET,       ///< The SET (Settings) service
     Service_SM,        ///< The SM (Service manager) service
-    Service_SPL,       ///< The SPL service
-    Service_SSL,       ///< The SSL service
     Service_Time,      ///< The time service
     Service_VI,        ///< The VI (Video interface) service
     HW,                ///< Low-level hardware emulation
@@ -87,12 +79,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 +96,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 +118,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/vector_math.h

@@ -55,6 +55,10 @@ public:
     T x;
     T y;
 
+    T* AsArray() {
+        return &x;
+    }
+
     Vec2() = default;
     Vec2(const T& _x, const T& _y) : x(_x), y(_y) {}
 
@@ -67,6 +71,11 @@ public:
         return Vec2<T>(f, f);
     }
 
+    void Write(T a[2]) {
+        a[0] = x;
+        a[1] = y;
+    }
+
     Vec2<decltype(T{} + T{})> operator+(const Vec2& other) const {
         return MakeVec(x + other.x, y + other.y);
     }
@@ -196,6 +205,10 @@ public:
     T y;
     T z;
 
+    T* AsArray() {
+        return &x;
+    }
+
     Vec3() = default;
     Vec3(const T& _x, const T& _y, const T& _z) : x(_x), y(_y), z(_z) {}
 
@@ -212,6 +225,12 @@ public:
         return MakeVec(f, f, f);
     }
 
+    void Write(T a[3]) {
+        a[0] = x;
+        a[1] = y;
+        a[2] = z;
+    }
+
     Vec3<decltype(T{} + T{})> operator+(const Vec3& other) const {
         return MakeVec(x + other.x, y + other.y, z + other.z);
     }
@@ -397,6 +416,10 @@ public:
     T z;
     T w;
 
+    T* AsArray() {
+        return &x;
+    }
+
     Vec4() = default;
     Vec4(const T& _x, const T& _y, const T& _z, const T& _w) : x(_x), y(_y), z(_z), w(_w) {}
 
@@ -413,6 +436,13 @@ public:
         return Vec4<T>(f, f, f, f);
     }
 
+    void Write(T a[4]) {
+        a[0] = x;
+        a[1] = y;
+        a[2] = z;
+        a[3] = w;
+    }
+
     Vec4<decltype(T{} + T{})> operator+(const Vec4& other) const {
         return MakeVec(x + other.x, y + other.y, z + other.z, w + other.w);
     }

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,14 +80,8 @@ 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
@@ -108,8 +92,6 @@ add_library(core STATIC
     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,22 +106,10 @@ 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
@@ -152,14 +122,6 @@ add_library(core STATIC
     hle/service/nifm/nifm_s.h
     hle/service/nifm/nifm_u.cpp
     hle/service/nifm/nifm_u.h
-    hle/service/nfp/nfp.cpp
-    hle/service/nfp/nfp.h
-    hle/service/nfp/nfp_user.cpp
-    hle/service/nfp/nfp_user.h
-    hle/service/ns/ns.cpp
-    hle/service/ns/ns.h
-    hle/service/ns/pl_u.cpp
-    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
@@ -191,34 +153,16 @@ add_library(core STATIC
     hle/service/service.h
     hle/service/set/set.cpp
     hle/service/set/set.h
-    hle/service/set/set_cal.cpp
-    hle/service/set/set_cal.h
-    hle/service/set/set_fd.cpp
-    hle/service/set/set_fd.h
-    hle/service/set/set_sys.cpp
-    hle/service/set/set_sys.h
-    hle/service/set/settings.cpp
-    hle/service/set/settings.h
     hle/service/sm/controller.cpp
     hle/service/sm/controller.h
     hle/service/sm/sm.cpp
     hle/service/sm/sm.h
-    hle/service/sockets/bsd.cpp
-    hle/service/sockets/bsd.h
-    hle/service/sockets/nsd.cpp
-    hle/service/sockets/nsd.h
+    hle/service/sockets/bsd_u.cpp
+    hle/service/sockets/bsd_u.h
     hle/service/sockets/sfdnsres.cpp
     hle/service/sockets/sfdnsres.h
     hle/service/sockets/sockets.cpp
     hle/service/sockets/sockets.h
-    hle/service/spl/csrng.cpp
-    hle/service/spl/csrng.h
-    hle/service/spl/module.cpp
-    hle/service/spl/module.h
-    hle/service/spl/spl.cpp
-    hle/service/spl/spl.h
-    hle/service/ssl/ssl.cpp
-    hle/service/ssl/ssl.h
     hle/service/time/time.cpp
     hle/service/time/time.h
     hle/service/time/time_s.cpp

src/core/arm/arm_interface.h

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

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -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