configure_general: Add an option to reset defaults

.ci/scripts/common/post-upload.sh

@@ -1,15 +0,0 @@
-#!/bin/bash -ex
-
-# Copy documentation
-cp license.txt "$REV_NAME"
-cp README.md "$REV_NAME"
-
-tar $COMPRESSION_FLAGS "$ARCHIVE_NAME" "$REV_NAME"
-
-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/

.ci/scripts/common/pre-upload.sh

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

.ci/scripts/format/docker.sh

@@ -1,6 +0,0 @@
-#!/bin/bash -ex
-
-# Run clang-format
-cd /yuzu
-chmod a+x ./.ci/scripts/format/script.sh
-./.ci/scripts/format/script.sh

.ci/scripts/format/exec.sh

@@ -1,4 +0,0 @@
-#!/bin/bash -ex
-
-chmod a+x ./.ci/scripts/format/docker.sh
-docker run -v $(pwd):/yuzu yuzuemu/build-environments:linux-clang-format /bin/bash -ex /yuzu/.ci/scripts/format/docker.sh

.ci/scripts/format/script.sh

@@ -1,37 +0,0 @@
-#!/bin/bash -ex
-
-if grep -nrI '\s$' src *.yml *.txt *.md Doxyfile .gitignore .gitmodules .ci* 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-6.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

.ci/scripts/linux/docker.sh

@@ -1,14 +0,0 @@
-#!/bin/bash -ex
-
-cd /yuzu
-
-ccache -s
-
-mkdir build || true && cd build
-cmake .. -G Ninja -DYUZU_USE_BUNDLED_UNICORN=ON -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

.ci/scripts/linux/exec.sh

@@ -1,5 +0,0 @@
-#!/bin/bash -ex
-
-mkdir -p "ccache"  || true
-chmod a+x ./.ci/scripts/linux/docker.sh
-docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/linux/docker.sh

.ci/scripts/linux/upload.sh

@@ -1,14 +0,0 @@
-#!/bin/bash -ex
-
-. .ci/scripts/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"
-
-. .ci/scripts/common/post-upload.sh

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

@@ -1,28 +0,0 @@
-# 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
-
-http = urllib3.PoolManager()
-dl_list = {}
-
-def check_individual(labels):
-    for label in labels:
-        if (label["name"] == sys.argv[1]):
-            return True
-    return False
-
-try:
-    url = 'https://api.github.com/repos/yuzu-emu/yuzu/pulls'
-    response = requests.get(url)
-    if (response.ok):
-        j = json.loads(response.content)
-        for pr in j:
-            if (check_individual(pr["labels"])):
-                pn = pr["number"]
-                print("Matched PR# %s" % pn)
-                print(subprocess.check_output(["git", "fetch", "https://github.com/yuzu-emu/yuzu.git", "pull/%s/head:pr-%s" % (pn, pn), "-f"]))
-                print(subprocess.check_output(["git", "merge", "--squash", "pr-%s" % pn]))
-                print(subprocess.check_output(["git", "commit", "-m\"Merge PR %s\"" % pn]))
-except:
-    sys.exit(-1)

.ci/scripts/merge/check-label-presence.py

@@ -1,18 +0,0 @@
-# Checks to see if the specified pull request # has the specified tag
-# Usage: python check-label-presence.py <Pull Request ID> <Name of Label>
-
-import requests, json, sys
-
-try:
-    url = 'https://api.github.com/repos/yuzu-emu/yuzu/issues/%s' % sys.argv[1]
-    response = requests.get(url)
-    if (response.ok):
-        j = json.loads(response.content)
-        for label in j["labels"]:
-            if label["name"] == sys.argv[2]:
-                print('##vso[task.setvariable variable=enabletesting;]true')
-                sys.exit()
-except:
-    sys.exit(-1)
-
-print('##vso[task.setvariable variable=enabletesting;]false')

.ci/scripts/merge/yuzubot-git-config.sh

@@ -1,2 +0,0 @@
-git config --global user.email "yuzu@yuzu-emu.org"
-git config --global user.name "yuzubot"

.ci/scripts/windows/docker.sh

@@ -1,50 +0,0 @@
-#!/bin/bash -ex
-
-cd /yuzu
-
-ccache -s
-
-# Dirty hack to trick unicorn makefile into believing we are in a MINGW system
-mv /bin/uname /bin/uname1 && echo -e '#!/bin/sh\necho MINGW64' >> /bin/uname
-chmod +x /bin/uname
-
-# Dirty hack to trick unicorn makefile into believing we have cmd
-echo '' >> /bin/cmd
-chmod +x /bin/cmd
-
-mkdir build || true && cd build
-cmake .. -G Ninja -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=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 .ci/scripts/windows/scan_dll.py package/*.exe "package/"
-python3 .ci/scripts/windows/scan_dll.py package/imageformats/*.dll "package/"

.ci/scripts/windows/exec.sh

@@ -1,5 +0,0 @@
-#!/bin/bash -ex
-
-mkdir -p "ccache" || true
-chmod a+x ./.ci/scripts/windows/docker.sh
-docker run -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.ci/scripts/windows/docker.sh

.ci/scripts/windows/scan_dll.py

@@ -1,106 +0,0 @@
-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()

.ci/scripts/windows/upload.sh

@@ -1,13 +0,0 @@
-#!/bin/bash -ex
-
-. .ci/scripts/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"
-
-. .ci/scripts/common/post-upload.sh

.ci/templates/build-single.yml

@@ -1,21 +0,0 @@
-parameters:
-  artifactSource: 'true'
-
-steps:
-- task: DockerInstaller@0
-  displayName: 'Prepare Environment'
-  inputs:
-    dockerVersion: '17.09.0-ce'
-- task: CacheBeta@0
-  displayName: 'Cache Build System'
-  inputs:
-    key: yuzu-v1-$(BuildName)-$(BuildSuffix)-$(CacheSuffix)
-    path: $(System.DefaultWorkingDirectory)/ccache
-    cacheHitVar: CACHE_RESTORED
-- script: chmod a+x ./.ci/scripts/$(ScriptFolder)/exec.sh && ./.ci/scripts/$(ScriptFolder)/exec.sh
-  displayName: 'Build'
-- script: chmod a+x ./.ci/scripts/$(ScriptFolder)/upload.sh && ./.ci/scripts/$(ScriptFolder)/upload.sh
-  displayName: 'Package Artifacts'
-- publish: artifacts
-  artifact: 'yuzu-$(BuildName)-$(BuildSuffix)'
-  displayName: 'Upload Artifacts'

.ci/templates/build-standard.yml

@@ -1,22 +0,0 @@
-jobs:
-- job: build
-  displayName: 'standard'
-  pool:
-    vmImage: ubuntu-latest
-  strategy:
-    maxParallel: 10
-    matrix:
-      windows:
-        BuildSuffix: 'windows-mingw'
-        ScriptFolder: 'windows'
-      linux:
-        BuildSuffix: 'linux'
-        ScriptFolder: 'linux'
-  steps:
-  - template: ./sync-source.yml
-    parameters:
-      artifactSource: $(parameters.artifactSource)
-      needSubmodules: 'true'
-  - template: ./build-single.yml
-    parameters:
-      artifactSource: 'false'

.ci/templates/build-testing.yml

@@ -1,30 +0,0 @@
-jobs:
-- job: build_test
-  displayName: 'testing'
-  pool:
-    vmImage: ubuntu-latest
-  strategy:
-    maxParallel: 10
-    matrix:
-      windows:
-        BuildSuffix: 'windows-testing'
-        ScriptFolder: 'windows'
-  steps:
-  - task: PythonScript@0
-    condition: eq(variables['Build.Reason'], 'PullRequest')
-    displayName: 'Determine Testing Status'
-    inputs:
-      scriptSource: 'filePath'
-      scriptPath: '../scripts/merge/check-label-presence.py'
-      arguments: '$(System.PullRequest.PullRequestNumber) create-testing-build'
-  - ${{ if eq(variables.enabletesting, 'true') }}:
-    - template: ./sync-source.yml
-      parameters:
-        artifactSource: $(parameters.artifactSource)
-        needSubmodules: 'true'
-    - template: ./mergebot.yml
-      parameters:
-        matchLabel: 'testing-merge'
-    - template: ./build-single.yml
-      parameters:
-        artifactSource: 'false'

.ci/templates/format-check.yml

@@ -1,14 +0,0 @@
-parameters:
-  artifactSource: 'true'
-
-steps:
-- template: ./sync-source.yml
-  parameters:
-    artifactSource: $(parameters.artifactSource)
-    needSubmodules: 'false'
-- task: DockerInstaller@0
-  displayName: 'Prepare Environment'
-  inputs:
-    dockerVersion: '17.09.0-ce'
-- script: chmod a+x ./.ci/scripts/format/exec.sh && ./.ci/scripts/format/exec.sh
-  displayName: 'Verify Formatting'

.ci/templates/merge.yml

@@ -1,46 +0,0 @@
-jobs:
-- job: merge
-  displayName: 'pull requests'
-  steps:
-  - checkout: self
-    submodules: recursive
-  - template: ./mergebot.yml
-    parameters:
-      matchLabel: '$(BuildName)-merge'
-  - task: ArchiveFiles@2
-    displayName: 'Package Source'
-    inputs:
-      rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
-      includeRootFolder: false
-      archiveType: '7z'
-      archiveFile: '$(Build.ArtifactStagingDirectory)/yuzu-$(BuildName)-source.7z'
-  - task: PublishPipelineArtifact@1
-    displayName: 'Upload Artifacts'
-    inputs:
-      targetPath: '$(Build.ArtifactStagingDirectory)/yuzu-$(BuildName)-source.7z'
-      artifact: 'yuzu-$(BuildName)-source'
-      replaceExistingArchive: true
-- job: upload_source
-  displayName: 'upload'
-  dependsOn: merge
-  steps:
-  - template: ./sync-source.yml
-    parameters:
-      artifactSource: 'true'
-      needSubmodules: 'true'
-  - script: chmod a+x $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh && $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh
-    displayName: 'Apply Git Configuration'
-  - script: git tag -a $(BuildName)-$(Build.BuildId) -m "yuzu $(BuildName) $(Build.BuildNumber) $(Build.DefinitionName)"
-    displayName: 'Tag Source'
-  - script: git remote add other $(GitRepoPushChangesURL)
-    displayName: 'Register Repository'
-  - script: git push --follow-tags --force other HEAD:$(GitPushBranch)
-    displayName: 'Update Code'
-  - script: git rev-list -n 1 $(BuildName)-$(Build.BuildId) > $(Build.ArtifactStagingDirectory)/tag-commit.sha
-    displayName: 'Calculate Release Point'
-  - task: PublishPipelineArtifact@1
-    displayName: 'Upload Release Point'
-    inputs:
-      targetPath: '$(Build.ArtifactStagingDirectory)/tag-commit.sha'
-      artifact: 'yuzu-$(BuildName)-release-point'
-      replaceExistingArchive: true

.ci/templates/mergebot.yml

@@ -1,15 +0,0 @@
-parameters:
-  matchLabel: 'dummy-merge'
-
-steps:
-  - script: mkdir $(System.DefaultWorkingDirectory)/patches && pip install requests urllib3
-    displayName: 'Prepare Environment'
-  - script: chmod a+x $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh && $(System.DefaultWorkingDirectory)/.ci/scripts/merge/yuzubot-git-config.sh
-    displayName: 'Apply Git Configuration'
-  - task: PythonScript@0
-    displayName: 'Discover, Download, and Apply Patches'
-    inputs:
-      scriptSource: 'filePath'
-      scriptPath: '.ci/scripts/merge/apply-patches-by-label.py'
-      arguments: '${{ parameters.matchLabel }} patches'
-      workingDirectory: '$(System.DefaultWorkingDirectory)'

.ci/templates/retrieve-artifact-source.yml

@@ -1,16 +0,0 @@
-steps:
-- checkout: none
-- task: DownloadPipelineArtifact@2
-  displayName: 'Download Source'
-  inputs:
-    artifactName: 'yuzu-$(BuildName)-source'
-    buildType: 'current'
-    targetPath: '$(Build.ArtifactStagingDirectory)'
-- script: rm -rf $(System.DefaultWorkingDirectory) && mkdir $(System.DefaultWorkingDirectory)
-  displayName: 'Clean Working Directory'
-- task: ExtractFiles@1
-  displayName: 'Prepare Source'
-  inputs:
-    archiveFilePatterns: '$(Build.ArtifactStagingDirectory)/*.7z'
-    destinationFolder: '$(System.DefaultWorkingDirectory)'
-    cleanDestinationFolder: false

.ci/templates/retrieve-master-source.yml

@@ -1,11 +0,0 @@
-parameters:
-  needSubmodules: 'true'
-
-steps:
-- checkout: self
-  displayName: 'Checkout Recursive'
-  submodules: recursive
-#  condition: eq(parameters.needSubmodules, 'true')
-#- checkout: self
-#  displayName: 'Checkout Fast'
-#  condition: ne(parameters.needSubmodules, 'true')

.ci/templates/sync-source.yml

@@ -1,7 +0,0 @@
-steps:
-- ${{ if eq(parameters.artifactSource, 'true') }}:
-  - template: ./retrieve-artifact-source.yml
-- ${{ if ne(parameters.artifactSource, 'true') }}:
-  - template: ./retrieve-master-source.yml
-    parameters:
-      needSubmodules: $(parameters.needSubmodules)

.ci/yuzu-mainline.yml

@@ -1,23 +0,0 @@
-trigger:
-- master
-
-stages:
-- stage: merge
-  displayName: 'merge'
-  jobs:
-  - template: ./templates/merge.yml
-- stage: format
-  dependsOn: merge
-  displayName: 'format'
-  jobs:
-  - job: format
-    displayName: 'clang'
-    pool:
-      vmImage: ubuntu-latest
-    steps:
-    - template: ./templates/format-check.yml
-- stage: build
-  displayName: 'build'
-  dependsOn: format
-  jobs:
-  - template: ./templates/build-standard.yml

.ci/yuzu-patreon.yml

@@ -1,19 +0,0 @@
-# Starter pipeline
-# Start with a minimal pipeline that you can customize to build and deploy your code.
-# Add steps that build, run tests, deploy, and more:
-# https://aka.ms/yaml
-
-trigger:
-- master
-
-pool:
-  vmImage: 'ubuntu-latest'
-
-steps:
-- script: echo Hello, world!
-  displayName: 'Run a one-line script'
-
-- script: |
-    echo Add other tasks to build, test, and deploy your project.
-    echo See https://aka.ms/yaml
-  displayName: 'Run a multi-line script'

.ci/yuzu-repo-sync.yml

@@ -1,19 +0,0 @@
-trigger:
-- master
-
-jobs:
-- job: copy
-  displayName: 'Sync Repository'
-  pool:
-    vmImage: 'ubuntu-latest'
-  steps:
-  - script: echo 'https://$(GitUsername):$(GitAccessToken)@dev.azure.com' > $HOME/.git-credentials
-    displayName: 'Load Credentials'
-  - script: git config --global credential.helper store
-    displayName: 'Register Credential Helper'
-  - script: git remote add other $(GitRepoPushChangesURL)
-    displayName: 'Register Repository'
-  - script: git push --force other HEAD:$(GitPushBranch)
-    displayName: 'Update Code'
-  - script: rm -rf $HOME/.git-credentials
-    displayName: 'Clear Cached Credentials'

.ci/yuzu-verify.yml

@@ -1,18 +0,0 @@
-stages:
-- stage: format
-  displayName: 'format'
-  jobs:
-  - job: format
-    displayName: 'clang'
-    pool:
-      vmImage: ubuntu-latest
-    steps:
-    - template: ./templates/format-check.yml
-      parameters:
-        artifactSource: 'false'
-- stage: build
-  displayName: 'build'
-  dependsOn: format
-  jobs:
-  - template: ./templates/build-standard.yml
-  - template: ./templates/build-testing.yml

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-patreon: yuzuteam

CMakeLists.txt

@@ -132,7 +132,7 @@ find_package(Threads REQUIRED)
 if (ENABLE_SDL2)
     if (YUZU_USE_BUNDLED_SDL2)
         # Detect toolchain and platform
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
+        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
             set(SDL2_VER "SDL2-2.0.8")
         else()
             message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
@@ -165,7 +165,7 @@ if (YUZU_USE_BUNDLED_UNICORN)
     if (MSVC)
         message(STATUS "unicorn not found, falling back to bundled")
         # Detect toolchain and platform
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
+        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
             set(UNICORN_VER "unicorn-yuzu")
         else()
             message(FATAL_ERROR "No bundled Unicorn binaries for your toolchain. Disable YUZU_USE_BUNDLED_UNICORN and provide your own.")
@@ -233,7 +233,7 @@ endif()
 
 if (ENABLE_QT)
     if (YUZU_USE_BUNDLED_QT)
-        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
+        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1920) AND ARCHITECTURE_x86_64)
             set(QT_VER qt-5.12.0-msvc2017_64)
         else()
             message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")

CMakeModules/GenerateSCMRev.cmake

@@ -70,7 +70,6 @@ set(HASH_FILES
     "${VIDEO_CORE}/shader/decode/half_set.cpp"
     "${VIDEO_CORE}/shader/decode/half_set_predicate.cpp"
     "${VIDEO_CORE}/shader/decode/hfma2.cpp"
-    "${VIDEO_CORE}/shader/decode/image.cpp"
     "${VIDEO_CORE}/shader/decode/integer_set.cpp"
     "${VIDEO_CORE}/shader/decode/integer_set_predicate.cpp"
     "${VIDEO_CORE}/shader/decode/memory.cpp"
@@ -82,12 +81,7 @@ set(HASH_FILES
     "${VIDEO_CORE}/shader/decode/shift.cpp"
     "${VIDEO_CORE}/shader/decode/video.cpp"
     "${VIDEO_CORE}/shader/decode/xmad.cpp"
-    "${VIDEO_CORE}/shader/control_flow.cpp"
-    "${VIDEO_CORE}/shader/control_flow.h"
     "${VIDEO_CORE}/shader/decode.cpp"
-    "${VIDEO_CORE}/shader/node.h"
-    "${VIDEO_CORE}/shader/node_helper.cpp"
-    "${VIDEO_CORE}/shader/node_helper.h"
     "${VIDEO_CORE}/shader/shader_ir.cpp"
     "${VIDEO_CORE}/shader/shader_ir.h"
     "${VIDEO_CORE}/shader/track.cpp"

README.md

@@ -1,14 +1,13 @@
-yuzu  emulator
+yuzu emulator
 =============
 [![Travis CI Build Status](https://travis-ci.org/yuzu-emu/yuzu.svg?branch=master)](https://travis-ci.org/yuzu-emu/yuzu)
 [![AppVeyor CI Build Status](https://ci.appveyor.com/api/projects/status/77k97svb2usreu68?svg=true)](https://ci.appveyor.com/project/bunnei/yuzu)
-[![Azure Mainline CI Build Status](https://dev.azure.com/yuzu-emu/yuzu/_apis/build/status/yuzu%20mainline?branchName=master)](https://dev.azure.com/yuzu-emu/yuzu/)
 
 yuzu is an experimental open-source emulator for the Nintendo Switch from the creators of [Citra](https://citra-emu.org/).
 
 It is written in C++ with portability in mind, with builds actively maintained for Windows, Linux and macOS. The emulator is currently only useful for homebrew development and research purposes.
 
-yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. yuzu can boot some games, to varying degrees of success.
+yuzu only emulates a subset of Switch hardware and therefore is generally only useful for running/debugging homebrew applications. At this time, yuzu cannot play any commercial games without major problems. yuzu can boot some games, to varying degrees of success.
 
 yuzu is licensed under the GPLv2 (or any later version). Refer to the license.txt file included.
 

externals/CMakeLists.txt

@@ -7,10 +7,6 @@ include(DownloadExternals)
 add_library(catch-single-include INTERFACE)
 target_include_directories(catch-single-include INTERFACE catch/single_include)
 
-# libfmt
-add_subdirectory(fmt)
-add_library(fmt::fmt ALIAS fmt)
-
 # Dynarmic
 if (ARCHITECTURE_x86_64)
     set(DYNARMIC_TESTS OFF)
@@ -18,6 +14,10 @@ if (ARCHITECTURE_x86_64)
     add_subdirectory(dynarmic)
 endif()
 
+# libfmt
+add_subdirectory(fmt)
+add_library(fmt::fmt ALIAS fmt)
+
 # getopt
 if (MSVC)
     add_subdirectory(getopt)

externals/glad/include/KHR/khrplatform.h

@@ -90,20 +90,12 @@
  *                                  int arg2) KHRONOS_APIATTRIBUTES;
  */
 
-#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
-#   define KHRONOS_STATIC 1
-#endif
-
 /*-------------------------------------------------------------------------
  * Definition of KHRONOS_APICALL
  *-------------------------------------------------------------------------
  * This precedes the return type of the function in the function prototype.
  */
-#if defined(KHRONOS_STATIC)
-    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
-     * header compatible with static linking. */
-#   define KHRONOS_APICALL
-#elif defined(_WIN32)
+#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
 #   define KHRONOS_APICALL __declspec(dllimport)
 #elif defined (__SYMBIAN32__)
 #   define KHRONOS_APICALL IMPORT_C
@@ -119,7 +111,7 @@
  * This follows the return type of the function  and precedes the function
  * name in the function prototype.
  */
-#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(KHRONOS_STATIC)
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
     /* Win32 but not WinCE */
 #   define KHRONOS_APIENTRY __stdcall
 #else

src/CMakeLists.txt

@@ -21,29 +21,15 @@ if (MSVC)
     # Ensure that projects build with Unicode support.
     add_definitions(-DUNICODE -D_UNICODE)
 
-    # /W3                 - Level 3 warnings
-    # /MP                 - Multi-threaded compilation
-    # /Zi                 - Output debugging information
-    # /Zo                 - Enhanced debug info for optimized builds
-    # /permissive-        - Enables stricter C++ standards conformance checks
-    # /EHsc               - C++-only exception handling semantics
-    # /volatile:iso       - Use strict standards-compliant volatile semantics.
-    # /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
-    add_compile_options(
-        /W3
-        /MP
-        /Zi
-        /Zo
-        /permissive-
-        /EHsc
-        /std:c++latest
-        /volatile:iso
-        /Zc:externConstexpr
-        /Zc:inline
-        /Zc:throwingNew
-    )
+    # /W3 - Level 3 warnings
+    # /MP - Multi-threaded compilation
+    # /Zi - Output debugging information
+    # /Zo - enhanced debug info for optimized builds
+    # /permissive- - enables stricter C++ standards conformance checks
+    # /EHsc - C++-only exception handling semantics
+    # /Zc:throwingNew - let codegen assume `operator new` will never return null
+    # /Zc:inline - let codegen omit inline functions in object files
+    add_compile_options(/W3 /MP /Zi /Zo /permissive- /EHsc /std:c++latest /Zc:throwingNew,inline)
 
     # /GS- - No stack buffer overflow checks
     add_compile_options("$<$<CONFIG:Release>:/GS->")
@@ -51,10 +37,7 @@ if (MSVC)
     set(CMAKE_EXE_LINKER_FLAGS_DEBUG   "/DEBUG /MANIFEST:NO" CACHE STRING "" FORCE)
     set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/DEBUG /MANIFEST:NO /INCREMENTAL:NO /OPT:REF,ICF" CACHE STRING "" FORCE)
 else()
-    add_compile_options(
-        -Wall
-        -Wno-attributes
-    )
+    add_compile_options("-Wno-attributes")
 
     if (APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL Clang)
         add_compile_options("-stdlib=libc++")
@@ -88,7 +71,6 @@ add_subdirectory(tests)
 
 if (ENABLE_SDL2)
     add_subdirectory(yuzu_cmd)
-    add_subdirectory(yuzu_tester)
 endif()
 
 if (ENABLE_QT)

src/audio_core/audio_renderer.cpp

@@ -73,15 +73,13 @@ private:
     EffectInStatus info{};
 };
 AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, AudioRendererParameter params,
-                             Kernel::SharedPtr<Kernel::WritableEvent> buffer_event,
-                             std::size_t instance_number)
+                             Kernel::SharedPtr<Kernel::WritableEvent> buffer_event)
     : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count),
       effects(params.effect_count) {
 
     audio_out = std::make_unique<AudioCore::AudioOut>();
     stream = audio_out->OpenStream(core_timing, STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS,
-                                   fmt::format("AudioRenderer-Instance{}", instance_number),
-                                   [=]() { buffer_event->Signal(); });
+                                   "AudioRenderer", [=]() { buffer_event->Signal(); });
     audio_out->StartStream(stream);
 
     QueueMixedBuffer(0);
@@ -219,15 +217,13 @@ std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(std::size_t sample_co
     if (offset == samples.size()) {
         offset = 0;
 
-        if (!wave_buffer.is_looping && wave_buffer.buffer_sz) {
+        if (!wave_buffer.is_looping) {
             SetWaveIndex(wave_index + 1);
         }
 
-        if (wave_buffer.buffer_sz) {
-            out_status.wave_buffer_consumed++;
-        }
+        out_status.wave_buffer_consumed++;
 
-        if (wave_buffer.end_of_stream || wave_buffer.buffer_sz == 0) {
+        if (wave_buffer.end_of_stream) {
             info.play_state = PlayState::Paused;
         }
     }

src/audio_core/audio_renderer.h

@@ -215,8 +215,7 @@ static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size
 class AudioRenderer {
 public:
     AudioRenderer(Core::Timing::CoreTiming& core_timing, AudioRendererParameter params,
-                  Kernel::SharedPtr<Kernel::WritableEvent> buffer_event,
-                  std::size_t instance_number);
+                  Kernel::SharedPtr<Kernel::WritableEvent> buffer_event);
     ~AudioRenderer();
 
     std::vector<u8> UpdateAudioRenderer(const std::vector<u8>& input_params);

src/audio_core/stream.cpp

@@ -51,23 +51,17 @@ void Stream::Stop() {
     UNIMPLEMENTED();
 }
 
-void Stream::SetVolume(float volume) {
-    game_volume = volume;
-}
-
 Stream::State Stream::GetState() const {
     return state;
 }
 
 s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
     const std::size_t num_samples{buffer.GetSamples().size() / GetNumChannels()};
-    const auto us =
-        std::chrono::microseconds((static_cast<u64>(num_samples) * 1000000) / sample_rate);
-    return Core::Timing::usToCycles(us);
+    return Core::Timing::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);
 }
 
-static void VolumeAdjustSamples(std::vector<s16>& samples, float game_volume) {
-    const float volume{std::clamp(Settings::values.volume - (1.0f - game_volume), 0.0f, 1.0f)};
+static void VolumeAdjustSamples(std::vector<s16>& samples) {
+    const float volume{std::clamp(Settings::values.volume, 0.0f, 1.0f)};
 
     if (volume == 1.0f) {
         return;
@@ -101,11 +95,11 @@ void Stream::PlayNextBuffer() {
     active_buffer = queued_buffers.front();
     queued_buffers.pop();
 
-    VolumeAdjustSamples(active_buffer->GetSamples(), game_volume);
+    VolumeAdjustSamples(active_buffer->GetSamples());
 
     sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());
 
-    core_timing.ScheduleEvent(GetBufferReleaseCycles(*active_buffer), release_event, {});
+    core_timing.ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
 }
 
 void Stream::ReleaseActiveBuffer() {

src/audio_core/stream.h

@@ -61,12 +61,6 @@ public:
     /// Returns a vector of recently released buffers specified by tag
     std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(std::size_t max_count);
 
-    void SetVolume(float volume);
-
-    float GetVolume() const {
-        return game_volume;
-    }
-
     /// Returns true if the stream is currently playing
     bool IsPlaying() const {
         return state == State::Playing;
@@ -100,7 +94,6 @@ private:
 
     u32 sample_rate;                          ///< Sample rate of the stream
     Format format;                            ///< Format of the stream
-    float game_volume = 1.0f;                 ///< The volume the game currently has set
     ReleaseCallback release_callback;         ///< Buffer release callback for the stream
     State state{State::Stopped};              ///< Playback state of the stream
     Core::Timing::EventType* release_event{}; ///< Core timing release event for the stream

src/common/CMakeLists.txt

@@ -44,7 +44,6 @@ add_custom_command(OUTPUT scm_rev.cpp
       "${VIDEO_CORE}/shader/decode/half_set.cpp"
       "${VIDEO_CORE}/shader/decode/half_set_predicate.cpp"
       "${VIDEO_CORE}/shader/decode/hfma2.cpp"
-      "${VIDEO_CORE}/shader/decode/image.cpp"
       "${VIDEO_CORE}/shader/decode/integer_set.cpp"
       "${VIDEO_CORE}/shader/decode/integer_set_predicate.cpp"
       "${VIDEO_CORE}/shader/decode/memory.cpp"
@@ -56,12 +55,7 @@ add_custom_command(OUTPUT scm_rev.cpp
       "${VIDEO_CORE}/shader/decode/shift.cpp"
       "${VIDEO_CORE}/shader/decode/video.cpp"
       "${VIDEO_CORE}/shader/decode/xmad.cpp"
-      "${VIDEO_CORE}/shader/control_flow.cpp"
-      "${VIDEO_CORE}/shader/control_flow.h"
       "${VIDEO_CORE}/shader/decode.cpp"
-      "${VIDEO_CORE}/shader/node.h"
-      "${VIDEO_CORE}/shader/node_helper.cpp"
-      "${VIDEO_CORE}/shader/node_helper.h"
       "${VIDEO_CORE}/shader/shader_ir.cpp"
       "${VIDEO_CORE}/shader/shader_ir.h"
       "${VIDEO_CORE}/shader/track.cpp"
@@ -77,7 +71,6 @@ add_library(common STATIC
     assert.h
     detached_tasks.cpp
     detached_tasks.h
-    binary_find.h
     bit_field.h
     bit_util.h
     cityhash.cpp
@@ -130,8 +123,6 @@ add_library(common STATIC
     timer.h
     uint128.cpp
     uint128.h
-    uuid.cpp
-    uuid.h
     vector_math.h
     web_result.h
     zstd_compression.cpp

src/common/alignment.h

@@ -19,12 +19,6 @@ constexpr T AlignDown(T value, std::size_t size) {
     return static_cast<T>(value - value % size);
 }
 
-template <typename T>
-constexpr T AlignBits(T value, std::size_t align) {
-    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
-    return static_cast<T>((value + ((1ULL << align) - 1)) >> align << align);
-}
-
 template <typename T>
 constexpr bool Is4KBAligned(T value) {
     static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");

src/common/binary_find.h

@@ -1,21 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <algorithm>
-
-namespace Common {
-
-template <class ForwardIt, class T, class Compare = std::less<>>
-ForwardIt BinaryFind(ForwardIt first, ForwardIt last, const T& value, Compare comp = {}) {
-    // Note: BOTH type T and the type after ForwardIt is dereferenced
-    // must be implicitly convertible to BOTH Type1 and Type2, used in Compare.
-    // This is stricter than lower_bound requirement (see above)
-
-    first = std::lower_bound(first, last, value, comp);
-    return first != last && !comp(value, *first) ? first : last;
-}
-
-} // namespace Common

src/common/bit_util.h

@@ -97,48 +97,4 @@ inline u32 CountTrailingZeroes64(u64 value) {
 }
 #endif
 
-#ifdef _MSC_VER
-
-inline u32 MostSignificantBit32(const u32 value) {
-    unsigned long result;
-    _BitScanReverse(&result, value);
-    return static_cast<u32>(result);
-}
-
-inline u32 MostSignificantBit64(const u64 value) {
-    unsigned long result;
-    _BitScanReverse64(&result, value);
-    return static_cast<u32>(result);
-}
-
-#else
-
-inline u32 MostSignificantBit32(const u32 value) {
-    return 31U - static_cast<u32>(__builtin_clz(value));
-}
-
-inline u32 MostSignificantBit64(const u64 value) {
-    return 63U - static_cast<u32>(__builtin_clzll(value));
-}
-
-#endif
-
-inline u32 Log2Floor32(const u32 value) {
-    return MostSignificantBit32(value);
-}
-
-inline u32 Log2Ceil32(const u32 value) {
-    const u32 log2_f = Log2Floor32(value);
-    return log2_f + ((value ^ (1U << log2_f)) != 0U);
-}
-
-inline u32 Log2Floor64(const u64 value) {
-    return MostSignificantBit64(value);
-}
-
-inline u32 Log2Ceil64(const u64 value) {
-    const u64 log2_f = static_cast<u64>(Log2Floor64(value));
-    return static_cast<u32>(log2_f + ((value ^ (1ULL << log2_f)) != 0ULL));
-}
-
 } // namespace Common

src/common/common_funcs.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <algorithm>
 #include <string>
 
 #if !defined(ARCHITECTURE_x86_64)

src/common/file_util.cpp

@@ -78,17 +78,16 @@ namespace FileUtil {
 // Remove any ending forward slashes from directory paths
 // Modifies argument.
 static void StripTailDirSlashes(std::string& fname) {
-    if (fname.length() <= 1) {
-        return;
+    if (fname.length() > 1) {
+        std::size_t i = fname.length();
+        while (i > 0 && fname[i - 1] == DIR_SEP_CHR)
+            --i;
+        fname.resize(i);
     }
-
-    std::size_t i = fname.length();
-    while (i > 0 && fname[i - 1] == DIR_SEP_CHR) {
-        --i;
-    }
-    fname.resize(i);
+    return;
 }
 
+// Returns true if file filename exists
 bool Exists(const std::string& filename) {
     struct stat file_info;
 
@@ -108,6 +107,7 @@ bool Exists(const std::string& filename) {
     return (result == 0);
 }
 
+// Returns true if filename is a directory
 bool IsDirectory(const std::string& filename) {
     struct stat file_info;
 
@@ -132,6 +132,8 @@ bool IsDirectory(const std::string& filename) {
     return S_ISDIR(file_info.st_mode);
 }
 
+// Deletes a given filename, return true on success
+// Doesn't supports deleting a directory
 bool Delete(const std::string& filename) {
     LOG_TRACE(Common_Filesystem, "file {}", filename);
 
@@ -163,6 +165,7 @@ bool Delete(const std::string& filename) {
     return true;
 }
 
+// Returns true if successful, or path already exists.
 bool CreateDir(const std::string& path) {
     LOG_TRACE(Common_Filesystem, "directory {}", path);
 #ifdef _WIN32
@@ -191,6 +194,7 @@ bool CreateDir(const std::string& path) {
 #endif
 }
 
+// Creates the full path of fullPath returns true on success
 bool CreateFullPath(const std::string& fullPath) {
     int panicCounter = 100;
     LOG_TRACE(Common_Filesystem, "path {}", fullPath);
@@ -226,6 +230,7 @@ bool CreateFullPath(const std::string& fullPath) {
     }
 }
 
+// Deletes a directory filename, returns true on success
 bool DeleteDir(const std::string& filename) {
     LOG_TRACE(Common_Filesystem, "directory {}", filename);
 
@@ -247,6 +252,7 @@ bool DeleteDir(const std::string& filename) {
     return false;
 }
 
+// renames file srcFilename to destFilename, returns true on success
 bool Rename(const std::string& srcFilename, const std::string& destFilename) {
     LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
 #ifdef _WIN32
@@ -262,6 +268,7 @@ bool Rename(const std::string& srcFilename, const std::string& destFilename) {
     return false;
 }
 
+// copies file srcFilename to destFilename, returns true on success
 bool Copy(const std::string& srcFilename, const std::string& destFilename) {
     LOG_TRACE(Common_Filesystem, "{} --> {}", srcFilename, destFilename);
 #ifdef _WIN32
@@ -317,6 +324,7 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
 #endif
 }
 
+// Returns the size of filename (64bit)
 u64 GetSize(const std::string& filename) {
     if (!Exists(filename)) {
         LOG_ERROR(Common_Filesystem, "failed {}: No such file", filename);
@@ -343,6 +351,7 @@ u64 GetSize(const std::string& filename) {
     return 0;
 }
 
+// Overloaded GetSize, accepts file descriptor
 u64 GetSize(const int fd) {
     struct stat buf;
     if (fstat(fd, &buf) != 0) {
@@ -352,6 +361,7 @@ u64 GetSize(const int fd) {
     return buf.st_size;
 }
 
+// Overloaded GetSize, accepts FILE*
 u64 GetSize(FILE* f) {
     // can't use off_t here because it can be 32-bit
     u64 pos = ftello(f);
@@ -367,6 +377,7 @@ u64 GetSize(FILE* f) {
     return size;
 }
 
+// creates an empty file filename, returns true on success
 bool CreateEmptyFile(const std::string& filename) {
     LOG_TRACE(Common_Filesystem, "{}", filename);
 
@@ -491,6 +502,7 @@ bool DeleteDirRecursively(const std::string& directory, unsigned int recursion)
     return true;
 }
 
+// Create directory and copy contents (does not overwrite existing files)
 void CopyDir(const std::string& source_path, const std::string& dest_path) {
 #ifndef _WIN32
     if (source_path == dest_path)
@@ -527,7 +539,8 @@ void CopyDir(const std::string& source_path, const std::string& dest_path) {
 #endif
 }
 
-std::optional<std::string> GetCurrentDir() {
+// Returns the current directory
+std::string GetCurrentDir() {
 // Get the current working directory (getcwd uses malloc)
 #ifdef _WIN32
     wchar_t* dir;
@@ -537,7 +550,7 @@ std::optional<std::string> GetCurrentDir() {
     if (!(dir = getcwd(nullptr, 0))) {
 #endif
         LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: {}", GetLastErrorMsg());
-        return {};
+        return nullptr;
     }
 #ifdef _WIN32
     std::string strDir = Common::UTF16ToUTF8(dir);
@@ -548,6 +561,7 @@ std::optional<std::string> GetCurrentDir() {
     return strDir;
 }
 
+// Sets the current directory to the given directory
 bool SetCurrentDir(const std::string& directory) {
 #ifdef _WIN32
     return _wchdir(Common::UTF8ToUTF16W(directory).c_str()) == 0;
@@ -659,6 +673,8 @@ std::string GetSysDirectory() {
     return sysDir;
 }
 
+// Returns a string with a yuzu data dir or file in the user's home
+// directory. To be used in "multi-user" mode (that is, installed).
 const std::string& GetUserPath(UserPath path, const std::string& new_path) {
     static std::unordered_map<UserPath, std::string> paths;
     auto& user_path = paths[UserPath::UserDir];
@@ -746,11 +762,11 @@ std::string GetNANDRegistrationDir(bool system) {
     return GetUserPath(UserPath::NANDDir) + "user/Contents/registered/";
 }
 
-std::size_t WriteStringToFile(bool text_file, const std::string& filename, std::string_view str) {
-    return IOFile(filename, text_file ? "w" : "wb").WriteString(str);
+std::size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename) {
+    return FileUtil::IOFile(filename, text_file ? "w" : "wb").WriteBytes(str.data(), str.size());
 }
 
-std::size_t ReadFileToString(bool text_file, const std::string& filename, std::string& str) {
+std::size_t ReadFileToString(bool text_file, const char* filename, std::string& str) {
     IOFile file(filename, text_file ? "r" : "rb");
 
     if (!file.IsOpen())
@@ -760,6 +776,13 @@ std::size_t ReadFileToString(bool text_file, const std::string& filename, std::s
     return file.ReadArray(&str[0], str.size());
 }
 
+/**
+ * Splits the filename into 8.3 format
+ * Loosely implemented following https://en.wikipedia.org/wiki/8.3_filename
+ * @param filename The normal filename to use
+ * @param short_name A 9-char array in which the short name will be written
+ * @param extension A 4-char array in which the extension will be written
+ */
 void SplitFilename83(const std::string& filename, std::array<char, 9>& short_name,
                      std::array<char, 4>& extension) {
     const std::string forbidden_characters = ".\"/\\[]:;=, ";

src/common/file_util.h

@@ -9,7 +9,6 @@
 #include <fstream>
 #include <functional>
 #include <limits>
-#include <optional>
 #include <string>
 #include <string_view>
 #include <type_traits>
@@ -119,7 +118,7 @@ u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
 bool DeleteDirRecursively(const std::string& directory, unsigned int recursion = 256);
 
 // Returns the current directory
-std::optional<std::string> GetCurrentDir();
+std::string GetCurrentDir();
 
 // Create directory and copy contents (does not overwrite existing files)
 void CopyDir(const std::string& source_path, const std::string& dest_path);
@@ -147,9 +146,9 @@ const std::string& GetExeDirectory();
 std::string AppDataRoamingDirectory();
 #endif
 
-std::size_t WriteStringToFile(bool text_file, const std::string& filename, std::string_view str);
+std::size_t WriteStringToFile(bool text_file, const std::string& str, const char* filename);
 
-std::size_t ReadFileToString(bool text_file, const std::string& filename, std::string& str);
+std::size_t ReadFileToString(bool text_file, const char* filename, std::string& str);
 
 /**
  * Splits the filename into 8.3 format
@@ -258,8 +257,8 @@ public:
         return WriteArray(&object, 1);
     }
 
-    std::size_t WriteString(std::string_view str) {
-        return WriteArray(str.data(), str.length());
+    std::size_t WriteString(const std::string& str) {
+        return WriteArray(str.c_str(), str.length());
     }
 
     bool IsOpen() const {
@@ -287,8 +286,8 @@ private:
 template <typename T>
 void OpenFStream(T& fstream, const std::string& filename, std::ios_base::openmode openmode) {
 #ifdef _MSC_VER
-    fstream.open(Common::UTF8ToUTF16W(filename), openmode);
+    fstream.open(Common::UTF8ToUTF16W(filename).c_str(), openmode);
 #else
-    fstream.open(filename, openmode);
+    fstream.open(filename.c_str(), openmode);
 #endif
 }

src/common/hex_util.cpp

@@ -30,6 +30,13 @@ std::vector<u8> HexStringToVector(std::string_view str, bool little_endian) {
     return out;
 }
 
+std::string HexVectorToString(const std::vector<u8>& vector, bool upper) {
+    std::string out;
+    for (u8 c : vector)
+        out += fmt::format(upper ? "{:02X}" : "{:02x}", c);
+    return out;
+}
+
 std::array<u8, 16> operator""_array16(const char* str, std::size_t len) {
     if (len != 32) {
         LOG_ERROR(Common,

src/common/hex_util.h

@@ -7,7 +7,6 @@
 #include <array>
 #include <cstddef>
 #include <string>
-#include <type_traits>
 #include <vector>
 #include <fmt/format.h>
 #include "common/common_types.h"
@@ -31,20 +30,13 @@ std::array<u8, Size> HexStringToArray(std::string_view str) {
     return out;
 }
 
-template <typename ContiguousContainer>
-std::string HexToString(const ContiguousContainer& data, bool upper = true) {
-    static_assert(std::is_same_v<typename ContiguousContainer::value_type, u8>,
-                  "Underlying type within the contiguous container must be u8.");
-
-    constexpr std::size_t pad_width = 2;
+std::string HexVectorToString(const std::vector<u8>& vector, bool upper = true);
 
+template <std::size_t Size>
+std::string HexArrayToString(std::array<u8, Size> array, bool upper = true) {
     std::string out;
-    out.reserve(std::size(data) * pad_width);
-
-    for (const u8 c : data) {
+    for (u8 c : array)
         out += fmt::format(upper ? "{:02X}" : "{:02x}", c);
-    }
-
     return out;
 }
 

src/common/math_util.h

@@ -41,7 +41,4 @@ struct Rectangle {
     }
 };
 
-template <typename T>
-Rectangle(T, T, T, T)->Rectangle<T>;
-
 } // namespace Common

src/common/uuid.cpp

@@ -1,33 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <random>
-
-#include <fmt/format.h>
-
-#include "common/uuid.h"
-
-namespace Common {
-
-UUID UUID::Generate() {
-    std::random_device device;
-    std::mt19937 gen(device());
-    std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
-    return UUID{distribution(gen), distribution(gen)};
-}
-
-std::string UUID::Format() const {
-    return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
-}
-
-std::string UUID::FormatSwitch() const {
-    std::array<u8, 16> s{};
-    std::memcpy(s.data(), uuid.data(), sizeof(u128));
-    return fmt::format("{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{"
-                       ":02x}{:02x}{:02x}{:02x}{:02x}",
-                       s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], s[10], s[11],
-                       s[12], s[13], s[14], s[15]);
-}
-
-} // namespace Common

src/common/uuid.h

@@ -1,48 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-
-#include "common/common_types.h"
-
-namespace Common {
-
-constexpr u128 INVALID_UUID{{0, 0}};
-
-struct UUID {
-    // UUIDs which are 0 are considered invalid!
-    u128 uuid = INVALID_UUID;
-    constexpr UUID() = default;
-    constexpr explicit UUID(const u128& id) : uuid{id} {}
-    constexpr explicit UUID(const u64 lo, const u64 hi) : uuid{{lo, hi}} {}
-
-    constexpr explicit operator bool() const {
-        return uuid[0] != INVALID_UUID[0] && uuid[1] != INVALID_UUID[1];
-    }
-
-    constexpr bool operator==(const UUID& rhs) const {
-        // TODO(DarkLordZach): Replace with uuid == rhs.uuid with C++20
-        return uuid[0] == rhs.uuid[0] && uuid[1] == rhs.uuid[1];
-    }
-
-    constexpr bool operator!=(const UUID& rhs) const {
-        return !operator==(rhs);
-    }
-
-    // TODO(ogniK): Properly generate uuids based on RFC-4122
-    static UUID Generate();
-
-    // Set the UUID to {0,0} to be considered an invalid user
-    constexpr void Invalidate() {
-        uuid = INVALID_UUID;
-    }
-
-    std::string Format() const;
-    std::string FormatSwitch() const;
-};
-static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
-
-} // namespace Common

src/core/CMakeLists.txt

@@ -5,8 +5,6 @@ add_library(core STATIC
     arm/exclusive_monitor.h
     arm/unicorn/arm_unicorn.cpp
     arm/unicorn/arm_unicorn.h
-    constants.cpp
-    constants.h
     core.cpp
     core.h
     core_cpu.cpp
@@ -45,8 +43,6 @@ add_library(core STATIC
     file_sys/fsmitm_romfsbuild.h
     file_sys/ips_layer.cpp
     file_sys/ips_layer.h
-    file_sys/kernel_executable.cpp
-    file_sys/kernel_executable.h
     file_sys/mode.h
     file_sys/nca_metadata.cpp
     file_sys/nca_metadata.h
@@ -175,7 +171,6 @@ add_library(core STATIC
     hle/service/acc/acc_u0.h
     hle/service/acc/acc_u1.cpp
     hle/service/acc/acc_u1.h
-    hle/service/acc/errors.h
     hle/service/acc/profile_manager.cpp
     hle/service/acc/profile_manager.h
     hle/service/am/am.cpp
@@ -208,10 +203,10 @@ add_library(core STATIC
     hle/service/aoc/aoc_u.h
     hle/service/apm/apm.cpp
     hle/service/apm/apm.h
-    hle/service/apm/controller.cpp
-    hle/service/apm/controller.h
     hle/service/apm/interface.cpp
     hle/service/apm/interface.h
+    hle/service/arp/arp.cpp
+    hle/service/arp/arp.h
     hle/service/audio/audctl.cpp
     hle/service/audio/audctl.h
     hle/service/audio/auddbg.cpp
@@ -273,20 +268,10 @@ add_library(core STATIC
     hle/service/filesystem/fsp_srv.h
     hle/service/fgm/fgm.cpp
     hle/service/fgm/fgm.h
-    hle/service/friend/errors.h
     hle/service/friend/friend.cpp
     hle/service/friend/friend.h
     hle/service/friend/interface.cpp
     hle/service/friend/interface.h
-    hle/service/glue/arp.cpp
-    hle/service/glue/arp.h
-    hle/service/glue/bgtc.cpp
-    hle/service/glue/bgtc.h
-    hle/service/glue/errors.h
-    hle/service/glue/glue.cpp
-    hle/service/glue/glue.h
-    hle/service/glue/manager.cpp
-    hle/service/glue/manager.h
     hle/service/grc/grc.cpp
     hle/service/grc/grc.h
     hle/service/hid/hid.cpp
@@ -295,7 +280,6 @@ add_library(core STATIC
     hle/service/hid/irs.h
     hle/service/hid/xcd.cpp
     hle/service/hid/xcd.h
-    hle/service/hid/errors.h
     hle/service/hid/controllers/controller_base.cpp
     hle/service/hid/controllers/controller_base.h
     hle/service/hid/controllers/debug_pad.cpp
@@ -326,8 +310,6 @@ add_library(core STATIC
     hle/service/mig/mig.h
     hle/service/mii/mii.cpp
     hle/service/mii/mii.h
-    hle/service/mii/mii_manager.cpp
-    hle/service/mii/mii_manager.h
     hle/service/mm/mm_u.cpp
     hle/service/mm/mm_u.h
     hle/service/ncm/ncm.cpp
@@ -344,9 +326,6 @@ add_library(core STATIC
     hle/service/nim/nim.h
     hle/service/npns/npns.cpp
     hle/service/npns/npns.h
-    hle/service/ns/errors.h
-    hle/service/ns/language.cpp
-    hle/service/ns/language.h
     hle/service/ns/ns.cpp
     hle/service/ns/ns.h
     hle/service/ns/pl_u.cpp
@@ -434,8 +413,6 @@ add_library(core STATIC
     hle/service/time/interface.h
     hle/service/time/time.cpp
     hle/service/time/time.h
-    hle/service/time/time_sharedmemory.cpp
-    hle/service/time/time_sharedmemory.h
     hle/service/usb/usb.cpp
     hle/service/usb/usb.h
     hle/service/vi/display/vi_display.cpp
@@ -456,8 +433,6 @@ add_library(core STATIC
     loader/deconstructed_rom_directory.h
     loader/elf.cpp
     loader/elf.h
-    loader/kip.cpp
-    loader/kip.h
     loader/loader.cpp
     loader/loader.h
     loader/nax.cpp
@@ -477,20 +452,19 @@ add_library(core STATIC
     memory_setup.h
     perf_stats.cpp
     perf_stats.h
-    reporter.cpp
-    reporter.h
     settings.cpp
     settings.h
     telemetry_session.cpp
     telemetry_session.h
-    tools/freezer.cpp
-    tools/freezer.h
+    tracer/citrace.h
+    tracer/recorder.cpp
+    tracer/recorder.h
 )
 
 create_target_directory_groups(core)
 
 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt json-headers mbedtls opus unicorn open_source_archives)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt mbedtls opus unicorn open_source_archives)
 if (ENABLE_WEB_SERVICE)
     target_compile_definitions(core PRIVATE -DENABLE_WEB_SERVICE)
     target_link_libraries(core PRIVATE web_service)

src/core/arm/arm_interface.cpp

@@ -2,213 +2,26 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <map>
-#include <optional>
-#include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/arm/arm_interface.h"
-#include "core/core.h"
-#include "core/loader/loader.h"
 #include "core/memory.h"
 
 namespace Core {
+void ARM_Interface::LogBacktrace() const {
+    VAddr fp = GetReg(29);
+    VAddr lr = GetReg(30);
+    const VAddr sp = GetReg(13);
+    const VAddr pc = GetPC();
 
-namespace {
-
-constexpr u64 ELF_DYNAMIC_TAG_NULL = 0;
-constexpr u64 ELF_DYNAMIC_TAG_STRTAB = 5;
-constexpr u64 ELF_DYNAMIC_TAG_SYMTAB = 6;
-constexpr u64 ELF_DYNAMIC_TAG_SYMENT = 11;
-
-enum class ELFSymbolType : u8 {
-    None = 0,
-    Object = 1,
-    Function = 2,
-    Section = 3,
-    File = 4,
-    Common = 5,
-    TLS = 6,
-};
-
-enum class ELFSymbolBinding : u8 {
-    Local = 0,
-    Global = 1,
-    Weak = 2,
-};
-
-enum class ELFSymbolVisibility : u8 {
-    Default = 0,
-    Internal = 1,
-    Hidden = 2,
-    Protected = 3,
-};
-
-struct ELFSymbol {
-    u32 name_index;
-    union {
-        u8 info;
-
-        BitField<0, 4, ELFSymbolType> type;
-        BitField<4, 4, ELFSymbolBinding> binding;
-    };
-    ELFSymbolVisibility visibility;
-    u16 sh_index;
-    u64 value;
-    u64 size;
-};
-static_assert(sizeof(ELFSymbol) == 0x18, "ELFSymbol has incorrect size.");
-
-using Symbols = std::vector<std::pair<ELFSymbol, std::string>>;
-
-Symbols GetSymbols(VAddr text_offset) {
-    const auto mod_offset = text_offset + Memory::Read32(text_offset + 4);
-
-    if (mod_offset < text_offset || (mod_offset & 0b11) != 0 ||
-        Memory::Read32(mod_offset) != Common::MakeMagic('M', 'O', 'D', '0')) {
-        return {};
-    }
-
-    const auto dynamic_offset = Memory::Read32(mod_offset + 0x4) + mod_offset;
-
-    VAddr string_table_offset{};
-    VAddr symbol_table_offset{};
-    u64 symbol_entry_size{};
-
-    VAddr dynamic_index = dynamic_offset;
+    LOG_ERROR(Core_ARM, "Backtrace, sp={:016X}, pc={:016X}", sp, pc);
     while (true) {
-        const auto tag = Memory::Read64(dynamic_index);
-        const auto value = Memory::Read64(dynamic_index + 0x8);
-        dynamic_index += 0x10;
-
-        if (tag == ELF_DYNAMIC_TAG_NULL) {
-            break;
-        }
-
-        if (tag == ELF_DYNAMIC_TAG_STRTAB) {
-            string_table_offset = value;
-        } else if (tag == ELF_DYNAMIC_TAG_SYMTAB) {
-            symbol_table_offset = value;
-        } else if (tag == ELF_DYNAMIC_TAG_SYMENT) {
-            symbol_entry_size = value;
-        }
-    }
-
-    if (string_table_offset == 0 || symbol_table_offset == 0 || symbol_entry_size == 0) {
-        return {};
-    }
-
-    const auto string_table_address = text_offset + string_table_offset;
-    const auto symbol_table_address = text_offset + symbol_table_offset;
-
-    Symbols out;
-
-    VAddr symbol_index = symbol_table_address;
-    while (symbol_index < string_table_address) {
-        ELFSymbol symbol{};
-        Memory::ReadBlock(symbol_index, &symbol, sizeof(ELFSymbol));
-
-        VAddr string_offset = string_table_address + symbol.name_index;
-        std::string name;
-        for (u8 c = Memory::Read8(string_offset); c != 0; c = Memory::Read8(++string_offset)) {
-            name += static_cast<char>(c);
-        }
-
-        symbol_index += symbol_entry_size;
-        out.push_back({symbol, name});
-    }
-
-    return out;
-}
-
-std::optional<std::string> GetSymbolName(const Symbols& symbols, VAddr func_address) {
-    const auto iter =
-        std::find_if(symbols.begin(), symbols.end(), [func_address](const auto& pair) {
-            const auto& [symbol, name] = pair;
-            const auto end_address = symbol.value + symbol.size;
-            return func_address >= symbol.value && func_address < end_address;
-        });
-
-    if (iter == symbols.end()) {
-        return std::nullopt;
-    }
-
-    return iter->second;
-}
-
-} // Anonymous namespace
-
-constexpr u64 SEGMENT_BASE = 0x7100000000ull;
-
-std::vector<ARM_Interface::BacktraceEntry> ARM_Interface::GetBacktrace() const {
-    std::vector<BacktraceEntry> out;
-
-    auto fp = GetReg(29);
-    auto lr = GetReg(30);
-
-    while (true) {
-        out.push_back({"", 0, lr, 0});
+        LOG_ERROR(Core_ARM, "{:016X}", lr);
         if (!fp) {
             break;
         }
         lr = Memory::Read64(fp + 8) - 4;
         fp = Memory::Read64(fp);
     }
-
-    std::map<VAddr, std::string> modules;
-    auto& loader{System::GetInstance().GetAppLoader()};
-    if (loader.ReadNSOModules(modules) != Loader::ResultStatus::Success) {
-        return {};
-    }
-
-    std::map<std::string, Symbols> symbols;
-    for (const auto& module : modules) {
-        symbols.insert_or_assign(module.second, GetSymbols(module.first));
-    }
-
-    for (auto& entry : out) {
-        VAddr base = 0;
-        for (auto iter = modules.rbegin(); iter != modules.rend(); ++iter) {
-            const auto& module{*iter};
-            if (entry.original_address >= module.first) {
-                entry.module = module.second;
-                base = module.first;
-                break;
-            }
-        }
-
-        entry.offset = entry.original_address - base;
-        entry.address = SEGMENT_BASE + entry.offset;
-
-        if (entry.module.empty())
-            entry.module = "unknown";
-
-        const auto symbol_set = symbols.find(entry.module);
-        if (symbol_set != symbols.end()) {
-            const auto symbol = GetSymbolName(symbol_set->second, entry.offset);
-            if (symbol.has_value()) {
-                // TODO(DarkLordZach): Add demangling of symbol names.
-                entry.name = *symbol;
-            }
-        }
-    }
-
-    return out;
 }
-
-void ARM_Interface::LogBacktrace() const {
-    const VAddr sp = GetReg(13);
-    const VAddr pc = GetPC();
-    LOG_ERROR(Core_ARM, "Backtrace, sp={:016X}, pc={:016X}", sp, pc);
-    LOG_ERROR(Core_ARM, "{:20}{:20}{:20}{:20}{}", "Module Name", "Address", "Original Address",
-              "Offset", "Symbol");
-    LOG_ERROR(Core_ARM, "");
-
-    const auto backtrace = GetBacktrace();
-    for (const auto& entry : backtrace) {
-        LOG_ERROR(Core_ARM, "{:20}{:016X}    {:016X}    {:016X}    {}", entry.module, entry.address,
-                  entry.original_address, entry.offset, entry.name);
-    }
-}
-
 } // namespace Core

src/core/arm/arm_interface.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <array>
-#include <vector>
 #include "common/common_types.h"
 
 namespace Common {
@@ -44,6 +43,13 @@ public:
     /// Step CPU by one instruction
     virtual void Step() = 0;
 
+    /// Maps a backing memory region for the CPU
+    virtual void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
+                                  Kernel::VMAPermission perms) = 0;
+
+    /// Unmaps a region of memory that was previously mapped using MapBackingMemory
+    virtual void UnmapMemory(VAddr address, std::size_t size) = 0;
+
     /// Clear all instruction cache
     virtual void ClearInstructionCache() = 0;
 
@@ -146,16 +152,6 @@ public:
     /// Prepare core for thread reschedule (if needed to correctly handle state)
     virtual void PrepareReschedule() = 0;
 
-    struct BacktraceEntry {
-        std::string module;
-        u64 address;
-        u64 original_address;
-        u64 offset;
-        std::string name;
-    };
-
-    std::vector<BacktraceEntry> GetBacktrace() const;
-
     /// fp (= r29) points to the last frame record.
     /// Note that this is the frame record for the *previous* frame, not the current one.
     /// Note we need to subtract 4 from our last read to get the proper address

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -177,6 +177,15 @@ ARM_Dynarmic::ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor,
 
 ARM_Dynarmic::~ARM_Dynarmic() = default;
 
+void ARM_Dynarmic::MapBackingMemory(u64 address, std::size_t size, u8* memory,
+                                    Kernel::VMAPermission perms) {
+    inner_unicorn.MapBackingMemory(address, size, memory, perms);
+}
+
+void ARM_Dynarmic::UnmapMemory(u64 address, std::size_t size) {
+    inner_unicorn.UnmapMemory(address, size);
+}
+
 void ARM_Dynarmic::SetPC(u64 pc) {
     jit->SetPC(pc);
 }

src/core/arm/dynarmic/arm_dynarmic.h

@@ -23,6 +23,9 @@ public:
     ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor, std::size_t core_index);
     ~ARM_Dynarmic() override;
 
+    void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
+                          Kernel::VMAPermission perms) override;
+    void UnmapMemory(u64 address, std::size_t size) override;
     void SetPC(u64 pc) override;
     u64 GetPC() const override;
     u64 GetReg(int index) const override;

src/core/arm/unicorn/arm_unicorn.cpp

@@ -50,14 +50,11 @@ static void CodeHook(uc_engine* uc, uint64_t address, uint32_t size, void* user_
 
 static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int size, u64 value,
                                void* user_data) {
-    auto* const system = static_cast<System*>(user_data);
-
     ARM_Interface::ThreadContext ctx{};
-    system->CurrentArmInterface().SaveContext(ctx);
+    Core::CurrentArmInterface().SaveContext(ctx);
     ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x{:X}, pc=0x{:X}, lr=0x{:X}", addr,
                ctx.pc, ctx.cpu_registers[30]);
-
-    return false;
+    return {};
 }
 
 ARM_Unicorn::ARM_Unicorn(System& system) : system{system} {
@@ -68,7 +65,7 @@ ARM_Unicorn::ARM_Unicorn(System& system) : system{system} {
 
     uc_hook hook{};
     CHECKED(uc_hook_add(uc, &hook, UC_HOOK_INTR, (void*)InterruptHook, this, 0, -1));
-    CHECKED(uc_hook_add(uc, &hook, UC_HOOK_MEM_INVALID, (void*)UnmappedMemoryHook, &system, 0, -1));
+    CHECKED(uc_hook_add(uc, &hook, UC_HOOK_MEM_INVALID, (void*)UnmappedMemoryHook, this, 0, -1));
     if (GDBStub::IsServerEnabled()) {
         CHECKED(uc_hook_add(uc, &hook, UC_HOOK_CODE, (void*)CodeHook, this, 0, -1));
         last_bkpt_hit = false;
@@ -79,6 +76,15 @@ ARM_Unicorn::~ARM_Unicorn() {
     CHECKED(uc_close(uc));
 }
 
+void ARM_Unicorn::MapBackingMemory(VAddr address, std::size_t size, u8* memory,
+                                   Kernel::VMAPermission perms) {
+    CHECKED(uc_mem_map_ptr(uc, address, size, static_cast<u32>(perms), memory));
+}
+
+void ARM_Unicorn::UnmapMemory(VAddr address, std::size_t size) {
+    CHECKED(uc_mem_unmap(uc, address, size));
+}
+
 void ARM_Unicorn::SetPC(u64 pc) {
     CHECKED(uc_reg_write(uc, UC_ARM64_REG_PC, &pc));
 }

src/core/arm/unicorn/arm_unicorn.h

@@ -18,6 +18,9 @@ public:
     explicit ARM_Unicorn(System& system);
     ~ARM_Unicorn() override;
 
+    void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
+                          Kernel::VMAPermission perms) override;
+    void UnmapMemory(VAddr address, std::size_t size) override;
     void SetPC(u64 pc) override;
     u64 GetPC() const override;
     u64 GetReg(int index) const override;

src/core/constants.cpp

@@ -1,17 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/constants.h"
-
-namespace Core::Constants {
-const std::array<u8, 107> ACCOUNT_BACKUP_JPEG{{
-    0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02,
-    0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x06, 0x06, 0x05,
-    0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a, 0x0c, 0x0f, 0x0c, 0x0a, 0x0b, 0x0e,
-    0x0b, 0x09, 0x09, 0x0d, 0x11, 0x0d, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x10, 0x0a, 0x0c, 0x12, 0x13,
-    0x12, 0x10, 0x13, 0x0f, 0x10, 0x10, 0x10, 0xff, 0xc9, 0x00, 0x0b, 0x08, 0x00, 0x01, 0x00, 0x01,
-    0x01, 0x01, 0x11, 0x00, 0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08,
-    0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
-}};
-}

src/core/constants.h

@@ -1,17 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-
-// This is to consolidate system-wide constants that are used by multiple components of yuzu.
-// This is especially to prevent the case of something in frontend duplicating a constexpr array or
-// directly including some service header for the sole purpose of data.
-namespace Core::Constants {
-
-// ACC Service - Blank JPEG used as user icon in absentia of real one.
-extern const std::array<u8, 107> ACCOUNT_BACKUP_JPEG;
-
-} // namespace Core::Constants

src/core/core.cpp

@@ -18,6 +18,11 @@
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
+#include "core/frontend/applets/error.h"
+#include "core/frontend/applets/general_frontend.h"
+#include "core/frontend/applets/profile_select.h"
+#include "core/frontend/applets/software_keyboard.h"
+#include "core/frontend/applets/web_browser.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
@@ -25,48 +30,22 @@
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/service/am/applets/applets.h"
-#include "core/hle/service/apm/controller.h"
-#include "core/hle/service/glue/manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/loader/loader.h"
 #include "core/perf_stats.h"
-#include "core/reporter.h"
 #include "core/settings.h"
 #include "core/telemetry_session.h"
-#include "core/tools/freezer.h"
 #include "file_sys/cheat_engine.h"
-#include "file_sys/patch_manager.h"
+#include "frontend/applets/profile_select.h"
+#include "frontend/applets/software_keyboard.h"
+#include "frontend/applets/web_browser.h"
 #include "video_core/debug_utils/debug_utils.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 
 namespace Core {
 
-namespace {
-
-FileSys::StorageId GetStorageIdForFrontendSlot(
-    std::optional<FileSys::ContentProviderUnionSlot> slot) {
-    if (!slot.has_value()) {
-        return FileSys::StorageId::None;
-    }
-
-    switch (*slot) {
-    case FileSys::ContentProviderUnionSlot::UserNAND:
-        return FileSys::StorageId::NandUser;
-    case FileSys::ContentProviderUnionSlot::SysNAND:
-        return FileSys::StorageId::NandSystem;
-    case FileSys::ContentProviderUnionSlot::SDMC:
-        return FileSys::StorageId::SdCard;
-    case FileSys::ContentProviderUnionSlot::FrontendManual:
-        return FileSys::StorageId::Host;
-    default:
-        return FileSys::StorageId::None;
-    }
-}
-
-} // Anonymous namespace
-
 /*static*/ System System::s_instance;
 
 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
@@ -103,7 +82,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
     return vfs->OpenFile(path, FileSys::Mode::Read);
 }
 struct System::Impl {
-    explicit Impl(System& system) : kernel{system}, cpu_core_manager{system}, reporter{system} {}
+    explicit Impl(System& system) : kernel{system}, cpu_core_manager{system} {}
 
     Cpu& CurrentCpuCore() {
         return cpu_core_manager.GetCurrentCore();
@@ -138,13 +117,10 @@ struct System::Impl {
         /// Create default implementations of applets if one is not provided.
         applet_manager.SetDefaultAppletsIfMissing();
 
-        /// Reset all glue registrations
-        arp_manager.ResetAll();
-
         telemetry_session = std::make_unique<Core::TelemetrySession>();
         service_manager = std::make_shared<Service::SM::ServiceManager>();
 
-        Service::Init(service_manager, system);
+        Service::Init(service_manager, system, *virtual_filesystem);
         GDBStub::Init();
 
         renderer = VideoCore::CreateRenderer(emu_window, system);
@@ -168,10 +144,20 @@ struct System::Impl {
     ResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
                       const std::string& filepath) {
         app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
+
         if (!app_loader) {
             LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
             return ResultStatus::ErrorGetLoader;
         }
+        std::pair<std::optional<u32>, Loader::ResultStatus> system_mode =
+            app_loader->LoadKernelSystemMode();
+
+        if (system_mode.second != Loader::ResultStatus::Success) {
+            LOG_CRITICAL(Core, "Failed to determine system mode (Error {})!",
+                         static_cast<int>(system_mode.second));
+
+            return ResultStatus::ErrorSystemMode;
+        }
 
         ResultStatus init_result{Init(system, emu_window)};
         if (init_result != ResultStatus::Success) {
@@ -181,9 +167,7 @@ struct System::Impl {
             return init_result;
         }
 
-        telemetry_session->AddInitialInfo(*app_loader);
-        auto main_process =
-            Kernel::Process::Create(system, "main", Kernel::Process::ProcessType::Userland);
+        auto main_process = Kernel::Process::Create(system, "main");
         const auto [load_result, load_parameters] = app_loader->Load(*main_process);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
@@ -192,7 +176,6 @@ struct System::Impl {
             return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
                                              static_cast<u32>(load_result));
         }
-        AddGlueRegistrationForProcess(*app_loader, *main_process);
         kernel.MakeCurrentProcess(main_process.get());
 
         // Main process has been loaded and been made current.
@@ -251,31 +234,6 @@ struct System::Impl {
         return app_loader->ReadTitle(out);
     }
 
-    void AddGlueRegistrationForProcess(Loader::AppLoader& loader, Kernel::Process& process) {
-        std::vector<u8> nacp_data;
-        FileSys::NACP nacp;
-        if (loader.ReadControlData(nacp) == Loader::ResultStatus::Success) {
-            nacp_data = nacp.GetRawBytes();
-        } else {
-            nacp_data.resize(sizeof(FileSys::RawNACP));
-        }
-
-        Service::Glue::ApplicationLaunchProperty launch{};
-        launch.title_id = process.GetTitleID();
-
-        FileSys::PatchManager pm{launch.title_id};
-        launch.version = pm.GetGameVersion().value_or(0);
-
-        // TODO(DarkLordZach): When FSController/Game Card Support is added, if
-        // current_process_game_card use correct StorageId
-        launch.base_game_storage_id = GetStorageIdForFrontendSlot(content_provider->GetSlotForEntry(
-            launch.title_id, FileSys::ContentRecordType::Program));
-        launch.update_storage_id = GetStorageIdForFrontendSlot(content_provider->GetSlotForEntry(
-            FileSys::GetUpdateTitleID(launch.title_id), FileSys::ContentRecordType::Program));
-
-        arp_manager.Register(launch.title_id, launch, std::move(nacp_data));
-    }
-
     void SetStatus(ResultStatus new_status, const char* details = nullptr) {
         status = new_status;
         if (details) {
@@ -302,25 +260,16 @@ struct System::Impl {
     bool is_powered_on = false;
 
     std::unique_ptr<FileSys::CheatEngine> cheat_engine;
-    std::unique_ptr<Tools::Freezer> memory_freezer;
 
     /// Frontend applets
     Service::AM::Applets::AppletManager applet_manager;
 
-    /// APM (Performance) services
-    Service::APM::Controller apm_controller{core_timing};
-
-    /// Glue services
-    Service::Glue::ARPManager arp_manager;
-
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
 
     /// Telemetry session for this emulation session
     std::unique_ptr<Core::TelemetrySession> telemetry_session;
 
-    Reporter reporter;
-
     ResultStatus status = ResultStatus::Success;
     std::string status_details = "";
 
@@ -560,26 +509,6 @@ void System::ClearContentProvider(FileSys::ContentProviderUnionSlot slot) {
     impl->content_provider->ClearSlot(slot);
 }
 
-const Reporter& System::GetReporter() const {
-    return impl->reporter;
-}
-
-Service::Glue::ARPManager& System::GetARPManager() {
-    return impl->arp_manager;
-}
-
-const Service::Glue::ARPManager& System::GetARPManager() const {
-    return impl->arp_manager;
-}
-
-Service::APM::Controller& System::GetAPMController() {
-    return impl->apm_controller;
-}
-
-const Service::APM::Controller& System::GetAPMController() const {
-    return impl->apm_controller;
-}
-
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
     return impl->Init(*this, emu_window);
 }

src/core/core.h

@@ -8,7 +8,6 @@
 #include <memory>
 #include <string>
 
-#include <map>
 #include "common/common_types.h"
 #include "core/file_sys/vfs_types.h"
 #include "core/hle/kernel/object.h"
@@ -43,14 +42,6 @@ struct AppletFrontendSet;
 class AppletManager;
 } // namespace AM::Applets
 
-namespace APM {
-class Controller;
-}
-
-namespace Glue {
-class ARPManager;
-}
-
 namespace SM {
 class ServiceManager;
 } // namespace SM
@@ -77,7 +68,6 @@ class Cpu;
 class ExclusiveMonitor;
 class FrameLimiter;
 class PerfStats;
-class Reporter;
 class TelemetrySession;
 
 struct PerfStatsResults;
@@ -108,6 +98,7 @@ public:
         Success,             ///< Succeeded
         ErrorNotInitialized, ///< Error trying to use core prior to initialization
         ErrorGetLoader,      ///< Error finding the correct application loader
+        ErrorSystemMode,     ///< Error determining the system mode
         ErrorSystemFiles,    ///< Error in finding system files
         ErrorSharedFont,     ///< Error in finding shared font
         ErrorVideoCore,      ///< Error in the video core
@@ -294,16 +285,6 @@ public:
 
     void ClearContentProvider(FileSys::ContentProviderUnionSlot slot);
 
-    const Reporter& GetReporter() const;
-
-    Service::Glue::ARPManager& GetARPManager();
-
-    const Service::Glue::ARPManager& GetARPManager() const;
-
-    Service::APM::Controller& GetAPMController();
-
-    const Service::APM::Controller& GetAPMController() const;
-
 private:
     System();
 
@@ -327,6 +308,10 @@ private:
     static System s_instance;
 };
 
+inline ARM_Interface& CurrentArmInterface() {
+    return System::GetInstance().CurrentArmInterface();
+}
+
 inline Kernel::Process* CurrentProcess() {
     return System::GetInstance().CurrentProcess();
 }

src/core/core_cpu.cpp

@@ -53,12 +53,16 @@ bool CpuBarrier::Rendezvous() {
 Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
          std::size_t core_index)
     : cpu_barrier{cpu_barrier}, core_timing{system.CoreTiming()}, core_index{core_index} {
+    if (Settings::values.use_cpu_jit) {
 #ifdef ARCHITECTURE_x86_64
-    arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
+        arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
 #else
-    arm_interface = std::make_unique<ARM_Unicorn>(system);
-    LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
+        arm_interface = std::make_unique<ARM_Unicorn>(system);
+        LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
+    } else {
+        arm_interface = std::make_unique<ARM_Unicorn>(system);
+    }
 
     scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface);
 }
@@ -66,12 +70,15 @@ Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_ba
 Cpu::~Cpu() = default;
 
 std::unique_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(std::size_t num_cores) {
+    if (Settings::values.use_cpu_jit) {
 #ifdef ARCHITECTURE_x86_64
-    return std::make_unique<DynarmicExclusiveMonitor>(num_cores);
+        return std::make_unique<DynarmicExclusiveMonitor>(num_cores);
 #else
-    // TODO(merry): Passthrough exclusive monitor
-    return nullptr;
+        return nullptr; // TODO(merry): Passthrough exclusive monitor
 #endif
+    } else {
+        return nullptr; // TODO(merry): Passthrough exclusive monitor
+    }
 }
 
 void Cpu::RunLoop(bool tight_loop) {

src/core/core_timing.cpp

@@ -56,12 +56,12 @@ void CoreTiming::Initialize() {
 }
 
 void CoreTiming::Shutdown() {
+    MoveEvents();
     ClearPendingEvents();
     UnregisterAllEvents();
 }
 
 EventType* CoreTiming::RegisterEvent(const std::string& name, TimedCallback callback) {
-    std::lock_guard guard{inner_mutex};
     // check for existing type with same name.
     // we want event type names to remain unique so that we can use them for serialization.
     ASSERT_MSG(event_types.find(name) == event_types.end(),
@@ -82,7 +82,6 @@ void CoreTiming::UnregisterAllEvents() {
 
 void CoreTiming::ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata) {
     ASSERT(event_type != nullptr);
-    std::lock_guard guard{inner_mutex};
     const s64 timeout = GetTicks() + cycles_into_future;
 
     // If this event needs to be scheduled before the next advance(), force one early
@@ -94,8 +93,12 @@ void CoreTiming::ScheduleEvent(s64 cycles_into_future, const EventType* event_ty
     std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
 }
 
+void CoreTiming::ScheduleEventThreadsafe(s64 cycles_into_future, const EventType* event_type,
+                                         u64 userdata) {
+    ts_queue.Push(Event{global_timer + cycles_into_future, 0, userdata, event_type});
+}
+
 void CoreTiming::UnscheduleEvent(const EventType* event_type, u64 userdata) {
-    std::lock_guard guard{inner_mutex};
     const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
         return e.type == event_type && e.userdata == userdata;
     });
@@ -107,6 +110,10 @@ void CoreTiming::UnscheduleEvent(const EventType* event_type, u64 userdata) {
     }
 }
 
+void CoreTiming::UnscheduleEventThreadsafe(const EventType* event_type, u64 userdata) {
+    unschedule_queue.Push(std::make_pair(event_type, userdata));
+}
+
 u64 CoreTiming::GetTicks() const {
     u64 ticks = static_cast<u64>(global_timer);
     if (!is_global_timer_sane) {
@@ -128,7 +135,6 @@ void CoreTiming::ClearPendingEvents() {
 }
 
 void CoreTiming::RemoveEvent(const EventType* event_type) {
-    std::lock_guard guard{inner_mutex};
     const auto itr = std::remove_if(event_queue.begin(), event_queue.end(),
                                     [&](const Event& e) { return e.type == event_type; });
 
@@ -139,6 +145,11 @@ void CoreTiming::RemoveEvent(const EventType* event_type) {
     }
 }
 
+void CoreTiming::RemoveNormalAndThreadsafeEvent(const EventType* event_type) {
+    MoveEvents();
+    RemoveEvent(event_type);
+}
+
 void CoreTiming::ForceExceptionCheck(s64 cycles) {
     cycles = std::max<s64>(0, cycles);
     if (downcount <= cycles) {
@@ -151,8 +162,19 @@ void CoreTiming::ForceExceptionCheck(s64 cycles) {
     downcount = static_cast<int>(cycles);
 }
 
+void CoreTiming::MoveEvents() {
+    for (Event ev; ts_queue.Pop(ev);) {
+        ev.fifo_order = event_fifo_id++;
+        event_queue.emplace_back(std::move(ev));
+        std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
+    }
+}
+
 void CoreTiming::Advance() {
-    std::unique_lock<std::mutex> guard(inner_mutex);
+    MoveEvents();
+    for (std::pair<const EventType*, u64> ev; unschedule_queue.Pop(ev);) {
+        UnscheduleEvent(ev.first, ev.second);
+    }
 
     const int cycles_executed = slice_length - downcount;
     global_timer += cycles_executed;
@@ -164,9 +186,7 @@ void CoreTiming::Advance() {
         Event evt = std::move(event_queue.front());
         std::pop_heap(event_queue.begin(), event_queue.end(), std::greater<>());
         event_queue.pop_back();
-        inner_mutex.unlock();
         evt.type->callback(evt.userdata, global_timer - evt.time);
-        inner_mutex.lock();
     }
 
     is_global_timer_sane = false;

src/core/core_timing.h

@@ -6,7 +6,6 @@
 
 #include <chrono>
 #include <functional>
-#include <mutex>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -68,7 +67,7 @@ public:
     ///
     EventType* RegisterEvent(const std::string& name, TimedCallback callback);
 
-    /// Unregisters all registered events thus far. Note: not thread unsafe
+    /// Unregisters all registered events thus far.
     void UnregisterAllEvents();
 
     /// After the first Advance, the slice lengths and the downcount will be reduced whenever an
@@ -77,10 +76,20 @@ public:
     /// Scheduling from a callback will not update the downcount until the Advance() completes.
     void ScheduleEvent(s64 cycles_into_future, const EventType* event_type, u64 userdata = 0);
 
+    /// This is to be called when outside of hle threads, such as the graphics thread, wants to
+    /// schedule things to be executed on the main thread.
+    ///
+    /// @note This doesn't change slice_length and thus events scheduled by this might be
+    /// called with a delay of up to MAX_SLICE_LENGTH
+    void ScheduleEventThreadsafe(s64 cycles_into_future, const EventType* event_type,
+                                 u64 userdata = 0);
+
     void UnscheduleEvent(const EventType* event_type, u64 userdata);
+    void UnscheduleEventThreadsafe(const EventType* event_type, u64 userdata);
 
     /// We only permit one event of each type in the queue at a time.
     void RemoveEvent(const EventType* event_type);
+    void RemoveNormalAndThreadsafeEvent(const EventType* event_type);
 
     void ForceExceptionCheck(s64 cycles);
 
@@ -111,6 +120,7 @@ private:
 
     /// Clear all pending events. This should ONLY be done on exit.
     void ClearPendingEvents();
+    void MoveEvents();
 
     s64 global_timer = 0;
     s64 idled_cycles = 0;
@@ -133,9 +143,14 @@ private:
     // remain stable regardless of rehashes/resizing.
     std::unordered_map<std::string, EventType> event_types;
 
-    EventType* ev_lost = nullptr;
+    // The queue for storing the events from other threads threadsafe until they will be added
+    // to the event_queue by the emu thread
+    Common::MPSCQueue<Event> ts_queue;
 
-    std::mutex inner_mutex;
+    // The queue for unscheduling the events from other threads threadsafe
+    Common::MPSCQueue<std::pair<const EventType*, u64>> unschedule_queue;
+
+    EventType* ev_lost = nullptr;
 };
 
 } // namespace Core::Timing

src/core/core_timing_util.cpp

@@ -13,40 +13,52 @@ namespace Core::Timing {
 
 constexpr u64 MAX_VALUE_TO_MULTIPLY = std::numeric_limits<s64>::max() / BASE_CLOCK_RATE;
 
-s64 msToCycles(std::chrono::milliseconds ms) {
-    if (static_cast<u64>(ms.count() / 1000) > MAX_VALUE_TO_MULTIPLY) {
+s64 usToCycles(s64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
         LOG_ERROR(Core_Timing, "Integer overflow, use max value");
         return std::numeric_limits<s64>::max();
     }
-    if (static_cast<u64>(ms.count()) > MAX_VALUE_TO_MULTIPLY) {
+    if (us > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (ms.count() / 1000);
+        return BASE_CLOCK_RATE * (us / 1000000);
     }
-    return (BASE_CLOCK_RATE * ms.count()) / 1000;
+    return (BASE_CLOCK_RATE * us) / 1000000;
 }
 
-s64 usToCycles(std::chrono::microseconds us) {
-    if (static_cast<u64>(us.count() / 1000000) > MAX_VALUE_TO_MULTIPLY) {
+s64 usToCycles(u64 us) {
+    if (us / 1000000 > MAX_VALUE_TO_MULTIPLY) {
         LOG_ERROR(Core_Timing, "Integer overflow, use max value");
         return std::numeric_limits<s64>::max();
     }
-    if (static_cast<u64>(us.count()) > MAX_VALUE_TO_MULTIPLY) {
+    if (us > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (us.count() / 1000000);
+        return BASE_CLOCK_RATE * static_cast<s64>(us / 1000000);
     }
-    return (BASE_CLOCK_RATE * us.count()) / 1000000;
+    return (BASE_CLOCK_RATE * static_cast<s64>(us)) / 1000000;
 }
 
-s64 nsToCycles(std::chrono::nanoseconds ns) {
-    if (static_cast<u64>(ns.count() / 1000000000) > MAX_VALUE_TO_MULTIPLY) {
+s64 nsToCycles(s64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
         LOG_ERROR(Core_Timing, "Integer overflow, use max value");
         return std::numeric_limits<s64>::max();
     }
-    if (static_cast<u64>(ns.count()) > MAX_VALUE_TO_MULTIPLY) {
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
         LOG_DEBUG(Core_Timing, "Time very big, do rounding");
-        return BASE_CLOCK_RATE * (ns.count() / 1000000000);
+        return BASE_CLOCK_RATE * (ns / 1000000000);
     }
-    return (BASE_CLOCK_RATE * ns.count()) / 1000000000;
+    return (BASE_CLOCK_RATE * ns) / 1000000000;
+}
+
+s64 nsToCycles(u64 ns) {
+    if (ns / 1000000000 > MAX_VALUE_TO_MULTIPLY) {
+        LOG_ERROR(Core_Timing, "Integer overflow, use max value");
+        return std::numeric_limits<s64>::max();
+    }
+    if (ns > MAX_VALUE_TO_MULTIPLY) {
+        LOG_DEBUG(Core_Timing, "Time very big, do rounding");
+        return BASE_CLOCK_RATE * (static_cast<s64>(ns) / 1000000000);
+    }
+    return (BASE_CLOCK_RATE * static_cast<s64>(ns)) / 1000000000;
 }
 
 u64 CpuCyclesToClockCycles(u64 ticks) {

src/core/core_timing_util.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <chrono>
 #include "common/common_types.h"
 
 namespace Core::Timing {
@@ -14,20 +13,53 @@ namespace Core::Timing {
 constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
 constexpr u64 CNTFREQ = 19200000;           // Value from fusee.
 
-s64 msToCycles(std::chrono::milliseconds ms);
-s64 usToCycles(std::chrono::microseconds us);
-s64 nsToCycles(std::chrono::nanoseconds ns);
-
-inline std::chrono::milliseconds CyclesToMs(s64 cycles) {
-    return std::chrono::milliseconds(cycles * 1000 / BASE_CLOCK_RATE);
+inline s64 msToCycles(int ms) {
+    // since ms is int there is no way to overflow
+    return BASE_CLOCK_RATE * static_cast<s64>(ms) / 1000;
 }
 
-inline std::chrono::nanoseconds CyclesToNs(s64 cycles) {
-    return std::chrono::nanoseconds(cycles * 1000000000 / BASE_CLOCK_RATE);
+inline s64 msToCycles(float ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001f) * ms);
 }
 
-inline std::chrono::microseconds CyclesToUs(s64 cycles) {
-    return std::chrono::microseconds(cycles * 1000000 / BASE_CLOCK_RATE);
+inline s64 msToCycles(double ms) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.001) * ms);
+}
+
+inline s64 usToCycles(float us) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000001f) * us);
+}
+
+inline s64 usToCycles(int us) {
+    return (BASE_CLOCK_RATE * static_cast<s64>(us) / 1000000);
+}
+
+s64 usToCycles(s64 us);
+
+s64 usToCycles(u64 us);
+
+inline s64 nsToCycles(float ns) {
+    return static_cast<s64>(BASE_CLOCK_RATE * (0.000000001f) * ns);
+}
+
+inline s64 nsToCycles(int ns) {
+    return BASE_CLOCK_RATE * static_cast<s64>(ns) / 1000000000;
+}
+
+s64 nsToCycles(s64 ns);
+
+s64 nsToCycles(u64 ns);
+
+inline u64 cyclesToNs(s64 cycles) {
+    return cycles * 1000000000 / BASE_CLOCK_RATE;
+}
+
+inline s64 cyclesToUs(s64 cycles) {
+    return cycles * 1000000 / BASE_CLOCK_RATE;
+}
+
+inline u64 cyclesToMs(s64 cycles) {
+    return cycles * 1000 / BASE_CLOCK_RATE;
 }
 
 u64 CpuCyclesToClockCycles(u64 ticks);

src/core/crypto/key_manager.cpp

@@ -572,7 +572,7 @@ void KeyManager::WriteKeyToFile(KeyCategory category, std::string_view keyname,
             << "# If you are experiencing issues involving keys, it may help to delete this file\n";
     }
 
-    file << fmt::format("\n{} = {}", keyname, Common::HexToString(key));
+    file << fmt::format("\n{} = {}", keyname, Common::HexArrayToString(key));
     AttemptLoadKeyFile(yuzu_keys_dir, yuzu_keys_dir, filename, category == KeyCategory::Title);
 }
 
@@ -583,7 +583,7 @@ void KeyManager::SetKey(S128KeyType id, Key128 key, u64 field1, u64 field2) {
         Key128 rights_id;
         std::memcpy(rights_id.data(), &field2, sizeof(u64));
         std::memcpy(rights_id.data() + sizeof(u64), &field1, sizeof(u64));
-        WriteKeyToFile(KeyCategory::Title, Common::HexToString(rights_id), key);
+        WriteKeyToFile(KeyCategory::Title, Common::HexArrayToString(rights_id), key);
     }
 
     auto category = KeyCategory::Standard;

src/core/crypto/partition_data_manager.cpp

@@ -22,10 +22,8 @@
 #include "core/crypto/key_manager.h"
 #include "core/crypto/partition_data_manager.h"
 #include "core/crypto/xts_encryption_layer.h"
-#include "core/file_sys/kernel_executable.h"
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_offset.h"
-#include "core/file_sys/vfs_vector.h"
 
 using namespace Common;
 
@@ -47,6 +45,36 @@ struct Package2Header {
 };
 static_assert(sizeof(Package2Header) == 0x200, "Package2Header has incorrect size.");
 
+struct INIHeader {
+    u32_le magic;
+    u32_le size;
+    u32_le process_count;
+    INSERT_PADDING_BYTES(4);
+};
+static_assert(sizeof(INIHeader) == 0x10, "INIHeader has incorrect size.");
+
+struct SectionHeader {
+    u32_le offset;
+    u32_le size_decompressed;
+    u32_le size_compressed;
+    u32_le attribute;
+};
+static_assert(sizeof(SectionHeader) == 0x10, "SectionHeader has incorrect size.");
+
+struct KIPHeader {
+    u32_le magic;
+    std::array<char, 12> name;
+    u64_le title_id;
+    u32_le category;
+    u8 priority;
+    u8 core;
+    INSERT_PADDING_BYTES(1);
+    u8 flags;
+    std::array<SectionHeader, 6> sections;
+    std::array<u32, 0x20> capabilities;
+};
+static_assert(sizeof(KIPHeader) == 0x100, "KIPHeader has incorrect size.");
+
 const std::array<SHA256Hash, 0x10> source_hashes{
     "B24BD293259DBC7AC5D63F88E60C59792498E6FC5443402C7FFE87EE8B61A3F0"_array32, // keyblob_mac_key_source
     "7944862A3A5C31C6720595EFD302245ABD1B54CCDCF33000557681E65C5664A4"_array32, // master_key_source
@@ -142,6 +170,65 @@ const std::array<SHA256Hash, 0x20> master_key_hashes{
     "0000000000000000000000000000000000000000000000000000000000000000"_array32, // master_key_1F
 };
 
+static std::vector<u8> DecompressBLZ(const std::vector<u8>& in) {
+    const auto data_size = in.size() - 0xC;
+
+    u32 compressed_size{};
+    u32 init_index{};
+    u32 additional_size{};
+    std::memcpy(&compressed_size, in.data() + data_size, sizeof(u32));
+    std::memcpy(&init_index, in.data() + data_size + 0x4, sizeof(u32));
+    std::memcpy(&additional_size, in.data() + data_size + 0x8, sizeof(u32));
+
+    std::vector<u8> out(in.size() + additional_size);
+
+    if (compressed_size == in.size())
+        std::memcpy(out.data(), in.data() + in.size() - compressed_size, compressed_size);
+    else
+        std::memcpy(out.data(), in.data(), compressed_size);
+
+    auto index = in.size() - init_index;
+    auto out_index = out.size();
+
+    while (out_index > 0) {
+        --index;
+        auto control = in[index];
+        for (size_t i = 0; i < 8; ++i) {
+            if ((control & 0x80) > 0) {
+                ASSERT(index >= 2);
+                index -= 2;
+                u64 segment_offset = in[index] | in[index + 1] << 8;
+                u64 segment_size = ((segment_offset >> 12) & 0xF) + 3;
+                segment_offset &= 0xFFF;
+                segment_offset += 3;
+
+                if (out_index < segment_size)
+                    segment_size = out_index;
+
+                ASSERT(out_index >= segment_size);
+
+                out_index -= segment_size;
+
+                for (size_t j = 0; j < segment_size; ++j) {
+                    ASSERT(out_index + j + segment_offset < out.size());
+                    out[out_index + j] = out[out_index + j + segment_offset];
+                }
+            } else {
+                ASSERT(out_index >= 1);
+                --out_index;
+                --index;
+                out[out_index] = in[index];
+            }
+
+            control <<= 1;
+            if (out_index == 0)
+                return out;
+        }
+    }
+
+    return out;
+}
+
 static u8 CalculateMaxKeyblobSourceHash() {
     for (s8 i = 0x1F; i >= 0; --i) {
         if (keyblob_source_hashes[i] != SHA256Hash{})
@@ -391,22 +478,37 @@ void PartitionDataManager::DecryptPackage2(const std::array<Key128, 0x20>& packa
     cipher.SetIV({header.section_ctr[1].begin(), header.section_ctr[1].end()});
     cipher.Transcode(c.data(), c.size(), c.data(), Op::Decrypt);
 
-    const auto ini_file = std::make_shared<FileSys::VectorVfsFile>(c);
-    const FileSys::INI ini{ini_file};
-    if (ini.GetStatus() != Loader::ResultStatus::Success)
+    INIHeader ini;
+    std::memcpy(&ini, c.data(), sizeof(INIHeader));
+    if (ini.magic != Common::MakeMagic('I', 'N', 'I', '1'))
         return;
 
-    for (const auto& kip : ini.GetKIPs()) {
-        if (kip.GetStatus() != Loader::ResultStatus::Success)
+    u64 offset = sizeof(INIHeader);
+    for (size_t i = 0; i < ini.process_count; ++i) {
+        KIPHeader kip;
+        std::memcpy(&kip, c.data() + offset, sizeof(KIPHeader));
+        if (kip.magic != Common::MakeMagic('K', 'I', 'P', '1'))
             return;
 
-        if (kip.GetName() != "FS" && kip.GetName() != "spl") {
+        const auto name =
+            Common::StringFromFixedZeroTerminatedBuffer(kip.name.data(), kip.name.size());
+
+        if (name != "FS" && name != "spl") {
+            offset += sizeof(KIPHeader) + kip.sections[0].size_compressed +
+                      kip.sections[1].size_compressed + kip.sections[2].size_compressed;
             continue;
         }
 
-        const auto& text = kip.GetTextSection();
-        const auto& rodata = kip.GetRODataSection();
-        const auto& data = kip.GetDataSection();
+        const u64 initial_offset = sizeof(KIPHeader) + offset;
+        const auto text_begin = c.cbegin() + initial_offset;
+        const auto text_end = text_begin + kip.sections[0].size_compressed;
+        const std::vector<u8> text = DecompressBLZ({text_begin, text_end});
+
+        const auto rodata_end = text_end + kip.sections[1].size_compressed;
+        const std::vector<u8> rodata = DecompressBLZ({text_end, rodata_end});
+
+        const auto data_end = rodata_end + kip.sections[2].size_compressed;
+        const std::vector<u8> data = DecompressBLZ({rodata_end, data_end});
 
         std::vector<u8> out;
         out.reserve(text.size() + rodata.size() + data.size());
@@ -414,9 +516,12 @@ void PartitionDataManager::DecryptPackage2(const std::array<Key128, 0x20>& packa
         out.insert(out.end(), rodata.begin(), rodata.end());
         out.insert(out.end(), data.begin(), data.end());
 
-        if (kip.GetName() == "FS")
+        offset += sizeof(KIPHeader) + kip.sections[0].size_compressed +
+                  kip.sections[1].size_compressed + kip.sections[2].size_compressed;
+
+        if (name == "FS")
             package2_fs[static_cast<size_t>(type)] = std::move(out);
-        else if (kip.GetName() == "spl")
+        else if (name == "spl")
             package2_spl[static_cast<size_t>(type)] = std::move(out);
     }
 }

src/core/file_sys/card_image.cpp

@@ -18,16 +18,11 @@
 
 namespace FileSys {
 
-constexpr std::array partition_names{
-    "update",
-    "normal",
-    "secure",
-    "logo",
-};
+constexpr std::array<const char*, 0x4> partition_names = {"update", "normal", "secure", "logo"};
 
 XCI::XCI(VirtualFile file_)
     : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
-      partitions(partition_names.size()) {
+      partitions(0x4) {
     if (file->ReadObject(&header) != sizeof(GamecardHeader)) {
         status = Loader::ResultStatus::ErrorBadXCIHeader;
         return;
@@ -48,24 +43,23 @@ XCI::XCI(VirtualFile file_)
 
     for (XCIPartition partition :
          {XCIPartition::Update, XCIPartition::Normal, XCIPartition::Secure, XCIPartition::Logo}) {
-        const auto partition_idx = static_cast<std::size_t>(partition);
-        auto raw = main_hfs.GetFile(partition_names[partition_idx]);
-
-        if (raw != nullptr) {
-            partitions[partition_idx] = std::make_shared<PartitionFilesystem>(std::move(raw));
-        }
+        auto raw = main_hfs.GetFile(partition_names[static_cast<std::size_t>(partition)]);
+        if (raw != nullptr)
+            partitions[static_cast<std::size_t>(partition)] =
+                std::make_shared<PartitionFilesystem>(raw);
     }
 
     secure_partition = std::make_shared<NSP>(
         main_hfs.GetFile(partition_names[static_cast<std::size_t>(XCIPartition::Secure)]));
 
-    ncas = secure_partition->GetNCAsCollapsed();
+    const auto secure_ncas = secure_partition->GetNCAsCollapsed();
+    std::copy(secure_ncas.begin(), secure_ncas.end(), std::back_inserter(ncas));
+
     program =
         secure_partition->GetNCA(secure_partition->GetProgramTitleID(), ContentRecordType::Program);
     program_nca_status = secure_partition->GetProgramStatus(secure_partition->GetProgramTitleID());
-    if (program_nca_status == Loader::ResultStatus::ErrorNSPMissingProgramNCA) {
+    if (program_nca_status == Loader::ResultStatus::ErrorNSPMissingProgramNCA)
         program_nca_status = Loader::ResultStatus::ErrorXCIMissingProgramNCA;
-    }
 
     auto result = AddNCAFromPartition(XCIPartition::Update);
     if (result != Loader::ResultStatus::Success) {
@@ -153,9 +147,8 @@ std::shared_ptr<NCA> XCI::GetNCAByType(NCAContentType type) const {
 
 VirtualFile XCI::GetNCAFileByType(NCAContentType type) const {
     auto nca = GetNCAByType(type);
-    if (nca != nullptr) {
+    if (nca != nullptr)
         return nca->GetBaseFile();
-    }
     return nullptr;
 }
 
@@ -176,22 +169,17 @@ VirtualDir XCI::GetParentDirectory() const {
 }
 
 Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
-    const auto partition_index = static_cast<std::size_t>(part);
-    const auto& partition = partitions[partition_index];
-
-    if (partition == nullptr) {
+    if (partitions[static_cast<std::size_t>(part)] == nullptr) {
         return Loader::ResultStatus::ErrorXCIMissingPartition;
     }
 
-    for (const VirtualFile& file : partition->GetFiles()) {
-        if (file->GetExtension() != "nca") {
+    for (const VirtualFile& file : partitions[static_cast<std::size_t>(part)]->GetFiles()) {
+        if (file->GetExtension() != "nca")
             continue;
-        }
-
         auto nca = std::make_shared<NCA>(file, nullptr, 0, keys);
-        if (nca->IsUpdate()) {
+        // TODO(DarkLordZach): Add proper Rev1+ Support
+        if (nca->IsUpdate())
             continue;
-        }
         if (nca->GetType() == NCAContentType::Program) {
             program_nca_status = nca->GetStatus();
         }
@@ -200,7 +188,7 @@ Loader::ResultStatus XCI::AddNCAFromPartition(XCIPartition part) {
         } else {
             const u16 error_id = static_cast<u16>(nca->GetStatus());
             LOG_CRITICAL(Loader, "Could not load NCA {}/{}, failed with error code {:04X} ({})",
-                         partition_names[partition_index], nca->GetName(), error_id,
+                         partition_names[static_cast<std::size_t>(part)], nca->GetName(), error_id,
                          nca->GetStatus());
         }
     }

src/core/file_sys/content_archive.cpp

@@ -452,13 +452,13 @@ VirtualFile NCA::Decrypt(const NCASectionHeader& s_header, VirtualFile in, u64 s
 
     switch (s_header.raw.header.crypto_type) {
     case NCASectionCryptoType::NONE:
-        LOG_TRACE(Crypto, "called with mode=NONE");
+        LOG_DEBUG(Crypto, "called with mode=NONE");
         return in;
     case NCASectionCryptoType::CTR:
     // During normal BKTR decryption, this entire function is skipped. This is for the metadata,
     // which uses the same CTR as usual.
     case NCASectionCryptoType::BKTR:
-        LOG_TRACE(Crypto, "called with mode=CTR, starting_offset={:016X}", starting_offset);
+        LOG_DEBUG(Crypto, "called with mode=CTR, starting_offset={:016X}", starting_offset);
         {
             std::optional<Core::Crypto::Key128> key = {};
             if (has_rights_id) {

src/core/file_sys/control_metadata.cpp

@@ -87,14 +87,6 @@ u64 NACP::GetDefaultJournalSaveSize() const {
     return raw.user_account_save_data_journal_size;
 }
 
-bool NACP::GetUserAccountSwitchLock() const {
-    return raw.user_account_switch_lock != 0;
-}
-
-u32 NACP::GetSupportedLanguages() const {
-    return raw.supported_languages;
-}
-
 std::vector<u8> NACP::GetRawBytes() const {
     std::vector<u8> out(sizeof(RawNACP));
     std::memcpy(out.data(), &raw, sizeof(RawNACP));

src/core/file_sys/control_metadata.h

@@ -30,8 +30,7 @@ struct RawNACP {
     std::array<LanguageEntry, 16> language_entries;
     std::array<u8, 0x25> isbn;
     u8 startup_user_account;
-    u8 user_account_switch_lock;
-    u8 addon_content_registration_type;
+    INSERT_PADDING_BYTES(2);
     u32_le application_attribute;
     u32_le supported_languages;
     u32_le parental_control;
@@ -110,9 +109,7 @@ public:
     std::string GetVersionString() const;
     u64 GetDefaultNormalSaveSize() const;
     u64 GetDefaultJournalSaveSize() const;
-    u32 GetSupportedLanguages() const;
     std::vector<u8> GetRawBytes() const;
-    bool GetUserAccountSwitchLock() const;
 
 private:
     RawNACP raw{};

src/core/file_sys/ips_layer.cpp

@@ -287,6 +287,7 @@ void IPSwitchCompiler::Parse() {
                 } else {
                     // hex replacement
                     const auto value = patch_line.substr(9);
+                    replace.reserve(value.size() / 2);
                     replace = Common::HexStringToVector(value, is_little_endian);
                 }
 
@@ -294,7 +295,7 @@ void IPSwitchCompiler::Parse() {
                     LOG_INFO(Loader,
                              "[IPSwitchCompiler ('{}')]     - Patching value at offset 0x{:08X} "
                              "with byte string '{}'",
-                             patch_text->GetName(), offset, Common::HexToString(replace));
+                             patch_text->GetName(), offset, Common::HexVectorToString(replace));
                 }
 
                 patch.records.insert_or_assign(offset, std::move(replace));

src/core/file_sys/kernel_executable.cpp

@@ -1,228 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/string_util.h"
-#include "core/file_sys/kernel_executable.h"
-#include "core/file_sys/vfs_offset.h"
-
-namespace FileSys {
-
-constexpr u32 INI_MAX_KIPS = 0x50;
-
-namespace {
-bool DecompressBLZ(std::vector<u8>& data) {
-    if (data.size() < 0xC)
-        return {};
-
-    const auto data_size = data.size() - 0xC;
-
-    u32 compressed_size{};
-    u32 init_index{};
-    u32 additional_size{};
-    std::memcpy(&compressed_size, data.data() + data_size, sizeof(u32));
-    std::memcpy(&init_index, data.data() + data_size + 0x4, sizeof(u32));
-    std::memcpy(&additional_size, data.data() + data_size + 0x8, sizeof(u32));
-
-    const auto start_offset = data.size() - compressed_size;
-    data.resize(compressed_size + additional_size + start_offset);
-
-    std::size_t index = compressed_size - init_index;
-    std::size_t out_index = compressed_size + additional_size;
-
-    while (out_index > 0) {
-        --index;
-        auto control = data[index + start_offset];
-        for (size_t i = 0; i < 8; ++i) {
-            if (((control << i) & 0x80) > 0) {
-                if (index < 2) {
-                    return false;
-                }
-                index -= 2;
-                std::size_t segment_offset =
-                    data[index + start_offset] | data[index + start_offset + 1] << 8;
-                std::size_t segment_size = ((segment_offset >> 12) & 0xF) + 3;
-                segment_offset &= 0xFFF;
-                segment_offset += 3;
-
-                if (out_index < segment_size)
-                    segment_size = out_index;
-
-                if (out_index < segment_size) {
-                    return false;
-                }
-
-                out_index -= segment_size;
-
-                for (size_t j = 0; j < segment_size; ++j) {
-                    if (out_index + j + segment_offset + start_offset >= data.size()) {
-                        return false;
-                    }
-                    data[out_index + j + start_offset] =
-                        data[out_index + j + segment_offset + start_offset];
-                }
-            } else {
-                if (out_index < 1) {
-                    return false;
-                }
-                --out_index;
-                --index;
-                data[out_index + start_offset] = data[index + start_offset];
-            }
-
-            if (out_index == 0)
-                break;
-        }
-    }
-
-    return true;
-}
-} // Anonymous namespace
-
-KIP::KIP(const VirtualFile& file) : status(Loader::ResultStatus::Success) {
-    if (file == nullptr) {
-        status = Loader::ResultStatus::ErrorNullFile;
-        return;
-    }
-
-    if (file->GetSize() < sizeof(KIPHeader) || file->ReadObject(&header) != sizeof(KIPHeader)) {
-        status = Loader::ResultStatus::ErrorBadKIPHeader;
-        return;
-    }
-
-    if (header.magic != Common::MakeMagic('K', 'I', 'P', '1')) {
-        status = Loader::ResultStatus::ErrorBadKIPHeader;
-        return;
-    }
-
-    u64 offset = sizeof(KIPHeader);
-    for (std::size_t i = 0; i < header.sections.size(); ++i) {
-        auto compressed = file->ReadBytes(header.sections[i].compressed_size, offset);
-        offset += header.sections[i].compressed_size;
-
-        if (header.sections[i].compressed_size == 0 && header.sections[i].decompressed_size != 0) {
-            decompressed_sections[i] = std::vector<u8>(header.sections[i].decompressed_size);
-        } else if (header.sections[i].compressed_size == header.sections[i].decompressed_size) {
-            decompressed_sections[i] = std::move(compressed);
-        } else {
-            decompressed_sections[i] = compressed;
-            if (!DecompressBLZ(decompressed_sections[i])) {
-                status = Loader::ResultStatus::ErrorBLZDecompressionFailed;
-                return;
-            }
-        }
-    }
-}
-
-Loader::ResultStatus KIP::GetStatus() const {
-    return status;
-}
-
-std::string KIP::GetName() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(header.name.data(), header.name.size());
-}
-
-u64 KIP::GetTitleID() const {
-    return header.title_id;
-}
-
-std::vector<u8> KIP::GetSectionDecompressed(u8 index) const {
-    return decompressed_sections[index];
-}
-
-bool KIP::Is64Bit() const {
-    return (header.flags & 0x8) != 0;
-}
-
-bool KIP::Is39BitAddressSpace() const {
-    return (header.flags & 0x10) != 0;
-}
-
-bool KIP::IsService() const {
-    return (header.flags & 0x20) != 0;
-}
-
-std::vector<u32> KIP::GetKernelCapabilities() const {
-    return std::vector<u32>(header.capabilities.begin(), header.capabilities.end());
-}
-
-s32 KIP::GetMainThreadPriority() const {
-    return header.main_thread_priority;
-}
-
-u32 KIP::GetMainThreadStackSize() const {
-    return header.sections[1].attribute;
-}
-
-u32 KIP::GetMainThreadCpuCore() const {
-    return header.default_core;
-}
-
-const std::vector<u8>& KIP::GetTextSection() const {
-    return decompressed_sections[0];
-}
-
-const std::vector<u8>& KIP::GetRODataSection() const {
-    return decompressed_sections[1];
-}
-
-const std::vector<u8>& KIP::GetDataSection() const {
-    return decompressed_sections[2];
-}
-
-u32 KIP::GetTextOffset() const {
-    return header.sections[0].offset;
-}
-
-u32 KIP::GetRODataOffset() const {
-    return header.sections[1].offset;
-}
-
-u32 KIP::GetDataOffset() const {
-    return header.sections[2].offset;
-}
-
-u32 KIP::GetBSSSize() const {
-    return header.sections[3].decompressed_size;
-}
-
-u32 KIP::GetBSSOffset() const {
-    return header.sections[3].offset;
-}
-
-INI::INI(const VirtualFile& file) : status(Loader::ResultStatus::Success) {
-    if (file->GetSize() < sizeof(INIHeader) || file->ReadObject(&header) != sizeof(INIHeader)) {
-        status = Loader::ResultStatus::ErrorBadINIHeader;
-        return;
-    }
-
-    if (header.magic != Common::MakeMagic('I', 'N', 'I', '1')) {
-        status = Loader::ResultStatus::ErrorBadINIHeader;
-        return;
-    }
-
-    if (header.kip_count > INI_MAX_KIPS) {
-        status = Loader::ResultStatus::ErrorINITooManyKIPs;
-        return;
-    }
-
-    u64 offset = sizeof(INIHeader);
-    for (std::size_t i = 0; i < header.kip_count; ++i) {
-        const auto kip_file =
-            std::make_shared<OffsetVfsFile>(file, file->GetSize() - offset, offset);
-        KIP kip(kip_file);
-        if (kip.GetStatus() == Loader::ResultStatus::Success) {
-            kips.push_back(std::move(kip));
-        }
-    }
-}
-
-Loader::ResultStatus INI::GetStatus() const {
-    return status;
-}
-
-const std::vector<KIP>& INI::GetKIPs() const {
-    return kips;
-}
-
-} // namespace FileSys

src/core/file_sys/kernel_executable.h

@@ -1,99 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_funcs.h"
-#include "common/swap.h"
-#include "core/file_sys/vfs_types.h"
-#include "core/loader/loader.h"
-
-namespace FileSys {
-
-struct KIPSectionHeader {
-    u32_le offset;
-    u32_le decompressed_size;
-    u32_le compressed_size;
-    u32_le attribute;
-};
-static_assert(sizeof(KIPSectionHeader) == 0x10, "KIPSectionHeader has incorrect size.");
-
-struct KIPHeader {
-    u32_le magic;
-    std::array<char, 0xC> name;
-    u64_le title_id;
-    u32_le process_category;
-    u8 main_thread_priority;
-    u8 default_core;
-    INSERT_PADDING_BYTES(1);
-    u8 flags;
-    std::array<KIPSectionHeader, 6> sections;
-    std::array<u32, 0x20> capabilities;
-};
-static_assert(sizeof(KIPHeader) == 0x100, "KIPHeader has incorrect size.");
-
-struct INIHeader {
-    u32_le magic;
-    u32_le size;
-    u32_le kip_count;
-    INSERT_PADDING_BYTES(0x4);
-};
-static_assert(sizeof(INIHeader) == 0x10, "INIHeader has incorrect size.");
-
-// Kernel Internal Process
-class KIP {
-public:
-    explicit KIP(const VirtualFile& file);
-
-    Loader::ResultStatus GetStatus() const;
-
-    std::string GetName() const;
-    u64 GetTitleID() const;
-    std::vector<u8> GetSectionDecompressed(u8 index) const;
-
-    // Executable Flags
-    bool Is64Bit() const;
-    bool Is39BitAddressSpace() const;
-    bool IsService() const;
-
-    std::vector<u32> GetKernelCapabilities() const;
-
-    s32 GetMainThreadPriority() const;
-    u32 GetMainThreadStackSize() const;
-    u32 GetMainThreadCpuCore() const;
-
-    const std::vector<u8>& GetTextSection() const;
-    const std::vector<u8>& GetRODataSection() const;
-    const std::vector<u8>& GetDataSection() const;
-
-    u32 GetTextOffset() const;
-    u32 GetRODataOffset() const;
-    u32 GetDataOffset() const;
-
-    u32 GetBSSSize() const;
-    u32 GetBSSOffset() const;
-
-private:
-    Loader::ResultStatus status;
-
-    KIPHeader header{};
-    std::array<std::vector<u8>, 6> decompressed_sections;
-};
-
-class INI {
-public:
-    explicit INI(const VirtualFile& file);
-
-    Loader::ResultStatus GetStatus() const;
-
-    const std::vector<KIP>& GetKIPs() const;
-
-private:
-    Loader::ResultStatus status;
-
-    INIHeader header{};
-    std::vector<KIP> kips;
-};
-
-} // namespace FileSys

src/core/file_sys/nca_metadata.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <array>
 #include <memory>
 #include <vector>
 #include "common/common_funcs.h"
@@ -35,9 +34,9 @@ enum class ContentRecordType : u8 {
     Program = 1,
     Data = 2,
     Control = 3,
-    HtmlDocument = 4,
-    LegalInformation = 5,
-    DeltaFragment = 6,
+    Manual = 4,
+    Legal = 5,
+    Patch = 6,
 };
 
 struct ContentRecord {
@@ -70,15 +69,11 @@ struct CNMTHeader {
     u64_le title_id;
     u32_le title_version;
     TitleType type;
-    u8 reserved;
+    INSERT_PADDING_BYTES(1);
     u16_le table_offset;
     u16_le number_content_entries;
     u16_le number_meta_entries;
-    u8 attributes;
-    std::array<u8, 2> reserved2;
-    u8 is_committed;
-    u32_le required_download_system_version;
-    std::array<u8, 4> reserved3;
+    INSERT_PADDING_BYTES(12);
 };
 static_assert(sizeof(CNMTHeader) == 0x20, "CNMTHeader has incorrect size.");
 

src/core/file_sys/patch_manager.cpp

@@ -142,7 +142,7 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
                     if (!compiler.IsValid())
                         continue;
 
-                    auto this_build_id = Common::HexToString(compiler.GetBuildID());
+                    auto this_build_id = Common::HexArrayToString(compiler.GetBuildID());
                     this_build_id =
                         this_build_id.substr(0, this_build_id.find_last_not_of('0') + 1);
 
@@ -168,7 +168,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
         return nso;
     }
 
-    const auto build_id_raw = Common::HexToString(header.build_id);
+    const auto build_id_raw = Common::HexArrayToString(header.build_id);
     const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
 
     if (Settings::values.dump_nso) {
@@ -219,7 +219,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
 }
 
 bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
-    const auto build_id_raw = Common::HexToString(build_id_);
+    const auto build_id_raw = Common::HexArrayToString(build_id_);
     const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
 
     LOG_INFO(Loader, "Querying NSO patch existence for build_id={}", build_id);
@@ -235,7 +235,7 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
 static std::optional<CheatList> ReadCheatFileFromFolder(const Core::System& system, u64 title_id,
                                                         const std::array<u8, 0x20>& build_id_,
                                                         const VirtualDir& base_path, bool upper) {
-    const auto build_id_raw = Common::HexToString(build_id_, upper);
+    const auto build_id_raw = Common::HexArrayToString(build_id_, upper);
     const auto build_id = build_id_raw.substr(0, sizeof(u64) * 2);
     const auto file = base_path->GetFile(fmt::format("{}.txt", build_id));
 
@@ -493,16 +493,6 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
     return out;
 }
 
-std::optional<u32> PatchManager::GetGameVersion() const {
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
-    const auto update_tid = GetUpdateTitleID(title_id);
-    if (installed.HasEntry(update_tid, ContentRecordType::Program)) {
-        return installed.GetEntryVersion(update_tid);
-    }
-
-    return installed.GetEntryVersion(title_id);
-}
-
 std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
     const auto& installed = Core::System::GetInstance().GetContentProvider();
 

src/core/file_sys/patch_manager.h

@@ -66,13 +66,8 @@ public:
     std::map<std::string, std::string, std::less<>> GetPatchVersionNames(
         VirtualFile update_raw = nullptr) const;
 
-    // If the game update exists, returns the u32 version field in its Meta-type NCA. If that fails,
-    // it will fallback to the Meta-type NCA of the base game. If that fails, the result will be
-    // std::nullopt
-    std::optional<u32> GetGameVersion() const;
-
-    // Given title_id of the program, attempts to get the control data of the update and parse
-    // it, falling back to the base control data.
+    // Given title_id of the program, attempts to get the control data of the update and parse it,
+    // falling back to the base control data.
     std::pair<std::unique_ptr<NACP>, VirtualFile> GetControlMetadata() const;
 
     // Version of GetControlMetadata that takes an arbitrary NCA

src/core/file_sys/program_metadata.cpp

@@ -51,21 +51,6 @@ Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
     return Loader::ResultStatus::Success;
 }
 
-void ProgramMetadata::LoadManual(bool is_64_bit, ProgramAddressSpaceType address_space,
-                                 u8 main_thread_prio, u8 main_thread_core,
-                                 u32 main_thread_stack_size, u64 title_id,
-                                 u64 filesystem_permissions,
-                                 KernelCapabilityDescriptors capabilities) {
-    npdm_header.has_64_bit_instructions.Assign(is_64_bit);
-    npdm_header.address_space_type.Assign(address_space);
-    npdm_header.main_thread_priority = main_thread_prio;
-    npdm_header.main_thread_cpu = main_thread_core;
-    npdm_header.main_stack_size = main_thread_stack_size;
-    aci_header.title_id = title_id;
-    aci_file_access.permissions = filesystem_permissions;
-    aci_kernel_capabilities = std ::move(capabilities);
-}
-
 bool ProgramMetadata::Is64BitProgram() const {
     return npdm_header.has_64_bit_instructions;
 }
@@ -94,10 +79,6 @@ u64 ProgramMetadata::GetFilesystemPermissions() const {
     return aci_file_access.permissions;
 }
 
-u32 ProgramMetadata::GetSystemResourceSize() const {
-    return npdm_header.system_resource_size;
-}
-
 const ProgramMetadata::KernelCapabilityDescriptors& ProgramMetadata::GetKernelCapabilities() const {
     return aci_kernel_capabilities;
 }

src/core/file_sys/program_metadata.h

@@ -46,11 +46,6 @@ public:
 
     Loader::ResultStatus Load(VirtualFile file);
 
-    // Load from parameters instead of NPDM file, used for KIP
-    void LoadManual(bool is_64_bit, ProgramAddressSpaceType address_space, u8 main_thread_prio,
-                    u8 main_thread_core, u32 main_thread_stack_size, u64 title_id,
-                    u64 filesystem_permissions, KernelCapabilityDescriptors capabilities);
-
     bool Is64BitProgram() const;
     ProgramAddressSpaceType GetAddressSpaceType() const;
     u8 GetMainThreadPriority() const;
@@ -58,7 +53,6 @@ public:
     u32 GetMainThreadStackSize() const;
     u64 GetTitleID() const;
     u64 GetFilesystemPermissions() const;
-    u32 GetSystemResourceSize() const;
     const KernelCapabilityDescriptors& GetKernelCapabilities() const;
 
     void Print() const;
@@ -77,8 +71,7 @@ private:
         u8 reserved_3;
         u8 main_thread_priority;
         u8 main_thread_cpu;
-        std::array<u8, 4> reserved_4;
-        u32_le system_resource_size;
+        std::array<u8, 8> reserved_4;
         u32_le process_category;
         u32_le main_stack_size;
         std::array<u8, 0x10> application_name;

src/core/file_sys/registered_cache.cpp

@@ -53,14 +53,13 @@ static bool FollowsNcaIdFormat(std::string_view name) {
 
 static std::string GetRelativePathFromNcaID(const std::array<u8, 16>& nca_id, bool second_hex_upper,
                                             bool within_two_digit) {
-    if (!within_two_digit) {
-        return fmt::format("/{}.nca", Common::HexToString(nca_id, second_hex_upper));
-    }
+    if (!within_two_digit)
+        return fmt::format("/{}.nca", Common::HexArrayToString(nca_id, second_hex_upper));
 
     Core::Crypto::SHA256Hash hash{};
     mbedtls_sha256(nca_id.data(), nca_id.size(), hash.data(), 0);
     return fmt::format("/000000{:02X}/{}.nca", hash[0],
-                       Common::HexToString(nca_id, second_hex_upper));
+                       Common::HexArrayToString(nca_id, second_hex_upper));
 }
 
 static std::string GetCNMTName(TitleType type, u64 title_id) {
@@ -99,7 +98,7 @@ ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
         return ContentRecordType::Data;
     case NCAContentType::Manual:
         // TODO(DarkLordZach): Peek at NCA contents to differentiate Manual and Legal.
-        return ContentRecordType::HtmlDocument;
+        return ContentRecordType::Manual;
     default:
         UNREACHABLE_MSG("Invalid NCAContentType={:02X}", static_cast<u8>(type));
     }
@@ -377,11 +376,10 @@ std::vector<ContentProviderEntry> RegisteredCache::ListEntriesFilter(
 }
 
 static std::shared_ptr<NCA> GetNCAFromNSPForID(const NSP& nsp, const NcaID& id) {
-    auto file = nsp.GetFile(fmt::format("{}.nca", Common::HexToString(id, false)));
-    if (file == nullptr) {
+    const auto file = nsp.GetFile(fmt::format("{}.nca", Common::HexArrayToString(id, false)));
+    if (file == nullptr)
         return nullptr;
-    }
-    return std::make_shared<NCA>(std::move(file));
+    return std::make_shared<NCA>(file);
 }
 
 InstallResult RegisteredCache::InstallEntry(const XCI& xci, bool overwrite_if_exists,
@@ -397,8 +395,8 @@ InstallResult RegisteredCache::InstallEntry(const NSP& nsp, bool overwrite_if_ex
     });
 
     if (meta_iter == ncas.end()) {
-        LOG_ERROR(Loader, "The file you are attempting to install does not have a metadata NCA and "
-                          "is therefore malformed. Check your encryption keys.");
+        LOG_ERROR(Loader, "The XCI you are attempting to install does not have a metadata NCA and "
+                          "is therefore malformed. Double check your encryption keys.");
         return InstallResult::ErrorMetaFailed;
     }
 
@@ -415,9 +413,6 @@ InstallResult RegisteredCache::InstallEntry(const NSP& nsp, bool overwrite_if_ex
     const auto cnmt_file = section0->GetFiles()[0];
     const CNMT cnmt(cnmt_file);
     for (const auto& record : cnmt.GetContentRecords()) {
-        // Ignore DeltaFragments, they are not useful to us
-        if (record.type == ContentRecordType::DeltaFragment)
-            continue;
         const auto nca = GetNCAFromNSPForID(nsp, record.nca_id);
         if (nca == nullptr)
             return InstallResult::ErrorCopyFailed;
@@ -648,20 +643,6 @@ ContentProviderUnion::ListEntriesFilterOrigin(std::optional<ContentProviderUnion
     return out;
 }
 
-std::optional<ContentProviderUnionSlot> ContentProviderUnion::GetSlotForEntry(
-    u64 title_id, ContentRecordType type) const {
-    const auto iter =
-        std::find_if(providers.begin(), providers.end(), [title_id, type](const auto& provider) {
-            return provider.second != nullptr && provider.second->HasEntry(title_id, type);
-        });
-
-    if (iter == providers.end()) {
-        return std::nullopt;
-    }
-
-    return iter->first;
-}
-
 ManualContentProvider::~ManualContentProvider() = default;
 
 void ManualContentProvider::AddEntry(TitleType title_type, ContentRecordType content_type,

src/core/file_sys/registered_cache.h

@@ -199,9 +199,6 @@ public:
         std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
         std::optional<u64> title_id = {}) const;
 
-    std::optional<ContentProviderUnionSlot> GetSlotForEntry(u64 title_id,
-                                                            ContentRecordType type) const;
-
 private:
     std::map<ContentProviderUnionSlot, ContentProvider*> providers;
 };

src/core/file_sys/submission_package.cpp

@@ -235,33 +235,27 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
         const auto section0 = nca->GetSubdirectories()[0];
 
         for (const auto& inner_file : section0->GetFiles()) {
-            if (inner_file->GetExtension() != "cnmt") {
+            if (inner_file->GetExtension() != "cnmt")
                 continue;
-            }
 
             const CNMT cnmt(inner_file);
             auto& ncas_title = ncas[cnmt.GetTitleID()];
 
             ncas_title[{cnmt.GetType(), ContentRecordType::Meta}] = nca;
             for (const auto& rec : cnmt.GetContentRecords()) {
-                const auto id_string = Common::HexToString(rec.nca_id, false);
-                auto next_file = pfs->GetFile(fmt::format("{}.nca", id_string));
-
+                const auto id_string = Common::HexArrayToString(rec.nca_id, false);
+                const auto next_file = pfs->GetFile(fmt::format("{}.nca", id_string));
                 if (next_file == nullptr) {
-                    if (rec.type != ContentRecordType::DeltaFragment) {
-                        LOG_WARNING(Service_FS,
-                                    "NCA with ID {}.nca is listed in content metadata, but cannot "
-                                    "be found in PFS. NSP appears to be corrupted.",
-                                    id_string);
-                    }
-
+                    LOG_WARNING(Service_FS,
+                                "NCA with ID {}.nca is listed in content metadata, but cannot "
+                                "be found in PFS. NSP appears to be corrupted.",
+                                id_string);
                     continue;
                 }
 
-                auto next_nca = std::make_shared<NCA>(std::move(next_file), nullptr, 0, keys);
-                if (next_nca->GetType() == NCAContentType::Program) {
+                auto next_nca = std::make_shared<NCA>(next_file, nullptr, 0, keys);
+                if (next_nca->GetType() == NCAContentType::Program)
                     program_status[cnmt.GetTitleID()] = next_nca->GetStatus();
-                }
                 if (next_nca->GetStatus() == Loader::ResultStatus::Success ||
                     (next_nca->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS &&
                      (cnmt.GetTitleID() & 0x800) != 0)) {

src/core/file_sys/xts_archive.cpp

@@ -66,7 +66,7 @@ NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
     Core::Crypto::SHA256Hash hash{};
     mbedtls_sha256(nca_id.data(), nca_id.size(), hash.data(), 0);
     status = Parse(fmt::format("/registered/000000{:02X}/{}.nca", hash[0],
-                               Common::HexToString(nca_id, false)));
+                               Common::HexArrayToString(nca_id, false)));
 }
 
 NAX::~NAX() = default;

src/core/frontend/applets/general_frontend.cpp

@@ -7,38 +7,9 @@
 
 namespace Core::Frontend {
 
-ParentalControlsApplet::~ParentalControlsApplet() = default;
-
-DefaultParentalControlsApplet::~DefaultParentalControlsApplet() = default;
-
-void DefaultParentalControlsApplet::VerifyPIN(std::function<void(bool)> finished,
-                                              bool suspend_future_verification_temporarily) {
-    LOG_INFO(Service_AM,
-             "Application requested frontend to verify PIN (normal), "
-             "suspend_future_verification_temporarily={}, verifying as correct.",
-             suspend_future_verification_temporarily);
-    finished(true);
-}
-
-void DefaultParentalControlsApplet::VerifyPINForSettings(std::function<void(bool)> finished) {
-    LOG_INFO(Service_AM,
-             "Application requested frontend to verify PIN (settings), verifying as correct.");
-    finished(true);
-}
-
-void DefaultParentalControlsApplet::RegisterPIN(std::function<void()> finished) {
-    LOG_INFO(Service_AM, "Application requested frontend to register new PIN");
-    finished();
-}
-
-void DefaultParentalControlsApplet::ChangePIN(std::function<void()> finished) {
-    LOG_INFO(Service_AM, "Application requested frontend to change PIN to new value");
-    finished();
-}
-
 PhotoViewerApplet::~PhotoViewerApplet() = default;
 
-DefaultPhotoViewerApplet::~DefaultPhotoViewerApplet() = default;
+DefaultPhotoViewerApplet::~DefaultPhotoViewerApplet() {}
 
 void DefaultPhotoViewerApplet::ShowPhotosForApplication(u64 title_id,
                                                         std::function<void()> finished) const {
@@ -53,72 +24,4 @@ void DefaultPhotoViewerApplet::ShowAllPhotos(std::function<void()> finished) con
     finished();
 }
 
-ECommerceApplet::~ECommerceApplet() = default;
-
-DefaultECommerceApplet::~DefaultECommerceApplet() = default;
-
-void DefaultECommerceApplet::ShowApplicationInformation(
-    std::function<void()> finished, u64 title_id, std::optional<u128> user_id,
-    std::optional<bool> full_display, std::optional<std::string> extra_parameter) {
-    const auto value = user_id.value_or(u128{});
-    LOG_INFO(Service_AM,
-             "Application requested frontend show application information for EShop, "
-             "title_id={:016X}, user_id={:016X}{:016X}, full_display={}, extra_parameter={}",
-             title_id, value[1], value[0],
-             full_display.has_value() ? fmt::format("{}", *full_display) : "null",
-             extra_parameter.value_or("null"));
-    finished();
-}
-
-void DefaultECommerceApplet::ShowAddOnContentList(std::function<void()> finished, u64 title_id,
-                                                  std::optional<u128> user_id,
-                                                  std::optional<bool> full_display) {
-    const auto value = user_id.value_or(u128{});
-    LOG_INFO(Service_AM,
-             "Application requested frontend show add on content list for EShop, "
-             "title_id={:016X}, user_id={:016X}{:016X}, full_display={}",
-             title_id, value[1], value[0],
-             full_display.has_value() ? fmt::format("{}", *full_display) : "null");
-    finished();
-}
-
-void DefaultECommerceApplet::ShowSubscriptionList(std::function<void()> finished, u64 title_id,
-                                                  std::optional<u128> user_id) {
-    const auto value = user_id.value_or(u128{});
-    LOG_INFO(Service_AM,
-             "Application requested frontend show subscription list for EShop, title_id={:016X}, "
-             "user_id={:016X}{:016X}",
-             title_id, value[1], value[0]);
-    finished();
-}
-
-void DefaultECommerceApplet::ShowConsumableItemList(std::function<void()> finished, u64 title_id,
-                                                    std::optional<u128> user_id) {
-    const auto value = user_id.value_or(u128{});
-    LOG_INFO(
-        Service_AM,
-        "Application requested frontend show consumable item list for EShop, title_id={:016X}, "
-        "user_id={:016X}{:016X}",
-        title_id, value[1], value[0]);
-    finished();
-}
-
-void DefaultECommerceApplet::ShowShopHome(std::function<void()> finished, u128 user_id,
-                                          bool full_display) {
-    LOG_INFO(Service_AM,
-             "Application requested frontend show home menu for EShop, user_id={:016X}{:016X}, "
-             "full_display={}",
-             user_id[1], user_id[0], full_display);
-    finished();
-}
-
-void DefaultECommerceApplet::ShowSettings(std::function<void()> finished, u128 user_id,
-                                          bool full_display) {
-    LOG_INFO(Service_AM,
-             "Application requested frontend show settings menu for EShop, user_id={:016X}{:016X}, "
-             "full_display={}",
-             user_id[1], user_id[0], full_display);
-    finished();
-}
-
 } // namespace Core::Frontend

src/core/frontend/applets/general_frontend.h

@@ -5,43 +5,10 @@
 #pragma once
 
 #include <functional>
-#include <optional>
 #include "common/common_types.h"
 
 namespace Core::Frontend {
 
-class ParentalControlsApplet {
-public:
-    virtual ~ParentalControlsApplet();
-
-    // Prompts the user to enter a PIN and calls the callback with whether or not it matches the
-    // correct PIN. If the bool is passed, and the PIN was recently entered correctly, the frontend
-    // should not prompt and simply return true.
-    virtual void VerifyPIN(std::function<void(bool)> finished,
-                           bool suspend_future_verification_temporarily) = 0;
-
-    // Prompts the user to enter a PIN and calls the callback for correctness. Frontends can
-    // optionally alert the user that this is to change parental controls settings.
-    virtual void VerifyPINForSettings(std::function<void(bool)> finished) = 0;
-
-    // Prompts the user to create a new PIN for pctl and stores it with the service.
-    virtual void RegisterPIN(std::function<void()> finished) = 0;
-
-    // Prompts the user to verify the current PIN and then store a new one into pctl.
-    virtual void ChangePIN(std::function<void()> finished) = 0;
-};
-
-class DefaultParentalControlsApplet final : public ParentalControlsApplet {
-public:
-    ~DefaultParentalControlsApplet() override;
-
-    void VerifyPIN(std::function<void(bool)> finished,
-                   bool suspend_future_verification_temporarily) override;
-    void VerifyPINForSettings(std::function<void(bool)> finished) override;
-    void RegisterPIN(std::function<void()> finished) override;
-    void ChangePIN(std::function<void()> finished) override;
-};
-
 class PhotoViewerApplet {
 public:
     virtual ~PhotoViewerApplet();
@@ -58,55 +25,4 @@ public:
     void ShowAllPhotos(std::function<void()> finished) const override;
 };
 
-class ECommerceApplet {
-public:
-    virtual ~ECommerceApplet();
-
-    // Shows a page with application icons, description, name, and price.
-    virtual void ShowApplicationInformation(std::function<void()> finished, u64 title_id,
-                                            std::optional<u128> user_id = {},
-                                            std::optional<bool> full_display = {},
-                                            std::optional<std::string> extra_parameter = {}) = 0;
-
-    // Shows a page with all of the add on content available for a game, with name, description, and
-    // price.
-    virtual void ShowAddOnContentList(std::function<void()> finished, u64 title_id,
-                                      std::optional<u128> user_id = {},
-                                      std::optional<bool> full_display = {}) = 0;
-
-    // Shows a page with all of the subscriptions (recurring payments) for a game, with name,
-    // description, price, and renewal period.
-    virtual void ShowSubscriptionList(std::function<void()> finished, u64 title_id,
-                                      std::optional<u128> user_id = {}) = 0;
-
-    // Shows a page with a list of any additional game related purchasable items (DLC,
-    // subscriptions, etc) for a particular game, with name, description, type, and price.
-    virtual void ShowConsumableItemList(std::function<void()> finished, u64 title_id,
-                                        std::optional<u128> user_id = {}) = 0;
-
-    // Shows the home page of the shop.
-    virtual void ShowShopHome(std::function<void()> finished, u128 user_id, bool full_display) = 0;
-
-    // Shows the user settings page of the shop.
-    virtual void ShowSettings(std::function<void()> finished, u128 user_id, bool full_display) = 0;
-};
-
-class DefaultECommerceApplet : public ECommerceApplet {
-public:
-    ~DefaultECommerceApplet() override;
-
-    void ShowApplicationInformation(std::function<void()> finished, u64 title_id,
-                                    std::optional<u128> user_id, std::optional<bool> full_display,
-                                    std::optional<std::string> extra_parameter) override;
-    void ShowAddOnContentList(std::function<void()> finished, u64 title_id,
-                              std::optional<u128> user_id,
-                              std::optional<bool> full_display) override;
-    void ShowSubscriptionList(std::function<void()> finished, u64 title_id,
-                              std::optional<u128> user_id) override;
-    void ShowConsumableItemList(std::function<void()> finished, u64 title_id,
-                                std::optional<u128> user_id) override;
-    void ShowShopHome(std::function<void()> finished, u128 user_id, bool full_display) override;
-    void ShowSettings(std::function<void()> finished, u128 user_id, bool full_display) override;
-};
-
 } // namespace Core::Frontend

src/core/frontend/applets/profile_select.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "core/frontend/applets/profile_select.h"
-#include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
 
 namespace Core::Frontend {
@@ -11,9 +10,9 @@ namespace Core::Frontend {
 ProfileSelectApplet::~ProfileSelectApplet() = default;
 
 void DefaultProfileSelectApplet::SelectProfile(
-    std::function<void(std::optional<Common::UUID>)> callback) const {
+    std::function<void(std::optional<Service::Account::UUID>)> callback) const {
     Service::Account::ProfileManager manager;
-    callback(manager.GetUser(Settings::values.current_user).value_or(Common::UUID{}));
+    callback(manager.GetUser(Settings::values.current_user).value_or(Service::Account::UUID{}));
     LOG_INFO(Service_ACC, "called, selecting current user instead of prompting...");
 }
 

src/core/frontend/applets/profile_select.h

@@ -6,7 +6,7 @@
 
 #include <functional>
 #include <optional>
-#include "common/uuid.h"
+#include "core/hle/service/acc/profile_manager.h"
 
 namespace Core::Frontend {
 
@@ -14,12 +14,14 @@ class ProfileSelectApplet {
 public:
     virtual ~ProfileSelectApplet();
 
-    virtual void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const = 0;
+    virtual void SelectProfile(
+        std::function<void(std::optional<Service::Account::UUID>)> callback) const = 0;
 };
 
 class DefaultProfileSelectApplet final : public ProfileSelectApplet {
 public:
-    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const override;
+    void SelectProfile(
+        std::function<void(std::optional<Service::Account::UUID>)> callback) const override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/applets/web_browser.cpp

@@ -11,9 +11,9 @@ WebBrowserApplet::~WebBrowserApplet() = default;
 
 DefaultWebBrowserApplet::~DefaultWebBrowserApplet() = default;
 
-void DefaultWebBrowserApplet::OpenPageLocal(std::string_view filename,
-                                            std::function<void()> unpack_romfs_callback,
-                                            std::function<void()> finished_callback) {
+void DefaultWebBrowserApplet::OpenPage(std::string_view filename,
+                                       std::function<void()> unpack_romfs_callback,
+                                       std::function<void()> finished_callback) {
     LOG_INFO(Service_AM,
              "(STUBBED) called - No suitable web browser implementation found to open website page "
              "at '{}'!",

src/core/frontend/applets/web_browser.h

@@ -13,16 +13,16 @@ class WebBrowserApplet {
 public:
     virtual ~WebBrowserApplet();
 
-    virtual void OpenPageLocal(std::string_view url, std::function<void()> unpack_romfs_callback,
-                               std::function<void()> finished_callback) = 0;
+    virtual void OpenPage(std::string_view url, std::function<void()> unpack_romfs_callback,
+                          std::function<void()> finished_callback) = 0;
 };
 
 class DefaultWebBrowserApplet final : public WebBrowserApplet {
 public:
     ~DefaultWebBrowserApplet() override;
 
-    void OpenPageLocal(std::string_view url, std::function<void()> unpack_romfs_callback,
-                       std::function<void()> finished_callback) override;
+    void OpenPage(std::string_view url, std::function<void()> unpack_romfs_callback,
+                  std::function<void()> finished_callback) override;
 };
 
 } // namespace Core::Frontend

src/core/frontend/emu_window.h

@@ -169,7 +169,8 @@ private:
      * For the request to be honored, EmuWindow implementations will usually reimplement this
      * function.
      */
-    virtual void OnMinimalClientAreaChangeRequest(std::pair<unsigned, unsigned>) {
+    virtual void OnMinimalClientAreaChangeRequest(
+        const std::pair<unsigned, unsigned>& minimal_size) {
         // By default, ignore this request and do nothing.
     }
 

src/core/frontend/framebuffer_layout.cpp

@@ -20,7 +20,7 @@ static Common::Rectangle<T> MaxRectangle(Common::Rectangle<T> window_area,
                                 static_cast<T>(std::round(scale * screen_aspect_ratio))};
 }
 
-FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
+FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height) {
     ASSERT(width > 0);
     ASSERT(height > 0);
     // The drawing code needs at least somewhat valid values for both screens
@@ -29,23 +29,22 @@ FramebufferLayout DefaultFrameLayout(u32 width, u32 height) {
 
     const float emulation_aspect_ratio{static_cast<float>(ScreenUndocked::Height) /
                                        ScreenUndocked::Width};
-    const auto window_aspect_ratio = static_cast<float>(height) / width;
+    Common::Rectangle<unsigned> screen_window_area{0, 0, width, height};
+    Common::Rectangle<unsigned> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);
 
-    const Common::Rectangle<u32> screen_window_area{0, 0, width, height};
-    Common::Rectangle<u32> screen = MaxRectangle(screen_window_area, emulation_aspect_ratio);
+    float window_aspect_ratio = static_cast<float>(height) / width;
 
     if (window_aspect_ratio < emulation_aspect_ratio) {
         screen = screen.TranslateX((screen_window_area.GetWidth() - screen.GetWidth()) / 2);
     } else {
         screen = screen.TranslateY((height - screen.GetHeight()) / 2);
     }
-
     res.screen = screen;
     return res;
 }
 
-FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale) {
-    u32 width, height;
+FramebufferLayout FrameLayoutFromResolutionScale(u16 res_scale) {
+    int width, height;
 
     if (Settings::values.use_docked_mode) {
         width = ScreenDocked::WidthDocked * res_scale;

src/core/frontend/framebuffer_layout.h

@@ -8,22 +8,15 @@
 
 namespace Layout {
 
-enum ScreenUndocked : u32 {
-    Width = 1280,
-    Height = 720,
-};
-
-enum ScreenDocked : u32 {
-    WidthDocked = 1920,
-    HeightDocked = 1080,
-};
+enum ScreenUndocked : unsigned { Width = 1280, Height = 720 };
+enum ScreenDocked : unsigned { WidthDocked = 1920, HeightDocked = 1080 };
 
 /// Describes the layout of the window framebuffer
 struct FramebufferLayout {
-    u32 width{ScreenUndocked::Width};
-    u32 height{ScreenUndocked::Height};
+    unsigned width{ScreenUndocked::Width};
+    unsigned height{ScreenUndocked::Height};
 
-    Common::Rectangle<u32> screen;
+    Common::Rectangle<unsigned> screen;
 
     /**
      * Returns the ration of pixel size of the screen, compared to the native size of the undocked
@@ -40,12 +33,12 @@ struct FramebufferLayout {
  * @param height Window framebuffer height in pixels
  * @return Newly created FramebufferLayout object with default screen regions initialized
  */
-FramebufferLayout DefaultFrameLayout(u32 width, u32 height);
+FramebufferLayout DefaultFrameLayout(unsigned width, unsigned height);
 
 /**
  * Convenience method to get frame layout by resolution scale
  * @param res_scale resolution scale factor
  */
-FramebufferLayout FrameLayoutFromResolutionScale(u32 res_scale);
+FramebufferLayout FrameLayoutFromResolutionScale(u16 res_scale);
 
 } // namespace Layout

src/core/hle/ipc_helpers.h

@@ -438,7 +438,7 @@ inline float RequestParser::Pop() {
 template <>
 inline double RequestParser::Pop() {
     const u64 value = Pop<u64>();
-    double real;
+    float real;
     std::memcpy(&real, &value, sizeof(real));
     return real;
 }

src/core/hle/kernel/hle_ipc.cpp

@@ -43,7 +43,7 @@ void SessionRequestHandler::ClientDisconnected(const SharedPtr<ServerSession>& s
 }
 
 SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
-    const std::string& reason, u64 timeout, WakeupCallback&& callback,
+    SharedPtr<Thread> thread, const std::string& reason, u64 timeout, WakeupCallback&& callback,
     SharedPtr<WritableEvent> writable_event) {
     // Put the client thread to sleep until the wait event is signaled or the timeout expires.
     thread->SetWakeupCallback([context = *this, callback](
@@ -58,7 +58,7 @@ SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
     auto& kernel = Core::System::GetInstance().Kernel();
     if (!writable_event) {
         // Create event if not provided
-        const auto pair = WritableEvent::CreateEventPair(kernel, ResetType::Automatic,
+        const auto pair = WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
                                                          "HLE Pause Event: " + reason);
         writable_event = pair.writable;
     }
@@ -76,9 +76,8 @@ SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
     return writable_event;
 }
 
-HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_session,
-                                     SharedPtr<Thread> thread)
-    : server_session(std::move(server_session)), thread(std::move(thread)) {
+HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_session)
+    : server_session(std::move(server_session)) {
     cmd_buf[0] = 0;
 }