common/math_util: Provide a template deduction guide for Common::Rectangle

Allows for things such as: auto rect = Common::Rectangle{0, 0, 0, 0}; as opposed to being required to explicitly write out the underlying type, such as: auto rect = Common::Rectangle<int>{0, 0, 0, 0}; The only requirement for the deduction is that all constructor arguments be the same type.
2019-05-29 02:47:03 -04:00
476 changed files with 8975 additions and 20927 deletions
@@ -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/
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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)
@@ -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')
@@ -1,2 +0,0 @@
-git config --global user.email "yuzu@yuzu-emu.org"
-git config --global user.name "yuzubot"
@@ -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/"
@@ -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
@@ -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()
@@ -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
@@ -1,23 +0,0 @@
-parameters:
-  artifactSource: 'true'
-  cache: 'false'
-
-steps:
- task: DockerInstaller@0
-  displayName: 'Prepare Environment'
-  inputs:
-    dockerVersion: '17.09.0-ce'
- ${{ if eq(parameters.cache, 'true') }}:
-  - 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 && RELEASE_NAME=$(BuildName) ./.ci/scripts/$(ScriptFolder)/upload.sh
-  displayName: 'Package Artifacts'
- publish: artifacts
-  artifact: 'yuzu-$(BuildName)-$(BuildSuffix)'
-  displayName: 'Upload Artifacts'
@@ -1,23 +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'
-      cache: $(parameters.cache)
@@ -1,33 +0,0 @@
-jobs:
- job: build_test
-  displayName: 'testing'
-  pool:
-    vmImage: ubuntu-latest
-  strategy:
-    maxParallel: 5
-    matrix:
-      windows:
-        BuildSuffix: 'windows-testing'
-        ScriptFolder: 'windows'
-  steps:
-  - script: sudo apt upgrade python3-pip && pip install requests urllib3
-    displayName: 'Prepare Environment'
-  - task: PythonScript@0
-    condition: eq(variables['Build.Reason'], 'PullRequest')
-    displayName: 'Determine Testing Status'
-    inputs:
-      scriptSource: 'filePath'
-      scriptPath: '.ci/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'
-        cache: 'false'
@@ -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'
@@ -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
@@ -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)'
@@ -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
@@ -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')
@@ -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)
@@ -1,25 +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
-    parameters:
-      cache: 'true'
@@ -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'
@@ -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'
@@ -1,20 +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
-    parameters:
-      cache: 'false'
-  - template: ./templates/build-testing.yml
@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-patreon: yuzuteam
@@ -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"
@@ -81,14 +80,8 @@ set(HASH_FILES
    "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
    "${VIDEO_CORE}/shader/decode/shift.cpp"
    "${VIDEO_CORE}/shader/decode/video.cpp"
-    "${VIDEO_CORE}/shader/decode/warp.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"
@@ -2,13 +2,12 @@ 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.

@@ -88,7 +88,6 @@ add_subdirectory(tests)

 if (ENABLE_SDL2)
    add_subdirectory(yuzu_cmd)
-    add_subdirectory(yuzu_tester)
 endif()

 if (ENABLE_QT)
@@ -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;
        }
    }
@@ -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);
@@ -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() {
@@ -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
@@ -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"
@@ -55,14 +54,8 @@ add_custom_command(OUTPUT scm_rev.cpp
      "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
      "${VIDEO_CORE}/shader/decode/shift.cpp"
      "${VIDEO_CORE}/shader/decode/video.cpp"
-      "${VIDEO_CORE}/shader/decode/warp.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"
@@ -78,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
@@ -131,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
@@ -3,7 +3,6 @@
 #pragma once

 #include <cstddef>
-#include <memory>
 #include <type_traits>

 namespace Common {
@@ -20,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.");
@@ -38,63 +31,4 @@ constexpr bool IsWordAligned(T value) {
    return (value & 0b11) == 0;
 }

-template <typename T, std::size_t Align = 16>
-class AlignmentAllocator {
-public:
-    using value_type = T;
-    using size_type = std::size_t;
-    using difference_type = std::ptrdiff_t;
-
-    using pointer = T*;
-    using const_pointer = const T*;
-
-    using reference = T&;
-    using const_reference = const T&;
-
-public:
-    pointer address(reference r) noexcept {
-        return std::addressof(r);
-    }
-
-    const_pointer address(const_reference r) const noexcept {
-        return std::addressof(r);
-    }
-
-    pointer allocate(size_type n) {
-        return static_cast<pointer>(::operator new (n, std::align_val_t{Align}));
-    }
-
-    void deallocate(pointer p, size_type) {
-        ::operator delete (p, std::align_val_t{Align});
-    }
-
-    void construct(pointer p, const value_type& wert) {
-        new (p) value_type(wert);
-    }
-
-    void destroy(pointer p) {
-        p->~value_type();
-    }
-
-    size_type max_size() const noexcept {
-        return size_type(-1) / sizeof(value_type);
-    }
-
-    template <typename T2>
-    struct rebind {
-        using other = AlignmentAllocator<T2, Align>;
-    };
-
-    bool operator!=(const AlignmentAllocator<T, Align>& other) const noexcept {
-        return !(*this == other);
-    }
-
-    // Returns true if and only if storage allocated from *this
-    // can be deallocated from other, and vice versa.
-    // Always returns true for stateless allocators.
-    bool operator==(const AlignmentAllocator<T, Align>& other) const noexcept {
-        return true;
-    }
-};
-
 } // namespace Common
@@ -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
@@ -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
@@ -4,7 +4,6 @@

 #pragma once

-#include <algorithm>
 #include <string>

 #if !defined(ARCHITECTURE_x86_64)
@@ -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,
@@ -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;
 }

@@ -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
@@ -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
@@ -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
@@ -111,8 +107,6 @@ add_library(core STATIC
    frontend/scope_acquire_window_context.h
    gdbstub/gdbstub.cpp
    gdbstub/gdbstub.h
-    hardware_interrupt_manager.cpp
-    hardware_interrupt_manager.h
    hle/ipc.h
    hle/ipc_helpers.h
    hle/kernel/address_arbiter.cpp
@@ -177,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
@@ -210,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
@@ -275,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
@@ -297,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
@@ -328,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
@@ -346,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
@@ -374,7 +351,6 @@ add_library(core STATIC
    hle/service/nvdrv/devices/nvmap.h
    hle/service/nvdrv/interface.cpp
    hle/service/nvdrv/interface.h
-    hle/service/nvdrv/nvdata.h
    hle/service/nvdrv/nvdrv.cpp
    hle/service/nvdrv/nvdrv.h
    hle/service/nvdrv/nvmemp.cpp
@@ -437,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
@@ -459,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
@@ -480,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)
@@ -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
@@ -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
@@ -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);
 }
@@ -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;
@@ -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));
 }
@@ -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;
@@ -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,
-}};
-}
@@ -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
@@ -18,56 +18,34 @@
 #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/hardware_interrupt_manager.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #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,
@@ -104,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();
@@ -139,20 +117,17 @@ 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);
        if (!renderer->Init()) {
            return ResultStatus::ErrorVideoCore;
        }
-        interrupt_manager = std::make_unique<Core::Hardware::InterruptManager>(system);
+
        gpu_core = VideoCore::CreateGPU(system);

        is_powered_on = true;
@@ -169,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) {
@@ -182,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));
@@ -193,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.
@@ -252,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) {
@@ -299,30 +256,20 @@ struct System::Impl {
    std::unique_ptr<VideoCore::RendererBase> renderer;
    std::unique_ptr<Tegra::GPU> gpu_core;
    std::shared_ptr<Tegra::DebugContext> debug_context;
-    std::unique_ptr<Core::Hardware::InterruptManager> interrupt_manager;
    CpuCoreManager cpu_core_manager;
    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 = "";

@@ -446,14 +393,6 @@ const Tegra::GPU& System::GPU() const {
    return *impl->gpu_core;
 }

-Core::Hardware::InterruptManager& System::InterruptManager() {
-    return *impl->interrupt_manager;
-}
-
-const Core::Hardware::InterruptManager& System::InterruptManager() const {
-    return *impl->interrupt_manager;
-}
-
 VideoCore::RendererBase& System::Renderer() {
    return *impl->renderer;
 }
@@ -570,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);
 }
@@ -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
@@ -70,10 +61,6 @@ namespace Core::Timing {
 class CoreTiming;
 }

-namespace Core::Hardware {
-class InterruptManager;
-}
-
 namespace Core {

 class ARM_Interface;
@@ -81,7 +68,6 @@ class Cpu;
 class ExclusiveMonitor;
 class FrameLimiter;
 class PerfStats;
-class Reporter;
 class TelemetrySession;

 struct PerfStatsResults;
@@ -112,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
@@ -238,12 +225,6 @@ public:
    /// Provides a constant reference to the core timing instance.
    const Timing::CoreTiming& CoreTiming() const;

-    /// Provides a reference to the interrupt manager instance.
-    Core::Hardware::InterruptManager& InterruptManager();
-
-    /// Provides a constant reference to the interrupt manager instance.
-    const Core::Hardware::InterruptManager& InterruptManager() const;
-
    /// Provides a reference to the kernel instance.
    Kernel::KernelCore& Kernel();

@@ -304,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();

@@ -337,6 +308,10 @@ private:
    static System s_instance;
 };

+inline ARM_Interface& CurrentArmInterface() {
+    return System::GetInstance().CurrentArmInterface();
+}
+
 inline Kernel::Process* CurrentProcess() {
    return System::GetInstance().CurrentProcess();
 }
@@ -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) {
@@ -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;
@@ -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
@@ -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) {
@@ -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);
@@ -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;
@@ -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);
    }
 }
@@ -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());
        }
    }
@@ -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) {
@@ -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));
@@ -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{};
@@ -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));
@@ -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
@@ -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
@@ -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.");

@@ -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();

@@ -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
@@ -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;
 }
@@ -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;
@@ -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,
@@ -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;
 };
@@ -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)) {
@@ -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;
@@ -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
@@ -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
@@ -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...");
 }

@@ -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
@@ -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 '{}'!",
@@ -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
@@ -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.
    }

@@ -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;
@@ -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
@@ -1,30 +0,0 @@
-// Copyright 2019 Yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/hardware_interrupt_manager.h"
-#include "core/hle/service/nvdrv/interface.h"
-#include "core/hle/service/sm/sm.h"
-
-namespace Core::Hardware {
-
-InterruptManager::InterruptManager(Core::System& system_in) : system(system_in) {
-    gpu_interrupt_event =
-        system.CoreTiming().RegisterEvent("GPUInterrupt", [this](u64 message, s64) {
-            auto nvdrv = system.ServiceManager().GetService<Service::Nvidia::NVDRV>("nvdrv");
-            const u32 syncpt = static_cast<u32>(message >> 32);
-            const u32 value = static_cast<u32>(message);
-            nvdrv->SignalGPUInterruptSyncpt(syncpt, value);
-        });
-}
-
-InterruptManager::~InterruptManager() = default;
-
-void InterruptManager::GPUInterruptSyncpt(const u32 syncpoint_id, const u32 value) {
-    const u64 msg = (static_cast<u64>(syncpoint_id) << 32ULL) | value;
-    system.CoreTiming().ScheduleEvent(10, gpu_interrupt_event, msg);
-}
-
-} // namespace Core::Hardware
@@ -1,31 +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"
-
-namespace Core {
-class System;
-}
-
-namespace Core::Timing {
-struct EventType;
-}
-
-namespace Core::Hardware {
-
-class InterruptManager {
-public:
-    explicit InterruptManager(Core::System& system);
-    ~InterruptManager();
-
-    void GPUInterruptSyncpt(u32 syncpoint_id, u32 value);
-
-private:
-    Core::System& system;
-    Core::Timing::EventType* gpu_interrupt_event{};
-};
-
-} // namespace Core::Hardware
@@ -8,7 +8,6 @@
 #include <vector>

 #include "common/common_types.h"
-#include "core/hle/kernel/physical_memory.h"

 namespace Kernel {

@@ -78,7 +77,7 @@ struct CodeSet final {
    }

    /// The overall data that backs this code set.
-    Kernel::PhysicalMemory memory;
+    std::vector<u8> memory;

    /// The segments that comprise this code set.
    std::array<Segment, 3> segments;
@@ -99,8 +99,7 @@ struct KernelCore::Impl {

    void Shutdown() {
        next_object_id = 0;
-        next_kernel_process_id = Process::InitialKIPIDMin;
-        next_user_process_id = Process::ProcessIDMin;
+        next_process_id = Process::ProcessIDMin;
        next_thread_id = 1;

        process_list.clear();
@@ -133,8 +132,7 @@ struct KernelCore::Impl {
    }

    std::atomic<u32> next_object_id{0};
-    std::atomic<u64> next_kernel_process_id{Process::InitialKIPIDMin};
-    std::atomic<u64> next_user_process_id{Process::ProcessIDMin};
+    std::atomic<u64> next_process_id{Process::ProcessIDMin};
    std::atomic<u64> next_thread_id{1};

    // Lists all processes that exist in the current session.
@@ -228,12 +226,8 @@ u64 KernelCore::CreateNewThreadID() {
    return impl->next_thread_id++;
 }

-u64 KernelCore::CreateNewKernelProcessID() {
-    return impl->next_kernel_process_id++;
-}
-
-u64 KernelCore::CreateNewUserProcessID() {
-    return impl->next_user_process_id++;
+u64 KernelCore::CreateNewProcessID() {
+    return impl->next_process_id++;
 }

 Core::Timing::EventType* KernelCore::ThreadWakeupCallbackEventType() const {
@@ -96,10 +96,7 @@ private:
    u32 CreateNewObjectID();

    /// Creates a new process ID, incrementing the internal process ID counter;
-    u64 CreateNewKernelProcessID();
-
-    /// Creates a new process ID, incrementing the internal process ID counter;
-    u64 CreateNewUserProcessID();
+    u64 CreateNewProcessID();

    /// Creates a new thread ID, incrementing the internal thread ID counter.
    u64 CreateNewThreadID();
@@ -1,19 +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/alignment.h"
-
-namespace Kernel {
-
-// This encapsulation serves 2 purposes:
-// - First, to encapsulate host physical memory under a single type and set an
-// standard for managing it.
-// - Second to ensure all host backing memory used is aligned to 256 bytes due
-// to strict alignment restrictions on GPU memory.
-
-using PhysicalMemory = std::vector<u8, Common::AlignmentAllocator<u8, 256>>;
-
-} // namespace Kernel
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.

 #include <algorithm>
-#include <bitset>
 #include <memory>
 #include <random>
 #include "common/alignment.h"
@@ -49,58 +48,7 @@ void SetupMainThread(Process& owner_process, KernelCore& kernel, u32 priority) {
 }
 } // Anonymous namespace

-// Represents a page used for thread-local storage.
-//
-// Each TLS page contains slots that may be used by processes and threads.
-// Every process and thread is created with a slot in some arbitrary page
-// (whichever page happens to have an available slot).
-class TLSPage {
-public:
-    static constexpr std::size_t num_slot_entries = Memory::PAGE_SIZE / Memory::TLS_ENTRY_SIZE;
-
-    explicit TLSPage(VAddr address) : base_address{address} {}
-
-    bool HasAvailableSlots() const {
-        return !is_slot_used.all();
-    }
-
-    VAddr GetBaseAddress() const {
-        return base_address;
-    }
-
-    std::optional<VAddr> ReserveSlot() {
-        for (std::size_t i = 0; i < is_slot_used.size(); i++) {
-            if (is_slot_used[i]) {
-                continue;
-            }
-
-            is_slot_used[i] = true;
-            return base_address + (i * Memory::TLS_ENTRY_SIZE);
-        }
-
-        return std::nullopt;
-    }
-
-    void ReleaseSlot(VAddr address) {
-        // Ensure that all given addresses are consistent with how TLS pages
-        // are intended to be used when releasing slots.
-        ASSERT(IsWithinPage(address));
-        ASSERT((address % Memory::TLS_ENTRY_SIZE) == 0);
-
-        const std::size_t index = (address - base_address) / Memory::TLS_ENTRY_SIZE;
-        is_slot_used[index] = false;
-    }
-
-private:
-    bool IsWithinPage(VAddr address) const {
-        return base_address <= address && address < base_address + Memory::PAGE_SIZE;
-    }
-
-    VAddr base_address;
-    std::bitset<num_slot_entries> is_slot_used;
-};
-
-SharedPtr<Process> Process::Create(Core::System& system, std::string name, ProcessType type) {
+SharedPtr<Process> Process::Create(Core::System& system, std::string&& name) {
    auto& kernel = system.Kernel();

    SharedPtr<Process> process(new Process(system));
@@ -108,8 +56,7 @@ SharedPtr<Process> Process::Create(Core::System& system, std::string name, Proce
    process->resource_limit = kernel.GetSystemResourceLimit();
    process->status = ProcessStatus::Created;
    process->program_id = 0;
-    process->process_id = type == ProcessType::KernelInternal ? kernel.CreateNewKernelProcessID()
-                                                              : kernel.CreateNewUserProcessID();
+    process->process_id = kernel.CreateNewProcessID();
    process->capabilities.InitializeForMetadatalessProcess();

    std::mt19937 rng(Settings::values.rng_seed.value_or(0));
@@ -125,21 +72,8 @@ SharedPtr<ResourceLimit> Process::GetResourceLimit() const {
    return resource_limit;
 }

-u64 Process::GetTotalPhysicalMemoryAvailable() const {
-    return vm_manager.GetTotalPhysicalMemoryAvailable();
-}
-
-u64 Process::GetTotalPhysicalMemoryAvailableWithoutSystemResource() const {
-    return GetTotalPhysicalMemoryAvailable() - GetSystemResourceSize();
-}
-
 u64 Process::GetTotalPhysicalMemoryUsed() const {
-    return vm_manager.GetCurrentHeapSize() + main_thread_stack_size + code_memory_size +
-           GetSystemResourceUsage();
-}
-
-u64 Process::GetTotalPhysicalMemoryUsedWithoutSystemResource() const {
-    return GetTotalPhysicalMemoryUsed() - GetSystemResourceUsage();
+    return vm_manager.GetCurrentHeapSize() + main_thread_stack_size + code_memory_size;
 }

 void Process::RegisterThread(const Thread* thread) {
@@ -169,7 +103,6 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
    program_id = metadata.GetTitleID();
    ideal_core = metadata.GetMainThreadCore();
    is_64bit_process = metadata.Is64BitProgram();
-    system_resource_size = metadata.GetSystemResourceSize();

    vm_manager.Reset(metadata.GetAddressSpaceType());

@@ -184,11 +117,19 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
 }

 void Process::Run(s32 main_thread_priority, u64 stack_size) {
-    AllocateMainThreadStack(stack_size);
-    tls_region_address = CreateTLSRegion();
+    // The kernel always ensures that the given stack size is page aligned.
+    main_thread_stack_size = Common::AlignUp(stack_size, Memory::PAGE_SIZE);
+
+    // Allocate and map the main thread stack
+    // TODO(bunnei): This is heap area that should be allocated by the kernel and not mapped as part
+    // of the user address space.
+    const VAddr mapping_address = vm_manager.GetTLSIORegionEndAddress() - main_thread_stack_size;
+    vm_manager
+        .MapMemoryBlock(mapping_address, std::make_shared<std::vector<u8>>(main_thread_stack_size),
+                        0, main_thread_stack_size, MemoryState::Stack)
+        .Unwrap();

    vm_manager.LogLayout();
-
    ChangeStatus(ProcessStatus::Running);

    SetupMainThread(*this, kernel, main_thread_priority);
@@ -218,66 +159,69 @@ void Process::PrepareForTermination() {
    stop_threads(system.Scheduler(2).GetThreadList());
    stop_threads(system.Scheduler(3).GetThreadList());

-    FreeTLSRegion(tls_region_address);
-    tls_region_address = 0;
-
    ChangeStatus(ProcessStatus::Exited);
 }

 /**
- * Attempts to find a TLS page that contains a free slot for
- * use by a thread.
- *
- * @returns If a page with an available slot is found, then an iterator
- *          pointing to the page is returned. Otherwise the end iterator
- *          is returned instead.
+ * Finds a free location for the TLS section of a thread.
+ * @param tls_slots The TLS page array of the thread's owner process.
+ * Returns a tuple of (page, slot, alloc_needed) where:
+ * page: The index of the first allocated TLS page that has free slots.
+ * slot: The index of the first free slot in the indicated page.
+ * alloc_needed: Whether there's a need to allocate a new TLS page (All pages are full).
 */
-static auto FindTLSPageWithAvailableSlots(std::vector<TLSPage>& tls_pages) {
-    return std::find_if(tls_pages.begin(), tls_pages.end(),
-                        [](const auto& page) { return page.HasAvailableSlots(); });
-}
-
-VAddr Process::CreateTLSRegion() {
-    auto tls_page_iter = FindTLSPageWithAvailableSlots(tls_pages);
-
-    if (tls_page_iter == tls_pages.cend()) {
-        const auto region_address =
-            vm_manager.FindFreeRegion(vm_manager.GetTLSIORegionBaseAddress(),
-                                      vm_manager.GetTLSIORegionEndAddress(), Memory::PAGE_SIZE);
-        ASSERT(region_address.Succeeded());
-
-        const auto map_result = vm_manager.MapMemoryBlock(
-            *region_address, std::make_shared<PhysicalMemory>(Memory::PAGE_SIZE), 0,
-            Memory::PAGE_SIZE, MemoryState::ThreadLocal);
-        ASSERT(map_result.Succeeded());
-
-        tls_pages.emplace_back(*region_address);
-
-        const auto reserve_result = tls_pages.back().ReserveSlot();
-        ASSERT(reserve_result.has_value());
-
-        return *reserve_result;
+static std::tuple<std::size_t, std::size_t, bool> FindFreeThreadLocalSlot(
+    const std::vector<std::bitset<8>>& tls_slots) {
+    // Iterate over all the allocated pages, and try to find one where not all slots are used.
+    for (std::size_t page = 0; page < tls_slots.size(); ++page) {
+        const auto& page_tls_slots = tls_slots[page];
+        if (!page_tls_slots.all()) {
+            // We found a page with at least one free slot, find which slot it is
+            for (std::size_t slot = 0; slot < page_tls_slots.size(); ++slot) {
+                if (!page_tls_slots.test(slot)) {
+                    return std::make_tuple(page, slot, false);
+                }
+            }
+        }
    }

-    return *tls_page_iter->ReserveSlot();
+    return std::make_tuple(0, 0, true);
 }

-void Process::FreeTLSRegion(VAddr tls_address) {
-    const VAddr aligned_address = Common::AlignDown(tls_address, Memory::PAGE_SIZE);
-    auto iter =
-        std::find_if(tls_pages.begin(), tls_pages.end(), [aligned_address](const auto& page) {
-            return page.GetBaseAddress() == aligned_address;
-        });
+VAddr Process::MarkNextAvailableTLSSlotAsUsed(Thread& thread) {
+    auto [available_page, available_slot, needs_allocation] = FindFreeThreadLocalSlot(tls_slots);
+    const VAddr tls_begin = vm_manager.GetTLSIORegionBaseAddress();

-    // Something has gone very wrong if we're freeing a region
-    // with no actual page available.
-    ASSERT(iter != tls_pages.cend());
+    if (needs_allocation) {
+        tls_slots.emplace_back(0); // The page is completely available at the start
+        available_page = tls_slots.size() - 1;
+        available_slot = 0; // Use the first slot in the new page

-    iter->ReleaseSlot(tls_address);
+        // Allocate some memory from the end of the linear heap for this region.
+        auto& tls_memory = thread.GetTLSMemory();
+        tls_memory->insert(tls_memory->end(), Memory::PAGE_SIZE, 0);
+
+        vm_manager.RefreshMemoryBlockMappings(tls_memory.get());
+
+        vm_manager.MapMemoryBlock(tls_begin + available_page * Memory::PAGE_SIZE, tls_memory, 0,
+                                  Memory::PAGE_SIZE, MemoryState::ThreadLocal);
+    }
+
+    tls_slots[available_page].set(available_slot);
+
+    return tls_begin + available_page * Memory::PAGE_SIZE + available_slot * Memory::TLS_ENTRY_SIZE;
+}
+
+void Process::FreeTLSSlot(VAddr tls_address) {
+    const VAddr tls_base = tls_address - vm_manager.GetTLSIORegionBaseAddress();
+    const VAddr tls_page = tls_base / Memory::PAGE_SIZE;
+    const VAddr tls_slot = (tls_base % Memory::PAGE_SIZE) / Memory::TLS_ENTRY_SIZE;
+
+    tls_slots[tls_page].reset(tls_slot);
 }

 void Process::LoadModule(CodeSet module_, VAddr base_addr) {
-    const auto memory = std::make_shared<PhysicalMemory>(std::move(module_.memory));
+    const auto memory = std::make_shared<std::vector<u8>>(std::move(module_.memory));

    const auto MapSegment = [&](const CodeSet::Segment& segment, VMAPermission permissions,
                                MemoryState memory_state) {
@@ -320,16 +264,4 @@ void Process::ChangeStatus(ProcessStatus new_status) {
    WakeupAllWaitingThreads();
 }

-void Process::AllocateMainThreadStack(u64 stack_size) {
-    // The kernel always ensures that the given stack size is page aligned.
-    main_thread_stack_size = Common::AlignUp(stack_size, Memory::PAGE_SIZE);
-
-    // Allocate and map the main thread stack
-    const VAddr mapping_address = vm_manager.GetTLSIORegionEndAddress() - main_thread_stack_size;
-    vm_manager
-        .MapMemoryBlock(mapping_address, std::make_shared<PhysicalMemory>(main_thread_stack_size),
-                        0, main_thread_stack_size, MemoryState::Stack)
-        .Unwrap();
-}
-
 } // namespace Kernel
@@ -5,10 +5,12 @@
 #pragma once

 #include <array>
+#include <bitset>
 #include <cstddef>
 #include <list>
 #include <string>
 #include <vector>
+#include <boost/container/static_vector.hpp>
 #include "common/common_types.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/handle_table.h"
@@ -31,7 +33,6 @@ namespace Kernel {
 class KernelCore;
 class ResourceLimit;
 class Thread;
-class TLSPage;

 struct CodeSet;

@@ -73,15 +74,9 @@ public:
        ProcessIDMax = 0xFFFFFFFFFFFFFFFF,
    };

-    // Used to determine how process IDs are assigned.
-    enum class ProcessType {
-        KernelInternal,
-        Userland,
-    };
-
    static constexpr std::size_t RANDOM_ENTROPY_SIZE = 4;

-    static SharedPtr<Process> Create(Core::System& system, std::string name, ProcessType type);
+    static SharedPtr<Process> Create(Core::System& system, std::string&& name);

    std::string GetTypeName() const override {
        return "Process";
@@ -135,11 +130,6 @@ public:
        return mutex;
    }

-    /// Gets the address to the process' dedicated TLS region.
-    VAddr GetTLSRegionAddress() const {
-        return tls_region_address;
-    }
-
    /// Gets the current status of the process
    ProcessStatus GetStatus() const {
        return status;
@@ -173,24 +163,8 @@ public:
        return capabilities.GetPriorityMask();
    }

-    /// Gets the amount of secure memory to allocate for memory management.
-    u32 GetSystemResourceSize() const {
-        return system_resource_size;
-    }
-
-    /// Gets the amount of secure memory currently in use for memory management.
-    u32 GetSystemResourceUsage() const {
-        // On hardware, this returns the amount of system resource memory that has
-        // been used by the kernel. This is problematic for Yuzu to emulate, because
-        // system resource memory is used for page tables -- and yuzu doesn't really
-        // have a way to calculate how much memory is required for page tables for
-        // the current process at any given time.
-        // TODO: Is this even worth implementing? Games may retrieve this value via
-        // an SDK function that gets used + available system resource size for debug
-        // or diagnostic purposes. However, it seems unlikely that a game would make
-        // decisions based on how much system memory is dedicated to its page tables.
-        // Is returning a value other than zero wise?
-        return 0;
+    u32 IsVirtualMemoryEnabled() const {
+        return is_virtual_address_memory_enabled;
    }

    /// Whether this process is an AArch64 or AArch32 process.
@@ -213,20 +187,9 @@ public:
        return random_entropy.at(index);
    }

-    /// Retrieves the total physical memory available to this process in bytes.
-    u64 GetTotalPhysicalMemoryAvailable() const;
-
-    /// Retrieves the total physical memory available to this process in bytes,
-    /// without the size of the personal system resource heap added to it.
-    u64 GetTotalPhysicalMemoryAvailableWithoutSystemResource() const;
-
    /// Retrieves the total physical memory used by this process in bytes.
    u64 GetTotalPhysicalMemoryUsed() const;

-    /// Retrieves the total physical memory used by this process in bytes,
-    /// without the size of the personal system resource heap added to it.
-    u64 GetTotalPhysicalMemoryUsedWithoutSystemResource() const;
-
    /// Gets the list of all threads created with this process as their owner.
    const std::list<const Thread*>& GetThreadList() const {
        return thread_list;
@@ -281,10 +244,10 @@ public:
    // Thread-local storage management

    // Marks the next available region as used and returns the address of the slot.
-    [[nodiscard]] VAddr CreateTLSRegion();
+    VAddr MarkNextAvailableTLSSlotAsUsed(Thread& thread);

    // Frees a used TLS slot identified by the given address
-    void FreeTLSRegion(VAddr tls_address);
+    void FreeTLSSlot(VAddr tls_address);

 private:
    explicit Process(Core::System& system);
@@ -301,9 +264,6 @@ private:
    /// a process signal.
    void ChangeStatus(ProcessStatus new_status);

-    /// Allocates the main thread stack for the process, given the stack size in bytes.
-    void AllocateMainThreadStack(u64 stack_size);
-
    /// Memory manager for this process.
    Kernel::VMManager vm_manager;

@@ -314,7 +274,7 @@ private:
    u64 code_memory_size = 0;

    /// Current status of the process
-    ProcessStatus status{};
+    ProcessStatus status;

    /// The ID of this process
    u64 process_id = 0;
@@ -322,23 +282,19 @@ private:
    /// Title ID corresponding to the process
    u64 program_id = 0;

-    /// Specifies additional memory to be reserved for the process's memory management by the
-    /// system. When this is non-zero, secure memory is allocated and used for page table allocation
-    /// instead of using the normal global page tables/memory block management.
-    u32 system_resource_size = 0;
-
    /// Resource limit descriptor for this process
    SharedPtr<ResourceLimit> resource_limit;

    /// The ideal CPU core for this process, threads are scheduled on this core by default.
    u8 ideal_core = 0;
+    u32 is_virtual_address_memory_enabled = 0;

    /// The Thread Local Storage area is allocated as processes create threads,
    /// each TLS area is 0x200 bytes, so one page (0x1000) is split up in 8 parts, and each part
    /// holds the TLS for a specific thread. This vector contains which parts are in use for each
    /// page as a bitmask.
    /// This vector will grow as more pages are allocated for new threads.
-    std::vector<TLSPage> tls_pages;
+    std::vector<std::bitset<8>> tls_slots;

    /// Contains the parsed process capability descriptors.
    ProcessCapabilities capabilities;
@@ -366,11 +322,8 @@ private:
    /// variable related facilities.
    Mutex mutex;

-    /// Address indicating the location of the process' dedicated TLS region.
-    VAddr tls_region_address = 0;
-
    /// Random values for svcGetInfo RandomEntropy
-    std::array<u64, RANDOM_ENTROPY_SIZE> random_entropy{};
+    std::array<u64, RANDOM_ENTROPY_SIZE> random_entropy;

    /// List of threads that are running with this process as their owner.
    std::list<const Thread*> thread_list;
@@ -28,7 +28,7 @@ SharedPtr<SharedMemory> SharedMemory::Create(KernelCore& kernel, Process* owner_
    shared_memory->other_permissions = other_permissions;

    if (address == 0) {
-        shared_memory->backing_block = std::make_shared<Kernel::PhysicalMemory>(size);
+        shared_memory->backing_block = std::make_shared<std::vector<u8>>(size);
        shared_memory->backing_block_offset = 0;

        // Refresh the address mappings for the current process.
@@ -59,8 +59,8 @@ SharedPtr<SharedMemory> SharedMemory::Create(KernelCore& kernel, Process* owner_
 }

 SharedPtr<SharedMemory> SharedMemory::CreateForApplet(
-    KernelCore& kernel, std::shared_ptr<Kernel::PhysicalMemory> heap_block, std::size_t offset,
-    u64 size, MemoryPermission permissions, MemoryPermission other_permissions, std::string name) {
+    KernelCore& kernel, std::shared_ptr<std::vector<u8>> heap_block, std::size_t offset, u64 size,
+    MemoryPermission permissions, MemoryPermission other_permissions, std::string name) {
    SharedPtr<SharedMemory> shared_memory(new SharedMemory(kernel));

    shared_memory->owner_process = nullptr;
@@ -10,7 +10,6 @@

 #include "common/common_types.h"
 #include "core/hle/kernel/object.h"
-#include "core/hle/kernel/physical_memory.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/result.h"

@@ -63,10 +62,12 @@ public:
     * block.
     * @param name Optional object name, used for debugging purposes.
     */
-    static SharedPtr<SharedMemory> CreateForApplet(
-        KernelCore& kernel, std::shared_ptr<Kernel::PhysicalMemory> heap_block, std::size_t offset,
-        u64 size, MemoryPermission permissions, MemoryPermission other_permissions,
-        std::string name = "Unknown Applet");
+    static SharedPtr<SharedMemory> CreateForApplet(KernelCore& kernel,
+                                                   std::shared_ptr<std::vector<u8>> heap_block,
+                                                   std::size_t offset, u64 size,
+                                                   MemoryPermission permissions,
+                                                   MemoryPermission other_permissions,
+                                                   std::string name = "Unknown Applet");

    std::string GetTypeName() const override {
        return "SharedMemory";
@@ -134,7 +135,7 @@ private:
    ~SharedMemory() override;

    /// Backing memory for this shared memory block.
-    std::shared_ptr<PhysicalMemory> backing_block;
+    std::shared_ptr<std::vector<u8>> backing_block;
    /// Offset into the backing block for this shared memory.
    std::size_t backing_block_offset = 0;
    /// Size of the memory block. Page-aligned.
@@ -38,7 +38,6 @@
 #include "core/hle/result.h"
 #include "core/hle/service/service.h"
 #include "core/memory.h"
-#include "core/reporter.h"

 namespace Kernel {
 namespace {
@@ -98,9 +97,9 @@ ResultCode MapUnmapMemorySanityChecks(const VMManager& vm_manager, VAddr dst_add
        return ERR_INVALID_ADDRESS_STATE;
    }

-    if (!vm_manager.IsWithinStackRegion(dst_addr, size)) {
+    if (!vm_manager.IsWithinNewMapRegion(dst_addr, size)) {
        LOG_ERROR(Kernel_SVC,
-                  "Destination is not within the stack region, addr=0x{:016X}, size=0x{:016X}",
+                  "Destination is not within the new map region, addr=0x{:016X}, size=0x{:016X}",
                  dst_addr, size);
        return ERR_INVALID_MEMORY_RANGE;
    }
@@ -318,14 +317,7 @@ static ResultCode UnmapMemory(Core::System& system, VAddr dst_addr, VAddr src_ad
        return result;
    }

-    const auto unmap_res = vm_manager.UnmapRange(dst_addr, size);
-
-    // Reprotect the source mapping on success
-    if (unmap_res.IsSuccess()) {
-        ASSERT(vm_manager.ReprotectRange(src_addr, size, VMAPermission::ReadWrite).IsSuccess());
-    }
-
-    return unmap_res;
+    return vm_manager.UnmapRange(dst_addr, size);
 }

 /// Connect to an OS service given the port name, returns the handle to the port to out
@@ -602,7 +594,6 @@ struct BreakReason {
 static void Break(Core::System& system, u32 reason, u64 info1, u64 info2) {
    BreakReason break_reason{reason};
    bool has_dumped_buffer{};
-    std::vector<u8> debug_buffer;

    const auto handle_debug_buffer = [&](VAddr addr, u64 sz) {
        if (sz == 0 || addr == 0 || has_dumped_buffer) {
@@ -614,7 +605,7 @@ static void Break(Core::System& system, u32 reason, u64 info1, u64 info2) {
            LOG_CRITICAL(Debug_Emulated, "debug_buffer_err_code={:X}", Memory::Read32(addr));
        } else {
            // We don't know what's in here so we'll hexdump it
-            debug_buffer.resize(sz);
+            std::vector<u8> debug_buffer(sz);
            Memory::ReadBlock(addr, debug_buffer.data(), sz);
            std::string hexdump;
            for (std::size_t i = 0; i < debug_buffer.size(); i++) {
@@ -673,10 +664,6 @@ static void Break(Core::System& system, u32 reason, u64 info1, u64 info2) {
        break;
    }

-    system.GetReporter().SaveSvcBreakReport(
-        static_cast<u32>(break_reason.break_type.Value()), break_reason.signal_debugger, info1,
-        info2, has_dumped_buffer ? std::make_optional(debug_buffer) : std::nullopt);
-
    if (!break_reason.signal_debugger) {
        LOG_CRITICAL(
            Debug_Emulated,
@@ -723,29 +710,27 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
        MapRegionSize = 3,
        HeapRegionBaseAddr = 4,
        HeapRegionSize = 5,
-        TotalPhysicalMemoryAvailable = 6,
+        TotalMemoryUsage = 6,
        TotalPhysicalMemoryUsed = 7,
        IsCurrentProcessBeingDebugged = 8,
        RegisterResourceLimit = 9,
        IdleTickCount = 10,
        RandomEntropy = 11,
-        ThreadTickCount = 0xF0000002,
+        PerformanceCounter = 0xF0000002,
        // 2.0.0+
        ASLRRegionBaseAddr = 12,
        ASLRRegionSize = 13,
-        StackRegionBaseAddr = 14,
-        StackRegionSize = 15,
+        NewMapRegionBaseAddr = 14,
+        NewMapRegionSize = 15,
        // 3.0.0+
-        SystemResourceSize = 16,
-        SystemResourceUsage = 17,
+        IsVirtualAddressMemoryEnabled = 16,
+        PersonalMmHeapUsage = 17,
        TitleId = 18,
        // 4.0.0+
        PrivilegedProcessId = 19,
        // 5.0.0+
        UserExceptionContextAddr = 20,
-        // 6.0.0+
-        TotalPhysicalMemoryAvailableWithoutSystemResource = 21,
-        TotalPhysicalMemoryUsedWithoutSystemResource = 22,
+        ThreadTickCount = 0xF0000002,
    };

    const auto info_id_type = static_cast<GetInfoType>(info_id);
@@ -759,16 +744,14 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
    case GetInfoType::HeapRegionSize:
    case GetInfoType::ASLRRegionBaseAddr:
    case GetInfoType::ASLRRegionSize:
-    case GetInfoType::StackRegionBaseAddr:
-    case GetInfoType::StackRegionSize:
-    case GetInfoType::TotalPhysicalMemoryAvailable:
+    case GetInfoType::NewMapRegionBaseAddr:
+    case GetInfoType::NewMapRegionSize:
+    case GetInfoType::TotalMemoryUsage:
    case GetInfoType::TotalPhysicalMemoryUsed:
-    case GetInfoType::SystemResourceSize:
-    case GetInfoType::SystemResourceUsage:
+    case GetInfoType::IsVirtualAddressMemoryEnabled:
+    case GetInfoType::PersonalMmHeapUsage:
    case GetInfoType::TitleId:
-    case GetInfoType::UserExceptionContextAddr:
-    case GetInfoType::TotalPhysicalMemoryAvailableWithoutSystemResource:
-    case GetInfoType::TotalPhysicalMemoryUsedWithoutSystemResource: {
+    case GetInfoType::UserExceptionContextAddr: {
        if (info_sub_id != 0) {
            return ERR_INVALID_ENUM_VALUE;
        }
@@ -813,29 +796,24 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
            *result = process->VMManager().GetASLRRegionSize();
            return RESULT_SUCCESS;

-        case GetInfoType::StackRegionBaseAddr:
-            *result = process->VMManager().GetStackRegionBaseAddress();
+        case GetInfoType::NewMapRegionBaseAddr:
+            *result = process->VMManager().GetNewMapRegionBaseAddress();
            return RESULT_SUCCESS;

-        case GetInfoType::StackRegionSize:
-            *result = process->VMManager().GetStackRegionSize();
+        case GetInfoType::NewMapRegionSize:
+            *result = process->VMManager().GetNewMapRegionSize();
            return RESULT_SUCCESS;

-        case GetInfoType::TotalPhysicalMemoryAvailable:
-            *result = process->GetTotalPhysicalMemoryAvailable();
+        case GetInfoType::TotalMemoryUsage:
+            *result = process->VMManager().GetTotalMemoryUsage();
            return RESULT_SUCCESS;

        case GetInfoType::TotalPhysicalMemoryUsed:
            *result = process->GetTotalPhysicalMemoryUsed();
            return RESULT_SUCCESS;

-        case GetInfoType::SystemResourceSize:
-            *result = process->GetSystemResourceSize();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::SystemResourceUsage:
-            LOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query system resource usage");
-            *result = process->GetSystemResourceUsage();
+        case GetInfoType::IsVirtualAddressMemoryEnabled:
+            *result = process->IsVirtualMemoryEnabled();
            return RESULT_SUCCESS;

        case GetInfoType::TitleId:
@@ -843,15 +821,9 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
            return RESULT_SUCCESS;

        case GetInfoType::UserExceptionContextAddr:
-            *result = process->GetTLSRegionAddress();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::TotalPhysicalMemoryAvailableWithoutSystemResource:
-            *result = process->GetTotalPhysicalMemoryAvailableWithoutSystemResource();
-            return RESULT_SUCCESS;
-
-        case GetInfoType::TotalPhysicalMemoryUsedWithoutSystemResource:
-            *result = process->GetTotalPhysicalMemoryUsedWithoutSystemResource();
+            LOG_WARNING(Kernel_SVC,
+                        "(STUBBED) Attempted to query user exception context address, returned 0");
+            *result = 0;
            return RESULT_SUCCESS;

        default:
@@ -956,86 +928,6 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
    }
 }

-/// Maps memory at a desired address
-static ResultCode MapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
-    LOG_DEBUG(Kernel_SVC, "called, addr=0x{:016X}, size=0x{:X}", addr, size);
-
-    if (!Common::Is4KBAligned(addr)) {
-        LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
-        return ERR_INVALID_ADDRESS;
-    }
-
-    if (!Common::Is4KBAligned(size)) {
-        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:X}", size);
-        return ERR_INVALID_SIZE;
-    }
-
-    if (size == 0) {
-        LOG_ERROR(Kernel_SVC, "Size is zero");
-        return ERR_INVALID_SIZE;
-    }
-
-    if (!(addr < addr + size)) {
-        LOG_ERROR(Kernel_SVC, "Size causes 64-bit overflow of address");
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    Process* const current_process = system.Kernel().CurrentProcess();
-    auto& vm_manager = current_process->VMManager();
-
-    if (current_process->GetSystemResourceSize() == 0) {
-        LOG_ERROR(Kernel_SVC, "System Resource Size is zero");
-        return ERR_INVALID_STATE;
-    }
-
-    if (!vm_manager.IsWithinMapRegion(addr, size)) {
-        LOG_ERROR(Kernel_SVC, "Range not within map region");
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    return vm_manager.MapPhysicalMemory(addr, size);
-}
-
-/// Unmaps memory previously mapped via MapPhysicalMemory
-static ResultCode UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
-    LOG_DEBUG(Kernel_SVC, "called, addr=0x{:016X}, size=0x{:X}", addr, size);
-
-    if (!Common::Is4KBAligned(addr)) {
-        LOG_ERROR(Kernel_SVC, "Address is not aligned to 4KB, 0x{:016X}", addr);
-        return ERR_INVALID_ADDRESS;
-    }
-
-    if (!Common::Is4KBAligned(size)) {
-        LOG_ERROR(Kernel_SVC, "Size is not aligned to 4KB, 0x{:X}", size);
-        return ERR_INVALID_SIZE;
-    }
-
-    if (size == 0) {
-        LOG_ERROR(Kernel_SVC, "Size is zero");
-        return ERR_INVALID_SIZE;
-    }
-
-    if (!(addr < addr + size)) {
-        LOG_ERROR(Kernel_SVC, "Size causes 64-bit overflow of address");
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    Process* const current_process = system.Kernel().CurrentProcess();
-    auto& vm_manager = current_process->VMManager();
-
-    if (current_process->GetSystemResourceSize() == 0) {
-        LOG_ERROR(Kernel_SVC, "System Resource Size is zero");
-        return ERR_INVALID_STATE;
-    }
-
-    if (!vm_manager.IsWithinMapRegion(addr, size)) {
-        LOG_ERROR(Kernel_SVC, "Range not within map region");
-        return ERR_INVALID_MEMORY_RANGE;
-    }
-
-    return vm_manager.UnmapPhysicalMemory(addr, size);
-}
-
 /// Sets the thread activity
 static ResultCode SetThreadActivity(Core::System& system, Handle handle, u32 activity) {
    LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, activity=0x{:08X}", handle, activity);
@@ -1737,8 +1629,8 @@ static ResultCode SignalProcessWideKey(Core::System& system, VAddr condition_var
 // Wait for an address (via Address Arbiter)
 static ResultCode WaitForAddress(Core::System& system, VAddr address, u32 type, s32 value,
                                 s64 timeout) {
-    LOG_TRACE(Kernel_SVC, "called, address=0x{:X}, type=0x{:X}, value=0x{:X}, timeout={}", address,
-              type, value, timeout);
+    LOG_WARNING(Kernel_SVC, "called, address=0x{:X}, type=0x{:X}, value=0x{:X}, timeout={}",
+                address, type, value, timeout);

    // If the passed address is a kernel virtual address, return invalid memory state.
    if (Memory::IsKernelVirtualAddress(address)) {
@@ -1760,8 +1652,8 @@ static ResultCode WaitForAddress(Core::System& system, VAddr address, u32 type,
 // Signals to an address (via Address Arbiter)
 static ResultCode SignalToAddress(Core::System& system, VAddr address, u32 type, s32 value,
                                  s32 num_to_wake) {
-    LOG_TRACE(Kernel_SVC, "called, address=0x{:X}, type=0x{:X}, value=0x{:X}, num_to_wake=0x{:X}",
-              address, type, value, num_to_wake);
+    LOG_WARNING(Kernel_SVC, "called, address=0x{:X}, type=0x{:X}, value=0x{:X}, num_to_wake=0x{:X}",
+                address, type, value, num_to_wake);

    // If the passed address is a kernel virtual address, return invalid memory state.
    if (Memory::IsKernelVirtualAddress(address)) {
@@ -2393,8 +2285,8 @@ static const FunctionDef SVC_Table[] = {
    {0x29, SvcWrap<GetInfo>, "GetInfo"},
    {0x2A, nullptr, "FlushEntireDataCache"},
    {0x2B, nullptr, "FlushDataCache"},
-    {0x2C, SvcWrap<MapPhysicalMemory>, "MapPhysicalMemory"},
-    {0x2D, SvcWrap<UnmapPhysicalMemory>, "UnmapPhysicalMemory"},
+    {0x2C, nullptr, "MapPhysicalMemory"},
+    {0x2D, nullptr, "UnmapPhysicalMemory"},
    {0x2E, nullptr, "GetFutureThreadInfo"},
    {0x2F, nullptr, "GetLastThreadInfo"},
    {0x30, SvcWrap<GetResourceLimitLimitValue>, "GetResourceLimitLimitValue"},
--- a/Show More
+++ b/Show More