Run clang-format

.ci/scripts/merge/apply-patches-by-label.py

@@ -1,7 +1,7 @@
 # Download all pull requests as patches that match a specific label
 # Usage: python download-patches-by-label.py <Label to Match> <Root Path Folder to DL to>
 
-import requests, sys, json, urllib3.request, shutil, subprocess, os, traceback
+import requests, sys, json, urllib3.request, shutil, subprocess, os
 
 tagline = sys.argv[2]
 
@@ -33,5 +33,4 @@ try:
     for i in range(1,30):
         do_page(i)
 except:
-    traceback.print_exc(file=sys.stdout)
     sys.exit(-1)

.ci/scripts/transifex/docker.sh

@@ -1,25 +0,0 @@
-#!/bin/bash -e
-
-# Setup RC file for tx
-cat << EOF > ~/.transifexrc
-[https://www.transifex.com]
-hostname = https://www.transifex.com
-username = api
-password = $TRANSIFEX_API_TOKEN
-EOF
-
-
-set -x
-
-echo -e "\e[1m\e[33mBuild tools information:\e[0m"
-cmake --version
-gcc -v
-tx --version
-
-mkdir build && cd build
-cmake .. -DENABLE_QT_TRANSLATION=ON -DGENERATE_QT_TRANSLATION=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_SDL2=OFF
-make translation
-cd ..
-
-cd dist/languages
-tx push -s

.ci/templates/merge-private.yml

@@ -1,8 +1,6 @@
 jobs:
 - job: merge
   displayName: 'pull requests'
-  pool:
-    vmImage: 'ubuntu-latest'
   steps:
   - checkout: self
     submodules: recursive
@@ -26,8 +24,6 @@ jobs:
 - job: upload_source
   displayName: 'upload'
   dependsOn: merge
-  pool:
-    vmImage: 'ubuntu-latest'
   steps:
   - template: ./sync-source.yml
     parameters:

.ci/templates/merge.yml

@@ -1,8 +1,6 @@
 jobs:
 - job: merge
   displayName: 'pull requests'
-  pool:
-    vmImage: 'ubuntu-latest'
   steps:
   - checkout: self
     submodules: recursive
@@ -25,8 +23,6 @@ jobs:
 - job: upload_source
   displayName: 'upload'
   dependsOn: merge
-  pool:
-    vmImage: 'ubuntu-latest'
   steps:
   - template: ./sync-source.yml
     parameters:

.ci/yuzu-mainline-step2.yml

@@ -66,7 +66,5 @@ stages:
   jobs:
   - job: github
     displayName: 'github'
-    pool:
-      vmImage: ubuntu-latest
     steps:
     - template: ./templates/release-github.yml

.ci/yuzu-patreon-step2.yml

@@ -29,7 +29,5 @@ stages:
   jobs:
     - job: release
       displayName: 'source'
-      pool:
-        vmImage: 'ubuntu-latest'
       steps:
         - template: ./templates/release-private-tag.yml

.github/workflows/ci.yml

@@ -1,23 +0,0 @@
-name: yuzu-ci
-
-on:
-  push:
-    branches: [ master ]
-    tags: [ "*" ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  transifex:
-    runs-on: ubuntu-latest
-    container: yuzuemu/build-environments:linux-transifex
-    if: ${{ github.repository == 'yuzu-emu/yuzu' && !github.head_ref }}
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-          fetch-depth: 0   
-      - name: Update Translation
-        run: ./.ci/scripts/transifex/docker.sh
-        env:
-          TRANSIFEX_API_TOKEN: ${{ secrets.TRANSIFEX_API_TOKEN }}

.travis.yml

@@ -0,0 +1,59 @@
+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
+      dist: trusty
+      services: docker
+      addons:
+        apt:
+          packages:
+            - p7zip-full
+      install: "./.travis/linux/deps.sh"
+      script: "./.travis/linux/build.sh"
+      after_success: "./.travis/linux/upload.sh"
+      cache: ccache
+    - os: osx
+      env: NAME="macos build"
+      sudo: false
+      osx_image: xcode10.2
+      install: "./.travis/macos/deps.sh"
+      script: "./.travis/macos/build.sh"
+      after_success: "./.travis/macos/upload.sh"
+      cache: ccache
+    - os: linux
+      env: NAME="MinGW build"
+      sudo: required
+      dist: trusty
+      services: docker
+      addons:
+        apt:
+          packages:
+            - p7zip-full
+      install: "./.travis/linux-mingw/deps.sh"
+      script: "./.travis/linux-mingw/build.sh"
+      after_success: "./.travis/linux-mingw/upload.sh"
+      cache: ccache
+
+deploy:
+  provider: releases
+  api_key:
+    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

.travis/clang-format/build.sh

@@ -0,0 +1,3 @@
+#!/bin/bash -ex
+
+docker run --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache citraemu/build-environments:linux-clang-format /bin/bash -ex /yuzu/.travis/clang-format/docker.sh

.travis/clang-format/deps.sh

@@ -0,0 +1,3 @@
+#!/bin/sh -ex
+
+docker pull citraemu/build-environments:linux-clang-format

.travis/clang-format/docker.sh

@@ -0,0 +1,5 @@
+#!/bin/bash -ex
+
+# Run clang-format
+cd /yuzu
+./.travis/clang-format/script.sh

.travis/clang-format/script.sh

@@ -0,0 +1,37 @@
+#!/bin/bash -ex
+
+if grep -nrI '\s$' src *.yml *.txt *.md Doxyfile .gitignore .gitmodules .travis* dist/*.desktop \
+                 dist/*.svg dist/*.xml; then
+    echo Trailing whitespace found, aborting
+    exit 1
+fi
+
+# Default clang-format points to default 3.5 version one
+CLANG_FORMAT=clang-format-10.0
+$CLANG_FORMAT --version
+
+if [ "$TRAVIS_EVENT_TYPE" = "pull_request" ]; then
+    # Get list of every file modified in this pull request
+    files_to_lint="$(git diff --name-only --diff-filter=ACMRTUXB $TRAVIS_COMMIT_RANGE | grep '^src/[^.]*[.]\(cpp\|h\)$' || true)"
+else
+    # Check everything for branch pushes
+    files_to_lint="$(find src/ -name '*.cpp' -or -name '*.h')"
+fi
+
+# Turn off tracing for this because it's too verbose
+set +x
+
+for f in $files_to_lint; do
+    d=$(diff -u "$f" <($CLANG_FORMAT "$f") || true)
+    if ! [ -z "$d" ]; then
+        echo "!!! $f not compliant to coding style, here is the fix:"
+        echo "$d"
+        fail=1
+    fi
+done
+
+set -x
+
+if [ "$fail" = 1 ]; then
+    exit 1
+fi

.travis/common/post-upload.sh

@@ -0,0 +1,25 @@
+#!/bin/bash -ex
+
+# Copy documentation
+cp license.txt "$REV_NAME"
+cp README.md "$REV_NAME"
+
+tar $COMPRESSION_FLAGS "$ARCHIVE_NAME" "$REV_NAME"
+
+# Find out what release we are building
+if [ -z $TRAVIS_TAG ]; then
+    RELEASE_NAME=head
+else
+    RELEASE_NAME=$(echo $TRAVIS_TAG | cut -d- -f1)
+    if [ "$NAME" = "MinGW build" ]; then
+        RELEASE_NAME="${RELEASE_NAME}-mingw"
+    fi
+fi
+
+mv "$REV_NAME" $RELEASE_NAME
+
+7z a "$REV_NAME.7z" $RELEASE_NAME
+
+# move the compiled archive into the artifacts directory to be uploaded by travis releases
+mv "$ARCHIVE_NAME" artifacts/
+mv "$REV_NAME.7z" artifacts/

.travis/common/pre-upload.sh

@@ -0,0 +1,6 @@
+#!/bin/bash -ex
+
+GITDATE="`git show -s --date=short --format='%ad' | sed 's/-//g'`"
+GITREV="`git show -s --format='%h'`"
+
+mkdir -p artifacts

.travis/common/travis-ci.env

@@ -0,0 +1,18 @@
+# List of environment variables to be shared with Docker containers
+CI
+TRAVIS
+CONTINUOUS_INTEGRATION
+TRAVIS_BRANCH
+TRAVIS_BUILD_ID
+TRAVIS_BUILD_NUMBER
+TRAVIS_COMMIT
+TRAVIS_COMMIT_RANGE
+TRAVIS_EVENT_TYPE
+TRAVIS_JOB_ID
+TRAVIS_JOB_NUMBER
+TRAVIS_REPO_SLUG
+TRAVIS_TAG
+
+# yuzu specific flags
+ENABLE_COMPATIBILITY_REPORTING
+USE_DISCORD_PRESENCE

.travis/linux-mingw/build.sh

@@ -0,0 +1,3 @@
+#!/bin/bash -ex
+mkdir "$HOME/.ccache" || true
+docker run --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.travis/linux-mingw/docker.sh

.travis/linux-mingw/deps.sh

@@ -0,0 +1,3 @@
+#!/bin/sh -ex
+
+docker pull yuzuemu/build-environments:linux-mingw

.travis/linux-mingw/docker.sh

@@ -0,0 +1,42 @@
+#!/bin/bash -ex
+
+cd /yuzu
+# override Travis CI unreasonable ccache size
+echo 'max_size = 3.0G' > "$HOME/.ccache/ccache.conf"
+
+mkdir build && cd build
+cmake .. -G Ninja -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
+ninja
+
+# Clean up the dirty hacks
+rm /bin/uname && mv /bin/uname1 /bin/uname
+rm /bin/cmd
+
+ccache -s
+
+echo "Tests skipped"
+#ctest -VV -C Release
+
+echo 'Prepare binaries...'
+cd ..
+mkdir package
+
+QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/'
+find build/ -name "yuzu*.exe" -exec cp {} 'package' \;
+
+# copy Qt plugins
+mkdir package/platforms
+cp "${QT_PLATFORM_DLL_PATH}/qwindows.dll" package/platforms/
+cp -rv "${QT_PLATFORM_DLL_PATH}/../mediaservice/" package/
+cp -rv "${QT_PLATFORM_DLL_PATH}/../imageformats/" package/
+rm -f package/mediaservice/*d.dll
+
+for i in package/*.exe; do
+  # we need to process pdb here, however, cv2pdb
+  # does not work here, so we just simply strip all the debug symbols
+  x86_64-w64-mingw32-strip "${i}"
+done
+
+pip3 install pefile
+python3 .travis/linux-mingw/scan_dll.py package/*.exe "package/"
+python3 .travis/linux-mingw/scan_dll.py package/imageformats/*.dll "package/"

.travis/linux-mingw/scan_dll.py

@@ -0,0 +1,106 @@
+import pefile
+import sys
+import re
+import os
+import queue
+import shutil
+
+# constant definitions
+KNOWN_SYS_DLLS = ['WINMM.DLL', 'MSVCRT.DLL', 'VERSION.DLL', 'MPR.DLL',
+                  'DWMAPI.DLL', 'UXTHEME.DLL', 'DNSAPI.DLL', 'IPHLPAPI.DLL']
+# below is for Ubuntu 18.04 with specified PPA enabled, if you are using
+# other distro or different repositories, change the following accordingly
+DLL_PATH = [
+    '/usr/x86_64-w64-mingw32/bin/',
+    '/usr/x86_64-w64-mingw32/lib/',
+    '/usr/lib/gcc/x86_64-w64-mingw32/7.3-posix/'
+]
+
+missing = []
+
+
+def parse_imports(file_name):
+    results = []
+    pe = pefile.PE(file_name, fast_load=True)
+    pe.parse_data_directories()
+
+    for entry in pe.DIRECTORY_ENTRY_IMPORT:
+        current = entry.dll.decode()
+        current_u = current.upper()  # b/c Windows is often case insensitive
+        # here we filter out system dlls
+        # dll w/ names like *32.dll are likely to be system dlls
+        if current_u.upper() not in KNOWN_SYS_DLLS and not re.match(string=current_u, pattern=r'.*32\.DLL'):
+            results.append(current)
+
+    return results
+
+
+def parse_imports_recursive(file_name, path_list=[]):
+    q = queue.Queue()  # create a FIFO queue
+    # file_name can be a string or a list for the convience
+    if isinstance(file_name, str):
+        q.put(file_name)
+    elif isinstance(file_name, list):
+        for i in file_name:
+            q.put(i)
+    full_list = []
+    while q.qsize():
+        current = q.get_nowait()
+        print('> %s' % current)
+        deps = parse_imports(current)
+        # if this dll does not have any import, ignore it
+        if not deps:
+            continue
+        for dep in deps:
+            # the dependency already included in the list, skip
+            if dep in full_list:
+                continue
+            # find the requested dll in the provided paths
+            full_path = find_dll(dep)
+            if not full_path:
+                missing.append(dep)
+                continue
+            full_list.append(dep)
+            q.put(full_path)
+            path_list.append(full_path)
+    return full_list
+
+
+def find_dll(name):
+    for path in DLL_PATH:
+        for root, _, files in os.walk(path):
+            for f in files:
+                if name.lower() == f.lower():
+                    return os.path.join(root, f)
+
+
+def deploy(name, dst, dry_run=False):
+    dlls_path = []
+    parse_imports_recursive(name, dlls_path)
+    for dll_entry in dlls_path:
+        if not dry_run:
+            shutil.copy(dll_entry, dst)
+        else:
+            print('[Dry-Run] Copy %s to %s' % (dll_entry, dst))
+    print('Deploy completed.')
+    return dlls_path
+
+
+def main():
+    if len(sys.argv) < 3:
+        print('Usage: %s [files to examine ...] [target deploy directory]')
+        return 1
+    to_deploy = sys.argv[1:-1]
+    tgt_dir = sys.argv[-1]
+    if not os.path.isdir(tgt_dir):
+        print('%s is not a directory.' % tgt_dir)
+        return 1
+    print('Scanning dependencies...')
+    deploy(to_deploy, tgt_dir)
+    if missing:
+        print('Following DLLs are not found: %s' % ('\n'.join(missing)))
+    return 0
+
+
+if __name__ == '__main__':
+    main()

.travis/linux-mingw/upload.sh

@@ -0,0 +1,13 @@
+#!/bin/bash -ex
+
+. .travis/common/pre-upload.sh
+
+REV_NAME="yuzu-windows-mingw-${GITDATE}-${GITREV}"
+ARCHIVE_NAME="${REV_NAME}.tar.gz"
+COMPRESSION_FLAGS="-czvf"
+
+mkdir "$REV_NAME"
+# get around the permission issues
+cp -r package/* "$REV_NAME"
+
+. .travis/common/post-upload.sh

.travis/linux/build.sh

@@ -0,0 +1,4 @@
+#!/bin/bash -ex
+
+mkdir -p "$HOME/.ccache"
+docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/home/yuzu/.ccache yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.travis/linux/docker.sh

.travis/linux/deps.sh

@@ -0,0 +1,3 @@
+#!/bin/sh -ex
+
+docker pull yuzuemu/build-environments:linux-fresh

.travis/linux/docker.sh

@@ -0,0 +1,11 @@
+#!/bin/bash -ex
+
+cd /yuzu
+
+mkdir build && cd build
+cmake .. -G Ninja -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON
+ninja
+
+ccache -s
+
+ctest -VV -C Release

.travis/linux/upload.sh

@@ -0,0 +1,14 @@
+#!/bin/bash -ex
+
+. .travis/common/pre-upload.sh
+
+REV_NAME="yuzu-linux-${GITDATE}-${GITREV}"
+ARCHIVE_NAME="${REV_NAME}.tar.xz"
+COMPRESSION_FLAGS="-cJvf"
+
+mkdir "$REV_NAME"
+
+cp build/bin/yuzu-cmd "$REV_NAME"
+cp build/bin/yuzu "$REV_NAME"
+
+. .travis/common/post-upload.sh

.travis/macos/build.sh

@@ -0,0 +1,17 @@
+#!/bin/bash -ex
+
+set -o pipefail
+
+export MACOSX_DEPLOYMENT_TARGET=10.14
+export Qt5_DIR=$(brew --prefix)/opt/qt5
+export PATH="/usr/local/opt/ccache/libexec:$PATH"
+
+# TODO: Build using ninja instead of make
+mkdir build && cd build
+cmake --version
+cmake .. -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON
+make -j4
+
+ccache -s
+
+ctest -VV -C Release

.travis/macos/deps.sh

@@ -0,0 +1,6 @@
+#!/bin/sh -ex
+
+brew update
+brew install p7zip qt5 sdl2 ccache
+brew outdated cmake || brew upgrade cmake
+pip3 install macpack

.travis/macos/upload.sh

@@ -0,0 +1,28 @@
+#!/bin/bash -ex
+
+. .travis/common/pre-upload.sh
+
+REV_NAME="yuzu-osx-${GITDATE}-${GITREV}"
+ARCHIVE_NAME="${REV_NAME}.tar.gz"
+COMPRESSION_FLAGS="-czvf"
+
+mkdir "$REV_NAME"
+
+cp build/bin/yuzu-cmd "$REV_NAME"
+cp -r build/bin/yuzu.app "$REV_NAME"
+
+# move libs into folder for deployment
+macpack "${REV_NAME}/yuzu.app/Contents/MacOS/yuzu" -d "../Frameworks"
+# move qt frameworks into app bundle for deployment
+$(brew --prefix)/opt/qt5/bin/macdeployqt "${REV_NAME}/yuzu.app" -executable="${REV_NAME}/yuzu.app/Contents/MacOS/yuzu"
+
+# move libs into folder for deployment
+macpack "${REV_NAME}/yuzu-cmd" -d "libs"
+
+# Make the launching script executable
+chmod +x ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu
+
+# Verify loader instructions
+find "$REV_NAME" -exec otool -L {} \;
+
+. .travis/common/post-upload.sh

CMakeLists.txt

@@ -411,13 +411,12 @@ if (CONAN_REQUIRED_LIBS)
     # Download conan.cmake automatically, you can also just copy the conan.cmake file
     if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
         message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
-        # TODO: Use a tagged release. The latest tagged release does not support VS2022 as of this writing.
-        file(DOWNLOAD "https://raw.githubusercontent.com/conan-io/cmake-conan/43e385830ee35377dbd2dcbe8d5a9e750301ea00/conan.cmake"
+        file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.15/conan.cmake"
                         "${CMAKE_BINARY_DIR}/conan.cmake")
     endif()
     include(${CMAKE_BINARY_DIR}/conan.cmake)
 
-    conan_check(VERSION 1.41.0 REQUIRED)
+    conan_check(VERSION 1.24.0 REQUIRED)
 
     # Manually add iconv to fix a dep conflict between qt and sdl2
     # We don't need to add it through find_package or anything since the other two can find it just fine
@@ -600,7 +599,6 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                 ${LIBVA_LIBRARIES})
             set(FFmpeg_HWACCEL_FLAGS
                 --enable-hwaccel=h264_vaapi
-                --enable-hwaccel=vp8_vaapi
                 --enable-hwaccel=vp9_vaapi
                 --enable-libdrm)
             list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
@@ -621,7 +619,6 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                 --enable-ffnvcodec
                 --enable-nvdec
                 --enable-hwaccel=h264_nvdec
-                --enable-hwaccel=vp8_nvdec
                 --enable-hwaccel=vp9_nvdec
                 --extra-cflags=-I${CUDA_INCLUDE_DIRS}
             )
@@ -672,7 +669,6 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                     --disable-postproc
                     --disable-swresample
                     --enable-decoder=h264
-                    --enable-decoder=vp8
                     --enable-decoder=vp9
                     --cc="${CMAKE_C_COMPILER}"
                     --cxx="${CMAKE_CXX_COMPILER}"

src/CMakeLists.txt

@@ -32,7 +32,6 @@ if (MSVC)
     # /Zc:externConstexpr - Allow extern constexpr variables to have external linkage, like the standard mandates
     # /Zc:inline          - Let codegen omit inline functions in object files
     # /Zc:throwingNew     - Let codegen assume `operator new` (without std::nothrow) will never return null
-    # /GT                 - Supports fiber safety for data allocated using static thread-local storage
     add_compile_options(
         /MP
         /Zi
@@ -45,7 +44,6 @@ if (MSVC)
         /Zc:externConstexpr
         /Zc:inline
         /Zc:throwingNew
-        /GT
 
         # External headers diagnostics
         /experimental:external  # Enables the external headers options. This option isn't required in Visual Studio 2019 version 16.10 and later
@@ -71,10 +69,6 @@ if (MSVC)
         /we5038 # data member 'member1' will be initialized after data member 'member2'
     )
 
-    if (ARCHITECTURE_x86_64)
-        add_compile_options(/QIntel-jcc-erratum)
-    endif()
-
     # /GS- - No stack buffer overflow checks
     add_compile_options("$<$<CONFIG:Release>:/GS->")
 

src/common/CMakeLists.txt

@@ -55,7 +55,6 @@ add_library(common STATIC
     dynamic_library.h
     error.cpp
     error.h
-    expected.h
     fiber.cpp
     fiber.h
     fs/file.cpp

src/common/alignment.h

@@ -64,7 +64,7 @@ public:
     using propagate_on_container_copy_assignment = std::true_type;
     using propagate_on_container_move_assignment = std::true_type;
     using propagate_on_container_swap = std::true_type;
-    using is_always_equal = std::false_type;
+    using is_always_equal = std::true_type;
 
     constexpr AlignmentAllocator() noexcept = default;
 
@@ -83,11 +83,6 @@ public:
     struct rebind {
         using other = AlignmentAllocator<T2, Align>;
     };
-
-    template <typename T2, size_t Align2>
-    constexpr bool operator==(const AlignmentAllocator<T2, Align2>&) const noexcept {
-        return std::is_same_v<T, T2> && Align == Align2;
-    }
 };
 
 } // namespace Common

src/common/expected.h

@@ -1,987 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-// This is based on the proposed implementation of std::expected (P0323)
-// https://github.com/TartanLlama/expected/blob/master/include/tl/expected.hpp
-
-#pragma once
-
-#include <type_traits>
-#include <utility>
-
-namespace Common {
-
-template <typename T, typename E>
-class Expected;
-
-template <typename E>
-class Unexpected {
-public:
-    Unexpected() = delete;
-
-    constexpr explicit Unexpected(const E& e) : m_val{e} {}
-
-    constexpr explicit Unexpected(E&& e) : m_val{std::move(e)} {}
-
-    constexpr E& value() & {
-        return m_val;
-    }
-
-    constexpr const E& value() const& {
-        return m_val;
-    }
-
-    constexpr E&& value() && {
-        return std::move(m_val);
-    }
-
-    constexpr const E&& value() const&& {
-        return std::move(m_val);
-    }
-
-private:
-    E m_val;
-};
-
-template <typename E>
-constexpr auto operator<=>(const Unexpected<E>& lhs, const Unexpected<E>& rhs) {
-    return lhs.value() <=> rhs.value();
-}
-
-struct unexpect_t {
-    constexpr explicit unexpect_t() = default;
-};
-
-namespace detail {
-
-struct no_init_t {
-    constexpr explicit no_init_t() = default;
-};
-
-/**
- * This specialization is for when T is not trivially destructible,
- * so the destructor must be called on destruction of `expected'
- * Additionally, this requires E to be trivially destructible
- */
-template <typename T, typename E, bool = std::is_trivially_destructible_v<T>>
-requires std::is_trivially_destructible_v<E>
-struct expected_storage_base {
-    constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}
-
-    constexpr expected_storage_base(no_init_t) : m_has_val{false} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
-    constexpr expected_storage_base(std::in_place_t, Args&&... args)
-        : m_val{std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)
-        : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args&&... args)
-        : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,
-                                             Args&&... args)
-        : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}
-
-    ~expected_storage_base() {
-        if (m_has_val) {
-            m_val.~T();
-        }
-    }
-
-    union {
-        T m_val;
-        Unexpected<E> m_unexpect;
-    };
-
-    bool m_has_val;
-};
-
-/**
- * This specialization is for when T is trivially destructible,
- * so the destructor of `expected` can be trivial
- * Additionally, this requires E to be trivially destructible
- */
-template <typename T, typename E>
-requires std::is_trivially_destructible_v<E>
-struct expected_storage_base<T, E, true> {
-    constexpr expected_storage_base() : m_val{T{}}, m_has_val{true} {}
-
-    constexpr expected_storage_base(no_init_t) : m_has_val{false} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
-    constexpr expected_storage_base(std::in_place_t, Args&&... args)
-        : m_val{std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr expected_storage_base(std::in_place_t, std::initializer_list<U> il, Args&&... args)
-        : m_val{il, std::forward<Args>(args)...}, m_has_val{true} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, Args&&... args)
-        : m_unexpect{std::forward<Args>(args)...}, m_has_val{false} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr explicit expected_storage_base(unexpect_t, std::initializer_list<U> il,
-                                             Args&&... args)
-        : m_unexpect{il, std::forward<Args>(args)...}, m_has_val{false} {}
-
-    ~expected_storage_base() = default;
-
-    union {
-        T m_val;
-        Unexpected<E> m_unexpect;
-    };
-
-    bool m_has_val;
-};
-
-template <typename T, typename E>
-struct expected_operations_base : expected_storage_base<T, E> {
-    using expected_storage_base<T, E>::expected_storage_base;
-
-    template <typename... Args>
-    void construct(Args&&... args) noexcept {
-        new (std::addressof(this->m_val)) T{std::forward<Args>(args)...};
-        this->m_has_val = true;
-    }
-
-    template <typename Rhs>
-    void construct_with(Rhs&& rhs) noexcept {
-        new (std::addressof(this->m_val)) T{std::forward<Rhs>(rhs).get()};
-        this->m_has_val = true;
-    }
-
-    template <typename... Args>
-    void construct_error(Args&&... args) noexcept {
-        new (std::addressof(this->m_unexpect)) Unexpected<E>{std::forward<Args>(args)...};
-        this->m_has_val = false;
-    }
-
-    void assign(const expected_operations_base& rhs) noexcept {
-        if (!this->m_has_val && rhs.m_has_val) {
-            geterr().~Unexpected<E>();
-            construct(rhs.get());
-        } else {
-            assign_common(rhs);
-        }
-    }
-
-    void assign(expected_operations_base&& rhs) noexcept {
-        if (!this->m_has_val && rhs.m_has_val) {
-            geterr().~Unexpected<E>();
-            construct(std::move(rhs).get());
-        } else {
-            assign_common(rhs);
-        }
-    }
-
-    template <typename Rhs>
-    void assign_common(Rhs&& rhs) {
-        if (this->m_has_val) {
-            if (rhs.m_has_val) {
-                get() = std::forward<Rhs>(rhs).get();
-            } else {
-                destroy_val();
-                construct_error(std::forward<Rhs>(rhs).geterr());
-            }
-        } else {
-            if (!rhs.m_has_val) {
-                geterr() = std::forward<Rhs>(rhs).geterr();
-            }
-        }
-    }
-
-    bool has_value() const {
-        return this->m_has_val;
-    }
-
-    constexpr T& get() & {
-        return this->m_val;
-    }
-
-    constexpr const T& get() const& {
-        return this->m_val;
-    }
-
-    constexpr T&& get() && {
-        return std::move(this->m_val);
-    }
-
-    constexpr const T&& get() const&& {
-        return std::move(this->m_val);
-    }
-
-    constexpr Unexpected<E>& geterr() & {
-        return this->m_unexpect;
-    }
-
-    constexpr const Unexpected<E>& geterr() const& {
-        return this->m_unexpect;
-    }
-
-    constexpr Unexpected<E>&& geterr() && {
-        return std::move(this->m_unexpect);
-    }
-
-    constexpr const Unexpected<E>&& geterr() const&& {
-        return std::move(this->m_unexpect);
-    }
-
-    constexpr void destroy_val() {
-        get().~T();
-    }
-};
-
-/**
- * This manages conditionally having a trivial copy constructor
- * This specialization is for when T is trivially copy constructible
- * Additionally, this requires E to be trivially copy constructible
- */
-template <typename T, typename E, bool = std::is_trivially_copy_constructible_v<T>>
-requires std::is_trivially_copy_constructible_v<E>
-struct expected_copy_base : expected_operations_base<T, E> {
-    using expected_operations_base<T, E>::expected_operations_base;
-};
-
-/**
- * This specialization is for when T is not trivially copy constructible
- * Additionally, this requires E to be trivially copy constructible
- */
-template <typename T, typename E>
-requires std::is_trivially_copy_constructible_v<E>
-struct expected_copy_base<T, E, false> : expected_operations_base<T, E> {
-    using expected_operations_base<T, E>::expected_operations_base;
-
-    expected_copy_base() = default;
-
-    expected_copy_base(const expected_copy_base& rhs)
-        : expected_operations_base<T, E>{no_init_t{}} {
-        if (rhs.has_value()) {
-            this->construct_with(rhs);
-        } else {
-            this->construct_error(rhs.geterr());
-        }
-    }
-
-    expected_copy_base(expected_copy_base&&) = default;
-
-    expected_copy_base& operator=(const expected_copy_base&) = default;
-
-    expected_copy_base& operator=(expected_copy_base&&) = default;
-};
-
-/**
- * This manages conditionally having a trivial move constructor
- * This specialization is for when T is trivially move constructible
- * Additionally, this requires E to be trivially move constructible
- */
-template <typename T, typename E, bool = std::is_trivially_move_constructible_v<T>>
-requires std::is_trivially_move_constructible_v<E>
-struct expected_move_base : expected_copy_base<T, E> {
-    using expected_copy_base<T, E>::expected_copy_base;
-};
-
-/**
- * This specialization is for when T is not trivially move constructible
- * Additionally, this requires E to be trivially move constructible
- */
-template <typename T, typename E>
-requires std::is_trivially_move_constructible_v<E>
-struct expected_move_base<T, E, false> : expected_copy_base<T, E> {
-    using expected_copy_base<T, E>::expected_copy_base;
-
-    expected_move_base() = default;
-
-    expected_move_base(const expected_move_base&) = default;
-
-    expected_move_base(expected_move_base&& rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
-        : expected_copy_base<T, E>{no_init_t{}} {
-        if (rhs.has_value()) {
-            this->construct_with(std::move(rhs));
-        } else {
-            this->construct_error(std::move(rhs.geterr()));
-        }
-    }
-
-    expected_move_base& operator=(const expected_move_base&) = default;
-
-    expected_move_base& operator=(expected_move_base&&) = default;
-};
-
-/**
- * This manages conditionally having a trivial copy assignment operator
- * This specialization is for when T is trivially copy assignable
- * Additionally, this requires E to be trivially copy assignable
- */
-template <typename T, typename E,
-          bool = std::conjunction_v<std::is_trivially_copy_assignable<T>,
-                                    std::is_trivially_copy_constructible<T>,
-                                    std::is_trivially_destructible<T>>>
-requires std::conjunction_v<std::is_trivially_copy_assignable<E>,
-                            std::is_trivially_copy_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_copy_assign_base : expected_move_base<T, E> {
-    using expected_move_base<T, E>::expected_move_base;
-};
-
-/**
- * This specialization is for when T is not trivially copy assignable
- * Additionally, this requires E to be trivially copy assignable
- */
-template <typename T, typename E>
-requires std::conjunction_v<std::is_trivially_copy_assignable<E>,
-                            std::is_trivially_copy_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_copy_assign_base<T, E, false> : expected_move_base<T, E> {
-    using expected_move_base<T, E>::expected_move_base;
-
-    expected_copy_assign_base() = default;
-
-    expected_copy_assign_base(const expected_copy_assign_base&) = default;
-
-    expected_copy_assign_base(expected_copy_assign_base&&) = default;
-
-    expected_copy_assign_base& operator=(const expected_copy_assign_base& rhs) {
-        this->assign(rhs);
-        return *this;
-    }
-
-    expected_copy_assign_base& operator=(expected_copy_assign_base&&) = default;
-};
-
-/**
- * This manages conditionally having a trivial move assignment operator
- * This specialization is for when T is trivially move assignable
- * Additionally, this requires E to be trivially move assignable
- */
-template <typename T, typename E,
-          bool = std::conjunction_v<std::is_trivially_move_assignable<T>,
-                                    std::is_trivially_move_constructible<T>,
-                                    std::is_trivially_destructible<T>>>
-requires std::conjunction_v<std::is_trivially_move_assignable<E>,
-                            std::is_trivially_move_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_move_assign_base : expected_copy_assign_base<T, E> {
-    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
-};
-
-/**
- * This specialization is for when T is not trivially move assignable
- * Additionally, this requires E to be trivially move assignable
- */
-template <typename T, typename E>
-requires std::conjunction_v<std::is_trivially_move_assignable<E>,
-                            std::is_trivially_move_constructible<E>,
-                            std::is_trivially_destructible<E>>
-struct expected_move_assign_base<T, E, false> : expected_copy_assign_base<T, E> {
-    using expected_copy_assign_base<T, E>::expected_copy_assign_base;
-
-    expected_move_assign_base() = default;
-
-    expected_move_assign_base(const expected_move_assign_base&) = default;
-
-    expected_move_assign_base(expected_move_assign_base&&) = default;
-
-    expected_move_assign_base& operator=(const expected_move_assign_base&) = default;
-
-    expected_move_assign_base& operator=(expected_move_assign_base&& rhs) noexcept(
-        std::conjunction_v<std::is_nothrow_move_constructible<T>,
-                           std::is_nothrow_move_assignable<T>>) {
-        this->assign(std::move(rhs));
-        return *this;
-    }
-};
-
-/**
- * expected_delete_ctor_base will conditionally delete copy and move constructors
- * depending on whether T is copy/move constructible
- * Additionally, this requires E to be copy/move constructible
- */
-template <typename T, typename E, bool EnableCopy = std::is_copy_constructible_v<T>,
-          bool EnableMove = std::is_move_constructible_v<T>>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base<T, E, true, false> {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base<T, E, false, true> {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = default;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>>
-struct expected_delete_ctor_base<T, E, false, false> {
-    expected_delete_ctor_base() = default;
-    expected_delete_ctor_base(const expected_delete_ctor_base&) = delete;
-    expected_delete_ctor_base(expected_delete_ctor_base&&) noexcept = delete;
-    expected_delete_ctor_base& operator=(const expected_delete_ctor_base&) = default;
-    expected_delete_ctor_base& operator=(expected_delete_ctor_base&&) noexcept = default;
-};
-
-/**
- * expected_delete_assign_base will conditionally delete copy and move assignment operators
- * depending on whether T is copy/move constructible + assignable
- * Additionally, this requires E to be copy/move constructible + assignable
- */
-template <
-    typename T, typename E,
-    bool EnableCopy = std::conjunction_v<std::is_copy_constructible<T>, std::is_copy_assignable<T>>,
-    bool EnableMove = std::conjunction_v<std::is_move_constructible<T>, std::is_move_assignable<T>>>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base<T, E, true, false> {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base<T, E, false, true> {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = default;
-};
-
-template <typename T, typename E>
-requires std::conjunction_v<std::is_copy_constructible<E>, std::is_move_constructible<E>,
-                            std::is_copy_assignable<E>, std::is_move_assignable<E>>
-struct expected_delete_assign_base<T, E, false, false> {
-    expected_delete_assign_base() = default;
-    expected_delete_assign_base(const expected_delete_assign_base&) = default;
-    expected_delete_assign_base(expected_delete_assign_base&&) noexcept = default;
-    expected_delete_assign_base& operator=(const expected_delete_assign_base&) = delete;
-    expected_delete_assign_base& operator=(expected_delete_assign_base&&) noexcept = delete;
-};
-
-/**
- * This is needed to be able to construct the expected_default_ctor_base which follows,
- * while still conditionally deleting the default constructor.
- */
-struct default_constructor_tag {
-    constexpr explicit default_constructor_tag() = default;
-};
-
-/**
- * expected_default_ctor_base will ensure that expected
- * has a deleted default constructor if T is not default constructible
- * This specialization is for when T is default constructible
- */
-template <typename T, typename E, bool Enable = std::is_default_constructible_v<T>>
-struct expected_default_ctor_base {
-    constexpr expected_default_ctor_base() noexcept = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;
-
-    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
-};
-
-template <typename T, typename E>
-struct expected_default_ctor_base<T, E, false> {
-    constexpr expected_default_ctor_base() noexcept = delete;
-    constexpr expected_default_ctor_base(expected_default_ctor_base const&) noexcept = default;
-    constexpr expected_default_ctor_base(expected_default_ctor_base&&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base const&) noexcept = default;
-    expected_default_ctor_base& operator=(expected_default_ctor_base&&) noexcept = default;
-
-    constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
-};
-
-template <typename T, typename E, typename U>
-using expected_enable_forward_value =
-    std::enable_if_t<std::is_constructible_v<T, U&&> &&
-                     !std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> &&
-                     !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
-                     !std::is_same_v<Unexpected<E>, std::remove_cvref_t<U>>>;
-
-template <typename T, typename E, typename U, typename G, typename UR, typename GR>
-using expected_enable_from_other = std::enable_if_t<
-    std::is_constructible_v<T, UR> && std::is_constructible_v<E, GR> &&
-    !std::is_constructible_v<T, Expected<U, G>&> && !std::is_constructible_v<T, Expected<U, G>&&> &&
-    !std::is_constructible_v<T, const Expected<U, G>&> &&
-    !std::is_constructible_v<T, const Expected<U, G>&&> &&
-    !std::is_convertible_v<Expected<U, G>&, T> && !std::is_convertible_v<Expected<U, G>&&, T> &&
-    !std::is_convertible_v<const Expected<U, G>&, T> &&
-    !std::is_convertible_v<const Expected<U, G>&&, T>>;
-
-} // namespace detail
-
-template <typename T, typename E>
-class Expected : private detail::expected_move_assign_base<T, E>,
-                 private detail::expected_delete_ctor_base<T, E>,
-                 private detail::expected_delete_assign_base<T, E>,
-                 private detail::expected_default_ctor_base<T, E> {
-public:
-    using value_type = T;
-    using error_type = E;
-    using unexpected_type = Unexpected<E>;
-
-    constexpr Expected() = default;
-    constexpr Expected(const Expected&) = default;
-    constexpr Expected(Expected&&) = default;
-    Expected& operator=(const Expected&) = default;
-    Expected& operator=(Expected&&) = default;
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args&&...>>* = nullptr>
-    constexpr Expected(std::in_place_t, Args&&... args)
-        : impl_base{std::in_place, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr Expected(std::in_place_t, std::initializer_list<U> il, Args&&... args)
-        : impl_base{std::in_place, il, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,
-              std::enable_if_t<!std::is_convertible_v<const G&, E>>* = nullptr>
-    constexpr explicit Expected(const Unexpected<G>& e)
-        : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, const G&>>* = nullptr,
-              std::enable_if_t<std::is_convertible_v<const G&, E>>* = nullptr>
-    constexpr Expected(Unexpected<G> const& e)
-        : impl_base{unexpect_t{}, e.value()}, ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
-              std::enable_if_t<!std::is_convertible_v<G&&, E>>* = nullptr>
-    constexpr explicit Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
-        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
-                                                             detail::default_constructor_tag{}} {}
-
-    template <typename G = E, std::enable_if_t<std::is_constructible_v<E, G&&>>* = nullptr,
-              std::enable_if_t<std::is_convertible_v<G&&, E>>* = nullptr>
-    constexpr Expected(Unexpected<G>&& e) noexcept(std::is_nothrow_constructible_v<E, G&&>)
-        : impl_base{unexpect_t{}, std::move(e.value())}, ctor_base{
-                                                             detail::default_constructor_tag{}} {}
-
-    template <typename... Args, std::enable_if_t<std::is_constructible_v<E, Args&&...>>* = nullptr>
-    constexpr explicit Expected(unexpect_t, Args&&... args)
-        : impl_base{unexpect_t{}, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_constructible_v<E, std::initializer_list<U>&, Args&&...>>* =
-                  nullptr>
-    constexpr explicit Expected(unexpect_t, std::initializer_list<U> il, Args&&... args)
-        : impl_base{unexpect_t{}, il, std::forward<Args>(args)...},
-          ctor_base{detail::default_constructor_tag{}} {}
-
-    template <typename U, typename G,
-              std::enable_if_t<!(std::is_convertible_v<U const&, T> &&
-                                 std::is_convertible_v<G const&, E>)>* = nullptr,
-              detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>
-    constexpr explicit Expected(const Expected<U, G>& rhs)
-        : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(*rhs);
-        } else {
-            this->construct_error(rhs.error());
-        }
-    }
-
-    template <typename U, typename G,
-              std::enable_if_t<(std::is_convertible_v<U const&, T> &&
-                                std::is_convertible_v<G const&, E>)>* = nullptr,
-              detail::expected_enable_from_other<T, E, U, G, const U&, const G&>* = nullptr>
-    constexpr Expected(const Expected<U, G>& rhs) : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(*rhs);
-        } else {
-            this->construct_error(rhs.error());
-        }
-    }
-
-    template <typename U, typename G,
-              std::enable_if_t<!(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =
-                  nullptr,
-              detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>
-    constexpr explicit Expected(Expected<U, G>&& rhs)
-        : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(std::move(*rhs));
-        } else {
-            this->construct_error(std::move(rhs.error()));
-        }
-    }
-
-    template <typename U, typename G,
-              std::enable_if_t<(std::is_convertible_v<U&&, T> && std::is_convertible_v<G&&, E>)>* =
-                  nullptr,
-              detail::expected_enable_from_other<T, E, U, G, U&&, G&&>* = nullptr>
-    constexpr Expected(Expected<U, G>&& rhs) : ctor_base{detail::default_constructor_tag{}} {
-        if (rhs.has_value()) {
-            this->construct(std::move(*rhs));
-        } else {
-            this->construct_error(std::move(rhs.error()));
-        }
-    }
-
-    template <typename U = T, std::enable_if_t<!std::is_convertible_v<U&&, T>>* = nullptr,
-              detail::expected_enable_forward_value<T, E, U>* = nullptr>
-    constexpr explicit Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}
-
-    template <typename U = T, std::enable_if_t<std::is_convertible_v<U&&, T>>* = nullptr,
-              detail::expected_enable_forward_value<T, E, U>* = nullptr>
-    constexpr Expected(U&& v) : Expected{std::in_place, std::forward<U>(v)} {}
-
-    template <typename U = T, typename G = T,
-              std::enable_if_t<std::is_nothrow_constructible_v<T, U&&>>* = nullptr,
-              std::enable_if_t<(
-                  !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
-                  !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&
-                  std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&
-                  std::is_nothrow_move_constructible_v<E>)>* = nullptr>
-    Expected& operator=(U&& v) {
-        if (has_value()) {
-            val() = std::forward<U>(v);
-        } else {
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<U>(v)};
-            this->m_has_val = true;
-        }
-
-        return *this;
-    }
-
-    template <typename U = T, typename G = T,
-              std::enable_if_t<!std::is_nothrow_constructible_v<T, U&&>>* = nullptr,
-              std::enable_if_t<(
-                  !std::is_same_v<Expected<T, E>, std::remove_cvref_t<U>> &&
-                  !std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::remove_cvref_t<U>>> &&
-                  std::is_constructible_v<T, U> && std::is_assignable_v<G&, U> &&
-                  std::is_nothrow_move_constructible_v<E>)>* = nullptr>
-    Expected& operator=(U&& v) {
-        if (has_value()) {
-            val() = std::forward<U>(v);
-        } else {
-            auto tmp = std::move(err());
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<U>(v)};
-            this->m_has_val = true;
-        }
-
-        return *this;
-    }
-
-    template <typename G = E, std::enable_if_t<std::is_nothrow_copy_constructible_v<G> &&
-                                               std::is_assignable_v<G&, G>>* = nullptr>
-    Expected& operator=(const Unexpected<G>& rhs) {
-        if (!has_value()) {
-            err() = rhs;
-        } else {
-            this->destroy_val();
-            new (errptr()) Unexpected<E>{rhs};
-            this->m_has_val = false;
-        }
-
-        return *this;
-    }
-
-    template <typename G = E, std::enable_if_t<std::is_nothrow_move_constructible_v<G> &&
-                                               std::is_move_assignable_v<G>>* = nullptr>
-    Expected& operator=(Unexpected<G>&& rhs) noexcept {
-        if (!has_value()) {
-            err() = std::move(rhs);
-        } else {
-            this->destroy_val();
-            new (errptr()) Unexpected<E>{std::move(rhs)};
-            this->m_has_val = false;
-        }
-
-        return *this;
-    }
-
-    template <typename... Args,
-              std::enable_if_t<std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>
-    void emplace(Args&&... args) {
-        if (has_value()) {
-            val() = T{std::forward<Args>(args)...};
-        } else {
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    template <typename... Args,
-              std::enable_if_t<!std::is_nothrow_constructible_v<T, Args&&...>>* = nullptr>
-    void emplace(Args&&... args) {
-        if (has_value()) {
-            val() = T{std::forward<Args>(args)...};
-        } else {
-            auto tmp = std::move(err());
-            err().~Unexpected<E>();
-            new (valptr()) T{std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    template <typename U, typename... Args,
-              std::enable_if_t<std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
-                                                               Args&&...>>* = nullptr>
-    void emplace(std::initializer_list<U> il, Args&&... args) {
-        if (has_value()) {
-            T t{il, std::forward<Args>(args)...};
-            val() = std::move(t);
-        } else {
-            err().~Unexpected<E>();
-            new (valptr()) T{il, std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    template <typename U, typename... Args,
-              std::enable_if_t<!std::is_nothrow_constructible_v<T, std::initializer_list<U>&,
-                                                                Args&&...>>* = nullptr>
-    void emplace(std::initializer_list<U> il, Args&&... args) {
-        if (has_value()) {
-            T t{il, std::forward<Args>(args)...};
-            val() = std::move(t);
-        } else {
-            auto tmp = std::move(err());
-            err().~Unexpected<E>();
-            new (valptr()) T{il, std::forward<Args>(args)...};
-            this->m_has_val = true;
-        }
-    }
-
-    constexpr T* operator->() {
-        return valptr();
-    }
-
-    constexpr const T* operator->() const {
-        return valptr();
-    }
-
-    template <typename U = T>
-    constexpr U& operator*() & {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr const U& operator*() const& {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr U&& operator*() && {
-        return std::move(val());
-    }
-
-    template <typename U = T>
-    constexpr const U&& operator*() const&& {
-        return std::move(val());
-    }
-
-    constexpr bool has_value() const noexcept {
-        return this->m_has_val;
-    }
-
-    constexpr explicit operator bool() const noexcept {
-        return this->m_has_val;
-    }
-
-    template <typename U = T>
-    constexpr U& value() & {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr const U& value() const& {
-        return val();
-    }
-
-    template <typename U = T>
-    constexpr U&& value() && {
-        return std::move(val());
-    }
-
-    template <typename U = T>
-    constexpr const U&& value() const&& {
-        return std::move(val());
-    }
-
-    constexpr E& error() & {
-        return err().value();
-    }
-
-    constexpr const E& error() const& {
-        return err().value();
-    }
-
-    constexpr E&& error() && {
-        return std::move(err().value());
-    }
-
-    constexpr const E&& error() const&& {
-        return std::move(err().value());
-    }
-
-    template <typename U>
-    constexpr T value_or(U&& v) const& {
-        static_assert(std::is_copy_constructible_v<T> && std::is_convertible_v<U&&, T>,
-                      "T must be copy-constructible and convertible from U&&");
-        return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));
-    }
-
-    template <typename U>
-    constexpr T value_or(U&& v) && {
-        static_assert(std::is_move_constructible_v<T> && std::is_convertible_v<U&&, T>,
-                      "T must be move-constructible and convertible from U&&");
-        return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
-    }
-
-private:
-    static_assert(!std::is_reference_v<T>, "T must not be a reference");
-    static_assert(!std::is_same_v<T, std::remove_cv_t<std::in_place_t>>,
-                  "T must not be std::in_place_t");
-    static_assert(!std::is_same_v<T, std::remove_cv_t<unexpect_t>>, "T must not be unexpect_t");
-    static_assert(!std::is_same_v<T, std::remove_cv_t<Unexpected<E>>>,
-                  "T must not be Unexpected<E>");
-    static_assert(!std::is_reference_v<E>, "E must not be a reference");
-
-    T* valptr() {
-        return std::addressof(this->m_val);
-    }
-
-    const T* valptr() const {
-        return std::addressof(this->m_val);
-    }
-
-    Unexpected<E>* errptr() {
-        return std::addressof(this->m_unexpect);
-    }
-
-    const Unexpected<E>* errptr() const {
-        return std::addressof(this->m_unexpect);
-    }
-
-    template <typename U = T>
-    constexpr U& val() {
-        return this->m_val;
-    }
-
-    template <typename U = T>
-    constexpr const U& val() const {
-        return this->m_val;
-    }
-
-    constexpr Unexpected<E>& err() {
-        return this->m_unexpect;
-    }
-
-    constexpr const Unexpected<E>& err() const {
-        return this->m_unexpect;
-    }
-
-    using impl_base = detail::expected_move_assign_base<T, E>;
-    using ctor_base = detail::expected_default_ctor_base<T, E>;
-};
-
-template <typename T, typename E, typename U, typename F>
-constexpr bool operator==(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {
-    return (lhs.has_value() != rhs.has_value())
-               ? false
-               : (!lhs.has_value() ? lhs.error() == rhs.error() : *lhs == *rhs);
-}
-
-template <typename T, typename E, typename U, typename F>
-constexpr bool operator!=(const Expected<T, E>& lhs, const Expected<U, F>& rhs) {
-    return !operator==(lhs, rhs);
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator==(const Expected<T, E>& x, const U& v) {
-    return x.has_value() ? *x == v : false;
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator==(const U& v, const Expected<T, E>& x) {
-    return x.has_value() ? *x == v : false;
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator!=(const Expected<T, E>& x, const U& v) {
-    return !operator==(x, v);
-}
-
-template <typename T, typename E, typename U>
-constexpr bool operator!=(const U& v, const Expected<T, E>& x) {
-    return !operator==(v, x);
-}
-
-template <typename T, typename E>
-constexpr bool operator==(const Expected<T, E>& x, const Unexpected<E>& e) {
-    return x.has_value() ? false : x.error() == e.value();
-}
-
-template <typename T, typename E>
-constexpr bool operator==(const Unexpected<E>& e, const Expected<T, E>& x) {
-    return x.has_value() ? false : x.error() == e.value();
-}
-
-template <typename T, typename E>
-constexpr bool operator!=(const Expected<T, E>& x, const Unexpected<E>& e) {
-    return !operator==(x, e);
-}
-
-template <typename T, typename E>
-constexpr bool operator!=(const Unexpected<E>& e, const Expected<T, E>& x) {
-    return !operator==(e, x);
-}
-
-} // namespace Common

src/common/fs/path_util.cpp

@@ -82,35 +82,32 @@ public:
 
 private:
     PathManagerImpl() {
-        fs::path yuzu_path;
-        fs::path yuzu_path_cache;
-        fs::path yuzu_path_config;
-
 #ifdef _WIN32
-        yuzu_path = GetExeDirectory() / PORTABLE_DIR;
+        auto yuzu_path = GetExeDirectory() / PORTABLE_DIR;
 
         if (!IsDir(yuzu_path)) {
             yuzu_path = GetAppDataRoamingDirectory() / YUZU_DIR;
         }
 
-        yuzu_path_cache = yuzu_path / CACHE_DIR;
-        yuzu_path_config = yuzu_path / CONFIG_DIR;
+        GenerateYuzuPath(YuzuPath::YuzuDir, yuzu_path);
+        GenerateYuzuPath(YuzuPath::CacheDir, yuzu_path / CACHE_DIR);
+        GenerateYuzuPath(YuzuPath::ConfigDir, yuzu_path / CONFIG_DIR);
 #else
-        yuzu_path = GetCurrentDir() / PORTABLE_DIR;
+        auto yuzu_path = GetCurrentDir() / PORTABLE_DIR;
 
         if (Exists(yuzu_path) && IsDir(yuzu_path)) {
-            yuzu_path_cache = yuzu_path / CACHE_DIR;
-            yuzu_path_config = yuzu_path / CONFIG_DIR;
+            GenerateYuzuPath(YuzuPath::YuzuDir, yuzu_path);
+            GenerateYuzuPath(YuzuPath::CacheDir, yuzu_path / CACHE_DIR);
+            GenerateYuzuPath(YuzuPath::ConfigDir, yuzu_path / CONFIG_DIR);
         } else {
             yuzu_path = GetDataDirectory("XDG_DATA_HOME") / YUZU_DIR;
-            yuzu_path_cache = GetDataDirectory("XDG_CACHE_HOME") / YUZU_DIR;
-            yuzu_path_config = GetDataDirectory("XDG_CONFIG_HOME") / YUZU_DIR;
+
+            GenerateYuzuPath(YuzuPath::YuzuDir, yuzu_path);
+            GenerateYuzuPath(YuzuPath::CacheDir, GetDataDirectory("XDG_CACHE_HOME") / YUZU_DIR);
+            GenerateYuzuPath(YuzuPath::ConfigDir, GetDataDirectory("XDG_CONFIG_HOME") / YUZU_DIR);
         }
 #endif
 
-        GenerateYuzuPath(YuzuPath::YuzuDir, yuzu_path);
-        GenerateYuzuPath(YuzuPath::CacheDir, yuzu_path_cache);
-        GenerateYuzuPath(YuzuPath::ConfigDir, yuzu_path_config);
         GenerateYuzuPath(YuzuPath::DumpDir, yuzu_path / DUMP_DIR);
         GenerateYuzuPath(YuzuPath::KeysDir, yuzu_path / KEYS_DIR);
         GenerateYuzuPath(YuzuPath::LoadDir, yuzu_path / LOAD_DIR);

src/common/logging/backend.cpp

@@ -6,7 +6,6 @@
 #include <chrono>
 #include <climits>
 #include <exception>
-#include <stop_token>
 #include <thread>
 #include <vector>
 
@@ -187,10 +186,6 @@ public:
         initialization_in_progress_suppress_logging = false;
     }
 
-    static void Start() {
-        instance->StartBackendThread();
-    }
-
     Impl(const Impl&) = delete;
     Impl& operator=(const Impl&) = delete;
 
@@ -206,7 +201,7 @@ public:
     }
 
     void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, std::string&& message) {
+                   const char* function, std::string message) {
         if (!filter.CheckMessage(log_class, log_level))
             return;
         const Entry& entry =
@@ -216,41 +211,40 @@ public:
 
 private:
     Impl(const std::filesystem::path& file_backend_filename, const Filter& filter_)
-        : filter{filter_}, file_backend{file_backend_filename} {}
+        : filter{filter_}, file_backend{file_backend_filename}, backend_thread{std::thread([this] {
+              Common::SetCurrentThreadName("yuzu:Log");
+              Entry entry;
+              const auto write_logs = [this, &entry]() {
+                  ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
+              };
+              while (true) {
+                  entry = message_queue.PopWait();
+                  if (entry.final_entry) {
+                      break;
+                  }
+                  write_logs();
+              }
+              // 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.
+              int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
+              while (max_logs_to_write-- && message_queue.Pop(entry)) {
+                  write_logs();
+              }
+          })} {}
 
     ~Impl() {
         StopBackendThread();
     }
 
-    void StartBackendThread() {
-        backend_thread = std::thread([this] {
-            Common::SetCurrentThreadName("yuzu:Log");
-            Entry entry;
-            const auto write_logs = [this, &entry]() {
-                ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
-            };
-            while (!stop.stop_requested()) {
-                entry = message_queue.PopWait(stop.get_token());
-                if (entry.filename != nullptr) {
-                    write_logs();
-                }
-            }
-            // 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.
-            int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-            while (max_logs_to_write-- && message_queue.Pop(entry)) {
-                write_logs();
-            }
-        });
-    }
-
     void StopBackendThread() {
-        stop.request_stop();
+        Entry stop_entry{};
+        stop_entry.final_entry = true;
+        message_queue.Push(stop_entry);
         backend_thread.join();
     }
 
     Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                      const char* function, std::string&& message) const {
+                      const char* function, std::string message) const {
         using std::chrono::duration_cast;
         using std::chrono::microseconds;
         using std::chrono::steady_clock;
@@ -263,6 +257,7 @@ private:
             .line_num = line_nr,
             .function = function,
             .message = std::move(message),
+            .final_entry = false,
         };
     }
 
@@ -283,9 +278,8 @@ private:
     ColorConsoleBackend color_console_backend{};
     FileBackend file_backend;
 
-    std::stop_source stop;
     std::thread backend_thread;
-    MPSCQueue<Entry, true> message_queue{};
+    MPSCQueue<Entry> message_queue{};
     std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
 } // namespace
@@ -294,10 +288,6 @@ void Initialize() {
     Impl::Initialize();
 }
 
-void Start() {
-    Impl::Start();
-}
-
 void DisableLoggingInTests() {
     initialization_in_progress_suppress_logging = true;
 }

src/common/logging/backend.h

@@ -14,8 +14,6 @@ class Filter;
 /// Initializes the logging system. This should be the first thing called in main.
 void Initialize();
 
-void Start();
-
 void DisableLoggingInTests();
 
 /**

src/common/logging/log_entry.h

@@ -22,6 +22,7 @@ struct Entry {
     unsigned int line_num = 0;
     std::string function;
     std::string message;
+    bool final_entry = false;
 };
 
 } // namespace Common::Log

src/common/settings.h

@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <array>
 #include <atomic>
+#include <chrono>
 #include <map>
 #include <optional>
 #include <string>
@@ -486,9 +487,9 @@ struct Values {
     // System
     Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
     // Measured in seconds since epoch
-    std::optional<s64> custom_rtc;
+    std::optional<std::chrono::seconds> custom_rtc;
     // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
-    s64 custom_rtc_differential;
+    std::chrono::seconds custom_rtc_differential;
 
     BasicSetting<s32> current_user{0, "current_user"};
     RangedSetting<s32> language_index{1, 0, 17, "language_index"};

src/common/string_util.cpp

@@ -180,20 +180,20 @@ std::wstring UTF8ToUTF16W(const std::string& input) {
 
 #endif
 
-std::string StringFromFixedZeroTerminatedBuffer(std::string_view buffer, std::size_t max_len) {
+std::string StringFromFixedZeroTerminatedBuffer(const char* buffer, std::size_t max_len) {
     std::size_t len = 0;
-    while (len < buffer.length() && len < max_len && buffer[len] != '\0') {
+    while (len < max_len && buffer[len] != '\0')
         ++len;
-    }
-    return std::string(buffer.begin(), buffer.begin() + len);
+
+    return std::string(buffer, len);
 }
 
 std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer,
                                                         std::size_t max_len) {
     std::size_t len = 0;
-    while (len < buffer.length() && len < max_len && buffer[len] != '\0') {
+    while (len < max_len && buffer[len] != '\0')
         ++len;
-    }
+
     return std::u16string(buffer.begin(), buffer.begin() + len);
 }
 

src/common/string_util.h

@@ -63,7 +63,7 @@ template <typename InIt>
  * Creates a std::string from a fixed-size NUL-terminated char buffer. If the buffer isn't
  * NUL-terminated then the string ends at max_len characters.
  */
-[[nodiscard]] std::string StringFromFixedZeroTerminatedBuffer(std::string_view buffer,
+[[nodiscard]] std::string StringFromFixedZeroTerminatedBuffer(const char* buffer,
                                                               std::size_t max_len);
 
 /**

src/core/arm/dynarmic/arm_dynarmic_32.h

@@ -9,6 +9,7 @@
 
 #include <dynarmic/interface/A32/a32.h>
 #include <dynarmic/interface/A64/a64.h>
+#include <dynarmic/interface/exclusive_monitor.h>
 #include "common/common_types.h"
 #include "common/hash.h"
 #include "core/arm/arm_interface.h"

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -18,6 +18,7 @@
 #include "core/core_timing.h"
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/k_process.h"
+#include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/svc.h"
 #include "core/memory.h"
 
@@ -262,7 +263,7 @@ void ARM_Dynarmic_64::Run() {
 }
 
 void ARM_Dynarmic_64::Step() {
-    jit->Step();
+    cb->InterpreterFallback(jit->GetPC(), 1);
 }
 
 ARM_Dynarmic_64::ARM_Dynarmic_64(System& system_, CPUInterrupts& interrupt_handlers_,

src/core/arm/dynarmic/arm_dynarmic_cp15.cpp

@@ -8,6 +8,7 @@
 #include "core/arm/dynarmic/arm_dynarmic_cp15.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 
 using Callback = Dynarmic::A32::Coprocessor::Callback;
 using CallbackOrAccessOneWord = Dynarmic::A32::Coprocessor::CallbackOrAccessOneWord;

src/core/arm/dynarmic/arm_dynarmic_cp15.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <memory>
 #include <optional>
 
 #include <dynarmic/interface/A32/coprocessor.h>

src/core/arm/dynarmic/arm_exclusive_monitor.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <cinttypes>
+#include <memory>
 #include "core/arm/dynarmic/arm_exclusive_monitor.h"
 #include "core/memory.h"
 

src/core/arm/dynarmic/arm_exclusive_monitor.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <memory>
 #include <unordered_map>
 
 #include <dynarmic/interface/exclusive_monitor.h>

src/core/core.cpp

@@ -19,16 +19,20 @@
 #include "core/cpu_manager.h"
 #include "core/device_memory.h"
 #include "core/file_sys/bis_factory.h"
+#include "core/file_sys/card_image.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/romfs_factory.h"
 #include "core/file_sys/savedata_factory.h"
+#include "core/file_sys/sdmc_factory.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/hardware_interrupt_manager.h"
+#include "core/hle/kernel/k_client_port.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_scheduler.h"
+#include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/service/am/applets/applets.h"
@@ -79,6 +83,12 @@ FileSys::StorageId GetStorageIdForFrontendSlot(
     }
 }
 
+void KProcessDeleter(Kernel::KProcess* process) {
+    process->Destroy();
+}
+
+using KProcessPtr = std::unique_ptr<Kernel::KProcess, decltype(&KProcessDeleter)>;
+
 } // Anonymous namespace
 
 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
@@ -129,47 +139,27 @@ struct System::Impl {
         : kernel{system}, fs_controller{system}, memory{system},
           cpu_manager{system}, reporter{system}, applet_manager{system}, time_manager{system} {}
 
-    SystemResultStatus Run() {
-        std::unique_lock<std::mutex> lk(suspend_guard);
-        status = SystemResultStatus::Success;
+    ResultStatus Run() {
+        status = ResultStatus::Success;
 
         kernel.Suspend(false);
         core_timing.SyncPause(false);
         cpu_manager.Pause(false);
-        is_paused = false;
 
         return status;
     }
 
-    SystemResultStatus Pause() {
-        std::unique_lock<std::mutex> lk(suspend_guard);
-        status = SystemResultStatus::Success;
+    ResultStatus Pause() {
+        status = ResultStatus::Success;
 
         core_timing.SyncPause(true);
         kernel.Suspend(true);
         cpu_manager.Pause(true);
-        is_paused = true;
 
         return status;
     }
 
-    std::unique_lock<std::mutex> StallCPU() {
-        std::unique_lock<std::mutex> lk(suspend_guard);
-        kernel.Suspend(true);
-        core_timing.SyncPause(true);
-        cpu_manager.Pause(true);
-        return lk;
-    }
-
-    void UnstallCPU() {
-        if (!is_paused) {
-            core_timing.SyncPause(false);
-            kernel.Suspend(false);
-            cpu_manager.Pause(false);
-        }
-    }
-
-    SystemResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
+    ResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
         LOG_DEBUG(Core, "initialized OK");
 
         device_memory = std::make_unique<Core::DeviceMemory>();
@@ -186,9 +176,8 @@ struct System::Impl {
         cpu_manager.Initialize();
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
 
-        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
-        const auto current_time =
-            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
+        const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
+            std::chrono::system_clock::now().time_since_epoch());
         Settings::values.custom_rtc_differential =
             Settings::values.custom_rtc.value_or(current_time) - current_time;
 
@@ -208,7 +197,7 @@ struct System::Impl {
 
         gpu_core = VideoCore::CreateGPU(emu_window, system);
         if (!gpu_core) {
-            return SystemResultStatus::ErrorVideoCore;
+            return ResultStatus::ErrorVideoCore;
         }
 
         service_manager = std::make_shared<Service::SM::ServiceManager>(kernel);
@@ -228,22 +217,21 @@ struct System::Impl {
 
         LOG_DEBUG(Core, "Initialized OK");
 
-        return SystemResultStatus::Success;
+        return ResultStatus::Success;
     }
 
-    SystemResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
-                            const std::string& filepath, u64 program_id,
-                            std::size_t program_index) {
+    ResultStatus Load(System& system, Frontend::EmuWindow& emu_window, const std::string& filepath,
+                      u64 program_id, std::size_t program_index) {
         app_loader = Loader::GetLoader(system, GetGameFileFromPath(virtual_filesystem, filepath),
                                        program_id, program_index);
 
         if (!app_loader) {
             LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
-            return SystemResultStatus::ErrorGetLoader;
+            return ResultStatus::ErrorGetLoader;
         }
 
-        SystemResultStatus init_result{Init(system, emu_window)};
-        if (init_result != SystemResultStatus::Success) {
+        ResultStatus init_result{Init(system, emu_window)};
+        if (init_result != ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
                          static_cast<int>(init_result));
             Shutdown();
@@ -251,20 +239,21 @@ struct System::Impl {
         }
 
         telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
-        auto main_process = Kernel::KProcess::Create(system.Kernel());
-        ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
+        main_process = KProcessPtr{Kernel::KProcess::Create(system.Kernel()), KProcessDeleter};
+        ASSERT(Kernel::KProcess::Initialize(main_process.get(), system, "main",
                                             Kernel::KProcess::ProcessType::Userland)
                    .IsSuccess());
+        main_process->Open();
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
             Shutdown();
 
-            return static_cast<SystemResultStatus>(
-                static_cast<u32>(SystemResultStatus::ErrorLoader) + static_cast<u32>(load_result));
+            return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
+                                             static_cast<u32>(load_result));
         }
         AddGlueRegistrationForProcess(*app_loader, *main_process);
-        kernel.MakeCurrentProcess(main_process);
+        kernel.MakeCurrentProcess(main_process.get());
         kernel.InitializeCores();
 
         // Initialize cheat engine
@@ -293,7 +282,7 @@ struct System::Impl {
         GetAndResetPerfStats();
         perf_stats->BeginSystemFrame();
 
-        status = SystemResultStatus::Success;
+        status = ResultStatus::Success;
         return status;
     }
 
@@ -324,11 +313,13 @@ struct System::Impl {
         time_manager.Shutdown();
         core_timing.Shutdown();
         app_loader.reset();
-        gpu_core.reset();
         perf_stats.reset();
+        gpu_core.reset();
         kernel.Shutdown();
         memory.Reset();
         applet_manager.ClearAll();
+        // TODO: The main process should be freed based on KAutoObject ref counting.
+        main_process.reset();
 
         LOG_DEBUG(Core, "Shutdown OK");
     }
@@ -349,7 +340,7 @@ struct System::Impl {
         }
 
         Service::Glue::ApplicationLaunchProperty launch{};
-        launch.title_id = process.GetProgramID();
+        launch.title_id = process.GetTitleID();
 
         FileSys::PatchManager pm{launch.title_id, fs_controller, *content_provider};
         launch.version = pm.GetGameVersion().value_or(0);
@@ -364,7 +355,7 @@ struct System::Impl {
         arp_manager.Register(launch.title_id, launch, std::move(nacp_data));
     }
 
-    void SetStatus(SystemResultStatus new_status, const char* details = nullptr) {
+    void SetStatus(ResultStatus new_status, const char* details = nullptr) {
         status = new_status;
         if (details) {
             status_details = details;
@@ -375,9 +366,6 @@ struct System::Impl {
         return perf_stats->GetAndResetStats(core_timing.GetGlobalTimeUs());
     }
 
-    std::mutex suspend_guard;
-    bool is_paused{};
-
     Timing::CoreTiming core_timing;
     Kernel::KernelCore kernel;
     /// RealVfsFilesystem instance
@@ -390,6 +378,7 @@ struct System::Impl {
     std::unique_ptr<Tegra::GPU> gpu_core;
     std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
     std::unique_ptr<Core::DeviceMemory> device_memory;
+    KProcessPtr main_process{nullptr, KProcessDeleter};
     Core::Memory::Memory memory;
     CpuManager cpu_manager;
     std::atomic_bool is_powered_on{};
@@ -422,7 +411,7 @@ struct System::Impl {
     /// Network instance
     Network::NetworkInstance network_instance;
 
-    SystemResultStatus status = SystemResultStatus::Success;
+    ResultStatus status = ResultStatus::Success;
     std::string status_details = "";
 
     std::unique_ptr<Core::PerfStats> perf_stats;
@@ -439,9 +428,22 @@ struct System::Impl {
 };
 
 System::System() : impl{std::make_unique<Impl>(*this)} {}
-
 System::~System() = default;
 
+System& System::GetInstance() {
+    if (!s_instance) {
+        throw std::runtime_error("Using System instance before its initialization");
+    }
+    return *s_instance;
+}
+
+void System::InitializeGlobalInstance() {
+    if (s_instance) {
+        throw std::runtime_error("Reinitializing Global System instance.");
+    }
+    s_instance = std::unique_ptr<System>(new System);
+}
+
 CpuManager& System::GetCpuManager() {
     return impl->cpu_manager;
 }
@@ -450,16 +452,16 @@ const CpuManager& System::GetCpuManager() const {
     return impl->cpu_manager;
 }
 
-SystemResultStatus System::Run() {
+System::ResultStatus System::Run() {
     return impl->Run();
 }
 
-SystemResultStatus System::Pause() {
+System::ResultStatus System::Pause() {
     return impl->Pause();
 }
 
-SystemResultStatus System::SingleStep() {
-    return SystemResultStatus::Success;
+System::ResultStatus System::SingleStep() {
+    return ResultStatus::Success;
 }
 
 void System::InvalidateCpuInstructionCaches() {
@@ -474,16 +476,8 @@ void System::Shutdown() {
     impl->Shutdown();
 }
 
-std::unique_lock<std::mutex> System::StallCPU() {
-    return impl->StallCPU();
-}
-
-void System::UnstallCPU() {
-    impl->UnstallCPU();
-}
-
-SystemResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath,
-                                u64 program_id, std::size_t program_index) {
+System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath,
+                                  u64 program_id, std::size_t program_index) {
     return impl->Load(*this, emu_window, filepath, program_id, program_index);
 }
 
@@ -639,15 +633,11 @@ const Core::SpeedLimiter& System::SpeedLimiter() const {
     return impl->speed_limiter;
 }
 
-u64 System::GetCurrentProcessProgramID() const {
-    return impl->kernel.CurrentProcess()->GetProgramID();
-}
-
 Loader::ResultStatus System::GetGameName(std::string& out) const {
     return impl->GetGameName(out);
 }
 
-void System::SetStatus(SystemResultStatus new_status, const char* details) {
+void System::SetStatus(ResultStatus new_status, const char* details) {
     impl->SetStatus(new_status, details);
 }
 

src/core/core.h

@@ -7,7 +7,6 @@
 #include <cstddef>
 #include <functional>
 #include <memory>
-#include <mutex>
 #include <string>
 #include <vector>
 
@@ -105,49 +104,55 @@ struct PerfStatsResults;
 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
                                          const std::string& path);
 
-/// Enumeration representing the return values of the System Initialize and Load process.
-enum class SystemResultStatus : u32 {
-    Success,             ///< Succeeded
-    ErrorNotInitialized, ///< Error trying to use core prior to initialization
-    ErrorGetLoader,      ///< Error finding the correct application loader
-    ErrorSystemFiles,    ///< Error in finding system files
-    ErrorSharedFont,     ///< Error in finding shared font
-    ErrorVideoCore,      ///< Error in the video core
-    ErrorUnknown,        ///< Any other error
-    ErrorLoader,         ///< The base for loader errors (too many to repeat)
-};
-
 class System {
 public:
     using CurrentBuildProcessID = std::array<u8, 0x20>;
 
-    explicit System();
-
-    ~System();
-
     System(const System&) = delete;
     System& operator=(const System&) = delete;
 
     System(System&&) = delete;
     System& operator=(System&&) = delete;
 
+    ~System();
+
+    /**
+     * Gets the instance of the System singleton class.
+     * @returns Reference to the instance of the System singleton class.
+     */
+    [[deprecated("Use of the global system instance is deprecated")]] static System& GetInstance();
+
+    static void InitializeGlobalInstance();
+
+    /// Enumeration representing the return values of the System Initialize and Load process.
+    enum class ResultStatus : u32 {
+        Success,             ///< Succeeded
+        ErrorNotInitialized, ///< Error trying to use core prior to initialization
+        ErrorGetLoader,      ///< Error finding the correct application loader
+        ErrorSystemFiles,    ///< Error in finding system files
+        ErrorSharedFont,     ///< Error in finding shared font
+        ErrorVideoCore,      ///< Error in the video core
+        ErrorUnknown,        ///< Any other error
+        ErrorLoader,         ///< The base for loader errors (too many to repeat)
+    };
+
     /**
      * Run the OS and Application
      * This function will start emulation and run the relevant devices
      */
-    [[nodiscard]] SystemResultStatus Run();
+    [[nodiscard]] ResultStatus Run();
 
     /**
      * Pause the OS and Application
      * This function will pause emulation and stop the relevant devices
      */
-    [[nodiscard]] SystemResultStatus Pause();
+    [[nodiscard]] ResultStatus Pause();
 
     /**
      * Step the CPU one instruction
      * @return Result status, indicating whether or not the operation succeeded.
      */
-    [[nodiscard]] SystemResultStatus SingleStep();
+    [[nodiscard]] ResultStatus SingleStep();
 
     /**
      * Invalidate the CPU instruction caches
@@ -161,20 +166,16 @@ public:
     /// Shutdown the emulated system.
     void Shutdown();
 
-    std::unique_lock<std::mutex> StallCPU();
-    void UnstallCPU();
-
     /**
      * Load an executable application.
      * @param emu_window Reference to the host-system window used for video output and keyboard
      *                   input.
      * @param filepath String path to the executable application to load on the host file system.
      * @param program_index Specifies the index within the container of the program to launch.
-     * @returns SystemResultStatus code, indicating if the operation succeeded.
+     * @returns ResultStatus code, indicating if the operation succeeded.
      */
-    [[nodiscard]] SystemResultStatus Load(Frontend::EmuWindow& emu_window,
-                                          const std::string& filepath, u64 program_id = 0,
-                                          std::size_t program_index = 0);
+    [[nodiscard]] ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath,
+                                    u64 program_id = 0, std::size_t program_index = 0);
 
     /**
      * Indicates if the emulated system is powered on (all subsystems initialized and able to run an
@@ -297,12 +298,10 @@ public:
     /// Provides a constant reference to the speed limiter
     [[nodiscard]] const Core::SpeedLimiter& SpeedLimiter() const;
 
-    [[nodiscard]] u64 GetCurrentProcessProgramID() const;
-
     /// Gets the name of the current game
     [[nodiscard]] Loader::ResultStatus GetGameName(std::string& out) const;
 
-    void SetStatus(SystemResultStatus new_status, const char* details);
+    void SetStatus(ResultStatus new_status, const char* details);
 
     [[nodiscard]] const std::string& GetStatusDetails() const;
 
@@ -404,8 +403,12 @@ public:
     void ApplySettings();
 
 private:
+    System();
+
     struct Impl;
     std::unique_ptr<Impl> impl;
+
+    inline static std::unique_ptr<System> s_instance{};
 };
 
 } // namespace Core

src/core/core_timing.h

@@ -8,6 +8,7 @@
 #include <chrono>
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <optional>
 #include <string>
 #include <thread>

src/core/cpu_manager.cpp

@@ -6,6 +6,7 @@
 #include "common/microprofile.h"
 #include "common/scope_exit.h"
 #include "common/thread.h"
+#include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/cpu_manager.h"

src/core/crypto/ctr_encryption_layer.cpp

@@ -4,6 +4,7 @@
 
 #include <algorithm>
 #include <cstring>
+#include "common/assert.h"
 #include "core/crypto/ctr_encryption_layer.h"
 
 namespace Core::Crypto {

src/core/crypto/key_manager.cpp

@@ -10,12 +10,14 @@
 #include <locale>
 #include <map>
 #include <sstream>
+#include <string_view>
 #include <tuple>
 #include <vector>
 #include <mbedtls/bignum.h>
 #include <mbedtls/cipher.h>
 #include <mbedtls/cmac.h>
 #include <mbedtls/sha256.h>
+#include "common/common_funcs.h"
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
@@ -28,6 +30,7 @@
 #include "core/crypto/partition_data_manager.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
+#include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/registered_cache.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"

src/core/crypto/key_manager.h

@@ -15,6 +15,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/crypto/partition_data_manager.h"
+#include "core/file_sys/vfs_types.h"
 
 namespace Common::FS {
 class IOFile;

src/core/crypto/partition_data_manager.cpp

@@ -12,6 +12,7 @@
 #include <cctype>
 #include <cstring>
 #include <mbedtls/sha256.h>
+#include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/hex_util.h"

src/core/crypto/xts_encryption_layer.cpp

@@ -4,6 +4,7 @@
 
 #include <algorithm>
 #include <cstring>
+#include "common/assert.h"
 #include "core/crypto/xts_encryption_layer.h"
 
 namespace Core::Crypto {

src/core/file_sys/card_image.cpp

@@ -14,6 +14,7 @@
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/partition_filesystem.h"
 #include "core/file_sys/submission_package.h"
+#include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/file_sys/vfs_vector.h"
 #include "core/loader/loader.h"

src/core/file_sys/control_metadata.cpp

@@ -9,7 +9,7 @@
 
 namespace FileSys {
 
-const std::array<const char*, 16> LANGUAGE_NAMES{{
+const std::array<const char*, 15> LANGUAGE_NAMES{{
     "AmericanEnglish",
     "BritishEnglish",
     "Japanese",
@@ -25,7 +25,6 @@ const std::array<const char*, 16> LANGUAGE_NAMES{{
     "Korean",
     "Taiwanese",
     "Chinese",
-    "BrazilianPortuguese",
 }};
 
 std::string LanguageEntry::GetApplicationName() const {

src/core/file_sys/control_metadata.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <array>
+#include <memory>
 #include <string>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -87,12 +88,11 @@ enum class Language : u8 {
     Korean = 12,
     Taiwanese = 13,
     Chinese = 14,
-    BrazilianPortuguese = 15,
 
     Default = 255,
 };
 
-extern const std::array<const char*, 16> LANGUAGE_NAMES;
+extern const std::array<const char*, 15> LANGUAGE_NAMES;
 
 // A class representing the format used by NX metadata files, typically named Control.nacp.
 // These store application name, dev name, title id, and other miscellaneous data.

src/core/file_sys/directory.h

@@ -6,6 +6,7 @@
 
 #include <cstddef>
 #include <iterator>
+#include <string_view>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 

src/core/file_sys/nca_metadata.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <array>
+#include <memory>
 #include <vector>
 #include "common/common_funcs.h"
 #include "common/common_types.h"

src/core/file_sys/program_metadata.cpp

@@ -53,16 +53,13 @@ Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
 }
 
 /*static*/ ProgramMetadata ProgramMetadata::GetDefault() {
-    // Allow use of cores 0~3 and thread priorities 1~63.
-    constexpr u32 default_thread_info_capability = 0x30007F7;
-
     ProgramMetadata result;
 
     result.LoadManual(
         true /*is_64_bit*/, FileSys::ProgramAddressSpaceType::Is39Bit /*address_space*/,
         0x2c /*main_thread_prio*/, 0 /*main_thread_core*/, 0x00100000 /*main_thread_stack_size*/,
         0 /*title_id*/, 0xFFFFFFFFFFFFFFFF /*filesystem_permissions*/,
-        0x1FE00000 /*system_resource_size*/, {default_thread_info_capability} /*capabilities*/);
+        0x1FE00000 /*system_resource_size*/, {} /*capabilities*/);
 
     return result;
 }

src/core/file_sys/romfs_factory.cpp

@@ -6,6 +6,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
+#include "core/file_sys/card_image.h"
 #include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
@@ -38,12 +39,13 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw_file) {
 
 ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
     if (!updatable) {
-        return file;
+        return MakeResult<VirtualFile>(file);
     }
 
     const PatchManager patch_manager{current_process_title_id, filesystem_controller,
                                      content_provider};
-    return patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw);
+    return MakeResult<VirtualFile>(
+        patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }
 
 ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const {
@@ -56,7 +58,8 @@ ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecor
 
     const PatchManager patch_manager{title_id, filesystem_controller, content_provider};
 
-    return patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type);
+    return MakeResult<VirtualFile>(
+        patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type));
 }
 
 ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFSWithProgramIndex(
@@ -80,7 +83,7 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
         return ResultUnknown;
     }
 
-    return romfs;
+    return MakeResult<VirtualFile>(romfs);
 }
 
 std::shared_ptr<NCA> RomFSFactory::GetEntry(u64 title_id, StorageId storage,

src/core/file_sys/romfs_factory.h

@@ -5,9 +5,8 @@
 #pragma once
 
 #include <memory>
-
 #include "common/common_types.h"
-#include "core/file_sys/vfs_types.h"
+#include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
 
 namespace Loader {

src/core/file_sys/savedata_factory.cpp

@@ -9,6 +9,7 @@
 #include "core/core.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs.h"
+#include "core/hle/kernel/k_process.h"
 
 namespace FileSys {
 
@@ -93,7 +94,7 @@ ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
         return ResultUnknown;
     }
 
-    return out;
+    return MakeResult<VirtualDir>(std::move(out));
 }
 
 ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
@@ -114,7 +115,7 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
         return ResultUnknown;
     }
 
-    return out;
+    return MakeResult<VirtualDir>(std::move(out));
 }
 
 VirtualDir SaveDataFactory::GetSaveDataSpaceDirectory(SaveDataSpaceId space) const {
@@ -142,7 +143,7 @@ std::string SaveDataFactory::GetFullPath(Core::System& system, SaveDataSpaceId s
     // be interpreted as the title id of the current process.
     if (type == SaveDataType::SaveData || type == SaveDataType::DeviceSaveData) {
         if (title_id == 0) {
-            title_id = system.GetCurrentProcessProgramID();
+            title_id = system.CurrentProcess()->GetTitleID();
         }
     }
 

src/core/file_sys/savedata_factory.h

@@ -8,6 +8,7 @@
 #include <string>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/swap.h"
 #include "core/file_sys/vfs.h"
 #include "core/hle/result.h"
 

src/core/file_sys/sdmc_factory.cpp

@@ -25,7 +25,7 @@ SDMCFactory::SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_)
 SDMCFactory::~SDMCFactory() = default;
 
 ResultVal<VirtualDir> SDMCFactory::Open() const {
-    return sd_dir;
+    return MakeResult<VirtualDir>(sd_dir);
 }
 
 VirtualDir SDMCFactory::GetSDMCModificationLoadRoot(u64 title_id) const {

src/core/file_sys/submission_package.cpp

@@ -4,6 +4,7 @@
 
 #include <algorithm>
 #include <cstring>
+#include <string_view>
 
 #include <fmt/ostream.h>
 

src/core/file_sys/system_archive/time_zone_binary.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <string>
 #include "core/file_sys/vfs_types.h"
 
 namespace FileSys::SystemArchive {

src/core/file_sys/vfs.h

@@ -9,6 +9,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <string_view>
 #include <type_traits>
 #include <vector>
 

src/core/file_sys/vfs_concat.h

@@ -6,6 +6,7 @@
 
 #include <map>
 #include <memory>
+#include <string_view>
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {

src/core/file_sys/vfs_offset.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <memory>
+#include <string_view>
 
 #include "core/file_sys/vfs.h"
 

src/core/frontend/applets/general_frontend.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <functional>
+#include <optional>
 #include "common/common_types.h"
 
 namespace Core::Frontend {

src/core/frontend/applets/software_keyboard.cpp

@@ -16,8 +16,7 @@ DefaultSoftwareKeyboardApplet::~DefaultSoftwareKeyboardApplet() = default;
 
 void DefaultSoftwareKeyboardApplet::InitializeKeyboard(
     bool is_inline, KeyboardInitializeParameters initialize_parameters,
-    std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
-        submit_normal_callback_,
+    std::function<void(Service::AM::Applets::SwkbdResult, std::u16string)> submit_normal_callback_,
     std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
         submit_inline_callback_) {
     if (is_inline) {
@@ -129,7 +128,7 @@ void DefaultSoftwareKeyboardApplet::ExitKeyboard() const {
 }
 
 void DefaultSoftwareKeyboardApplet::SubmitNormalText(std::u16string text) const {
-    submit_normal_callback(Service::AM::Applets::SwkbdResult::Ok, text, true);
+    submit_normal_callback(Service::AM::Applets::SwkbdResult::Ok, text);
 }
 
 void DefaultSoftwareKeyboardApplet::SubmitInlineText(std::u16string_view text) const {

src/core/frontend/applets/software_keyboard.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <functional>
+#include <thread>
 
 #include "common/common_types.h"
 
@@ -57,7 +58,7 @@ public:
 
     virtual void InitializeKeyboard(
         bool is_inline, KeyboardInitializeParameters initialize_parameters,
-        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
+        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string)>
             submit_normal_callback_,
         std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
             submit_inline_callback_) = 0;
@@ -82,7 +83,7 @@ public:
 
     void InitializeKeyboard(
         bool is_inline, KeyboardInitializeParameters initialize_parameters,
-        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
+        std::function<void(Service::AM::Applets::SwkbdResult, std::u16string)>
             submit_normal_callback_,
         std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
             submit_inline_callback_) override;
@@ -106,7 +107,7 @@ private:
 
     KeyboardInitializeParameters parameters;
 
-    mutable std::function<void(Service::AM::Applets::SwkbdResult, std::u16string, bool)>
+    mutable std::function<void(Service::AM::Applets::SwkbdResult, std::u16string)>
         submit_normal_callback;
     mutable std::function<void(Service::AM::Applets::SwkbdReplyType, std::u16string, s32)>
         submit_inline_callback;

src/core/frontend/applets/web_browser.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <functional>
+#include <string_view>
 
 #include "core/hle/service/am/applets/applet_web_browser_types.h"
 

src/core/frontend/emu_window.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <cmath>
 #include <mutex>
 #include "common/settings.h"
 #include "core/frontend/emu_window.h"

src/core/frontend/emu_window.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <memory>
+#include <tuple>
 #include <utility>
 #include "common/common_types.h"
 #include "core/frontend/framebuffer_layout.h"

src/core/hle/ipc_helpers.h

@@ -4,14 +4,17 @@
 
 #pragma once
 
+#include <array>
 #include <cstring>
 #include <memory>
+#include <tuple>
 #include <type_traits>
 #include <utility>
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/hle_ipc.h"
+#include "core/hle/kernel/k_client_port.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_session.h"

src/core/hle/kernel/board/nintendo/nx/secure_monitor.h

@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include "common/common_types.h"
+
 namespace Kernel::Board::Nintendo::Nx::Smc {
 
 enum MemorySize {

src/core/hle/kernel/code_set.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <cstddef>
+#include <vector>
 
 #include "common/common_types.h"
 #include "core/hle/kernel/physical_memory.h"

src/core/hle/kernel/hle_ipc.cpp

@@ -5,6 +5,7 @@
 #include <algorithm>
 #include <array>
 #include <sstream>
+#include <utility>
 
 #include <boost/range/algorithm_ext/erase.hpp>
 
@@ -14,13 +15,17 @@
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/hle_ipc.h"
-#include "core/hle/kernel/k_auto_object.h"
 #include "core/hle/kernel/k_handle_table.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_readable_event.h"
+#include "core/hle/kernel/k_scheduler.h"
+#include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
 #include "core/hle/kernel/k_server_session.h"
 #include "core/hle/kernel/k_thread.h"
+#include "core/hle/kernel/k_writable_event.h"
 #include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/svc_results.h"
+#include "core/hle/kernel/time_manager.h"
 #include "core/memory.h"
 
 namespace Kernel {