gdbstub: Get rid of a few signed/unsigned comparisons

Ensures both operands in comparisons are the same signedness.

.appveyor/UtilityFunctions.ps1

@@ -0,0 +1,39 @@
+# 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
+}

.gitignore

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

.gitmodules

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

.travis.yml

@@ -1,6 +1,13 @@
 language: cpp
 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"
     - os: linux
       env: NAME="linux build"
       sudo: required
@@ -16,25 +23,26 @@ matrix:
     - os: osx
       env: NAME="macos build"
       sudo: false
-      osx_image: xcode7.3
+      osx_image: xcode9.3
       install: "./.travis/macos/deps.sh"
       script: "./.travis/macos/build.sh"
       after_success: "./.travis/macos/upload.sh"
-    - os: linux
-      env: NAME="clang-format"
-      dist: trusty
-      addons:
-        apt:
-          packages:
-            - clang-format-3.9
-      script: "./.travis/clang-format/script.sh"
 
 deploy:
   provider: releases
   api_key:
-    secure: IuTT8DjxzNgOtaEsyOpz1JaSmtDtHSsWZnJKmSBwXAzgP2ZU4Ja3/q0z5PwbC5Ql7kuFahuYTE5oi7lbJBuu2P3y1Wj2zvFozGUkA3JUvEXDNOPS9QTJ1EYd6O+wenZoj7d/Pn+ZeIgyEafnnZsGBb8lMQnV9MfIHgYlZQ5EyF3n4XikT2h1UbDBYx74ciXZIxFEulx68kDr9Q4/U+zIYQmYv2N+lgXSLDkFrCJ046gRcujPYGPqE6jVw0kKni80CTTpuDF5prU8yIBeiffjkJ3Qx1a17G07eZ4r83P4XUOlaHbRBmA/8ywZvLF2Gep3wGKfSFgMWbPxBJk5ZSYcOOAgMsEcg0+gBK9gLTwO4pbmc2GvqP21yRQBzgtbFoEtAHLu5lVPBkZU7kZuRMJtRdqvFIwOLhpnRS8IknFOD5vjtaFiNdGWaK9ePdsGvplijnXcPafkumakc4+eVEiXb6/KzdX1zXdur5tuUPFytm0Oy6IJcGIf8FHXGvUlmWsnPzwfusij9JgeQOP+uegc9PdBfL+h7L5rk+ilELt3cXD5K7wgov/4hkl5istNJ2bm0IioIstWss8QQQTkyscGoeh/oXmUpOL4FdsTvsWhDR3QKeq8nSzgDkqLe0iSbplQGnC7o7ytNbldmxJvf3nylwglA8w3HlqLHtZLkUOcuQ0=
+    secure: ElsIAlbvVXBNKsP31nVPysh+mf0GQA4DiL/y5iJeQxKQYR6iRoNo+RfzOBmdswdo0bE/PGeBAlfzCkp15gjhWf6Je0N6dRpczmcmLq6SSQFn1Mpq00xMJB2AgQIlaHs6KFgoUA173EBKbPwgU/NubTFpJFm/Wa+NcSWAHQXKL9KT2M3qKpxNkPl3mKEVsbch4REP+T/46vsa+ikw0VE0kIs6V93LqUQZpI2F0Dhihx8Cxr5iedkE1QsNK+QSX9iItMHbfek9OH980gP7L3lkZltyAA1Pk0c37OAgz2PwczwNKwCT8jg9PMzdcKmWouvLyAkZFuA806ElzwHY3oEd91Zm6+Bk5n24yBKZ9027AZzw38NK2Z2m9Akb8+ar8PdsKU6N5pDutX9qSLayr0oMgJ0s7/xnGBGdL3gfkPCFc50xO/2DxlsOR+zAhPNM9Y76hhGy6A7/40+9uzrJvd4nAuDvIXRzi2Yl2L7mKBE4suMKbFLtk2LlgM0qY5JMVTQ8NliaEtqopfPur2KWFVJUpWDNLtNX8xGqhfwg7cLjIiGmnxSaJBTDuZI6dpEjkWkU0n1xYhGqEqit8DbehYzazozMJ+Vsr8hku7jGlUtlw+U6HG1e19O2y4aGeSwYPROcCNz+BLwmVM8oZE3Roy3qoaa2yiFf+sy6rUHznrhsfEM=
   file_glob: true
   file: "artifacts/*"
   skip_cleanup: true
   on:
     tags: true
+
+notifications:
+  webhooks:
+    urls:
+      - https://api.yuzu-emu.org/code/travis/notify
+
+cache:
+  directories:
+    - $HOME/.ccache

.travis/clang-format/build.sh

@@ -0,0 +1,3 @@
+#!/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

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

.travis/clang-format/docker.sh

@@ -0,0 +1,8 @@
+#!/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/clang-format/script.sh

@@ -7,7 +7,7 @@ if grep -nr '\s$' src *.yml *.txt *.md Doxyfile .gitignore .gitmodules .travis*
 fi
 
 # Default clang-format points to default 3.5 version one
-CLANG_FORMAT=clang-format-3.9
+CLANG_FORMAT=clang-format-6.0
 $CLANG_FORMAT --version
 
 if [ "$TRAVIS_EVENT_TYPE" = "pull_request" ]; then

.travis/linux/build.sh

@@ -1,3 +1,3 @@
 #!/bin/bash -ex
 
-docker run -v $(pwd):/yuzu ubuntu:18.04 /bin/bash /yuzu/.travis/linux/docker.sh
+docker run -e CCACHE_DIR=/ccache -v $HOME/.ccache:/ccache -v $(pwd):/yuzu ubuntu:18.04 /bin/bash /yuzu/.travis/linux/docker.sh

.travis/linux/docker.sh

@@ -1,16 +1,18 @@
 #!/bin/bash -ex
 
 apt-get update
-apt-get install -y build-essential git libqt5opengl5-dev libsdl2-dev libssl-dev python qtbase5-dev wget
-
-# Get a recent version of CMake
-wget https://cmake.org/files/v3.10/cmake-3.10.1-Linux-x86_64.sh
-sh cmake-3.10.1-Linux-x86_64.sh --exclude-subdir --prefix=/ --skip-license
+apt-get install --no-install-recommends -y build-essential git libqt5opengl5-dev libsdl2-dev libssl-dev python qtbase5-dev wget cmake ninja-build ccache
 
 cd /yuzu
 
+export PATH=/usr/lib/ccache:$PATH
+ln -sf /usr/bin/ccache /usr/lib/ccache/cc
+ln -sf /usr/bin/ccache /usr/lib/ccache/c++
 mkdir build && cd build
-cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release
-make -j4
+ccache --show-stats > ccache_before
+cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -G Ninja
+ninja
+ccache --show-stats > ccache_after
+diff -U100 ccache_before ccache_after || true
 
 ctest -VV -C Release

.travis/macos/build.sh

@@ -2,13 +2,17 @@
 
 set -o pipefail
 
-export MACOSX_DEPLOYMENT_TARGET=10.9
+export MACOSX_DEPLOYMENT_TARGET=10.12
 export Qt5_DIR=$(brew --prefix)/opt/qt5
 export UNICORNDIR=$(pwd)/externals/unicorn
 
 mkdir build && cd build
+export PATH=/usr/local/opt/ccache/libexec:$PATH
+ccache --show-stats > ccache_before
 cmake --version
-cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_OSX_ARCHITECTURES="x86_64;x86_64h" -DCMAKE_BUILD_TYPE=Release
+cmake .. -DYUZU_BUILD_UNICORN=ON -DCMAKE_BUILD_TYPE=Release
 make -j4
+ccache --show-stats > ccache_after
+diff -U100 ccache_before ccache_after || true
 
 ctest -VV -C Release

.travis/macos/deps.sh

@@ -1,4 +1,5 @@
 #!/bin/sh -ex
 
 brew update
-brew install dylibbundler p7zip qt5 sdl2
+brew install dylibbundler p7zip qt5 sdl2 ccache
+brew outdated cmake || brew upgrade cmake

CMakeLists.txt

@@ -3,14 +3,19 @@ cmake_minimum_required(VERSION 3.6)
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
 include(DownloadExternals)
+include(CMakeDependentOption)
 
 project(yuzu)
 
+# Set bundled sdl2/qt as dependent options.
+# OFF by default, but if ENABLE_SDL2 and MSVC are true then ON
 option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
-option(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" OFF)
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON "ENABLE_SDL2;MSVC" OFF)
 
 option(ENABLE_QT "Enable the Qt frontend" ON)
-option(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" OFF)
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_QT;MSVC" OFF)
+
+option(YUZU_USE_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)
 
 if(NOT EXISTS ${CMAKE_SOURCE_DIR}/.git/hooks/pre-commit)
     message(STATUS "Copying pre-commit hook")
@@ -54,15 +59,18 @@ function(detect_architecture symbol arch)
     endif()
 endfunction()
 
-if (MSVC)
-    detect_architecture("_M_AMD64" x86_64)
-    detect_architecture("_M_IX86" x86)
-    detect_architecture("_M_ARM" ARM)
-else()
-    detect_architecture("__x86_64__" x86_64)
-    detect_architecture("__i386__" x86)
-    detect_architecture("__arm__" ARM)
+if (NOT ENABLE_GENERIC)
+    if (MSVC)
+        detect_architecture("_M_AMD64" x86_64)
+        detect_architecture("_M_IX86" x86)
+        detect_architecture("_M_ARM" ARM)
+    else()
+        detect_architecture("__x86_64__" x86_64)
+        detect_architecture("__i386__" x86)
+        detect_architecture("__arm__" ARM)
+    endif()
 endif()
+
 if (NOT DEFINED ARCHITECTURE)
     set(ARCHITECTURE "GENERIC")
     set(ARCHITECTURE_GENERIC 1)
@@ -152,6 +160,9 @@ 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
 # ======================
 
@@ -203,8 +214,7 @@ else()
 endif()
 
 # If unicorn isn't found, msvc -> download bundled unicorn; everyone else -> build external
-find_package(Unicorn QUIET)
-if (NOT UNICORN_FOUND)
+if (YUZU_USE_BUNDLED_UNICORN)
     if (MSVC)
         message(STATUS "unicorn not found, falling back to bundled")
         # Detect toolchain and platform
@@ -243,7 +253,7 @@ if (NOT UNICORN_FOUND)
         find_package(PythonInterp 2.7 REQUIRED)
 
         add_custom_command(OUTPUT ${LIBUNICORN_LIBRARY}
-            COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" /bin/sh make.sh
+            COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" /bin/sh make.sh macos-universal-no
             WORKING_DIRECTORY ${UNICORN_PREFIX}
         )
         # ALL makes this custom target build every time
@@ -253,6 +263,8 @@ if (NOT UNICORN_FOUND)
         )
         unset(UNICORN_LIB_NAME)
     endif()
+else()
+    find_package(Unicorn REQUIRED)
 endif()
 
 if (UNICORN_FOUND)
@@ -266,7 +278,7 @@ endif()
 if (ENABLE_QT)
     if (YUZU_USE_BUNDLED_QT)
         if (MSVC14 AND ARCHITECTURE_x86_64)
-            set(QT_VER qt-5.7-msvc2015_64)
+            set(QT_VER qt-5.10.0-msvc2015_64)
         else()
             message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
         endif()
@@ -316,6 +328,53 @@ if (UNIX OR MINGW)
     endif()
 endif()
 
+# Setup a custom clang-format target (if clang-format can be found) that will run
+# against all the src files. This should be used before making a pull request.
+# =======================================================================
+
+set(CLANG_FORMAT_POSTFIX "-6.0")
+find_program(CLANG_FORMAT
+    NAMES clang-format${CLANG_FORMAT_POSTFIX}
+          clang-format
+    PATHS ${CMAKE_BINARY_DIR}/externals)
+# if find_program doesn't find it, try to download from externals
+if (NOT CLANG_FORMAT)
+    if (WIN32)
+        message(STATUS "Clang format not found! Downloading...")
+        set(CLANG_FORMAT "${CMAKE_BINARY_DIR}/externals/clang-format${CLANG_FORMAT_POSTFIX}.exe")
+        file(DOWNLOAD
+            https://github.com/yuzu-emu/ext-windows-bin/raw/master/clang-format${CLANG_FORMAT_POSTFIX}.exe
+            "${CLANG_FORMAT}" SHOW_PROGRESS
+            STATUS DOWNLOAD_SUCCESS)
+        if (NOT DOWNLOAD_SUCCESS EQUAL 0)
+            message(WARNING "Could not download clang format! Disabling the clang format target")
+            file(REMOVE ${CLANG_FORMAT})
+            unset(CLANG_FORMAT)
+        endif()
+    else()
+        message(WARNING "Clang format not found! Disabling the clang format target")
+    endif()
+endif()
+
+if (CLANG_FORMAT)
+    set(SRCS ${CMAKE_SOURCE_DIR}/src)
+    set(CCOMMENT "Running clang format against all the .h and .cpp files in src/")
+    if (WIN32)
+        add_custom_target(clang-format
+            COMMAND powershell.exe -Command "${CLANG_FORMAT} -i @(Get-ChildItem -Recurse ${SRCS}/* -Include \'*.h\', \'*.cpp\')"
+            COMMENT ${CCOMMENT})
+    elseif(MINGW)
+        add_custom_target(clang-format
+            COMMAND find `cygpath -u ${SRCS}` -iname *.h -o -iname *.cpp | xargs `cygpath -u ${CLANG_FORMAT}` -i
+            COMMENT ${CCOMMENT})
+    else()
+        add_custom_target(clang-format
+            COMMAND find ${SRCS} -iname *.h -o -iname *.cpp | xargs ${CLANG_FORMAT} -i
+            COMMENT ${CCOMMENT})
+    endif()
+    unset(SRCS)
+    unset(CCOMMENT)
+endif()
 
 # Include source code
 # ===================
@@ -323,12 +382,14 @@ endif()
 # This function should be passed a list of all files in a target. It will automatically generate
 # file groups following the directory hierarchy, so that the layout of the files in IDEs matches the
 # one in the filesystem.
-function(create_directory_groups)
+function(create_target_directory_groups target_name)
     # Place any files that aren't in the source list in a separate group so that they don't get in
     # the way.
     source_group("Other Files" REGULAR_EXPRESSION ".")
 
-    foreach(file_name ${ARGV})
+    get_target_property(target_sources "${target_name}" SOURCES)
+
+    foreach(file_name IN LISTS target_sources)
         get_filename_component(dir_name "${file_name}" PATH)
         # Group names use '\' as a separator even though the entire rest of CMake uses '/'...
         string(REPLACE "/" "\\" group_name "${dir_name}")
@@ -365,7 +426,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/pixmaps")
+            DESTINATION "${CMAKE_INSTALL_PREFIX}/share/icons/hicolor/scalable/apps")
     install(FILES "${CMAKE_SOURCE_DIR}/dist/yuzu.xml"
             DESTINATION "${CMAKE_INSTALL_PREFIX}/share/mime/packages")
 endif()

CMakeModules/CopyYuzuQt5Deps.cmake

@@ -3,7 +3,9 @@ function(copy_yuzu_Qt5_deps target_dir)
     set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
     set(Qt5_DLL_DIR "${Qt5_DIR}/../../../bin")
     set(Qt5_PLATFORMS_DIR "${Qt5_DIR}/../../../plugins/platforms/")
+    set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
     set(PLATFORMS ${DLL_DEST}platforms/)
+    set(STYLES ${DLL_DEST}styles/)
     windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
         icudt*.dll
         icuin*.dll
@@ -14,4 +16,5 @@ function(copy_yuzu_Qt5_deps target_dir)
         Qt5Widgets$<$<CONFIG:Debug>:d>.*
     )
     windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
+    windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
 endfunction(copy_yuzu_Qt5_deps)

CONTRIBUTING.md

@@ -1,11 +1,20 @@
 # Reporting Issues
 
-**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our Discord server, [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.
+**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our [Discord server](https://discordapp.com/invite/u77vRWY), [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.
 
 If you believe you have a valid issue report, please post text or a screenshot from the log (the console window that opens alongside yuzu) and build version (hex string visible in the titlebar and zip filename), as well as your hardware and software information if applicable.
 
 # Contributing
-yuzu is a brand new project, so we have a great opportunity to keep things clean and well organized early on. As such, coding style is very important when making commits. We run clang-format on our CI to check the code. Please use it to format your code when contributing. However, it doesn't cover all the rules below. Some of them aren't very strict rules since we want to be flexible and we understand that under certain circumstances some of them can be counterproductive. Just try to follow as many of them as possible:
+yuzu is a brand new project, so we have a great opportunity to keep things clean and well organized early on. As such, coding style is very important when making commits. We run clang-format on our CI to check the code. Please use it to format your code when contributing. However, it doesn't cover all the rules below. Some of them aren't very strict rules since we want to be flexible and we understand that under certain circumstances some of them can be counterproductive. Just try to follow as many of them as possible.
+
+# Using clang format (version 6.0)
+When generating the native build script for your toolset, cmake will try to find the correct version of clang format (or will download it on windows). Before running cmake, please install clang format version 6.0 for your platform as follows:
+
+* Windows: do nothing; cmake will download a pre built binary for MSVC and MINGW. MSVC users can additionally install a clang format Visual Studio extension to add features like format on save.
+* OSX: run `brew install clang-format`.
+* Linux: use your package manager to get an appropriate binary.
+
+If clang format is found, then cmake will add a custom build target that can be run at any time to run clang format against *all* source files and update the formatting in them. This should be used before making a pull request so that the reviewers can spend more time reviewing the code instead of having to worry about minor style violations. On MSVC, you can run clang format by building the clang-format project in the solution. On OSX, you can either use the Makefile target `make clang-format` or by building the clang-format target in XCode. For Makefile builds, you can use the clang-format target with `make clang-format`
 
 ### General Rules
 * A lot of code was taken from other projects (e.g. Citra, Dolphin, PPSSPP, Gekko). In general, when editing other people's code, follow the style of the module you're in (or better yet, fix the style if it drastically differs from our guide).

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 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 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 is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.
 

appveyor.yml

@@ -13,8 +13,8 @@ environment:
   # Tell msys2 to inherit the current directory when starting the shell
   CHERE_INVOKING: 1
   matrix:
-    - BUILD_TYPE: mingw
     - BUILD_TYPE: msvc
+    - BUILD_TYPE: mingw
 
 platform:
   - x64
@@ -80,12 +80,19 @@ after_build:
           $env:BUILD_SYMBOLS = $MSVC_BUILD_PDB
           $env:BUILD_UPDATE = $MSVC_SEVENZIP
 
+          $BUILD_DIR = ".\msvc_build\bin\Release"
+
+          # Make a debug symbol upload
           mkdir pdb
-          Get-ChildItem ".\msvc_build\bin\" -Recurse -Filter "*.pdb" | Copy-Item -destination .\pdb
+          Get-ChildItem "$BUILD_DIR\" -Recurse -Filter "*.pdb" | Copy-Item -destination .\pdb
           7z a -tzip $MSVC_BUILD_PDB .\pdb\*.pdb
+          rm "$BUILD_DIR\*.pdb"
 
           mkdir $RELEASE_DIST
-          Get-ChildItem ".\msvc_build\bin\" -Recurse -Filter "yuzu*.exe" | Copy-Item -destination $RELEASE_DIST
+          # get rid of extra exes by copying everything over, then deleting all the exes, then copying just the exes we want
+          Copy-Item "$BUILD_DIR\*" -Destination $RELEASE_DIST -Recurse
+          rm "$RELEASE_DIST\*.exe"
+          Get-ChildItem "$BUILD_DIR" -Recurse -Filter "yuzu*.exe" | Copy-Item -destination $RELEASE_DIST
           Copy-Item .\license.txt -Destination $RELEASE_DIST
           Copy-Item .\README.md -Destination $RELEASE_DIST
           7z a -tzip $MSVC_BUILD_ZIP $RELEASE_DIST\*
@@ -109,33 +116,30 @@ after_build:
 
           mkdir $RELEASE_DIST
           mkdir $RELEASE_DIST/platforms
+          mkdir $RELEASE_DIST/styles
 
           # copy the compiled binaries and other release files to the release folder
           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
-          # 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"
+          . "./.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
           foreach ($file in $MingwDLLs) {
-            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-Item -path "$file" -force -destination "$RELEASE_DIST"
           }
 
           # copy the qt windows plugin dll to platforms
           Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/platforms/qwindows.dll" -force -destination "$RELEASE_DIST/platforms"
 
+          # copy the qt windows vista style dll to platforms
+          Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/styles/qwindowsvistastyle.dll" -force -destination "$RELEASE_DIST/styles"
+
           7z a -tzip $MINGW_BUILD_ZIP $RELEASE_DIST\*
           7z a $MINGW_SEVENZIP $RELEASE_DIST
         }
@@ -163,7 +167,7 @@ deploy:
   provider: GitHub
   release: $(appveyor_repo_tag_name)
   auth_token:
-    secure: "argb6oi2TYLB4wDy+HoCC8PuGAmsnocSk12CQ5614XAPO+NVPndlkLv1utnDFfg2"
+    secure: QqePPnXbkzmXct5c8hZ2X5AbsthbI6cS1Sr+VBzcD8oUOIjfWJJKXVAQGUbQAbb0
   artifact: update,build
   draft: false
   prerelease: false

dist/icons/icons.qrc

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

dist/qt_themes/default/default.qrc

@@ -0,0 +1,11 @@
+<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

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

dist/qt_themes/qdarkstyle/icons/index.theme

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

dist/qt_themes/qdarkstyle/style.qrc

@@ -0,0 +1,49 @@
+<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,6 +17,7 @@ endif()
 
 # libfmt
 add_subdirectory(fmt)
+add_library(fmt::fmt ALIAS fmt)
 
 # getopt
 if (MSVC)

externals/cmake-modules/WindowsCopyFiles.cmake

@@ -1,4 +1,4 @@
-# Copyright 2016 Citra Emulator Project
+# Copyright 2018 Yuzu Emulator Project
 # Licensed under GPLv2 or any later version
 # Refer to the license.txt file included.
 
@@ -22,7 +22,7 @@ function(windows_copy_files TARGET SOURCE_DIR DEST_DIR)
     # cmake adds an extra check for command success which doesn't work too well with robocopy
     # so trick it into thinking the command was successful with the || cmd /c "exit /b 0"
     add_custom_command(TARGET ${TARGET} POST_BUILD
-        COMMAND if not exist ${DEST_DIR} mkdir ${DEST_DIR} 2> nul
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${DEST_DIR}
         COMMAND robocopy ${SOURCE_DIR} ${DEST_DIR} ${ARGN} /NJH /NJS /NDL /NFL /NC /NS /NP || cmd /c "exit /b 0"
     )
-endfunction()
+endfunction()

externals/getopt/CMakeLists.txt

@@ -1,11 +1,9 @@
-set(SRCS
-            getopt.c
-            )
-set(HEADERS
-            getopt.h
-            )
+add_library(getopt
+    getopt.c
+    getopt.h
+)
+
+create_target_directory_groups(getopt)
 
-create_directory_groups(${SRCS} ${HEADERS})
-add_library(getopt ${SRCS} ${HEADERS})
 target_compile_definitions(getopt PUBLIC STATIC_GETOPT)
 target_include_directories(getopt INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})

externals/glad/CMakeLists.txt

@@ -1,13 +1,10 @@
-set(SRCS
-            src/glad.c
-            )
-set(HEADERS
-            include/KHR/khrplatform.h
-            include/glad/glad.h
-            )
+add_library(glad STATIC
+    src/glad.c
+    include/KHR/khrplatform.h
+    include/glad/glad.h
+)
 
-create_directory_groups(${SRCS} ${HEADERS})
-add_library(glad STATIC ${SRCS} ${HEADERS})
+create_target_directory_groups(glad)
 target_include_directories(glad PUBLIC "include/")
 
 if ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")

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,gles=3.0
+python -m glad --profile core --out-path glad/ --api gl=3.3 --generator=c
 ```

externals/glad/include/KHR/khrplatform.h

@@ -26,7 +26,7 @@
 
 /* Khronos platform-specific types and definitions.
  *
- * $Revision: 23298 $ on $Date: 2013-09-30 17:07:13 -0700 (Mon, 30 Sep 2013) $
+ * $Revision: 32517 $ on $Date: 2016-03-11 02:41:19 -0800 (Fri, 11 Mar 2016) $
  *
  * Adopters may modify this file to suit their platform. Adopters are
  * encouraged to submit platform specific modifications to the Khronos
@@ -101,6 +101,8 @@
 #   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
@@ -223,7 +225,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.
  */

externals/inih/CMakeLists.txt

@@ -1,12 +1,9 @@
-set(SRCS
-            inih/ini.c
-            inih/cpp/INIReader.cpp
-            )
-set(HEADERS
-            inih/ini.h
-            inih/cpp/INIReader.h
-            )
+add_library(inih
+    inih/ini.c
+    inih/ini.h
+    inih/cpp/INIReader.cpp
+    inih/cpp/INIReader.h
+)
 
-create_directory_groups(${SRCS} ${HEADERS})
-add_library(inih ${SRCS} ${HEADERS})
+create_target_directory_groups(inih)
 target_include_directories(inih INTERFACE .)

hooks/pre-commit

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

src/common/CMakeLists.txt

@@ -17,86 +17,77 @@ if ($ENV{CI})
       string(SUBSTRING ${WORD} 1 -1 REMAINDER)
       string(TOUPPER ${FIRST_LETTER} FIRST_LETTER)
       # this leaves a trailing space on the last word, but we actually want that
-      # because of how its styled in the title bar.
+      # because of how it's styled in the title bar.
       set(REPO_NAME "${REPO_NAME}${FIRST_LETTER}${REMAINDER} ")
     endforeach()
   endif()
 endif()
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in" "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp" @ONLY)
 
-set(SRCS
-            break_points.cpp
-            file_util.cpp
-            hash.cpp
-            logging/filter.cpp
-            logging/text_formatter.cpp
-            logging/backend.cpp
-            memory_util.cpp
-            microprofile.cpp
-            misc.cpp
-            param_package.cpp
-            scm_rev.cpp
-            string_util.cpp
-            telemetry.cpp
-            thread.cpp
-            timer.cpp
-            )
-
-set(HEADERS
-            alignment.h
-            assert.h
-            bit_field.h
-            bit_set.h
-            break_points.h
-            chunk_file.h
-            code_block.h
-            color.h
-            common_funcs.h
-            common_paths.h
-            common_types.h
-            file_util.h
-            hash.h
-            linear_disk_cache.h
-            logging/text_formatter.h
-            logging/filter.h
-            logging/log.h
-            logging/backend.h
-            math_util.h
-            memory_util.h
-            microprofile.h
-            microprofileui.h
-            param_package.h
-            platform.h
-            quaternion.h
-            scm_rev.h
-            scope_exit.h
-            string_util.h
-            swap.h
-            synchronized_wrapper.h
-            telemetry.h
-            thread.h
-            thread_queue_list.h
-            threadsafe_queue.h
-            timer.h
-            vector_math.h
-            )
+add_library(common STATIC
+    alignment.h
+    assert.h
+    bit_field.h
+    bit_set.h
+    break_points.cpp
+    break_points.h
+    cityhash.cpp
+    cityhash.h
+    color.h
+    common_funcs.h
+    common_paths.h
+    common_types.h
+    file_util.cpp
+    file_util.h
+    hash.h
+    logging/backend.cpp
+    logging/backend.h
+    logging/filter.cpp
+    logging/filter.h
+    logging/log.h
+    logging/text_formatter.cpp
+    logging/text_formatter.h
+    math_util.h
+    memory_util.cpp
+    memory_util.h
+    microprofile.cpp
+    microprofile.h
+    microprofileui.h
+    misc.cpp
+    param_package.cpp
+    param_package.h
+    quaternion.h
+    scm_rev.cpp
+    scm_rev.h
+    scope_exit.h
+    string_util.cpp
+    string_util.h
+    swap.h
+    synchronized_wrapper.h
+    telemetry.cpp
+    telemetry.h
+    thread.cpp
+    thread.h
+    thread_queue_list.h
+    threadsafe_queue.h
+    timer.cpp
+    timer.h
+    vector_math.h
+)
 
 if(ARCHITECTURE_x86_64)
-    set(SRCS ${SRCS}
+    target_sources(common
+        PRIVATE
             x64/cpu_detect.cpp
-            )
-
-    set(HEADERS ${HEADERS}
             x64/cpu_detect.h
             x64/xbyak_abi.h
             x64/xbyak_util.h
-            )
+    )
 endif()
 
-create_directory_groups(${SRCS} ${HEADERS})
+create_target_directory_groups(common)
 
-add_library(common STATIC ${SRCS} ${HEADERS})
-target_link_libraries(common PUBLIC Boost::boost microprofile)
+target_link_libraries(common PUBLIC Boost::boost fmt microprofile)
 if (ARCHITECTURE_x86_64)
     target_link_libraries(common PRIVATE xbyak)
 endif()

src/common/assert.h

@@ -52,5 +52,5 @@ __declspec(noinline, noreturn)
 #define DEBUG_ASSERT_MSG(_a_, _desc_, ...)
 #endif
 
-#define UNIMPLEMENTED() DEBUG_ASSERT_MSG(false, "Unimplemented code!")
+#define UNIMPLEMENTED() LOG_CRITICAL(Debug, "Unimplemented code!")
 #define UNIMPLEMENTED_MSG(...) ASSERT_MSG(false, __VA_ARGS__)

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.
-    BitField& operator=(const BitField&) = default;
+    constexpr 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;
 
-    FORCE_INLINE operator T() const {
+    constexpr FORCE_INLINE operator T() const {
         return Value();
     }
 
-    FORCE_INLINE void Assign(const T& value) {
+    constexpr FORCE_INLINE void Assign(const T& value) {
         storage = (storage & ~mask) | FormatValue(value);
     }
 
-    FORCE_INLINE T Value() const {
+    constexpr T Value() const {
         return ExtractValue(storage);
     }
 
     // TODO: we may want to change this to explicit operator bool() if it's bug-free in VS2015
-    FORCE_INLINE bool ToBool() const {
+    constexpr FORCE_INLINE bool ToBool() const {
         return Value() != 0;
     }
 
@@ -192,11 +192,6 @@ 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_pod<T>::value, "Invalid base type");
+    static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable in a BitField");
 };
 #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/bit_set.h

@@ -236,7 +236,7 @@ public:
     IntTy m_val;
 };
 
-} // Common
+} // namespace Common
 
 typedef Common::BitSet<u8> BitSet8;
 typedef Common::BitSet<u16> BitSet16;

src/common/chunk_file.h

@@ -1,622 +0,0 @@
-// Copyright (C) 2003 Dolphin Project.
-
-// 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, version 2.0 or later versions.
-
-// 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 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official SVN repository and contact information can be found at
-// http://code.google.com/p/dolphin-emu/
-
-#pragma once
-
-// Extremely simple serialization framework.
-
-// (mis)-features:
-// + Super fast
-// + Very simple
-// + Same code is used for serialization and deserializaition (in most cases)
-// - Zero backwards/forwards compatibility
-// - Serialization code for anything complex has to be manually written.
-
-#include <cstring>
-#include <deque>
-#include <list>
-#include <map>
-#include <set>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "common/logging/log.h"
-
-template <class T>
-struct LinkedListItem : public T {
-    LinkedListItem<T>* next;
-};
-
-class PointerWrap;
-
-class PointerWrapSection {
-public:
-    PointerWrapSection(PointerWrap& p, int ver, const char* title)
-        : p_(p), ver_(ver), title_(title) {}
-    ~PointerWrapSection();
-
-    bool operator==(const int& v) const {
-        return ver_ == v;
-    }
-    bool operator!=(const int& v) const {
-        return ver_ != v;
-    }
-    bool operator<=(const int& v) const {
-        return ver_ <= v;
-    }
-    bool operator>=(const int& v) const {
-        return ver_ >= v;
-    }
-    bool operator<(const int& v) const {
-        return ver_ < v;
-    }
-    bool operator>(const int& v) const {
-        return ver_ > v;
-    }
-
-    operator bool() const {
-        return ver_ > 0;
-    }
-
-private:
-    PointerWrap& p_;
-    int ver_;
-    const char* title_;
-};
-
-// Wrapper class
-class PointerWrap {
-// This makes it a compile error if you forget to define DoState() on non-POD.
-// Which also can be a problem, for example struct tm is non-POD on linux, for whatever reason...
-#ifdef _MSC_VER
-    template <typename T, bool isPOD = std::is_pod<T>::value,
-              bool isPointer = std::is_pointer<T>::value>
-#else
-    template <typename T, bool isPOD = __is_pod(T), bool isPointer = std::is_pointer<T>::value>
-#endif
-    struct DoHelper {
-        static void DoArray(PointerWrap* p, T* x, int count) {
-            for (int i = 0; i < count; ++i)
-                p->Do(x[i]);
-        }
-
-        static void Do(PointerWrap* p, T& x) {
-            p->DoClass(x);
-        }
-    };
-
-    template <typename T>
-    struct DoHelper<T, true, false> {
-        static void DoArray(PointerWrap* p, T* x, int count) {
-            p->DoVoid((void*)x, sizeof(T) * count);
-        }
-
-        static void Do(PointerWrap* p, T& x) {
-            p->DoVoid((void*)&x, sizeof(x));
-        }
-    };
-
-public:
-    enum Mode {
-        MODE_READ = 1, // load
-        MODE_WRITE,    // save
-        MODE_MEASURE,  // calculate size
-        MODE_VERIFY,   // compare
-    };
-
-    enum Error {
-        ERROR_NONE = 0,
-        ERROR_WARNING = 1,
-        ERROR_FAILURE = 2,
-    };
-
-    u8** ptr;
-    Mode mode;
-    Error error;
-
-public:
-    PointerWrap(u8** ptr_, Mode mode_) : ptr(ptr_), mode(mode_), error(ERROR_NONE) {}
-    PointerWrap(unsigned char** ptr_, int mode_)
-        : ptr((u8**)ptr_), mode((Mode)mode_), error(ERROR_NONE) {}
-
-    PointerWrapSection Section(const char* title, int ver) {
-        return Section(title, ver, ver);
-    }
-
-    // The returned object can be compared against the version that was loaded.
-    // This can be used to support versions as old as minVer.
-    // Version = 0 means the section was not found.
-    PointerWrapSection Section(const char* title, int minVer, int ver) {
-        char marker[16] = {0};
-        int foundVersion = ver;
-
-        strncpy(marker, title, sizeof(marker));
-        if (!ExpectVoid(marker, sizeof(marker))) {
-            // Might be before we added name markers for safety.
-            if (foundVersion == 1 && ExpectVoid(&foundVersion, sizeof(foundVersion)))
-                DoMarker(title);
-            // Wasn't found, but maybe we can still load the state.
-            else
-                foundVersion = 0;
-        } else
-            Do(foundVersion);
-
-        if (error == ERROR_FAILURE || foundVersion < minVer || foundVersion > ver) {
-            LOG_ERROR(Common, "Savestate failure: wrong version %d found for %s", foundVersion,
-                      title);
-            SetError(ERROR_FAILURE);
-            return PointerWrapSection(*this, -1, title);
-        }
-        return PointerWrapSection(*this, foundVersion, title);
-    }
-
-    void SetMode(Mode mode_) {
-        mode = mode_;
-    }
-    Mode GetMode() const {
-        return mode;
-    }
-    u8** GetPPtr() {
-        return ptr;
-    }
-    void SetError(Error error_) {
-        if (error < error_)
-            error = error_;
-        if (error > ERROR_WARNING)
-            mode = PointerWrap::MODE_MEASURE;
-    }
-
-    bool ExpectVoid(void* data, int size) {
-        switch (mode) {
-        case MODE_READ:
-            if (memcmp(data, *ptr, size) != 0)
-                return false;
-            break;
-        case MODE_WRITE:
-            memcpy(*ptr, data, size);
-            break;
-        case MODE_MEASURE:
-            break; // MODE_MEASURE - don't need to do anything
-        case MODE_VERIFY:
-            for (int i = 0; i < size; i++) {
-                DEBUG_ASSERT_MSG(
-                    ((u8*)data)[i] == (*ptr)[i],
-                    "Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n",
-                    ((u8*)data)[i], ((u8*)data)[i], &((u8*)data)[i], (*ptr)[i], (*ptr)[i],
-                    &(*ptr)[i]);
-            }
-            break;
-        default:
-            break; // throw an error?
-        }
-        (*ptr) += size;
-        return true;
-    }
-
-    void DoVoid(void* data, int size) {
-        switch (mode) {
-        case MODE_READ:
-            memcpy(data, *ptr, size);
-            break;
-        case MODE_WRITE:
-            memcpy(*ptr, data, size);
-            break;
-        case MODE_MEASURE:
-            break; // MODE_MEASURE - don't need to do anything
-        case MODE_VERIFY:
-            for (int i = 0; i < size; i++) {
-                DEBUG_ASSERT_MSG(
-                    ((u8*)data)[i] == (*ptr)[i],
-                    "Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n",
-                    ((u8*)data)[i], ((u8*)data)[i], &((u8*)data)[i], (*ptr)[i], (*ptr)[i],
-                    &(*ptr)[i]);
-            }
-            break;
-        default:
-            break; // throw an error?
-        }
-        (*ptr) += size;
-    }
-
-    template <class K, class T>
-    void Do(std::map<K, T*>& x) {
-        if (mode == MODE_READ) {
-            for (auto it = x.begin(), end = x.end(); it != end; ++it) {
-                if (it->second != nullptr)
-                    delete it->second;
-            }
-        }
-        T* dv = nullptr;
-        DoMap(x, dv);
-    }
-
-    template <class K, class T>
-    void Do(std::map<K, T>& x) {
-        T dv = T();
-        DoMap(x, dv);
-    }
-
-    template <class K, class T>
-    void DoMap(std::map<K, T>& x, T& default_val) {
-        unsigned int number = (unsigned int)x.size();
-        Do(number);
-        switch (mode) {
-        case MODE_READ: {
-            x.clear();
-            while (number > 0) {
-                K first = K();
-                Do(first);
-                T second = default_val;
-                Do(second);
-                x[first] = second;
-                --number;
-            }
-        } break;
-        case MODE_WRITE:
-        case MODE_MEASURE:
-        case MODE_VERIFY: {
-            typename std::map<K, T>::iterator itr = x.begin();
-            while (number > 0) {
-                K first = itr->first;
-                Do(first);
-                Do(itr->second);
-                --number;
-                ++itr;
-            }
-        } break;
-        }
-    }
-
-    template <class K, class T>
-    void Do(std::multimap<K, T*>& x) {
-        if (mode == MODE_READ) {
-            for (auto it = x.begin(), end = x.end(); it != end; ++it) {
-                if (it->second != nullptr)
-                    delete it->second;
-            }
-        }
-        T* dv = nullptr;
-        DoMultimap(x, dv);
-    }
-
-    template <class K, class T>
-    void Do(std::multimap<K, T>& x) {
-        T dv = T();
-        DoMultimap(x, dv);
-    }
-
-    template <class K, class T>
-    void DoMultimap(std::multimap<K, T>& x, T& default_val) {
-        unsigned int number = (unsigned int)x.size();
-        Do(number);
-        switch (mode) {
-        case MODE_READ: {
-            x.clear();
-            while (number > 0) {
-                K first = K();
-                Do(first);
-                T second = default_val;
-                Do(second);
-                x.insert(std::make_pair(first, second));
-                --number;
-            }
-        } break;
-        case MODE_WRITE:
-        case MODE_MEASURE:
-        case MODE_VERIFY: {
-            typename std::multimap<K, T>::iterator itr = x.begin();
-            while (number > 0) {
-                Do(itr->first);
-                Do(itr->second);
-                --number;
-                ++itr;
-            }
-        } break;
-        }
-    }
-
-    // Store vectors.
-    template <class T>
-    void Do(std::vector<T*>& x) {
-        T* dv = nullptr;
-        DoVector(x, dv);
-    }
-
-    template <class T>
-    void Do(std::vector<T>& x) {
-        T dv = T();
-        DoVector(x, dv);
-    }
-
-    template <class T>
-    void DoPOD(std::vector<T>& x) {
-        T dv = T();
-        DoVectorPOD(x, dv);
-    }
-
-    template <class T>
-    void Do(std::vector<T>& x, T& default_val) {
-        DoVector(x, default_val);
-    }
-
-    template <class T>
-    void DoVector(std::vector<T>& x, T& default_val) {
-        u32 vec_size = (u32)x.size();
-        Do(vec_size);
-        x.resize(vec_size, default_val);
-        if (vec_size > 0)
-            DoArray(&x[0], vec_size);
-    }
-
-    template <class T>
-    void DoVectorPOD(std::vector<T>& x, T& default_val) {
-        u32 vec_size = (u32)x.size();
-        Do(vec_size);
-        x.resize(vec_size, default_val);
-        if (vec_size > 0)
-            DoArray(&x[0], vec_size);
-    }
-
-    // Store deques.
-    template <class T>
-    void Do(std::deque<T*>& x) {
-        T* dv = nullptr;
-        DoDeque(x, dv);
-    }
-
-    template <class T>
-    void Do(std::deque<T>& x) {
-        T dv = T();
-        DoDeque(x, dv);
-    }
-
-    template <class T>
-    void DoDeque(std::deque<T>& x, T& default_val) {
-        u32 deq_size = (u32)x.size();
-        Do(deq_size);
-        x.resize(deq_size, default_val);
-        u32 i;
-        for (i = 0; i < deq_size; i++)
-            Do(x[i]);
-    }
-
-    // Store STL lists.
-    template <class T>
-    void Do(std::list<T*>& x) {
-        T* dv = nullptr;
-        Do(x, dv);
-    }
-
-    template <class T>
-    void Do(std::list<T>& x) {
-        T dv = T();
-        DoList(x, dv);
-    }
-
-    template <class T>
-    void Do(std::list<T>& x, T& default_val) {
-        DoList(x, default_val);
-    }
-
-    template <class T>
-    void DoList(std::list<T>& x, T& default_val) {
-        u32 list_size = (u32)x.size();
-        Do(list_size);
-        x.resize(list_size, default_val);
-
-        typename std::list<T>::iterator itr, end;
-        for (itr = x.begin(), end = x.end(); itr != end; ++itr)
-            Do(*itr);
-    }
-
-    // Store STL sets.
-    template <class T>
-    void Do(std::set<T*>& x) {
-        if (mode == MODE_READ) {
-            for (auto it = x.begin(), end = x.end(); it != end; ++it) {
-                if (*it != nullptr)
-                    delete *it;
-            }
-        }
-        DoSet(x);
-    }
-
-    template <class T>
-    void Do(std::set<T>& x) {
-        DoSet(x);
-    }
-
-    template <class T>
-    void DoSet(std::set<T>& x) {
-        unsigned int number = (unsigned int)x.size();
-        Do(number);
-
-        switch (mode) {
-        case MODE_READ: {
-            x.clear();
-            while (number-- > 0) {
-                T it = T();
-                Do(it);
-                x.insert(it);
-            }
-        } break;
-        case MODE_WRITE:
-        case MODE_MEASURE:
-        case MODE_VERIFY: {
-            typename std::set<T>::iterator itr = x.begin();
-            while (number-- > 0)
-                Do(*itr++);
-        } break;
-
-        default:
-            LOG_ERROR(Common, "Savestate error: invalid mode %d.", mode);
-        }
-    }
-
-    // Store strings.
-    void Do(std::string& x) {
-        int stringLen = (int)x.length() + 1;
-        Do(stringLen);
-
-        switch (mode) {
-        case MODE_READ:
-            x = (char*)*ptr;
-            break;
-        case MODE_WRITE:
-            memcpy(*ptr, x.c_str(), stringLen);
-            break;
-        case MODE_MEASURE:
-            break;
-        case MODE_VERIFY:
-            DEBUG_ASSERT_MSG((x == (char*)*ptr),
-                             "Savestate verification failure: \"%s\" != \"%s\" (at %p).\n",
-                             x.c_str(), (char*)*ptr, ptr);
-            break;
-        }
-        (*ptr) += stringLen;
-    }
-
-    void Do(std::wstring& x) {
-        int stringLen = sizeof(wchar_t) * ((int)x.length() + 1);
-        Do(stringLen);
-
-        switch (mode) {
-        case MODE_READ:
-            x = (wchar_t*)*ptr;
-            break;
-        case MODE_WRITE:
-            memcpy(*ptr, x.c_str(), stringLen);
-            break;
-        case MODE_MEASURE:
-            break;
-        case MODE_VERIFY:
-            DEBUG_ASSERT_MSG((x == (wchar_t*)*ptr),
-                             "Savestate verification failure: \"%ls\" != \"%ls\" (at %p).\n",
-                             x.c_str(), (wchar_t*)*ptr, ptr);
-            break;
-        }
-        (*ptr) += stringLen;
-    }
-
-    template <class T>
-    void DoClass(T& x) {
-        x.DoState(*this);
-    }
-
-    template <class T>
-    void DoClass(T*& x) {
-        if (mode == MODE_READ) {
-            if (x != nullptr)
-                delete x;
-            x = new T();
-        }
-        x->DoState(*this);
-    }
-
-    template <class T>
-    void DoArray(T* x, int count) {
-        DoHelper<T>::DoArray(this, x, count);
-    }
-
-    template <class T>
-    void Do(T& x) {
-        DoHelper<T>::Do(this, x);
-    }
-
-    template <class T>
-    void DoPOD(T& x) {
-        DoHelper<T>::Do(this, x);
-    }
-
-    template <class T>
-    void DoPointer(T*& x, T* const base) {
-        // pointers can be more than 2^31 apart, but you're using this function wrong if you need
-        // that much range
-        s32 offset = x - base;
-        Do(offset);
-        if (mode == MODE_READ)
-            x = base + offset;
-    }
-
-    template <class T, LinkedListItem<T>* (*TNew)(), void (*TFree)(LinkedListItem<T>*),
-              void (*TDo)(PointerWrap&, T*)>
-    void DoLinkedList(LinkedListItem<T>*& list_start, LinkedListItem<T>** list_end = nullptr) {
-        LinkedListItem<T>* list_cur = list_start;
-        LinkedListItem<T>* prev = nullptr;
-
-        while (true) {
-            u8 shouldExist = (list_cur ? 1 : 0);
-            Do(shouldExist);
-            if (shouldExist == 1) {
-                LinkedListItem<T>* cur = list_cur ? list_cur : TNew();
-                TDo(*this, (T*)cur);
-                if (!list_cur) {
-                    if (mode == MODE_READ) {
-                        cur->next = nullptr;
-                        list_cur = cur;
-                        if (prev)
-                            prev->next = cur;
-                        else
-                            list_start = cur;
-                    } else {
-                        TFree(cur);
-                        continue;
-                    }
-                }
-            } else {
-                if (mode == MODE_READ) {
-                    if (prev)
-                        prev->next = nullptr;
-                    if (list_end)
-                        *list_end = prev;
-                    if (list_cur) {
-                        if (list_start == list_cur)
-                            list_start = nullptr;
-                        do {
-                            LinkedListItem<T>* next = list_cur->next;
-                            TFree(list_cur);
-                            list_cur = next;
-                        } while (list_cur);
-                    }
-                }
-                break;
-            }
-            prev = list_cur;
-            list_cur = list_cur->next;
-        }
-    }
-
-    void DoMarker(const char* prevName, u32 arbitraryNumber = 0x42) {
-        u32 cookie = arbitraryNumber;
-        Do(cookie);
-        if (mode == PointerWrap::MODE_READ && cookie != arbitraryNumber) {
-            LOG_ERROR(Common, "After \"%s\", found %d (0x%X) instead of save marker %d (0x%X). "
-                              "Aborting savestate load...",
-                      prevName, cookie, cookie, arbitraryNumber, arbitraryNumber);
-            SetError(ERROR_FAILURE);
-        }
-    }
-};
-
-inline PointerWrapSection::~PointerWrapSection() {
-    if (ver_ > 0) {
-        p_.DoMarker(title_);
-    }
-}

src/common/cityhash.cpp

@@ -0,0 +1,340 @@
+// 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

@@ -0,0 +1,110 @@
+// 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/code_block.h

@@ -1,85 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project
-// Licensed under GPLv2
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstddef>
-#include "common/common_types.h"
-#include "common/memory_util.h"
-
-// Everything that needs to generate code should inherit from this.
-// You get memory management for free, plus, you can use all emitter functions without
-// having to prefix them with gen-> or something similar.
-// Example implementation:
-// class JIT : public CodeBlock<ARMXEmitter> {}
-template <class T>
-class CodeBlock : public T, NonCopyable {
-private:
-    // A privately used function to set the executable RAM space to something invalid.
-    // For debugging usefulness it should be used to set the RAM to a host specific breakpoint
-    // instruction
-    virtual void PoisonMemory() = 0;
-
-protected:
-    u8* region;
-    size_t region_size;
-
-public:
-    CodeBlock() : region(nullptr), region_size(0) {}
-    virtual ~CodeBlock() {
-        if (region)
-            FreeCodeSpace();
-    }
-
-    // Call this before you generate any code.
-    void AllocCodeSpace(int size) {
-        region_size = size;
-        region = (u8*)AllocateExecutableMemory(region_size);
-        T::SetCodePtr(region);
-    }
-
-    // Always clear code space with breakpoints, so that if someone accidentally executes
-    // uninitialized, it just breaks into the debugger.
-    void ClearCodeSpace() {
-        PoisonMemory();
-        ResetCodePtr();
-    }
-
-    // Call this when shutting down. Don't rely on the destructor, even though it'll do the job.
-    void FreeCodeSpace() {
-#ifdef __SYMBIAN32__
-        ResetExecutableMemory(region);
-#else
-        FreeMemoryPages(region, region_size);
-#endif
-        region = nullptr;
-        region_size = 0;
-    }
-
-    bool IsInSpace(const u8* ptr) {
-        return (ptr >= region) && (ptr < (region + region_size));
-    }
-
-    // Cannot currently be undone. Will write protect the entire code region.
-    // Start over if you need to change the code (call FreeCodeSpace(), AllocCodeSpace()).
-    void WriteProtect() {
-        WriteProtectMemory(region, region_size, true);
-    }
-
-    void ResetCodePtr() {
-        T::SetCodePtr(region);
-    }
-
-    size_t GetSpaceLeft() const {
-        return region_size - (T::GetCodePtr() - region);
-    }
-
-    u8* GetBasePtr() {
-        return region;
-    }
-
-    size_t GetOffset(const u8* ptr) const {
-        return ptr - region;
-    }
-};

src/common/color.h

@@ -256,4 +256,4 @@ inline void EncodeX24S8(u8 stencil, u8* bytes) {
     bytes[3] = stencil;
 }
 
-} // namespace
+} // namespace Color

src/common/common_funcs.h

@@ -4,13 +4,13 @@
 
 #pragma once
 
-#if !defined(ARCHITECTURE_x86_64) && !defined(_M_ARM)
+#include <string>
+
+#if !defined(ARCHITECTURE_x86_64) && !defined(ARCHITECTURE_ARM)
 #include <cstdlib> // for exit
 #endif
 #include "common/common_types.h"
 
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
-
 /// Textually concatenates two tokens. The double-expansion is required by the C preprocessor.
 #define CONCAT2(x, y) DO_CONCAT2(x, y)
 #define DO_CONCAT2(x, y) x##y
@@ -32,53 +32,14 @@
 
 #ifdef ARCHITECTURE_x86_64
 #define Crash() __asm__ __volatile__("int $3")
-#elif defined(_M_ARM)
+#elif defined(ARCHITECTURE_ARM)
 #define Crash() __asm__ __volatile__("trap")
 #else
 #define Crash() exit(1)
 #endif
 
-// GCC 4.8 defines all the rotate functions now
-// Small issue with GCC's lrotl/lrotr intrinsics is they are still 32bit while we require 64bit
-#ifdef _rotl
-#define rotl _rotl
-#else
-inline u32 rotl(u32 x, int shift) {
-    shift &= 31;
-    if (!shift)
-        return x;
-    return (x << shift) | (x >> (32 - shift));
-}
-#endif
-
-#ifdef _rotr
-#define rotr _rotr
-#else
-inline u32 rotr(u32 x, int shift) {
-    shift &= 31;
-    if (!shift)
-        return x;
-    return (x >> shift) | (x << (32 - shift));
-}
-#endif
-
-inline u64 _rotl64(u64 x, unsigned int shift) {
-    unsigned int n = shift % 64;
-    return (x << n) | (x >> (64 - n));
-}
-
-inline u64 _rotr64(u64 x, unsigned int shift) {
-    unsigned int n = shift % 64;
-    return (x >> n) | (x << (64 - n));
-}
-
 #else // _MSC_VER
 
-#if (_MSC_VER < 1900)
-// Function Cross-Compatibility
-#define snprintf _snprintf
-#endif
-
 // Locale Cross-Compatibility
 #define locale_t _locale_t
 
@@ -87,17 +48,13 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
 }
 #define Crash() DebugBreak()
 
-// cstdlib provides these on MSVC
-#define rotr _rotr
-#define rotl _rotl
-
 #endif // _MSC_VER ndef
 
 // Generic function to get last error message.
 // Call directly after the command or use the error num.
 // This function might change the error code.
 // Defined in Misc.cpp.
-const char* GetLastErrorMsg();
+std::string GetLastErrorMsg();
 
 namespace Common {
 

src/common/common_paths.h

@@ -32,12 +32,15 @@
 #define SDMC_DIR "sdmc"
 #define NAND_DIR "nand"
 #define SYSDATA_DIR "sysdata"
+#define LOG_DIR "log"
 
 // Filenames
 // Files in the directory returned by GetUserPath(D_CONFIG_IDX)
 #define EMU_CONFIG "emu.ini"
 #define DEBUGGER_CONFIG "debugger.ini"
 #define LOGGER_CONFIG "logger.ini"
+// Files in the directory returned by GetUserPath(D_LOGS_IDX)
+#define LOG_FILE "yuzu_log.txt"
 
 // Sys files
 #define SHARED_FONT "shared_font.bin"

src/common/common_types.h

@@ -27,29 +27,23 @@
 #include <array>
 #include <cstdint>
 
-#ifdef _MSC_VER
-#ifndef __func__
-#define __func__ __FUNCTION__
-#endif
-#endif
+using u8 = std::uint8_t;   ///< 8-bit unsigned byte
+using u16 = std::uint16_t; ///< 16-bit unsigned short
+using u32 = std::uint32_t; ///< 32-bit unsigned word
+using u64 = std::uint64_t; ///< 64-bit unsigned int
 
-typedef std::uint8_t u8;   ///< 8-bit unsigned byte
-typedef std::uint16_t u16; ///< 16-bit unsigned short
-typedef std::uint32_t u32; ///< 32-bit unsigned word
-typedef std::uint64_t u64; ///< 64-bit unsigned int
+using s8 = std::int8_t;   ///< 8-bit signed byte
+using s16 = std::int16_t; ///< 16-bit signed short
+using s32 = std::int32_t; ///< 32-bit signed word
+using s64 = std::int64_t; ///< 64-bit signed int
 
-typedef std::int8_t s8;   ///< 8-bit signed byte
-typedef std::int16_t s16; ///< 16-bit signed short
-typedef std::int32_t s32; ///< 32-bit signed word
-typedef std::int64_t s64; ///< 64-bit signed int
-
-typedef float f32;  ///< 32-bit floating point
-typedef double f64; ///< 64-bit floating point
+using f32 = float;  ///< 32-bit floating point
+using f64 = double; ///< 64-bit floating point
 
 // TODO: It would be nice to eventually replace these with strong types that prevent accidental
 // conversion between each other.
-typedef u64 VAddr; ///< Represents a pointer in the userspace virtual address space.
-typedef u64 PAddr; ///< Represents a pointer in the ARM11 physical address space.
+using VAddr = u64; ///< Represents a pointer in the userspace virtual address space.
+using PAddr = u64; ///< Represents a pointer in the ARM11 physical address space.
 
 using u128 = std::array<std::uint64_t, 2>;
 static_assert(sizeof(u128) == 16, "u128 must be 128 bits wide");

src/common/file_util.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <sstream>
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_paths.h"
@@ -118,7 +119,7 @@ bool IsDirectory(const std::string& filename) {
 #endif
 
     if (result < 0) {
-        LOG_DEBUG(Common_Filesystem, "stat failed on %s: %s", filename.c_str(), GetLastErrorMsg());
+        LOG_DEBUG(Common_Filesystem, "stat failed on {}: {}", filename, GetLastErrorMsg());
         return false;
     }
 
@@ -128,31 +129,29 @@ bool IsDirectory(const std::string& filename) {
 // Deletes a given filename, return true on success
 // Doesn't supports deleting a directory
 bool Delete(const std::string& filename) {
-    LOG_TRACE(Common_Filesystem, "file %s", filename.c_str());
+    LOG_TRACE(Common_Filesystem, "file {}", filename);
 
     // Return true because we care about the file no
     // being there, not the actual delete.
     if (!Exists(filename)) {
-        LOG_DEBUG(Common_Filesystem, "%s does not exist", filename.c_str());
+        LOG_DEBUG(Common_Filesystem, "{} does not exist", filename);
         return true;
     }
 
     // We can't delete a directory
     if (IsDirectory(filename)) {
-        LOG_ERROR(Common_Filesystem, "Failed: %s is a directory", filename.c_str());
+        LOG_ERROR(Common_Filesystem, "Failed: {} is a directory", filename);
         return false;
     }
 
 #ifdef _WIN32
     if (!DeleteFileW(Common::UTF8ToUTF16W(filename).c_str())) {
-        LOG_ERROR(Common_Filesystem, "DeleteFile failed on %s: %s", filename.c_str(),
-                  GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "DeleteFile failed on {}: {}", filename, GetLastErrorMsg());
         return false;
     }
 #else
     if (unlink(filename.c_str()) == -1) {
-        LOG_ERROR(Common_Filesystem, "unlink failed on %s: %s", filename.c_str(),
-                  GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "unlink failed on {}: {}", filename, GetLastErrorMsg());
         return false;
     }
 #endif
@@ -162,16 +161,16 @@ bool Delete(const std::string& filename) {
 
 // Returns true if successful, or path already exists.
 bool CreateDir(const std::string& path) {
-    LOG_TRACE(Common_Filesystem, "directory %s", path.c_str());
+    LOG_TRACE(Common_Filesystem, "directory {}", path);
 #ifdef _WIN32
     if (::CreateDirectoryW(Common::UTF8ToUTF16W(path).c_str(), nullptr))
         return true;
     DWORD error = GetLastError();
     if (error == ERROR_ALREADY_EXISTS) {
-        LOG_DEBUG(Common_Filesystem, "CreateDirectory failed on %s: already exists", path.c_str());
+        LOG_DEBUG(Common_Filesystem, "CreateDirectory failed on {}: already exists", path);
         return true;
     }
-    LOG_ERROR(Common_Filesystem, "CreateDirectory failed on %s: %i", path.c_str(), error);
+    LOG_ERROR(Common_Filesystem, "CreateDirectory failed on {}: {}", path, error);
     return false;
 #else
     if (mkdir(path.c_str(), 0755) == 0)
@@ -180,11 +179,11 @@ bool CreateDir(const std::string& path) {
     int err = errno;
 
     if (err == EEXIST) {
-        LOG_DEBUG(Common_Filesystem, "mkdir failed on %s: already exists", path.c_str());
+        LOG_DEBUG(Common_Filesystem, "mkdir failed on {}: already exists", path);
         return true;
     }
 
-    LOG_ERROR(Common_Filesystem, "mkdir failed on %s: %s", path.c_str(), strerror(err));
+    LOG_ERROR(Common_Filesystem, "mkdir failed on {}: {}", path, strerror(err));
     return false;
 #endif
 }
@@ -192,10 +191,10 @@ bool CreateDir(const std::string& path) {
 // Creates the full path of fullPath returns true on success
 bool CreateFullPath(const std::string& fullPath) {
     int panicCounter = 100;
-    LOG_TRACE(Common_Filesystem, "path %s", fullPath.c_str());
+    LOG_TRACE(Common_Filesystem, "path {}", fullPath);
 
     if (FileUtil::Exists(fullPath)) {
-        LOG_DEBUG(Common_Filesystem, "path exists %s", fullPath.c_str());
+        LOG_DEBUG(Common_Filesystem, "path exists {}", fullPath);
         return true;
     }
 
@@ -227,11 +226,11 @@ bool CreateFullPath(const std::string& fullPath) {
 
 // Deletes a directory filename, returns true on success
 bool DeleteDir(const std::string& filename) {
-    LOG_TRACE(Common_Filesystem, "directory %s", filename.c_str());
+    LOG_TRACE(Common_Filesystem, "directory {}", filename);
 
     // check if a directory
     if (!FileUtil::IsDirectory(filename)) {
-        LOG_ERROR(Common_Filesystem, "Not a directory %s", filename.c_str());
+        LOG_ERROR(Common_Filesystem, "Not a directory {}", filename);
         return false;
     }
 
@@ -242,14 +241,14 @@ bool DeleteDir(const std::string& filename) {
     if (rmdir(filename.c_str()) == 0)
         return true;
 #endif
-    LOG_ERROR(Common_Filesystem, "failed %s: %s", filename.c_str(), GetLastErrorMsg());
+    LOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
 
     return false;
 }
 
 // renames file srcFilename to destFilename, returns true on success
 bool Rename(const std::string& srcFilename, const std::string& destFilename) {
-    LOG_TRACE(Common_Filesystem, "%s --> %s", srcFilename.c_str(), destFilename.c_str());
+    LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
 #ifdef _WIN32
     if (_wrename(Common::UTF8ToUTF16W(srcFilename).c_str(),
                  Common::UTF8ToUTF16W(destFilename).c_str()) == 0)
@@ -258,20 +257,20 @@ bool Rename(const std::string& srcFilename, const std::string& destFilename) {
     if (rename(srcFilename.c_str(), destFilename.c_str()) == 0)
         return true;
 #endif
-    LOG_ERROR(Common_Filesystem, "failed %s --> %s: %s", srcFilename.c_str(), destFilename.c_str(),
+    LOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
               GetLastErrorMsg());
     return false;
 }
 
 // copies file srcFilename to destFilename, returns true on success
 bool Copy(const std::string& srcFilename, const std::string& destFilename) {
-    LOG_TRACE(Common_Filesystem, "%s --> %s", srcFilename.c_str(), destFilename.c_str());
+    LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
 #ifdef _WIN32
     if (CopyFileW(Common::UTF8ToUTF16W(srcFilename).c_str(),
                   Common::UTF8ToUTF16W(destFilename).c_str(), FALSE))
         return true;
 
-    LOG_ERROR(Common_Filesystem, "failed %s --> %s: %s", srcFilename.c_str(), destFilename.c_str(),
+    LOG_ERROR(Common_Filesystem, "failed {} --> {}: {}", srcFilename, destFilename,
               GetLastErrorMsg());
     return false;
 #else
@@ -284,8 +283,8 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
     // Open input file
     FILE* input = fopen(srcFilename.c_str(), "rb");
     if (!input) {
-        LOG_ERROR(Common_Filesystem, "opening input failed %s --> %s: %s", srcFilename.c_str(),
-                  destFilename.c_str(), GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "opening input failed {} --> {}: {}", srcFilename,
+                  destFilename, GetLastErrorMsg());
         return false;
     }
 
@@ -293,8 +292,8 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
     FILE* output = fopen(destFilename.c_str(), "wb");
     if (!output) {
         fclose(input);
-        LOG_ERROR(Common_Filesystem, "opening output failed %s --> %s: %s", srcFilename.c_str(),
-                  destFilename.c_str(), GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "opening output failed {} --> {}: {}", srcFilename,
+                  destFilename, GetLastErrorMsg());
         return false;
     }
 
@@ -304,8 +303,8 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
         size_t rnum = fread(buffer, sizeof(char), BSIZE, input);
         if (rnum != BSIZE) {
             if (ferror(input) != 0) {
-                LOG_ERROR(Common_Filesystem, "failed reading from source, %s --> %s: %s",
-                          srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());
+                LOG_ERROR(Common_Filesystem, "failed reading from source, {} --> {}: {}",
+                          srcFilename, destFilename, GetLastErrorMsg());
                 goto bail;
             }
         }
@@ -313,8 +312,8 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
         // write output
         size_t wnum = fwrite(buffer, sizeof(char), rnum, output);
         if (wnum != rnum) {
-            LOG_ERROR(Common_Filesystem, "failed writing to output, %s --> %s: %s",
-                      srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());
+            LOG_ERROR(Common_Filesystem, "failed writing to output, {} --> {}: {}", srcFilename,
+                      destFilename, GetLastErrorMsg());
             goto bail;
         }
     }
@@ -334,12 +333,12 @@ bail:
 // Returns the size of filename (64bit)
 u64 GetSize(const std::string& filename) {
     if (!Exists(filename)) {
-        LOG_ERROR(Common_Filesystem, "failed %s: No such file", filename.c_str());
+        LOG_ERROR(Common_Filesystem, "failed {}: No such file", filename);
         return 0;
     }
 
     if (IsDirectory(filename)) {
-        LOG_ERROR(Common_Filesystem, "failed %s: is a directory", filename.c_str());
+        LOG_ERROR(Common_Filesystem, "failed {}: is a directory", filename);
         return 0;
     }
 
@@ -350,11 +349,11 @@ u64 GetSize(const std::string& filename) {
     if (stat(filename.c_str(), &buf) == 0)
 #endif
     {
-        LOG_TRACE(Common_Filesystem, "%s: %lld", filename.c_str(), (long long)buf.st_size);
+        LOG_TRACE(Common_Filesystem, "{}: {}", filename, buf.st_size);
         return buf.st_size;
     }
 
-    LOG_ERROR(Common_Filesystem, "Stat failed %s: %s", filename.c_str(), GetLastErrorMsg());
+    LOG_ERROR(Common_Filesystem, "Stat failed {}: {}", filename, GetLastErrorMsg());
     return 0;
 }
 
@@ -362,7 +361,7 @@ u64 GetSize(const std::string& filename) {
 u64 GetSize(const int fd) {
     struct stat buf;
     if (fstat(fd, &buf) != 0) {
-        LOG_ERROR(Common_Filesystem, "GetSize: stat failed %i: %s", fd, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetSize: stat failed {}: {}", fd, GetLastErrorMsg());
         return 0;
     }
     return buf.st_size;
@@ -373,12 +372,12 @@ u64 GetSize(FILE* f) {
     // can't use off_t here because it can be 32-bit
     u64 pos = ftello(f);
     if (fseeko(f, 0, SEEK_END) != 0) {
-        LOG_ERROR(Common_Filesystem, "GetSize: seek failed %p: %s", f, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f), GetLastErrorMsg());
         return 0;
     }
     u64 size = ftello(f);
     if ((size != pos) && (fseeko(f, pos, SEEK_SET) != 0)) {
-        LOG_ERROR(Common_Filesystem, "GetSize: seek failed %p: %s", f, GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f), GetLastErrorMsg());
         return 0;
     }
     return size;
@@ -386,10 +385,10 @@ u64 GetSize(FILE* f) {
 
 // creates an empty file filename, returns true on success
 bool CreateEmptyFile(const std::string& filename) {
-    LOG_TRACE(Common_Filesystem, "%s", filename.c_str());
+    LOG_TRACE(Common_Filesystem, "{}", filename);
 
-    if (!FileUtil::IOFile(filename, "wb")) {
-        LOG_ERROR(Common_Filesystem, "failed %s: %s", filename.c_str(), GetLastErrorMsg());
+    if (!FileUtil::IOFile(filename, "wb").IsOpen()) {
+        LOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
         return false;
     }
 
@@ -398,7 +397,7 @@ bool CreateEmptyFile(const std::string& filename) {
 
 bool ForeachDirectoryEntry(unsigned* num_entries_out, const std::string& directory,
                            DirectoryEntryCallable callback) {
-    LOG_TRACE(Common_Filesystem, "directory %s", directory.c_str());
+    LOG_TRACE(Common_Filesystem, "directory {}", directory);
 
     // How many files + directories we found
     unsigned found_entries = 0;
@@ -556,7 +555,7 @@ std::string GetCurrentDir() {
     char* dir;
     if (!(dir = getcwd(nullptr, 0))) {
 #endif
-        LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: %s", GetLastErrorMsg());
+        LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
         return nullptr;
     }
 #ifdef _WIN32
@@ -593,7 +592,7 @@ std::string GetBundleDirectory() {
 #endif
 
 #ifdef _WIN32
-std::string& GetExeDirectory() {
+const std::string& GetExeDirectory() {
     static std::string exe_path;
     if (exe_path.empty()) {
         wchar_t wchar_exe_path[2048];
@@ -653,12 +652,12 @@ static const std::string GetUserDirectory(const std::string& envvar) {
         else if (envvar == "XDG_CACHE_HOME")
             subdirectory = DIR_SEP ".cache";
         else
-            ASSERT_MSG(false, "Unknown XDG variable %s.", envvar.c_str());
+            ASSERT_MSG(false, "Unknown XDG variable {}.", envvar);
         user_dir = GetHomeDirectory() + subdirectory;
     }
 
-    ASSERT_MSG(!user_dir.empty(), "User directory %s musn’t be empty.", envvar.c_str());
-    ASSERT_MSG(user_dir[0] == '/', "User directory %s must be absolute.", envvar.c_str());
+    ASSERT_MSG(!user_dir.empty(), "User directory {} mustn’t be empty.", envvar);
+    ASSERT_MSG(user_dir[0] == '/', "User directory {} must be absolute.", envvar);
 
     return user_dir;
 }
@@ -676,11 +675,11 @@ std::string GetSysDirectory() {
 #endif
     sysDir += DIR_SEP;
 
-    LOG_DEBUG(Common_Filesystem, "Setting to %s:", sysDir.c_str());
+    LOG_DEBUG(Common_Filesystem, "Setting to {}:", sysDir);
     return sysDir;
 }
 
-// Returns a string with a Citra data dir or file in the user's home
+// Returns a string with a yuzu data dir or file 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) {
     static std::string paths[NUM_PATH_INDICES];
@@ -715,11 +714,13 @@ const std::string& GetUserPath(const unsigned int DirIDX, const std::string& new
         paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;
         paths[D_NAND_IDX] = paths[D_USER_IDX] + NAND_DIR DIR_SEP;
         paths[D_SYSDATA_IDX] = paths[D_USER_IDX] + SYSDATA_DIR DIR_SEP;
+        // TODO: Put the logs in a better location for each OS
+        paths[D_LOGS_IDX] = paths[D_USER_IDX] + LOG_DIR DIR_SEP;
     }
 
     if (!newPath.empty()) {
         if (!FileUtil::IsDirectory(newPath)) {
-            LOG_ERROR(Common_Filesystem, "Invalid path specified %s", newPath.c_str());
+            LOG_ERROR(Common_Filesystem, "Invalid path specified {}", newPath);
             return paths[DirIDX];
         } else {
             paths[DirIDX] = newPath;
@@ -750,7 +751,7 @@ size_t WriteStringToFile(bool text_file, const std::string& str, const char* fil
 size_t ReadFileToString(bool text_file, const char* filename, std::string& str) {
     IOFile file(filename, text_file ? "r" : "rb");
 
-    if (!file)
+    if (!file.IsOpen())
         return false;
 
     str.resize(static_cast<u32>(file.GetSize()));
@@ -799,49 +800,117 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam
     }
 }
 
+std::vector<std::string> SplitPathComponents(const std::string& filename) {
+    auto copy(filename);
+    std::replace(copy.begin(), copy.end(), '\\', '/');
+    std::vector<std::string> out;
+
+    std::stringstream stream(filename);
+    std::string item;
+    while (std::getline(stream, item, '/'))
+        out.push_back(std::move(item));
+
+    return out;
+}
+
+std::string GetParentPath(const std::string& path) {
+    auto out = path;
+    const auto name_bck_index = out.find_last_of('\\');
+    const auto name_fwd_index = out.find_last_of('/');
+    size_t name_index;
+    if (name_bck_index == std::string::npos || name_fwd_index == std::string::npos)
+        name_index = std::min<size_t>(name_bck_index, name_fwd_index);
+    else
+        name_index = std::max<size_t>(name_bck_index, name_fwd_index);
+
+    return out.erase(name_index);
+}
+
+std::string GetPathWithoutTop(std::string path) {
+    if (path.empty())
+        return "";
+    while (path[0] == '\\' || path[0] == '/') {
+        path = path.substr(1);
+        if (path.empty())
+            return "";
+    }
+    const auto name_bck_index = path.find_first_of('\\');
+    const auto name_fwd_index = path.find_first_of('/');
+    return path.substr(std::min<size_t>(name_bck_index, name_fwd_index) + 1);
+    return path.substr(std::min<size_t>(name_bck_index, name_fwd_index) + 1);
+}
+
+std::string GetFilename(std::string path) {
+    std::replace(path.begin(), path.end(), '\\', '/');
+    auto name_index = path.find_last_of('/');
+    if (name_index == std::string::npos)
+        return "";
+    return path.substr(name_index + 1);
+}
+
+std::string GetExtensionFromFilename(const std::string& name) {
+    size_t index = name.find_last_of('.');
+    if (index == std::string::npos)
+        return "";
+
+    return name.substr(index + 1);
+}
+
+std::string RemoveTrailingSlash(const std::string& path) {
+    if (path.empty())
+        return path;
+    if (path.back() == '\\' || path.back() == '/')
+        return path.substr(0, path.size() - 1);
+
+    return path;
+}
+
 IOFile::IOFile() {}
 
-IOFile::IOFile(const std::string& filename, const char openmode[]) {
-    Open(filename, openmode);
+IOFile::IOFile(const std::string& filename, const char openmode[], int flags) {
+    Open(filename, openmode, flags);
 }
 
 IOFile::~IOFile() {
     Close();
 }
 
-IOFile::IOFile(IOFile&& other) {
+IOFile::IOFile(IOFile&& other) noexcept {
     Swap(other);
 }
 
-IOFile& IOFile::operator=(IOFile&& other) {
+IOFile& IOFile::operator=(IOFile&& other) noexcept {
     Swap(other);
     return *this;
 }
 
-void IOFile::Swap(IOFile& other) {
+void IOFile::Swap(IOFile& other) noexcept {
     std::swap(m_file, other.m_file);
-    std::swap(m_good, other.m_good);
 }
 
-bool IOFile::Open(const std::string& filename, const char openmode[]) {
+bool IOFile::Open(const std::string& filename, const char openmode[], int flags) {
     Close();
 #ifdef _WIN32
-    _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
-              Common::UTF8ToUTF16W(openmode).c_str());
+    if (flags != 0) {
+        m_file = _wfsopen(Common::UTF8ToUTF16W(filename).c_str(),
+                          Common::UTF8ToUTF16W(openmode).c_str(), flags);
+    } else {
+        _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
+                  Common::UTF8ToUTF16W(openmode).c_str());
+    }
 #else
     m_file = fopen(filename.c_str(), openmode);
 #endif
 
-    m_good = IsOpen();
-    return m_good;
+    return IsOpen();
 }
 
 bool IOFile::Close() {
     if (!IsOpen() || 0 != std::fclose(m_file))
-        m_good = false;
+        return false;
 
     m_file = nullptr;
-    return m_good;
+    return true;
 }
 
 u64 IOFile::GetSize() const {
@@ -851,11 +920,8 @@ u64 IOFile::GetSize() const {
     return 0;
 }
 
-bool IOFile::Seek(s64 off, int origin) {
-    if (!IsOpen() || 0 != fseeko(m_file, off, origin))
-        m_good = false;
-
-    return m_good;
+bool IOFile::Seek(s64 off, int origin) const {
+    return IsOpen() && 0 == fseeko(m_file, off, origin);
 }
 
 u64 IOFile::Tell() const {
@@ -866,27 +932,20 @@ u64 IOFile::Tell() const {
 }
 
 bool IOFile::Flush() {
-    if (!IsOpen() || 0 != std::fflush(m_file))
-        m_good = false;
-
-    return m_good;
+    return IsOpen() && 0 == std::fflush(m_file);
 }
 
 bool IOFile::Resize(u64 size) {
-    if (!IsOpen() ||
-        0 !=
+    return IsOpen() && 0 ==
 #ifdef _WIN32
-            // ector: _chsize sucks, not 64-bit safe
-            // F|RES: changed to _chsize_s. i think it is 64-bit safe
-            _chsize_s(_fileno(m_file), size)
+                           // ector: _chsize sucks, not 64-bit safe
+                           // F|RES: changed to _chsize_s. i think it is 64-bit safe
+                           _chsize_s(_fileno(m_file), size)
 #else
-            // TODO: handle 64bit and growing
-            ftruncate(fileno(m_file), size)
+                           // TODO: handle 64bit and growing
+                           ftruncate(fileno(m_file), size)
 #endif
-            )
-        m_good = false;
-
-    return m_good;
+        ;
 }
 
-} // namespace
+} // namespace FileUtil

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 Citra data dir in the user's home
+// Returns a pointer to a string with a yuzu 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 = "");
 
@@ -133,7 +133,7 @@ std::string GetBundleDirectory();
 #endif
 
 #ifdef _WIN32
-std::string& GetExeDirectory();
+const std::string& GetExeDirectory();
 std::string AppDataRoamingDirectory();
 #endif
 
@@ -150,71 +150,84 @@ size_t ReadFileToString(bool text_file, const char* filename, std::string& str);
 void SplitFilename83(const std::string& filename, std::array<char, 9>& short_name,
                      std::array<char, 4>& extension);
 
+// Splits the path on '/' or '\' and put the components into a vector
+// i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
+std::vector<std::string> SplitPathComponents(const std::string& filename);
+
+// Gets all of the text up to the last '/' or '\' in the path.
+std::string GetParentPath(const std::string& path);
+
+// Gets all of the text after the first '/' or '\' in the path.
+std::string GetPathWithoutTop(std::string path);
+
+// Gets the filename of the path
+std::string GetFilename(std::string path);
+
+// Gets the extension of the filename
+std::string GetExtensionFromFilename(const std::string& name);
+
+// Removes the final '/' or '\' if one exists
+std::string RemoveTrailingSlash(const std::string& path);
+
+// Creates a new vector containing indices [first, last) from the original.
+template <typename T>
+std::vector<T> SliceVector(const std::vector<T>& vector, size_t first, size_t last) {
+    if (first >= last)
+        return {};
+    last = std::min<size_t>(last, vector.size());
+    return std::vector<T>(vector.begin() + first, vector.begin() + first + last);
+}
+
 // simple wrapper for cstdlib file functions to
 // hopefully will make error checking easier
 // and make forgetting an fclose() harder
 class IOFile : public NonCopyable {
 public:
     IOFile();
-    IOFile(const std::string& filename, const char openmode[]);
+    // flags is used for windows specific file open mode flags, which
+    // allows yuzu to open the logs in shared write mode, so that the file
+    // isn't considered "locked" while yuzu is open and people can open the log file and view it
+    IOFile(const std::string& filename, const char openmode[], int flags = 0);
 
     ~IOFile();
 
-    IOFile(IOFile&& other);
-    IOFile& operator=(IOFile&& other);
+    IOFile(IOFile&& other) noexcept;
+    IOFile& operator=(IOFile&& other) noexcept;
 
-    void Swap(IOFile& other);
+    void Swap(IOFile& other) noexcept;
 
-    bool Open(const std::string& filename, const char openmode[]);
+    bool Open(const std::string& filename, const char openmode[], int flags = 0);
     bool Close();
 
     template <typename T>
-    size_t ReadArray(T* data, size_t length) {
-        static_assert(std::is_standard_layout<T>(),
-                      "Given array does not consist of standard layout objects");
-#if (__GNUC__ >= 5) || defined(__clang__) || defined(_MSC_VER)
+    size_t ReadArray(T* data, size_t length) const {
         static_assert(std::is_trivially_copyable<T>(),
                       "Given array does not consist of trivially copyable objects");
-#endif
 
-        if (!IsOpen()) {
-            m_good = false;
+        if (!IsOpen())
             return -1;
-        }
 
-        size_t items_read = std::fread(data, sizeof(T), length, m_file);
-        if (items_read != length)
-            m_good = false;
-
-        return items_read;
+        return std::fread(data, sizeof(T), length, m_file);
     }
 
     template <typename T>
     size_t WriteArray(const T* data, size_t length) {
-        static_assert(std::is_standard_layout<T>(),
-                      "Given array does not consist of standard layout objects");
-#if (__GNUC__ >= 5) || defined(__clang__) || defined(_MSC_VER)
         static_assert(std::is_trivially_copyable<T>(),
                       "Given array does not consist of trivially copyable objects");
-#endif
-
-        if (!IsOpen()) {
-            m_good = false;
+        if (!IsOpen())
             return -1;
-        }
-
-        size_t items_written = std::fwrite(data, sizeof(T), length, m_file);
-        if (items_written != length)
-            m_good = false;
-
-        return items_written;
+        return std::fwrite(data, sizeof(T), length, m_file);
     }
 
-    size_t ReadBytes(void* data, size_t length) {
+    template <typename T>
+    size_t ReadBytes(T* data, size_t length) const {
+        static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
         return ReadArray(reinterpret_cast<char*>(data), length);
     }
 
-    size_t WriteBytes(const void* data, size_t length) {
+    template <typename T>
+    size_t WriteBytes(const T* data, size_t length) {
+        static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
         return WriteArray(reinterpret_cast<const char*>(data), length);
     }
 
@@ -224,19 +237,15 @@ public:
         return WriteArray(&object, 1);
     }
 
+    size_t WriteString(const std::string& str) {
+        return WriteArray(str.c_str(), str.length());
+    }
+
     bool IsOpen() const {
         return nullptr != m_file;
     }
 
-    // m_good is set to false when a read, write or other function fails
-    bool IsGood() const {
-        return m_good;
-    }
-    explicit operator bool() const {
-        return IsGood();
-    }
-
-    bool Seek(s64 off, int origin);
+    bool Seek(s64 off, int origin) const;
     u64 Tell() const;
     u64 GetSize() const;
     bool Resize(u64 size);
@@ -244,16 +253,14 @@ public:
 
     // clear error state
     void Clear() {
-        m_good = true;
         std::clearerr(m_file);
     }
 
 private:
     std::FILE* m_file = nullptr;
-    bool m_good = true;
 };
 
-} // namespace
+} // namespace FileUtil
 
 // To deal with Windows being dumb at unicode:
 template <typename T>

src/common/hash.cpp

@@ -1,141 +0,0 @@
-// 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,9 +18,54 @@ void MurmurHash3_128(const void* key, size_t len, u32 seed, void* out);
  * @returns 64-bit hash value that was computed over the data block
  */
 static inline u64 ComputeHash64(const void* data, size_t len) {
-    u64 res[2];
-    MurmurHash3_128(data, len, 0, res);
-    return res[0];
+    return CityHash64(static_cast<const char*>(data), len);
 }
 
+/**
+ * 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/linear_disk_cache.h

@@ -1,167 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <fstream>
-#include "common/common_types.h"
-
-// defined in Version.cpp
-extern const char* scm_rev_git_str;
-
-// On disk format:
-// header{
-// u32 'DCAC';
-// u32 version;  // svn_rev
-// u16 sizeof(key_type);
-// u16 sizeof(value_type);
-//}
-
-// key_value_pair{
-// u32 value_size;
-// key_type   key;
-// value_type[value_size]   value;
-//}
-
-template <typename K, typename V>
-class LinearDiskCacheReader {
-public:
-    virtual void Read(const K& key, const V* value, u32 value_size) = 0;
-};
-
-// Dead simple unsorted key-value store with append functionality.
-// No random read functionality, all reading is done in OpenAndRead.
-// Keys and values can contain any characters, including \0.
-//
-// Suitable for caching generated shader bytecode between executions.
-// Not tuned for extreme performance but should be reasonably fast.
-// Does not support keys or values larger than 2GB, which should be reasonable.
-// Keys must have non-zero length; values can have zero length.
-
-// K and V are some POD type
-// K : the key type
-// V : value array type
-template <typename K, typename V>
-class LinearDiskCache {
-public:
-    // return number of read entries
-    u32 OpenAndRead(const char* filename, LinearDiskCacheReader<K, V>& reader) {
-        using std::ios_base;
-
-        // close any currently opened file
-        Close();
-        m_num_entries = 0;
-
-        // try opening for reading/writing
-        OpenFStream(m_file, filename, ios_base::in | ios_base::out | ios_base::binary);
-
-        m_file.seekg(0, std::ios::end);
-        std::fstream::pos_type end_pos = m_file.tellg();
-        m_file.seekg(0, std::ios::beg);
-        std::fstream::pos_type start_pos = m_file.tellg();
-        std::streamoff file_size = end_pos - start_pos;
-
-        if (m_file.is_open() && ValidateHeader()) {
-            // good header, read some key/value pairs
-            K key;
-
-            V* value = nullptr;
-            u32 value_size;
-            u32 entry_number;
-
-            std::fstream::pos_type last_pos = m_file.tellg();
-
-            while (Read(&value_size)) {
-                std::streamoff next_extent =
-                    (last_pos - start_pos) + sizeof(value_size) + value_size;
-                if (next_extent > file_size)
-                    break;
-
-                delete[] value;
-                value = new V[value_size];
-
-                // read key/value and pass to reader
-                if (Read(&key) && Read(value, value_size) && Read(&entry_number) &&
-                    entry_number == m_num_entries + 1) {
-                    reader.Read(key, value, value_size);
-                } else {
-                    break;
-                }
-
-                m_num_entries++;
-                last_pos = m_file.tellg();
-            }
-            m_file.seekp(last_pos);
-            m_file.clear();
-
-            delete[] value;
-            return m_num_entries;
-        }
-
-        // failed to open file for reading or bad header
-        // close and recreate file
-        Close();
-        m_file.open(filename, ios_base::out | ios_base::trunc | ios_base::binary);
-        WriteHeader();
-        return 0;
-    }
-
-    void Sync() {
-        m_file.flush();
-    }
-
-    void Close() {
-        if (m_file.is_open())
-            m_file.close();
-        // clear any error flags
-        m_file.clear();
-    }
-
-    // Appends a key-value pair to the store.
-    void Append(const K& key, const V* value, u32 value_size) {
-        // TODO: Should do a check that we don't already have "key"? (I think each caller does that
-        // already.)
-        Write(&value_size);
-        Write(&key);
-        Write(value, value_size);
-        m_num_entries++;
-        Write(&m_num_entries);
-    }
-
-private:
-    void WriteHeader() {
-        Write(&m_header);
-    }
-
-    bool ValidateHeader() {
-        char file_header[sizeof(Header)];
-
-        return (Read(file_header, sizeof(Header)) &&
-                !memcmp((const char*)&m_header, file_header, sizeof(Header)));
-    }
-
-    template <typename D>
-    bool Write(const D* data, u32 count = 1) {
-        return m_file.write((const char*)data, count * sizeof(D)).good();
-    }
-
-    template <typename D>
-    bool Read(const D* data, u32 count = 1) {
-        return m_file.read((char*)data, count * sizeof(D)).good();
-    }
-
-    struct Header {
-        Header() : id(*(u32*)"DCAC"), key_t_size(sizeof(K)), value_t_size(sizeof(V)) {
-            memcpy(ver, scm_rev_git_str, 40);
-        }
-
-        const u32 id;
-        const u16 key_t_size, value_t_size;
-        char ver[40];
-
-    } m_header;
-
-    std::fstream m_file;
-    u32 m_num_entries;
-};

src/common/logging/backend.cpp

@@ -4,16 +4,146 @@
 
 #include <algorithm>
 #include <array>
-#include <cstdio>
+#include <chrono>
+#include <climits>
+#include <condition_variable>
+#include <memory>
+#include <thread>
+#ifdef _WIN32
+#include <share.h> // For _SH_DENYWR
+#else
+#define _SH_DENYWR 0
+#endif
 #include "common/assert.h"
 #include "common/common_funcs.h" // snprintf compatibility define
 #include "common/logging/backend.h"
-#include "common/logging/filter.h"
 #include "common/logging/log.h"
 #include "common/logging/text_formatter.h"
+#include "common/string_util.h"
+#include "common/threadsafe_queue.h"
 
 namespace Log {
 
+/**
+ * Static state as a singleton.
+ */
+class Impl {
+public:
+    static Impl& Instance() {
+        static Impl backend;
+        return backend;
+    }
+
+    Impl(Impl const&) = delete;
+    const Impl& operator=(Impl const&) = delete;
+
+    void PushEntry(Entry e) {
+        std::lock_guard<std::mutex> lock(message_mutex);
+        message_queue.Push(std::move(e));
+        message_cv.notify_one();
+    }
+
+    void AddBackend(std::unique_ptr<Backend> backend) {
+        std::lock_guard<std::mutex> lock(writing_mutex);
+        backends.push_back(std::move(backend));
+    }
+
+    void RemoveBackend(const std::string& backend_name) {
+        std::lock_guard<std::mutex> lock(writing_mutex);
+        auto it = std::remove_if(backends.begin(), backends.end(), [&backend_name](const auto& i) {
+            return !strcmp(i->GetName(), backend_name.c_str());
+        });
+        backends.erase(it, backends.end());
+    }
+
+    const Filter& GetGlobalFilter() const {
+        return filter;
+    }
+
+    void SetGlobalFilter(const Filter& f) {
+        filter = f;
+    }
+
+    Backend* GetBackend(const std::string& backend_name) {
+        auto it = std::find_if(backends.begin(), backends.end(), [&backend_name](const auto& i) {
+            return !strcmp(i->GetName(), backend_name.c_str());
+        });
+        if (it == backends.end())
+            return nullptr;
+        return it->get();
+    }
+
+private:
+    Impl() {
+        backend_thread = std::thread([&] {
+            Entry entry;
+            auto write_logs = [&](Entry& e) {
+                std::lock_guard<std::mutex> lock(writing_mutex);
+                for (const auto& backend : backends) {
+                    backend->Write(e);
+                }
+            };
+            while (true) {
+                {
+                    std::unique_lock<std::mutex> lock(message_mutex);
+                    message_cv.wait(lock, [&] { return !running || message_queue.Pop(entry); });
+                }
+                if (!running) {
+                    break;
+                }
+                write_logs(entry);
+            }
+            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a case
+            // where a system is repeatedly spamming logs even on close.
+            const int MAX_LOGS_TO_WRITE = filter.IsDebug() ? INT_MAX : 100;
+            int logs_written = 0;
+            while (logs_written++ < MAX_LOGS_TO_WRITE && message_queue.Pop(entry)) {
+                write_logs(entry);
+            }
+        });
+    }
+
+    ~Impl() {
+        running = false;
+        message_cv.notify_one();
+        backend_thread.join();
+    }
+
+    std::atomic_bool running{true};
+    std::mutex message_mutex, writing_mutex;
+    std::condition_variable message_cv;
+    std::thread backend_thread;
+    std::vector<std::unique_ptr<Backend>> backends;
+    Common::MPSCQueue<Log::Entry> message_queue;
+    Filter filter;
+};
+
+void ConsoleBackend::Write(const Entry& entry) {
+    PrintMessage(entry);
+}
+
+void ColorConsoleBackend::Write(const Entry& entry) {
+    PrintColoredMessage(entry);
+}
+
+// _SH_DENYWR allows read only access to the file for other programs.
+// It is #defined to 0 on other platforms
+FileBackend::FileBackend(const std::string& filename)
+    : file(filename, "w", _SH_DENYWR), bytes_written(0) {}
+
+void FileBackend::Write(const Entry& entry) {
+    // prevent logs from going over the maximum size (in case its spamming and the user doesn't
+    // know)
+    constexpr size_t MAX_BYTES_WRITTEN = 50 * 1024L * 1024L;
+    if (!file.IsOpen() || bytes_written > MAX_BYTES_WRITTEN) {
+        return;
+    }
+    bytes_written += file.WriteString(FormatLogMessage(entry) + '\n');
+    if (entry.log_level >= Level::Error) {
+        file.Flush();
+    }
+}
+
 /// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
 #define ALL_LOG_CLASSES()                                                                          \
     CLS(Log)                                                                                       \
@@ -32,17 +162,36 @@ namespace Log {
     CLS(Kernel)                                                                                    \
     SUB(Kernel, SVC)                                                                               \
     CLS(Service)                                                                                   \
-    SUB(Service, SM)                                                                               \
+    SUB(Service, ACC)                                                                              \
+    SUB(Service, Audio)                                                                            \
+    SUB(Service, AM)                                                                               \
+    SUB(Service, AOC)                                                                              \
+    SUB(Service, APM)                                                                              \
+    SUB(Service, BCAT)                                                                             \
+    SUB(Service, Fatal)                                                                            \
+    SUB(Service, Friend)                                                                           \
     SUB(Service, FS)                                                                               \
-    SUB(Service, GSP)                                                                              \
-    SUB(Service, CFG)                                                                              \
-    SUB(Service, DSP)                                                                              \
     SUB(Service, HID)                                                                              \
+    SUB(Service, LM)                                                                               \
+    SUB(Service, MM)                                                                               \
+    SUB(Service, NFP)                                                                              \
+    SUB(Service, NIFM)                                                                             \
+    SUB(Service, NS)                                                                               \
+    SUB(Service, NVDRV)                                                                            \
+    SUB(Service, PCTL)                                                                             \
+    SUB(Service, PREPO)                                                                            \
+    SUB(Service, SET)                                                                              \
+    SUB(Service, SM)                                                                               \
+    SUB(Service, SPL)                                                                              \
+    SUB(Service, SSL)                                                                              \
+    SUB(Service, Time)                                                                             \
+    SUB(Service, VI)                                                                               \
     CLS(HW)                                                                                        \
     SUB(HW, Memory)                                                                                \
     SUB(HW, LCD)                                                                                   \
     SUB(HW, GPU)                                                                                   \
     SUB(HW, AES)                                                                                   \
+    CLS(IPC)                                                                                       \
     CLS(Frontend)                                                                                  \
     CLS(Render)                                                                                    \
     SUB(Render, Software)                                                                          \
@@ -90,45 +239,50 @@ const char* GetLevelName(Level log_level) {
 }
 
 Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                  const char* function, const char* format, va_list args) {
-    using std::chrono::steady_clock;
+                  const char* function, std::string message) {
     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;
-
-    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());
+    entry.filename = Common::TrimSourcePath(filename);
+    entry.line_num = line_nr;
+    entry.function = function;
+    entry.message = std::move(message);
 
     return entry;
 }
 
-static Filter* filter = nullptr;
-
-void SetFilter(Filter* new_filter) {
-    filter = new_filter;
+void SetGlobalFilter(const Filter& filter) {
+    Impl::Instance().SetGlobalFilter(filter);
 }
 
-void LogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                const char* function, const char* format, ...) {
-    if (filter != nullptr && !filter->CheckMessage(log_class, log_level))
+void AddBackend(std::unique_ptr<Backend> backend) {
+    Impl::Instance().AddBackend(std::move(backend));
+}
+
+void RemoveBackend(const std::string& backend_name) {
+    Impl::Instance().RemoveBackend(backend_name);
+}
+
+Backend* GetBackend(const std::string& backend_name) {
+    return Impl::Instance().GetBackend(backend_name);
+}
+
+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) {
+    auto filter = Impl::Instance().GetGlobalFilter();
+    if (!filter.CheckMessage(log_class, log_level))
         return;
 
-    va_list args;
-    va_start(args, format);
-    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, fmt::vformat(format, args));
 
-    PrintColoredMessage(entry);
-}
+    Impl::Instance().PushEntry(std::move(entry));
 }
+} // namespace Log

src/common/logging/backend.h

@@ -1,13 +1,15 @@
 // Copyright 2014 Citra Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
-
 #pragma once
 
 #include <chrono>
 #include <cstdarg>
+#include <memory>
 #include <string>
 #include <utility>
+#include "common/file_util.h"
+#include "common/logging/filter.h"
 #include "common/logging/log.h"
 
 namespace Log {
@@ -22,15 +24,92 @@ struct Entry {
     std::chrono::microseconds timestamp;
     Class log_class;
     Level log_level;
-    std::string location;
+    std::string filename;
+    unsigned int line_num;
+    std::string function;
     std::string message;
 
     Entry() = default;
     Entry(Entry&& o) = default;
 
     Entry& operator=(Entry&& o) = default;
+    Entry& operator=(const Entry& o) = default;
 };
 
+/**
+ * Interface for logging backends. As loggers can be created and removed at runtime, this can be
+ * used by a frontend for adding a custom logging backend as needed
+ */
+class Backend {
+public:
+    virtual ~Backend() = default;
+    virtual void SetFilter(const Filter& new_filter) {
+        filter = new_filter;
+    }
+    virtual const char* GetName() const = 0;
+    virtual void Write(const Entry& entry) = 0;
+
+private:
+    Filter filter;
+};
+
+/**
+ * Backend that writes to stderr without any color commands
+ */
+class ConsoleBackend : public Backend {
+public:
+    static const char* Name() {
+        return "console";
+    }
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
+/**
+ * Backend that writes to stderr and with color
+ */
+class ColorConsoleBackend : public Backend {
+public:
+    static const char* Name() {
+        return "color_console";
+    }
+
+    const char* GetName() const override {
+        return Name();
+    }
+    void Write(const Entry& entry) override;
+};
+
+/**
+ * Backend that writes to a file passed into the constructor
+ */
+class FileBackend : public Backend {
+public:
+    explicit FileBackend(const std::string& filename);
+
+    static const char* Name() {
+        return "file";
+    }
+
+    const char* GetName() const override {
+        return Name();
+    }
+
+    void Write(const Entry& entry) override;
+
+private:
+    FileUtil::IOFile file;
+    size_t bytes_written;
+};
+
+void AddBackend(std::unique_ptr<Backend> backend);
+
+void RemoveBackend(const std::string& backend_name);
+
+Backend* GetBackend(const std::string& backend_name);
+
 /**
  * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
  * instead of underscores as in the enumeration.
@@ -44,7 +123,12 @@ 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, const char* format, va_list args);
+                  const char* function, std::string message);
 
-void SetFilter(Filter* filter);
-}
+/**
+ * The global filter will prevent any messages from even being processed if they are filtered. Each
+ * backend can have a filter, but if the level is lower than the global filter, the backend will
+ * never get the message
+ */
+void SetGlobalFilter(const Filter& filter);
+} // namespace Log