arm_dynarmic: Check if jit is nullptr when preparing reschedule

Prevents crash with multiprocess loading.

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

@@ -1,15 +0,0 @@
-#!/bin/bash -ex
-
-# Copy documentation
-cp license.txt "$REV_NAME"
-cp README.md "$REV_NAME"
-
-tar $COMPRESSION_FLAGS "$ARCHIVE_NAME" "$REV_NAME"
-
-mv "$REV_NAME" $RELEASE_NAME
-
-7z a "$REV_NAME.7z" $RELEASE_NAME
-
-# move the compiled archive into the artifacts directory to be uploaded by travis releases
-mv "$ARCHIVE_NAME" artifacts/
-mv "$REV_NAME.7z" artifacts/

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

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

.ci/scripts/format/docker.sh

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

.ci/scripts/format/exec.sh

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

.ci/scripts/format/script.sh

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

.ci/scripts/linux/docker.sh

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

.ci/scripts/linux/exec.sh

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

.ci/scripts/linux/upload.sh

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

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

@@ -1,28 +0,0 @@
-# Download all pull requests as patches that match a specific label
-# Usage: python download-patches-by-label.py <Label to Match> <Root Path Folder to DL to>
-
-import requests, sys, json, urllib3.request, shutil, subprocess
-
-http = urllib3.PoolManager()
-dl_list = {}
-
-def check_individual(labels):
-    for label in labels:
-        if (label["name"] == sys.argv[1]):
-            return True
-    return False
-
-try:
-    url = 'https://api.github.com/repos/yuzu-emu/yuzu/pulls'
-    response = requests.get(url)
-    if (response.ok):
-        j = json.loads(response.content)
-        for pr in j:
-            if (check_individual(pr["labels"])):
-                pn = pr["number"]
-                print("Matched PR# %s" % pn)
-                print(subprocess.check_output(["git", "fetch", "https://github.com/yuzu-emu/yuzu.git", "pull/%s/head:pr-%s" % (pn, pn), "-f"]))
-                print(subprocess.check_output(["git", "merge", "--squash", "pr-%s" % pn]))
-                print(subprocess.check_output(["git", "commit", "-m\"Merge PR %s\"" % pn]))
-except:
-    sys.exit(-1)

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

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

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

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

.ci/scripts/windows/docker.sh

@@ -1,50 +0,0 @@
-#!/bin/bash -ex
-
-cd /yuzu
-
-ccache -s
-
-# Dirty hack to trick unicorn makefile into believing we are in a MINGW system
-mv /bin/uname /bin/uname1 && echo -e '#!/bin/sh\necho MINGW64' >> /bin/uname
-chmod +x /bin/uname
-
-# Dirty hack to trick unicorn makefile into believing we have cmd
-echo '' >> /bin/cmd
-chmod +x /bin/cmd
-
-mkdir build || true && cd build
-cmake .. -G Ninja -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
-ninja
-
-# Clean up the dirty hacks
-rm /bin/uname && mv /bin/uname1 /bin/uname
-rm /bin/cmd
-
-ccache -s
-
-echo "Tests skipped"
-#ctest -VV -C Release
-
-echo 'Prepare binaries...'
-cd ..
-mkdir package
-
-QT_PLATFORM_DLL_PATH='/usr/x86_64-w64-mingw32/lib/qt5/plugins/platforms/'
-find build/ -name "yuzu*.exe" -exec cp {} 'package' \;
-
-# copy Qt plugins
-mkdir package/platforms
-cp "${QT_PLATFORM_DLL_PATH}/qwindows.dll" package/platforms/
-cp -rv "${QT_PLATFORM_DLL_PATH}/../mediaservice/" package/
-cp -rv "${QT_PLATFORM_DLL_PATH}/../imageformats/" package/
-rm -f package/mediaservice/*d.dll
-
-for i in package/*.exe; do
-  # we need to process pdb here, however, cv2pdb
-  # does not work here, so we just simply strip all the debug symbols
-  x86_64-w64-mingw32-strip "${i}"
-done
-
-pip3 install pefile
-python3 .ci/scripts/windows/scan_dll.py package/*.exe "package/"
-python3 .ci/scripts/windows/scan_dll.py package/imageformats/*.dll "package/"

.ci/scripts/windows/exec.sh

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

.ci/scripts/windows/scan_dll.py

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

.ci/scripts/windows/upload.sh

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

.ci/templates/build-single.yml

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

.ci/templates/build-standard.yml

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

.ci/templates/build-testing.yml

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

.ci/templates/format-check.yml

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

.ci/templates/merge.yml

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

.ci/templates/mergebot.yml

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

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

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

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

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

.ci/templates/sync-source.yml

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

.ci/yuzu-mainline.yml

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

.ci/yuzu-patreon.yml

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

.ci/yuzu-repo-sync.yml

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

.ci/yuzu-verify.yml

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

CMakeModules/GenerateSCMRev.cmake

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

README.md

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

src/CMakeLists.txt

@@ -88,7 +88,6 @@ add_subdirectory(tests)
 
 if (ENABLE_SDL2)
     add_subdirectory(yuzu_cmd)
-    add_subdirectory(yuzu_tester)
 endif()
 
 if (ENABLE_QT)

src/audio_core/audio_renderer.cpp

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

src/audio_core/audio_renderer.h

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

src/audio_core/stream.cpp

@@ -51,10 +51,6 @@ void Stream::Stop() {
     UNIMPLEMENTED();
 }
 
-void Stream::SetVolume(float volume) {
-    game_volume = volume;
-}
-
 Stream::State Stream::GetState() const {
     return state;
 }
@@ -66,8 +62,8 @@ s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
     return Core::Timing::usToCycles(us);
 }
 
-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 +97,11 @@ void Stream::PlayNextBuffer() {
     active_buffer = queued_buffers.front();
     queued_buffers.pop();
 
-    VolumeAdjustSamples(active_buffer->GetSamples(), game_volume);
+    VolumeAdjustSamples(active_buffer->GetSamples());
 
     sink_stream.EnqueueSamples(GetNumChannels(), active_buffer->GetSamples());
 
-    core_timing.ScheduleEvent(GetBufferReleaseCycles(*active_buffer), release_event, {});
+    core_timing.ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
 }
 
 void Stream::ReleaseActiveBuffer() {

src/audio_core/stream.h

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

src/common/CMakeLists.txt

@@ -44,7 +44,6 @@ add_custom_command(OUTPUT scm_rev.cpp
       "${VIDEO_CORE}/shader/decode/half_set.cpp"
       "${VIDEO_CORE}/shader/decode/half_set_predicate.cpp"
       "${VIDEO_CORE}/shader/decode/hfma2.cpp"
-      "${VIDEO_CORE}/shader/decode/image.cpp"
       "${VIDEO_CORE}/shader/decode/integer_set.cpp"
       "${VIDEO_CORE}/shader/decode/integer_set_predicate.cpp"
       "${VIDEO_CORE}/shader/decode/memory.cpp"
@@ -56,8 +55,6 @@ add_custom_command(OUTPUT scm_rev.cpp
       "${VIDEO_CORE}/shader/decode/shift.cpp"
       "${VIDEO_CORE}/shader/decode/video.cpp"
       "${VIDEO_CORE}/shader/decode/xmad.cpp"
-      "${VIDEO_CORE}/shader/control_flow.cpp"
-      "${VIDEO_CORE}/shader/control_flow.h"
       "${VIDEO_CORE}/shader/decode.cpp"
       "${VIDEO_CORE}/shader/node.h"
       "${VIDEO_CORE}/shader/node_helper.cpp"
@@ -77,7 +74,6 @@ add_library(common STATIC
     assert.h
     detached_tasks.cpp
     detached_tasks.h
-    binary_find.h
     bit_field.h
     bit_util.h
     cityhash.cpp

src/common/alignment.h

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

src/common/binary_find.h

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

src/common/bit_util.h

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

src/common/common_funcs.h

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

src/common/hex_util.cpp

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

src/common/hex_util.h

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

src/core/CMakeLists.txt

@@ -45,8 +45,6 @@ add_library(core STATIC
     file_sys/fsmitm_romfsbuild.h
     file_sys/ips_layer.cpp
     file_sys/ips_layer.h
-    file_sys/kernel_executable.cpp
-    file_sys/kernel_executable.h
     file_sys/mode.h
     file_sys/nca_metadata.cpp
     file_sys/nca_metadata.h
@@ -175,7 +173,6 @@ add_library(core STATIC
     hle/service/acc/acc_u0.h
     hle/service/acc/acc_u1.cpp
     hle/service/acc/acc_u1.h
-    hle/service/acc/errors.h
     hle/service/acc/profile_manager.cpp
     hle/service/acc/profile_manager.h
     hle/service/am/am.cpp
@@ -208,10 +205,10 @@ add_library(core STATIC
     hle/service/aoc/aoc_u.h
     hle/service/apm/apm.cpp
     hle/service/apm/apm.h
-    hle/service/apm/controller.cpp
-    hle/service/apm/controller.h
     hle/service/apm/interface.cpp
     hle/service/apm/interface.h
+    hle/service/arp/arp.cpp
+    hle/service/arp/arp.h
     hle/service/audio/audctl.cpp
     hle/service/audio/audctl.h
     hle/service/audio/auddbg.cpp
@@ -273,20 +270,10 @@ add_library(core STATIC
     hle/service/filesystem/fsp_srv.h
     hle/service/fgm/fgm.cpp
     hle/service/fgm/fgm.h
-    hle/service/friend/errors.h
     hle/service/friend/friend.cpp
     hle/service/friend/friend.h
     hle/service/friend/interface.cpp
     hle/service/friend/interface.h
-    hle/service/glue/arp.cpp
-    hle/service/glue/arp.h
-    hle/service/glue/bgtc.cpp
-    hle/service/glue/bgtc.h
-    hle/service/glue/errors.h
-    hle/service/glue/glue.cpp
-    hle/service/glue/glue.h
-    hle/service/glue/manager.cpp
-    hle/service/glue/manager.h
     hle/service/grc/grc.cpp
     hle/service/grc/grc.h
     hle/service/hid/hid.cpp
@@ -295,7 +282,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
@@ -434,8 +420,6 @@ add_library(core STATIC
     hle/service/time/interface.h
     hle/service/time/time.cpp
     hle/service/time/time.h
-    hle/service/time/time_sharedmemory.cpp
-    hle/service/time/time_sharedmemory.h
     hle/service/usb/usb.cpp
     hle/service/usb/usb.h
     hle/service/vi/display/vi_display.cpp
@@ -456,8 +440,6 @@ add_library(core STATIC
     loader/deconstructed_rom_directory.h
     loader/elf.cpp
     loader/elf.h
-    loader/kip.cpp
-    loader/kip.h
     loader/loader.cpp
     loader/loader.h
     loader/nax.cpp
@@ -477,20 +459,19 @@ add_library(core STATIC
     memory_setup.h
     perf_stats.cpp
     perf_stats.h
-    reporter.cpp
-    reporter.h
     settings.cpp
     settings.h
     telemetry_session.cpp
     telemetry_session.h
-    tools/freezer.cpp
-    tools/freezer.h
+    tracer/citrace.h
+    tracer/recorder.cpp
+    tracer/recorder.h
 )
 
 create_target_directory_groups(core)
 
 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt json-headers mbedtls opus unicorn open_source_archives)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt mbedtls opus unicorn open_source_archives)
 if (ENABLE_WEB_SERVICE)
     target_compile_definitions(core PRIVATE -DENABLE_WEB_SERVICE)
     target_link_libraries(core PRIVATE web_service)

src/core/arm/arm_interface.cpp

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

src/core/arm/arm_interface.h

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

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -177,6 +177,15 @@ ARM_Dynarmic::ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor,
 
 ARM_Dynarmic::~ARM_Dynarmic() = default;
 
+void ARM_Dynarmic::MapBackingMemory(u64 address, std::size_t size, u8* memory,
+                                    Kernel::VMAPermission perms) {
+    inner_unicorn.MapBackingMemory(address, size, memory, perms);
+}
+
+void ARM_Dynarmic::UnmapMemory(u64 address, std::size_t size) {
+    inner_unicorn.UnmapMemory(address, size);
+}
+
 void ARM_Dynarmic::SetPC(u64 pc) {
     jit->SetPC(pc);
 }
@@ -248,6 +257,9 @@ void ARM_Dynarmic::LoadContext(const ThreadContext& ctx) {
 }
 
 void ARM_Dynarmic::PrepareReschedule() {
+    if (jit == nullptr)
+        return;
+
     jit->HaltExecution();
 }
 

src/core/arm/dynarmic/arm_dynarmic.h

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

src/core/arm/unicorn/arm_unicorn.cpp

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

src/core/arm/unicorn/arm_unicorn.h

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

src/core/core.cpp

@@ -25,48 +25,19 @@
 #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 "video_core/debug_utils/debug_utils.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"
 
 namespace Core {
 
-namespace {
-
-FileSys::StorageId GetStorageIdForFrontendSlot(
-    std::optional<FileSys::ContentProviderUnionSlot> slot) {
-    if (!slot.has_value()) {
-        return FileSys::StorageId::None;
-    }
-
-    switch (*slot) {
-    case FileSys::ContentProviderUnionSlot::UserNAND:
-        return FileSys::StorageId::NandUser;
-    case FileSys::ContentProviderUnionSlot::SysNAND:
-        return FileSys::StorageId::NandSystem;
-    case FileSys::ContentProviderUnionSlot::SDMC:
-        return FileSys::StorageId::SdCard;
-    case FileSys::ContentProviderUnionSlot::FrontendManual:
-        return FileSys::StorageId::Host;
-    default:
-        return FileSys::StorageId::None;
-    }
-}
-
-} // Anonymous namespace
-
 /*static*/ System System::s_instance;
 
 FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
@@ -103,7 +74,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
     return vfs->OpenFile(path, FileSys::Mode::Read);
 }
 struct System::Impl {
-    explicit Impl(System& system) : kernel{system}, cpu_core_manager{system}, reporter{system} {}
+    explicit Impl(System& system) : kernel{system}, cpu_core_manager{system} {}
 
     Cpu& CurrentCpuCore() {
         return cpu_core_manager.GetCurrentCore();
@@ -138,13 +109,10 @@ struct System::Impl {
         /// Create default implementations of applets if one is not provided.
         applet_manager.SetDefaultAppletsIfMissing();
 
-        /// Reset all glue registrations
-        arp_manager.ResetAll();
-
         telemetry_session = std::make_unique<Core::TelemetrySession>();
         service_manager = std::make_shared<Service::SM::ServiceManager>();
 
-        Service::Init(service_manager, system);
+        Service::Init(service_manager, system, *virtual_filesystem);
         GDBStub::Init();
 
         renderer = VideoCore::CreateRenderer(emu_window, system);
@@ -182,8 +150,7 @@ struct System::Impl {
         }
 
         telemetry_session->AddInitialInfo(*app_loader);
-        auto main_process =
-            Kernel::Process::Create(system, "main", Kernel::Process::ProcessType::Userland);
+        auto main_process = Kernel::Process::Create(system, "main");
         const auto [load_result, load_parameters] = app_loader->Load(*main_process);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
@@ -192,7 +159,6 @@ struct System::Impl {
             return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
                                              static_cast<u32>(load_result));
         }
-        AddGlueRegistrationForProcess(*app_loader, *main_process);
         kernel.MakeCurrentProcess(main_process.get());
 
         // Main process has been loaded and been made current.
@@ -251,31 +217,6 @@ struct System::Impl {
         return app_loader->ReadTitle(out);
     }
 
-    void AddGlueRegistrationForProcess(Loader::AppLoader& loader, Kernel::Process& process) {
-        std::vector<u8> nacp_data;
-        FileSys::NACP nacp;
-        if (loader.ReadControlData(nacp) == Loader::ResultStatus::Success) {
-            nacp_data = nacp.GetRawBytes();
-        } else {
-            nacp_data.resize(sizeof(FileSys::RawNACP));
-        }
-
-        Service::Glue::ApplicationLaunchProperty launch{};
-        launch.title_id = process.GetTitleID();
-
-        FileSys::PatchManager pm{launch.title_id};
-        launch.version = pm.GetGameVersion().value_or(0);
-
-        // TODO(DarkLordZach): When FSController/Game Card Support is added, if
-        // current_process_game_card use correct StorageId
-        launch.base_game_storage_id = GetStorageIdForFrontendSlot(content_provider->GetSlotForEntry(
-            launch.title_id, FileSys::ContentRecordType::Program));
-        launch.update_storage_id = GetStorageIdForFrontendSlot(content_provider->GetSlotForEntry(
-            FileSys::GetUpdateTitleID(launch.title_id), FileSys::ContentRecordType::Program));
-
-        arp_manager.Register(launch.title_id, launch, std::move(nacp_data));
-    }
-
     void SetStatus(ResultStatus new_status, const char* details = nullptr) {
         status = new_status;
         if (details) {
@@ -302,25 +243,16 @@ struct System::Impl {
     bool is_powered_on = false;
 
     std::unique_ptr<FileSys::CheatEngine> cheat_engine;
-    std::unique_ptr<Tools::Freezer> memory_freezer;
 
     /// Frontend applets
     Service::AM::Applets::AppletManager applet_manager;
 
-    /// APM (Performance) services
-    Service::APM::Controller apm_controller{core_timing};
-
-    /// Glue services
-    Service::Glue::ARPManager arp_manager;
-
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
 
     /// Telemetry session for this emulation session
     std::unique_ptr<Core::TelemetrySession> telemetry_session;
 
-    Reporter reporter;
-
     ResultStatus status = ResultStatus::Success;
     std::string status_details = "";
 
@@ -560,26 +492,6 @@ void System::ClearContentProvider(FileSys::ContentProviderUnionSlot slot) {
     impl->content_provider->ClearSlot(slot);
 }
 
-const Reporter& System::GetReporter() const {
-    return impl->reporter;
-}
-
-Service::Glue::ARPManager& System::GetARPManager() {
-    return impl->arp_manager;
-}
-
-const Service::Glue::ARPManager& System::GetARPManager() const {
-    return impl->arp_manager;
-}
-
-Service::APM::Controller& System::GetAPMController() {
-    return impl->apm_controller;
-}
-
-const Service::APM::Controller& System::GetAPMController() const {
-    return impl->apm_controller;
-}
-
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
     return impl->Init(*this, emu_window);
 }

src/core/core.h

@@ -8,7 +8,6 @@
 #include <memory>
 #include <string>
 
-#include <map>
 #include "common/common_types.h"
 #include "core/file_sys/vfs_types.h"
 #include "core/hle/kernel/object.h"
@@ -43,14 +42,6 @@ struct AppletFrontendSet;
 class AppletManager;
 } // namespace AM::Applets
 
-namespace APM {
-class Controller;
-}
-
-namespace Glue {
-class ARPManager;
-}
-
 namespace SM {
 class ServiceManager;
 } // namespace SM
@@ -77,7 +68,6 @@ class Cpu;
 class ExclusiveMonitor;
 class FrameLimiter;
 class PerfStats;
-class Reporter;
 class TelemetrySession;
 
 struct PerfStatsResults;
@@ -294,16 +284,6 @@ public:
 
     void ClearContentProvider(FileSys::ContentProviderUnionSlot slot);
 
-    const Reporter& GetReporter() const;
-
-    Service::Glue::ARPManager& GetARPManager();
-
-    const Service::Glue::ARPManager& GetARPManager() const;
-
-    Service::APM::Controller& GetAPMController();
-
-    const Service::APM::Controller& GetAPMController() const;
-
 private:
     System();
 
@@ -327,6 +307,10 @@ private:
     static System s_instance;
 };
 
+inline ARM_Interface& CurrentArmInterface() {
+    return System::GetInstance().CurrentArmInterface();
+}
+
 inline Kernel::Process* CurrentProcess() {
     return System::GetInstance().CurrentProcess();
 }

src/core/core_cpu.cpp

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

src/core/core_timing.cpp

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

src/core/core_timing.h

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

src/core/crypto/key_manager.cpp

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

src/core/crypto/partition_data_manager.cpp

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

src/core/file_sys/card_image.cpp

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

src/core/file_sys/content_archive.cpp

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

src/core/file_sys/control_metadata.cpp

@@ -87,10 +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;
 }

src/core/file_sys/control_metadata.h

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

src/core/file_sys/ips_layer.cpp

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

src/core/file_sys/kernel_executable.cpp

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

src/core/file_sys/kernel_executable.h

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

src/core/file_sys/nca_metadata.h

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

src/core/file_sys/patch_manager.cpp

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

src/core/file_sys/patch_manager.h

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

src/core/file_sys/program_metadata.cpp

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

src/core/file_sys/program_metadata.h

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

src/core/file_sys/registered_cache.cpp

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

src/core/file_sys/registered_cache.h

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

src/core/file_sys/submission_package.cpp

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

src/core/file_sys/xts_archive.cpp

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

src/core/frontend/applets/general_frontend.cpp

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

src/core/frontend/applets/general_frontend.h

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

src/core/frontend/applets/web_browser.cpp

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

src/core/frontend/applets/web_browser.h

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

src/core/hle/kernel/kernel.cpp

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

src/core/hle/kernel/kernel.h

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

src/core/hle/kernel/process.cpp

@@ -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));
@@ -129,17 +76,20 @@ u64 Process::GetTotalPhysicalMemoryAvailable() const {
     return vm_manager.GetTotalPhysicalMemoryAvailable();
 }
 
-u64 Process::GetTotalPhysicalMemoryAvailableWithoutSystemResource() const {
-    return GetTotalPhysicalMemoryAvailable() - GetSystemResourceSize();
+u64 Process::GetTotalPhysicalMemoryAvailableWithoutMmHeap() const {
+    // TODO: Subtract the personal heap size from this when the
+    //       personal heap is implemented.
+    return GetTotalPhysicalMemoryAvailable();
 }
 
 u64 Process::GetTotalPhysicalMemoryUsed() const {
-    return vm_manager.GetCurrentHeapSize() + main_thread_stack_size + code_memory_size +
-           GetSystemResourceUsage();
+    return vm_manager.GetCurrentHeapSize() + main_thread_stack_size + code_memory_size;
 }
 
-u64 Process::GetTotalPhysicalMemoryUsedWithoutSystemResource() const {
-    return GetTotalPhysicalMemoryUsed() - GetSystemResourceUsage();
+u64 Process::GetTotalPhysicalMemoryUsedWithoutMmHeap() const {
+    // TODO: Subtract the personal heap size from this when the
+    //       personal heap is implemented.
+    return GetTotalPhysicalMemoryUsed();
 }
 
 void Process::RegisterThread(const Thread* thread) {
@@ -169,7 +119,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 +133,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,62 +175,65 @@ 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<std::vector<u8>>(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) {
@@ -320,16 +280,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<std::vector<u8>>(main_thread_stack_size),
-                        0, main_thread_stack_size, MemoryState::Stack)
-        .Unwrap();
-}
-
 } // namespace Kernel

src/core/hle/kernel/process.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <array>
+#include <bitset>
 #include <cstddef>
 #include <list>
 #include <string>
@@ -31,7 +32,6 @@ namespace Kernel {
 class KernelCore;
 class ResourceLimit;
 class Thread;
-class TLSPage;
 
 struct CodeSet;
 
@@ -73,15 +73,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 +129,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 +162,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.
@@ -217,15 +190,15 @@ public:
     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;
+    /// without the size of the personal heap added to it.
+    u64 GetTotalPhysicalMemoryAvailableWithoutMmHeap() 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;
+    /// without the size of the personal heap added to it.
+    u64 GetTotalPhysicalMemoryUsedWithoutMmHeap() const;
 
     /// Gets the list of all threads created with this process as their owner.
     const std::list<const Thread*>& GetThreadList() const {
@@ -281,10 +254,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 +274,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 +284,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 +292,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 +332,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;

src/core/hle/kernel/svc.cpp

@@ -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,
@@ -733,19 +720,19 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
         // 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,
+        TotalPhysicalMemoryAvailableWithoutMmHeap = 21,
+        TotalPhysicalMemoryUsedWithoutMmHeap = 22,
     };
 
     const auto info_id_type = static_cast<GetInfoType>(info_id);
@@ -759,16 +746,16 @@ 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::NewMapRegionBaseAddr:
+    case GetInfoType::NewMapRegionSize:
     case GetInfoType::TotalPhysicalMemoryAvailable:
     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::TotalPhysicalMemoryAvailableWithoutMmHeap:
+    case GetInfoType::TotalPhysicalMemoryUsedWithoutMmHeap: {
         if (info_sub_id != 0) {
             return ERR_INVALID_ENUM_VALUE;
         }
@@ -813,12 +800,12 @@ 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:
@@ -829,13 +816,8 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
             *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 +825,17 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha
             return RESULT_SUCCESS;
 
         case GetInfoType::UserExceptionContextAddr:
-            *result = process->GetTLSRegionAddress();
+            LOG_WARNING(Kernel_SVC,
+                        "(STUBBED) Attempted to query user exception context address, returned 0");
+            *result = 0;
             return RESULT_SUCCESS;
 
-        case GetInfoType::TotalPhysicalMemoryAvailableWithoutSystemResource:
-            *result = process->GetTotalPhysicalMemoryAvailableWithoutSystemResource();
+        case GetInfoType::TotalPhysicalMemoryAvailableWithoutMmHeap:
+            *result = process->GetTotalPhysicalMemoryAvailable();
             return RESULT_SUCCESS;
 
-        case GetInfoType::TotalPhysicalMemoryUsedWithoutSystemResource:
-            *result = process->GetTotalPhysicalMemoryUsedWithoutSystemResource();
+        case GetInfoType::TotalPhysicalMemoryUsedWithoutMmHeap:
+            *result = process->GetTotalPhysicalMemoryUsedWithoutMmHeap();
             return RESULT_SUCCESS;
 
         default:
@@ -956,86 +940,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 +1641,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 +1664,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 +2297,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"},

src/core/hle/kernel/svc_wrap.h

@@ -32,11 +32,6 @@ void SvcWrap(Core::System& system) {
     FuncReturn(system, func(system, Param(system, 0)).raw);
 }
 
-template <ResultCode func(Core::System&, u64, u64)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), Param(system, 1)).raw);
-}
-
 template <ResultCode func(Core::System&, u32)>
 void SvcWrap(Core::System& system) {
     FuncReturn(system, func(system, static_cast<u32>(Param(system, 0))).raw);

src/core/hle/kernel/thread.cpp

@@ -65,7 +65,7 @@ void Thread::Stop() {
     owner_process->UnregisterThread(this);
 
     // Mark the TLS slot in the thread's page as free.
-    owner_process->FreeTLSRegion(tls_address);
+    owner_process->FreeTLSSlot(tls_address);
 }
 
 void Thread::WakeAfterDelay(s64 nanoseconds) {
@@ -76,13 +76,13 @@ void Thread::WakeAfterDelay(s64 nanoseconds) {
     // This function might be called from any thread so we have to be cautious and use the
     // thread-safe version of ScheduleEvent.
     const s64 cycles = Core::Timing::nsToCycles(std::chrono::nanoseconds{nanoseconds});
-    Core::System::GetInstance().CoreTiming().ScheduleEvent(
+    Core::System::GetInstance().CoreTiming().ScheduleEventThreadsafe(
         cycles, kernel.ThreadWakeupCallbackEventType(), callback_handle);
 }
 
 void Thread::CancelWakeupTimer() {
-    Core::System::GetInstance().CoreTiming().UnscheduleEvent(kernel.ThreadWakeupCallbackEventType(),
-                                                             callback_handle);
+    Core::System::GetInstance().CoreTiming().UnscheduleEventThreadsafe(
+        kernel.ThreadWakeupCallbackEventType(), callback_handle);
 }
 
 static std::optional<s32> GetNextProcessorId(u64 mask) {
@@ -205,9 +205,9 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
     thread->name = std::move(name);
     thread->callback_handle = kernel.ThreadWakeupCallbackHandleTable().Create(thread).Unwrap();
     thread->owner_process = &owner_process;
-    thread->tls_address = thread->owner_process->CreateTLSRegion();
     thread->scheduler = &system.Scheduler(processor_id);
     thread->scheduler->AddThread(thread);
+    thread->tls_address = thread->owner_process->MarkNextAvailableTLSSlotAsUsed(*thread);
 
     thread->owner_process->RegisterThread(thread.get());
 

src/core/hle/kernel/thread.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <functional>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -77,6 +78,9 @@ enum class ThreadActivity : u32 {
 
 class Thread final : public WaitObject {
 public:
+    using TLSMemory = std::vector<u8>;
+    using TLSMemoryPtr = std::shared_ptr<TLSMemory>;
+
     using MutexWaitingThreads = std::vector<SharedPtr<Thread>>;
 
     using ThreadContext = Core::ARM_Interface::ThreadContext;
@@ -165,6 +169,14 @@ public:
         return thread_id;
     }
 
+    TLSMemoryPtr& GetTLSMemory() {
+        return tls_memory;
+    }
+
+    const TLSMemoryPtr& GetTLSMemory() const {
+        return tls_memory;
+    }
+
     /// Resumes a thread from waiting
     void ResumeFromWait();
 
@@ -451,9 +463,11 @@ private:
     u32 ideal_core{0xFFFFFFFF};
     u64 affinity_mask{0x1};
 
-    ThreadActivity activity = ThreadActivity::Normal;
+    TLSMemoryPtr tls_memory = std::make_shared<TLSMemory>();
 
     std::string name;
+
+    ThreadActivity activity = ThreadActivity::Normal;
 };
 
 /**

src/core/hle/kernel/vm_manager.cpp

@@ -8,11 +8,10 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/memory_hook.h"
+#include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/hle/kernel/errors.h"
-#include "core/hle/kernel/process.h"
-#include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/memory.h"
 #include "core/memory_setup.h"
@@ -50,14 +49,10 @@ bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const {
         type != next.type) {
         return false;
     }
-    if ((attribute & MemoryAttribute::DeviceMapped) == MemoryAttribute::DeviceMapped) {
-        // TODO: Can device mapped memory be merged sanely?
-        // Not merging it may cause inaccuracies versus hardware when memory layout is queried.
+    if (type == VMAType::AllocatedMemoryBlock &&
+        (backing_block != next.backing_block || offset + size != next.offset)) {
         return false;
     }
-    if (type == VMAType::AllocatedMemoryBlock) {
-        return true;
-    }
     if (type == VMAType::BackingMemory && backing_memory + size != next.backing_memory) {
         return false;
     }
@@ -73,7 +68,9 @@ VMManager::VMManager(Core::System& system) : system{system} {
     Reset(FileSys::ProgramAddressSpaceType::Is39Bit);
 }
 
-VMManager::~VMManager() = default;
+VMManager::~VMManager() {
+    Reset(FileSys::ProgramAddressSpaceType::Is39Bit);
+}
 
 void VMManager::Reset(FileSys::ProgramAddressSpaceType type) {
     Clear();
@@ -105,7 +102,7 @@ bool VMManager::IsValidHandle(VMAHandle handle) const {
 ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
                                                           std::shared_ptr<std::vector<u8>> block,
                                                           std::size_t offset, u64 size,
-                                                          MemoryState state, VMAPermission perm) {
+                                                          MemoryState state) {
     ASSERT(block != nullptr);
     ASSERT(offset + size <= block->size());
 
@@ -114,8 +111,17 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
     VirtualMemoryArea& final_vma = vma_handle->second;
     ASSERT(final_vma.size == size);
 
+    system.ArmInterface(0).MapBackingMemory(target, size, block->data() + offset,
+                                            VMAPermission::ReadWriteExecute);
+    system.ArmInterface(1).MapBackingMemory(target, size, block->data() + offset,
+                                            VMAPermission::ReadWriteExecute);
+    system.ArmInterface(2).MapBackingMemory(target, size, block->data() + offset,
+                                            VMAPermission::ReadWriteExecute);
+    system.ArmInterface(3).MapBackingMemory(target, size, block->data() + offset,
+                                            VMAPermission::ReadWriteExecute);
+
     final_vma.type = VMAType::AllocatedMemoryBlock;
-    final_vma.permissions = perm;
+    final_vma.permissions = VMAPermission::ReadWrite;
     final_vma.state = state;
     final_vma.backing_block = std::move(block);
     final_vma.offset = offset;
@@ -133,6 +139,11 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* me
     VirtualMemoryArea& final_vma = vma_handle->second;
     ASSERT(final_vma.size == size);
 
+    system.ArmInterface(0).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
+    system.ArmInterface(1).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
+    system.ArmInterface(2).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
+    system.ArmInterface(3).MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
+
     final_vma.type = VMAType::BackingMemory;
     final_vma.permissions = VMAPermission::ReadWrite;
     final_vma.state = state;
@@ -143,33 +154,22 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* me
 }
 
 ResultVal<VAddr> VMManager::FindFreeRegion(u64 size) const {
-    return FindFreeRegion(GetASLRRegionBaseAddress(), GetASLRRegionEndAddress(), size);
-}
+    // Find the first Free VMA.
+    const VAddr base = GetASLRRegionBaseAddress();
+    const VMAHandle vma_handle = std::find_if(vma_map.begin(), vma_map.end(), [&](const auto& vma) {
+        if (vma.second.type != VMAType::Free)
+            return false;
 
-ResultVal<VAddr> VMManager::FindFreeRegion(VAddr begin, VAddr end, u64 size) const {
-    ASSERT(begin < end);
-    ASSERT(size <= end - begin);
+        const VAddr vma_end = vma.second.base + vma.second.size;
+        return vma_end > base && vma_end >= base + size;
+    });
 
-    const VMAHandle vma_handle =
-        std::find_if(vma_map.begin(), vma_map.end(), [begin, end, size](const auto& vma) {
-            if (vma.second.type != VMAType::Free) {
-                return false;
-            }
-            const VAddr vma_base = vma.second.base;
-            const VAddr vma_end = vma_base + vma.second.size;
-            const VAddr assumed_base = (begin < vma_base) ? vma_base : begin;
-            const VAddr used_range = assumed_base + size;
-
-            return vma_base <= assumed_base && assumed_base < used_range && used_range < end &&
-                   used_range <= vma_end;
-        });
-
-    if (vma_handle == vma_map.cend()) {
+    if (vma_handle == vma_map.end()) {
         // TODO(Subv): Find the correct error code here.
         return ResultCode(-1);
     }
 
-    const VAddr target = std::max(begin, vma_handle->second.base);
+    const VAddr target = std::max(base, vma_handle->second.base);
     return MakeResult<VAddr>(target);
 }
 
@@ -221,6 +221,11 @@ ResultCode VMManager::UnmapRange(VAddr target, u64 size) {
 
     ASSERT(FindVMA(target)->second.size >= size);
 
+    system.ArmInterface(0).UnmapMemory(target, size);
+    system.ArmInterface(1).UnmapMemory(target, size);
+    system.ArmInterface(2).UnmapMemory(target, size);
+    system.ArmInterface(3).UnmapMemory(target, size);
+
     return RESULT_SUCCESS;
 }
 
@@ -294,166 +299,6 @@ ResultVal<VAddr> VMManager::SetHeapSize(u64 size) {
     return MakeResult<VAddr>(heap_region_base);
 }
 
-ResultCode VMManager::MapPhysicalMemory(VAddr target, u64 size) {
-    const auto end_addr = target + size;
-    const auto last_addr = end_addr - 1;
-    VAddr cur_addr = target;
-
-    ResultCode result = RESULT_SUCCESS;
-
-    // Check how much memory we've already mapped.
-    const auto mapped_size_result = SizeOfAllocatedVMAsInRange(target, size);
-    if (mapped_size_result.Failed()) {
-        return mapped_size_result.Code();
-    }
-
-    // If we've already mapped the desired amount, return early.
-    const std::size_t mapped_size = *mapped_size_result;
-    if (mapped_size == size) {
-        return RESULT_SUCCESS;
-    }
-
-    // Check that we can map the memory we want.
-    const auto res_limit = system.CurrentProcess()->GetResourceLimit();
-    const u64 physmem_remaining = res_limit->GetMaxResourceValue(ResourceType::PhysicalMemory) -
-                                  res_limit->GetCurrentResourceValue(ResourceType::PhysicalMemory);
-    if (physmem_remaining < (size - mapped_size)) {
-        return ERR_RESOURCE_LIMIT_EXCEEDED;
-    }
-
-    // Keep track of the memory regions we unmap.
-    std::vector<std::pair<u64, u64>> mapped_regions;
-
-    // Iterate, trying to map memory.
-    {
-        cur_addr = target;
-
-        auto iter = FindVMA(target);
-        ASSERT_MSG(iter != vma_map.end(), "MapPhysicalMemory iter != end");
-
-        while (true) {
-            const auto& vma = iter->second;
-            const auto vma_start = vma.base;
-            const auto vma_end = vma_start + vma.size;
-            const auto vma_last = vma_end - 1;
-
-            // Map the memory block
-            const auto map_size = std::min(end_addr - cur_addr, vma_end - cur_addr);
-            if (vma.state == MemoryState::Unmapped) {
-                const auto map_res =
-                    MapMemoryBlock(cur_addr, std::make_shared<std::vector<u8>>(map_size, 0), 0,
-                                   map_size, MemoryState::Heap, VMAPermission::ReadWrite);
-                result = map_res.Code();
-                if (result.IsError()) {
-                    break;
-                }
-
-                mapped_regions.emplace_back(cur_addr, map_size);
-            }
-
-            // Break once we hit the end of the range.
-            if (last_addr <= vma_last) {
-                break;
-            }
-
-            // Advance to the next block.
-            cur_addr = vma_end;
-            iter = FindVMA(cur_addr);
-            ASSERT_MSG(iter != vma_map.end(), "MapPhysicalMemory iter != end");
-        }
-    }
-
-    // If we failed, unmap memory.
-    if (result.IsError()) {
-        for (const auto [unmap_address, unmap_size] : mapped_regions) {
-            ASSERT_MSG(UnmapRange(unmap_address, unmap_size).IsSuccess(),
-                       "MapPhysicalMemory un-map on error");
-        }
-
-        return result;
-    }
-
-    // Update amount of mapped physical memory.
-    physical_memory_mapped += size - mapped_size;
-
-    return RESULT_SUCCESS;
-}
-
-ResultCode VMManager::UnmapPhysicalMemory(VAddr target, u64 size) {
-    const auto end_addr = target + size;
-    const auto last_addr = end_addr - 1;
-    VAddr cur_addr = target;
-
-    ResultCode result = RESULT_SUCCESS;
-
-    // Check how much memory is currently mapped.
-    const auto mapped_size_result = SizeOfUnmappablePhysicalMemoryInRange(target, size);
-    if (mapped_size_result.Failed()) {
-        return mapped_size_result.Code();
-    }
-
-    // If we've already unmapped all the memory, return early.
-    const std::size_t mapped_size = *mapped_size_result;
-    if (mapped_size == 0) {
-        return RESULT_SUCCESS;
-    }
-
-    // Keep track of the memory regions we unmap.
-    std::vector<std::pair<u64, u64>> unmapped_regions;
-
-    // Try to unmap regions.
-    {
-        cur_addr = target;
-
-        auto iter = FindVMA(target);
-        ASSERT_MSG(iter != vma_map.end(), "UnmapPhysicalMemory iter != end");
-
-        while (true) {
-            const auto& vma = iter->second;
-            const auto vma_start = vma.base;
-            const auto vma_end = vma_start + vma.size;
-            const auto vma_last = vma_end - 1;
-
-            // Unmap the memory block
-            const auto unmap_size = std::min(end_addr - cur_addr, vma_end - cur_addr);
-            if (vma.state == MemoryState::Heap) {
-                result = UnmapRange(cur_addr, unmap_size);
-                if (result.IsError()) {
-                    break;
-                }
-
-                unmapped_regions.emplace_back(cur_addr, unmap_size);
-            }
-
-            // Break once we hit the end of the range.
-            if (last_addr <= vma_last) {
-                break;
-            }
-
-            // Advance to the next block.
-            cur_addr = vma_end;
-            iter = FindVMA(cur_addr);
-            ASSERT_MSG(iter != vma_map.end(), "UnmapPhysicalMemory iter != end");
-        }
-    }
-
-    // If we failed, re-map regions.
-    // TODO: Preserve memory contents?
-    if (result.IsError()) {
-        for (const auto [map_address, map_size] : unmapped_regions) {
-            const auto remap_res =
-                MapMemoryBlock(map_address, std::make_shared<std::vector<u8>>(map_size, 0), 0,
-                               map_size, MemoryState::Heap, VMAPermission::None);
-            ASSERT_MSG(remap_res.Succeeded(), "UnmapPhysicalMemory re-map on error");
-        }
-    }
-
-    // Update mapped amount
-    physical_memory_mapped -= mapped_size;
-
-    return RESULT_SUCCESS;
-}
-
 ResultCode VMManager::MapCodeMemory(VAddr dst_address, VAddr src_address, u64 size) {
     constexpr auto ignore_attribute = MemoryAttribute::LockedForIPC | MemoryAttribute::DeviceMapped;
     const auto src_check_result = CheckRangeState(
@@ -601,7 +446,7 @@ ResultCode VMManager::MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size, Mem
     // Protect mirror with permissions from old region
     Reprotect(new_vma, vma->second.permissions);
     // Remove permissions from old region
-    ReprotectRange(src_addr, size, VMAPermission::None);
+    Reprotect(vma, VMAPermission::None);
 
     return RESULT_SUCCESS;
 }
@@ -734,14 +579,14 @@ VMManager::VMAIter VMManager::SplitVMA(VMAIter vma_handle, u64 offset_in_vma) {
 VMManager::VMAIter VMManager::MergeAdjacent(VMAIter iter) {
     const VMAIter next_vma = std::next(iter);
     if (next_vma != vma_map.end() && iter->second.CanBeMergedWith(next_vma->second)) {
-        MergeAdjacentVMA(iter->second, next_vma->second);
+        iter->second.size += next_vma->second.size;
         vma_map.erase(next_vma);
     }
 
     if (iter != vma_map.begin()) {
         VMAIter prev_vma = std::prev(iter);
         if (prev_vma->second.CanBeMergedWith(iter->second)) {
-            MergeAdjacentVMA(prev_vma->second, iter->second);
+            prev_vma->second.size += iter->second.size;
             vma_map.erase(iter);
             iter = prev_vma;
         }
@@ -750,38 +595,6 @@ VMManager::VMAIter VMManager::MergeAdjacent(VMAIter iter) {
     return iter;
 }
 
-void VMManager::MergeAdjacentVMA(VirtualMemoryArea& left, const VirtualMemoryArea& right) {
-    ASSERT(left.CanBeMergedWith(right));
-
-    // Always merge allocated memory blocks, even when they don't share the same backing block.
-    if (left.type == VMAType::AllocatedMemoryBlock &&
-        (left.backing_block != right.backing_block || left.offset + left.size != right.offset)) {
-        // Check if we can save work.
-        if (left.offset == 0 && left.size == left.backing_block->size()) {
-            // Fast case: left is an entire backing block.
-            left.backing_block->insert(left.backing_block->end(),
-                                       right.backing_block->begin() + right.offset,
-                                       right.backing_block->begin() + right.offset + right.size);
-        } else {
-            // Slow case: make a new memory block for left and right.
-            auto new_memory = std::make_shared<std::vector<u8>>();
-            new_memory->insert(new_memory->end(), left.backing_block->begin() + left.offset,
-                               left.backing_block->begin() + left.offset + left.size);
-            new_memory->insert(new_memory->end(), right.backing_block->begin() + right.offset,
-                               right.backing_block->begin() + right.offset + right.size);
-            left.backing_block = new_memory;
-            left.offset = 0;
-        }
-
-        // Page table update is needed, because backing memory changed.
-        left.size += right.size;
-        UpdatePageTableForVMA(left);
-    } else {
-        // Just update the size.
-        left.size += right.size;
-    }
-}
-
 void VMManager::UpdatePageTableForVMA(const VirtualMemoryArea& vma) {
     switch (vma.type) {
     case VMAType::Free:
@@ -803,11 +616,9 @@ void VMManager::UpdatePageTableForVMA(const VirtualMemoryArea& vma) {
 void VMManager::InitializeMemoryRegionRanges(FileSys::ProgramAddressSpaceType type) {
     u64 map_region_size = 0;
     u64 heap_region_size = 0;
-    u64 stack_region_size = 0;
+    u64 new_map_region_size = 0;
     u64 tls_io_region_size = 0;
 
-    u64 stack_and_tls_io_end = 0;
-
     switch (type) {
     case FileSys::ProgramAddressSpaceType::Is32Bit:
     case FileSys::ProgramAddressSpaceType::Is32BitNoMap:
@@ -823,7 +634,6 @@ void VMManager::InitializeMemoryRegionRanges(FileSys::ProgramAddressSpaceType ty
             map_region_size = 0;
             heap_region_size = 0x80000000;
         }
-        stack_and_tls_io_end = 0x40000000;
         break;
     case FileSys::ProgramAddressSpaceType::Is36Bit:
         address_space_width = 36;
@@ -833,7 +643,6 @@ void VMManager::InitializeMemoryRegionRanges(FileSys::ProgramAddressSpaceType ty
         aslr_region_end = aslr_region_base + 0xFF8000000;
         map_region_size = 0x180000000;
         heap_region_size = 0x180000000;
-        stack_and_tls_io_end = 0x80000000;
         break;
     case FileSys::ProgramAddressSpaceType::Is39Bit:
         address_space_width = 39;
@@ -843,7 +652,7 @@ void VMManager::InitializeMemoryRegionRanges(FileSys::ProgramAddressSpaceType ty
         aslr_region_end = aslr_region_base + 0x7FF8000000;
         map_region_size = 0x1000000000;
         heap_region_size = 0x180000000;
-        stack_region_size = 0x80000000;
+        new_map_region_size = 0x80000000;
         tls_io_region_size = 0x1000000000;
         break;
     default:
@@ -851,8 +660,6 @@ void VMManager::InitializeMemoryRegionRanges(FileSys::ProgramAddressSpaceType ty
         return;
     }
 
-    const u64 stack_and_tls_io_begin = aslr_region_base;
-
     address_space_base = 0;
     address_space_end = 1ULL << address_space_width;
 
@@ -863,20 +670,15 @@ void VMManager::InitializeMemoryRegionRanges(FileSys::ProgramAddressSpaceType ty
     heap_region_end = heap_region_base + heap_region_size;
     heap_end = heap_region_base;
 
-    stack_region_base = heap_region_end;
-    stack_region_end = stack_region_base + stack_region_size;
+    new_map_region_base = heap_region_end;
+    new_map_region_end = new_map_region_base + new_map_region_size;
 
-    tls_io_region_base = stack_region_end;
+    tls_io_region_base = new_map_region_end;
     tls_io_region_end = tls_io_region_base + tls_io_region_size;
 
-    if (stack_region_size == 0) {
-        stack_region_base = stack_and_tls_io_begin;
-        stack_region_end = stack_and_tls_io_end;
-    }
-
-    if (tls_io_region_size == 0) {
-        tls_io_region_base = stack_and_tls_io_begin;
-        tls_io_region_end = stack_and_tls_io_end;
+    if (new_map_region_size == 0) {
+        new_map_region_base = address_space_base;
+        new_map_region_end = address_space_end;
     }
 }
 
@@ -956,84 +758,6 @@ VMManager::CheckResults VMManager::CheckRangeState(VAddr address, u64 size, Memo
         std::make_tuple(initial_state, initial_permissions, initial_attributes & ~ignore_mask));
 }
 
-ResultVal<std::size_t> VMManager::SizeOfAllocatedVMAsInRange(VAddr address,
-                                                             std::size_t size) const {
-    const VAddr end_addr = address + size;
-    const VAddr last_addr = end_addr - 1;
-    std::size_t mapped_size = 0;
-
-    VAddr cur_addr = address;
-    auto iter = FindVMA(cur_addr);
-    ASSERT_MSG(iter != vma_map.end(), "SizeOfAllocatedVMAsInRange iter != end");
-
-    while (true) {
-        const auto& vma = iter->second;
-        const VAddr vma_start = vma.base;
-        const VAddr vma_end = vma_start + vma.size;
-        const VAddr vma_last = vma_end - 1;
-
-        // Add size if relevant.
-        if (vma.state != MemoryState::Unmapped) {
-            mapped_size += std::min(end_addr - cur_addr, vma_end - cur_addr);
-        }
-
-        // Break once we hit the end of the range.
-        if (last_addr <= vma_last) {
-            break;
-        }
-
-        // Advance to the next block.
-        cur_addr = vma_end;
-        iter = std::next(iter);
-        ASSERT_MSG(iter != vma_map.end(), "SizeOfAllocatedVMAsInRange iter != end");
-    }
-
-    return MakeResult(mapped_size);
-}
-
-ResultVal<std::size_t> VMManager::SizeOfUnmappablePhysicalMemoryInRange(VAddr address,
-                                                                        std::size_t size) const {
-    const VAddr end_addr = address + size;
-    const VAddr last_addr = end_addr - 1;
-    std::size_t mapped_size = 0;
-
-    VAddr cur_addr = address;
-    auto iter = FindVMA(cur_addr);
-    ASSERT_MSG(iter != vma_map.end(), "SizeOfUnmappablePhysicalMemoryInRange iter != end");
-
-    while (true) {
-        const auto& vma = iter->second;
-        const auto vma_start = vma.base;
-        const auto vma_end = vma_start + vma.size;
-        const auto vma_last = vma_end - 1;
-        const auto state = vma.state;
-        const auto attr = vma.attribute;
-
-        // Memory within region must be free or mapped heap.
-        if (!((state == MemoryState::Heap && attr == MemoryAttribute::None) ||
-              (state == MemoryState::Unmapped))) {
-            return ERR_INVALID_ADDRESS_STATE;
-        }
-
-        // Add size if relevant.
-        if (state != MemoryState::Unmapped) {
-            mapped_size += std::min(end_addr - cur_addr, vma_end - cur_addr);
-        }
-
-        // Break once we hit the end of the range.
-        if (last_addr <= vma_last) {
-            break;
-        }
-
-        // Advance to the next block.
-        cur_addr = vma_end;
-        iter = std::next(iter);
-        ASSERT_MSG(iter != vma_map.end(), "SizeOfUnmappablePhysicalMemoryInRange iter != end");
-    }
-
-    return MakeResult(mapped_size);
-}
-
 u64 VMManager::GetTotalPhysicalMemoryAvailable() const {
     LOG_WARNING(Kernel, "(STUBBED) called");
     return 0xF8000000;
@@ -1146,21 +870,21 @@ bool VMManager::IsWithinMapRegion(VAddr address, u64 size) const {
     return IsInsideAddressRange(address, size, GetMapRegionBaseAddress(), GetMapRegionEndAddress());
 }
 
-VAddr VMManager::GetStackRegionBaseAddress() const {
-    return stack_region_base;
+VAddr VMManager::GetNewMapRegionBaseAddress() const {
+    return new_map_region_base;
 }
 
-VAddr VMManager::GetStackRegionEndAddress() const {
-    return stack_region_end;
+VAddr VMManager::GetNewMapRegionEndAddress() const {
+    return new_map_region_end;
 }
 
-u64 VMManager::GetStackRegionSize() const {
-    return stack_region_end - stack_region_base;
+u64 VMManager::GetNewMapRegionSize() const {
+    return new_map_region_end - new_map_region_base;
 }
 
-bool VMManager::IsWithinStackRegion(VAddr address, u64 size) const {
-    return IsInsideAddressRange(address, size, GetStackRegionBaseAddress(),
-                                GetStackRegionEndAddress());
+bool VMManager::IsWithinNewMapRegion(VAddr address, u64 size) const {
+    return IsInsideAddressRange(address, size, GetNewMapRegionBaseAddress(),
+                                GetNewMapRegionEndAddress());
 }
 
 VAddr VMManager::GetTLSIORegionBaseAddress() const {

src/core/hle/kernel/vm_manager.h

@@ -349,8 +349,7 @@ public:
      * @param state MemoryState tag to attach to the VMA.
      */
     ResultVal<VMAHandle> MapMemoryBlock(VAddr target, std::shared_ptr<std::vector<u8>> block,
-                                        std::size_t offset, u64 size, MemoryState state,
-                                        VMAPermission perm = VMAPermission::ReadWrite);
+                                        std::size_t offset, u64 size, MemoryState state);
 
     /**
      * Maps an unmanaged host memory pointer at a given address.
@@ -363,38 +362,13 @@ public:
     ResultVal<VMAHandle> MapBackingMemory(VAddr target, u8* memory, u64 size, MemoryState state);
 
     /**
-     * Finds the first free memory region of the given size within
-     * the user-addressable ASLR memory region.
+     * Finds the first free address that can hold a region of the desired size.
      *
-     * @param size The size of the desired region in bytes.
-     *
-     * @returns If successful, the base address of the free region with
-     *          the given size.
+     * @param size Size of the desired region.
+     * @return The found free address.
      */
     ResultVal<VAddr> FindFreeRegion(u64 size) const;
 
-    /**
-     * Finds the first free address range that can hold a region of the desired size
-     *
-     * @param begin The starting address of the range.
-     *              This is treated as an inclusive beginning address.
-     *
-     * @param end   The ending address of the range.
-     *              This is treated as an exclusive ending address.
-     *
-     * @param size  The size of the free region to attempt to locate,
-     *              in bytes.
-     *
-     * @returns If successful, the base address of the free region with
-     *          the given size.
-     *
-     * @returns If unsuccessful, a result containing an error code.
-     *
-     * @pre The starting address must be less than the ending address.
-     * @pre The size must not exceed the address range itself.
-     */
-    ResultVal<VAddr> FindFreeRegion(VAddr begin, VAddr end, u64 size) const;
-
     /**
      * Maps a memory-mapped IO region at a given address.
      *
@@ -451,34 +425,6 @@ public:
     ///
     ResultVal<VAddr> SetHeapSize(u64 size);
 
-    /// Maps memory at a given address.
-    ///
-    /// @param addr The virtual address to map memory at.
-    /// @param size The amount of memory to map.
-    ///
-    /// @note The destination address must lie within the Map region.
-    ///
-    /// @note This function requires that SystemResourceSize be non-zero,
-    ///       however, this is just because if it were not then the
-    ///       resulting page tables could be exploited on hardware by
-    ///       a malicious program. SystemResource usage does not need
-    ///       to be explicitly checked or updated here.
-    ResultCode MapPhysicalMemory(VAddr target, u64 size);
-
-    /// Unmaps memory at a given address.
-    ///
-    /// @param addr The virtual address to unmap memory at.
-    /// @param size The amount of memory to unmap.
-    ///
-    /// @note The destination address must lie within the Map region.
-    ///
-    /// @note This function requires that SystemResourceSize be non-zero,
-    ///       however, this is just because if it were not then the
-    ///       resulting page tables could be exploited on hardware by
-    ///       a malicious program. SystemResource usage does not need
-    ///       to be explicitly checked or updated here.
-    ResultCode UnmapPhysicalMemory(VAddr target, u64 size);
-
     /// Maps a region of memory as code memory.
     ///
     /// @param dst_address The base address of the region to create the aliasing memory region.
@@ -625,17 +571,17 @@ public:
     /// Determines whether or not the specified range is within the map region.
     bool IsWithinMapRegion(VAddr address, u64 size) const;
 
-    /// Gets the base address of the stack region.
-    VAddr GetStackRegionBaseAddress() const;
+    /// Gets the base address of the new map region.
+    VAddr GetNewMapRegionBaseAddress() const;
 
-    /// Gets the end address of the stack region.
-    VAddr GetStackRegionEndAddress() const;
+    /// Gets the end address of the new map region.
+    VAddr GetNewMapRegionEndAddress() const;
 
-    /// Gets the total size of the stack region in bytes.
-    u64 GetStackRegionSize() const;
+    /// Gets the total size of the new map region in bytes.
+    u64 GetNewMapRegionSize() const;
 
-    /// Determines whether or not the given address range is within the stack region
-    bool IsWithinStackRegion(VAddr address, u64 size) const;
+    /// Determines whether or not the given address range is within the new map region
+    bool IsWithinNewMapRegion(VAddr address, u64 size) const;
 
     /// Gets the base address of the TLS IO region.
     VAddr GetTLSIORegionBaseAddress() const;
@@ -686,11 +632,6 @@ private:
      */
     VMAIter MergeAdjacent(VMAIter vma);
 
-    /**
-     * Merges two adjacent VMAs.
-     */
-    void MergeAdjacentVMA(VirtualMemoryArea& left, const VirtualMemoryArea& right);
-
     /// Updates the pages corresponding to this VMA so they match the VMA's attributes.
     void UpdatePageTableForVMA(const VirtualMemoryArea& vma);
 
@@ -735,13 +676,6 @@ private:
                                  MemoryAttribute attribute_mask, MemoryAttribute attribute,
                                  MemoryAttribute ignore_mask) const;
 
-    /// Gets the amount of memory currently mapped (state != Unmapped) in a range.
-    ResultVal<std::size_t> SizeOfAllocatedVMAsInRange(VAddr address, std::size_t size) const;
-
-    /// Gets the amount of memory unmappable by UnmapPhysicalMemory in a range.
-    ResultVal<std::size_t> SizeOfUnmappablePhysicalMemoryInRange(VAddr address,
-                                                                 std::size_t size) const;
-
     /**
      * A map covering the entirety of the managed address space, keyed by the `base` field of each
      * VMA. It must always be modified by splitting or merging VMAs, so that the invariant
@@ -767,8 +701,8 @@ private:
     VAddr map_region_base = 0;
     VAddr map_region_end = 0;
 
-    VAddr stack_region_base = 0;
-    VAddr stack_region_end = 0;
+    VAddr new_map_region_base = 0;
+    VAddr new_map_region_end = 0;
 
     VAddr tls_io_region_base = 0;
     VAddr tls_io_region_end = 0;
@@ -783,11 +717,6 @@ private:
     // end of the range. This is essentially 'base_address + current_size'.
     VAddr heap_end = 0;
 
-    // The current amount of memory mapped via MapPhysicalMemory.
-    // This is used here (and in Nintendo's kernel) only for debugging, and does not impact
-    // any behavior.
-    u64 physical_memory_mapped = 0;
-
     Core::System& system;
 };
 } // namespace Kernel

src/core/hle/service/acc/acc.cpp

@@ -12,22 +12,13 @@
 #include "common/swap.h"
 #include "core/constants.h"
 #include "core/core_timing.h"
-#include "core/file_sys/control_metadata.h"
-#include "core/file_sys/patch_manager.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/process.h"
 #include "core/hle/service/acc/acc.h"
 #include "core/hle/service/acc/acc_aa.h"
 #include "core/hle/service/acc/acc_su.h"
 #include "core/hle/service/acc/acc_u0.h"
 #include "core/hle/service/acc/acc_u1.h"
-#include "core/hle/service/acc/errors.h"
 #include "core/hle/service/acc/profile_manager.h"
-#include "core/hle/service/glue/arp.h"
-#include "core/hle/service/glue/manager.h"
-#include "core/hle/service/sm/sm.h"
-#include "core/loader/loader.h"
 
 namespace Service::Account {
 
@@ -99,7 +90,7 @@ private:
             LOG_WARNING(Service_ACC,
                         "Failed to load user provided image! Falling back to built-in backup...");
             ctx.WriteBuffer(Core::Constants::ACCOUNT_BACKUP_JPEG);
-            rb.Push(SanitizeJPEGSize(Core::Constants::ACCOUNT_BACKUP_JPEG.size()));
+            rb.Push<u32>(Core::Constants::ACCOUNT_BACKUP_JPEG.size());
             return;
         }
 
@@ -121,9 +112,9 @@ private:
         if (!image.IsOpen()) {
             LOG_WARNING(Service_ACC,
                         "Failed to load user provided image! Falling back to built-in backup...");
-            rb.Push(SanitizeJPEGSize(Core::Constants::ACCOUNT_BACKUP_JPEG.size()));
+            rb.Push<u32>(Core::Constants::ACCOUNT_BACKUP_JPEG.size());
         } else {
-            rb.Push(SanitizeJPEGSize(image.GetSize()));
+            rb.Push<u32>(SanitizeJPEGSize(image.GetSize()));
         }
     }
 
@@ -223,71 +214,9 @@ void Module::Interface::IsUserRegistrationRequestPermitted(Kernel::HLERequestCon
 }
 
 void Module::Interface::InitializeApplicationInfo(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    auto pid = rp.Pop<u64>();
-
-    LOG_DEBUG(Service_ACC, "called, process_id={}", pid);
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
     IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(InitializeApplicationInfoBase(pid));
-}
-
-void Module::Interface::InitializeApplicationInfoRestricted(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    auto pid = rp.Pop<u64>();
-
-    LOG_WARNING(Service_ACC, "(Partial implementation) called, process_id={}", pid);
-
-    // TODO(ogniK): We require checking if the user actually owns the title and what not. As of
-    // currently, we assume the user owns the title. InitializeApplicationInfoBase SHOULD be called
-    // first then we do extra checks if the game is a digital copy.
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(InitializeApplicationInfoBase(pid));
-}
-
-ResultCode Module::Interface::InitializeApplicationInfoBase(u64 process_id) {
-    if (application_info) {
-        LOG_ERROR(Service_ACC, "Application already initialized");
-        return ERR_ACCOUNTINFO_ALREADY_INITIALIZED;
-    }
-
-    const auto& list = system.Kernel().GetProcessList();
-    const auto iter = std::find_if(list.begin(), list.end(), [&process_id](const auto& process) {
-        return process->GetProcessID() == process_id;
-    });
-
-    if (iter == list.end()) {
-        LOG_ERROR(Service_ACC, "Failed to find process ID");
-        application_info.application_type = ApplicationType::Unknown;
-
-        return ERR_ACCOUNTINFO_BAD_APPLICATION;
-    }
-
-    const auto launch_property = system.GetARPManager().GetLaunchProperty((*iter)->GetTitleID());
-
-    if (launch_property.Failed()) {
-        LOG_ERROR(Service_ACC, "Failed to get launch property");
-        return ERR_ACCOUNTINFO_BAD_APPLICATION;
-    }
-
-    switch (launch_property->base_game_storage_id) {
-    case FileSys::StorageId::GameCard:
-        application_info.application_type = ApplicationType::GameCard;
-        break;
-    case FileSys::StorageId::Host:
-    case FileSys::StorageId::NandUser:
-    case FileSys::StorageId::SdCard:
-        application_info.application_type = ApplicationType::Digital;
-        break;
-    default:
-        LOG_ERROR(Service_ACC, "Invalid game storage ID");
-        return ERR_ACCOUNTINFO_BAD_APPLICATION;
-    }
-
-    LOG_WARNING(Service_ACC, "ApplicationInfo init required");
-    // TODO(ogniK): Actual initalization here
-
-    return RESULT_SUCCESS;
+    rb.Push(RESULT_SUCCESS);
 }
 
 void Module::Interface::GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx) {
@@ -297,31 +226,6 @@ void Module::Interface::GetBaasAccountManagerForApplication(Kernel::HLERequestCo
     rb.PushIpcInterface<IManagerForApplication>();
 }
 
-void Module::Interface::IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_ACC, "called");
-    FileSys::NACP nacp;
-    const auto res = system.GetAppLoader().ReadControlData(nacp);
-
-    bool is_locked = false;
-
-    if (res != Loader::ResultStatus::Success) {
-        FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID()};
-        auto nacp_unique = pm.GetControlMetadata().first;
-
-        if (nacp_unique != nullptr) {
-            is_locked = nacp_unique->GetUserAccountSwitchLock();
-        } else {
-            LOG_ERROR(Service_ACC, "nacp_unique is null!");
-        }
-    } else {
-        is_locked = nacp.GetUserAccountSwitchLock();
-    }
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(is_locked);
-}
-
 void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_ACC, "called");
     // A u8 is passed into this function which we can safely ignore. It's to determine if we have
@@ -347,25 +251,19 @@ void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContex
 }
 
 Module::Interface::Interface(std::shared_ptr<Module> module,
-                             std::shared_ptr<ProfileManager> profile_manager, Core::System& system,
-                             const char* name)
+                             std::shared_ptr<ProfileManager> profile_manager, const char* name)
     : ServiceFramework(name), module(std::move(module)),
-      profile_manager(std::move(profile_manager)), system(system) {}
+      profile_manager(std::move(profile_manager)) {}
 
 Module::Interface::~Interface() = default;
 
-void InstallInterfaces(Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module = std::make_shared<Module>();
     auto profile_manager = std::make_shared<ProfileManager>();
-
-    std::make_shared<ACC_AA>(module, profile_manager, system)
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<ACC_SU>(module, profile_manager, system)
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<ACC_U0>(module, profile_manager, system)
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<ACC_U1>(module, profile_manager, system)
-        ->InstallAsService(system.ServiceManager());
+    std::make_shared<ACC_AA>(module, profile_manager)->InstallAsService(service_manager);
+    std::make_shared<ACC_SU>(module, profile_manager)->InstallAsService(service_manager);
+    std::make_shared<ACC_U0>(module, profile_manager)->InstallAsService(service_manager);
+    std::make_shared<ACC_U1>(module, profile_manager)->InstallAsService(service_manager);
 }
 
 } // namespace Service::Account

src/core/hle/service/acc/acc.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include "core/hle/service/glue/manager.h"
 #include "core/hle/service/service.h"
 
 namespace Service::Account {
@@ -16,8 +15,7 @@ public:
     class Interface : public ServiceFramework<Interface> {
     public:
         explicit Interface(std::shared_ptr<Module> module,
-                           std::shared_ptr<ProfileManager> profile_manager, Core::System& system,
-                           const char* name);
+                           std::shared_ptr<ProfileManager> profile_manager, const char* name);
         ~Interface() override;
 
         void GetUserCount(Kernel::HLERequestContext& ctx);
@@ -27,40 +25,17 @@ public:
         void GetLastOpenedUser(Kernel::HLERequestContext& ctx);
         void GetProfile(Kernel::HLERequestContext& ctx);
         void InitializeApplicationInfo(Kernel::HLERequestContext& ctx);
-        void InitializeApplicationInfoRestricted(Kernel::HLERequestContext& ctx);
         void GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx);
         void IsUserRegistrationRequestPermitted(Kernel::HLERequestContext& ctx);
         void TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx);
-        void IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx);
-
-    private:
-        ResultCode InitializeApplicationInfoBase(u64 process_id);
-
-        enum class ApplicationType : u32_le {
-            GameCard = 0,
-            Digital = 1,
-            Unknown = 3,
-        };
-
-        struct ApplicationInfo {
-            Service::Glue::ApplicationLaunchProperty launch_property;
-            ApplicationType application_type;
-
-            constexpr explicit operator bool() const {
-                return launch_property.title_id != 0x0;
-            }
-        };
-
-        ApplicationInfo application_info{};
 
     protected:
         std::shared_ptr<Module> module;
         std::shared_ptr<ProfileManager> profile_manager;
-        Core::System& system;
     };
 };
 
 /// Registers all ACC services with the specified service manager.
-void InstallInterfaces(Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager);
 
 } // namespace Service::Account

src/core/hle/service/acc/acc_aa.cpp

@@ -6,9 +6,8 @@
 
 namespace Service::Account {
 
-ACC_AA::ACC_AA(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager,
-               Core::System& system)
-    : Module::Interface(std::move(module), std::move(profile_manager), system, "acc:aa") {
+ACC_AA::ACC_AA(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
+    : Module::Interface(std::move(module), std::move(profile_manager), "acc:aa") {
     static const FunctionInfo functions[] = {
         {0, nullptr, "EnsureCacheAsync"},
         {1, nullptr, "LoadCache"},

src/core/hle/service/acc/acc_aa.h

@@ -10,8 +10,8 @@ namespace Service::Account {
 
 class ACC_AA final : public Module::Interface {
 public:
-    explicit ACC_AA(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager,
-                    Core::System& system);
+    explicit ACC_AA(std::shared_ptr<Module> module,
+                    std::shared_ptr<ProfileManager> profile_manager);
     ~ACC_AA() override;
 };
 

src/core/hle/service/acc/acc_su.cpp

@@ -6,9 +6,8 @@
 
 namespace Service::Account {
 
-ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager,
-               Core::System& system)
-    : Module::Interface(std::move(module), std::move(profile_manager), system, "acc:su") {
+ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
+    : Module::Interface(std::move(module), std::move(profile_manager), "acc:su") {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ACC_SU::GetUserCount, "GetUserCount"},

src/core/hle/service/acc/acc_su.h

@@ -10,8 +10,8 @@ namespace Service::Account {
 
 class ACC_SU final : public Module::Interface {
 public:
-    explicit ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager,
-                    Core::System& system);
+    explicit ACC_SU(std::shared_ptr<Module> module,
+                    std::shared_ptr<ProfileManager> profile_manager);
     ~ACC_SU() override;
 };
 

src/core/hle/service/acc/acc_u0.cpp

@@ -6,9 +6,8 @@
 
 namespace Service::Account {
 
-ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager,
-               Core::System& system)
-    : Module::Interface(std::move(module), std::move(profile_manager), system, "acc:u0") {
+ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
+    : Module::Interface(std::move(module), std::move(profile_manager), "acc:u0") {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ACC_U0::GetUserCount, "GetUserCount"},
@@ -31,9 +30,9 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {120, nullptr, "CreateGuestLoginRequest"},
         {130, nullptr, "LoadOpenContext"},
         {131, nullptr, "ListOpenContextStoredUsers"},
-        {140, &ACC_U0::InitializeApplicationInfoRestricted, "InitializeApplicationInfoRestricted"},
+        {140, nullptr, "InitializeApplicationInfo"},
         {141, nullptr, "ListQualifiedUsers"},
-        {150, &ACC_U0::IsUserAccountSwitchLocked, "IsUserAccountSwitchLocked"},
+        {150, nullptr, "IsUserAccountSwitchLocked"},
     };
     // clang-format on
 

src/core/hle/service/acc/acc_u0.h

@@ -10,8 +10,8 @@ namespace Service::Account {
 
 class ACC_U0 final : public Module::Interface {
 public:
-    explicit ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager,
-                    Core::System& system);
+    explicit ACC_U0(std::shared_ptr<Module> module,
+                    std::shared_ptr<ProfileManager> profile_manager);
     ~ACC_U0() override;
 };
 

src/core/hle/service/acc/acc_u1.cpp

@@ -6,9 +6,8 @@
 
 namespace Service::Account {
 
-ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager,
-               Core::System& system)
-    : Module::Interface(std::move(module), std::move(profile_manager), system, "acc:u1") {
+ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
+    : Module::Interface(std::move(module), std::move(profile_manager), "acc:u1") {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ACC_U1::GetUserCount, "GetUserCount"},

src/core/hle/service/acc/acc_u1.h

@@ -10,8 +10,8 @@ namespace Service::Account {
 
 class ACC_U1 final : public Module::Interface {
 public:
-    explicit ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager,
-                    Core::System& system);
+    explicit ACC_U1(std::shared_ptr<Module> module,
+                    std::shared_ptr<ProfileManager> profile_manager);
     ~ACC_U1() override;
 };
 

src/core/hle/service/acc/errors.h

@@ -1,14 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/result.h"
-
-namespace Service::Account {
-
-constexpr ResultCode ERR_ACCOUNTINFO_BAD_APPLICATION{ErrorModule::Account, 22};
-constexpr ResultCode ERR_ACCOUNTINFO_ALREADY_INITIALIZED{ErrorModule::Account, 41};
-
-} // namespace Service::Account

src/core/hle/service/am/am.cpp

@@ -29,8 +29,7 @@
 #include "core/hle/service/am/omm.h"
 #include "core/hle/service/am/spsm.h"
 #include "core/hle/service/am/tcap.h"
-#include "core/hle/service/apm/controller.h"
-#include "core/hle/service/apm/interface.h"
+#include "core/hle/service/apm/apm.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
@@ -266,13 +265,13 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {65, nullptr, "ReportUserIsActive"},
         {66, nullptr, "GetCurrentIlluminance"},
         {67, nullptr, "IsIlluminanceAvailable"},
-        {68, &ISelfController::SetAutoSleepDisabled, "SetAutoSleepDisabled"},
-        {69, &ISelfController::IsAutoSleepDisabled, "IsAutoSleepDisabled"},
+        {68, nullptr, "SetAutoSleepDisabled"},
+        {69, nullptr, "IsAutoSleepDisabled"},
         {70, nullptr, "ReportMultimediaError"},
         {71, nullptr, "GetCurrentIlluminanceEx"},
         {80, nullptr, "SetWirelessPriorityMode"},
-        {90, &ISelfController::GetAccumulatedSuspendedTickValue, "GetAccumulatedSuspendedTickValue"},
-        {91, &ISelfController::GetAccumulatedSuspendedTickChangedEvent, "GetAccumulatedSuspendedTickChangedEvent"},
+        {90, nullptr, "GetAccumulatedSuspendedTickValue"},
+        {91, nullptr, "GetAccumulatedSuspendedTickChangedEvent"},
         {100, nullptr, "SetAlbumImageTakenNotificationEnabled"},
         {1000, nullptr, "GetDebugStorageChannel"},
     };
@@ -283,15 +282,6 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
     auto& kernel = Core::System::GetInstance().Kernel();
     launchable_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual,
                                                               "ISelfController:LaunchableEvent");
-
-    // This event is created by AM on the first time GetAccumulatedSuspendedTickChangedEvent() is
-    // called. Yuzu can just create it unconditionally, since it doesn't need to support multiple
-    // ISelfControllers. The event is signaled on creation, and on transition from suspended -> not
-    // suspended if the event has previously been created by a call to
-    // GetAccumulatedSuspendedTickChangedEvent.
-    accumulated_suspended_tick_changed_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, Kernel::ResetType::Manual, "ISelfController:AccumulatedSuspendedTickChangedEvent");
-    accumulated_suspended_tick_changed_event.writable->Signal();
 }
 
 ISelfController::~ISelfController() = default;
@@ -454,53 +444,6 @@ void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& c
     rb.Push<u32>(idle_time_detection_extension);
 }
 
-void ISelfController::SetAutoSleepDisabled(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    is_auto_sleep_disabled = rp.Pop<bool>();
-
-    // On the system itself, if the previous state of is_auto_sleep_disabled
-    // differed from the current value passed in, it'd signify the internal
-    // window manager to update (and also increment some statistics like update counts)
-    //
-    // It'd also indicate this change to an idle handling context.
-    //
-    // However, given we're emulating this behavior, most of this can be ignored
-    // and it's sufficient to simply set the member variable for querying via
-    // IsAutoSleepDisabled().
-
-    LOG_DEBUG(Service_AM, "called. is_auto_sleep_disabled={}", is_auto_sleep_disabled);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void ISelfController::IsAutoSleepDisabled(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called.");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(is_auto_sleep_disabled);
-}
-
-void ISelfController::GetAccumulatedSuspendedTickValue(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called.");
-
-    // This command returns the total number of system ticks since ISelfController creation
-    // where the game was suspended. Since Yuzu doesn't implement game suspension, this command
-    // can just always return 0 ticks.
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u64>(0);
-}
-
-void ISelfController::GetAccumulatedSuspendedTickChangedEvent(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called.");
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(accumulated_suspended_tick_changed_event.readable);
-}
-
 AppletMessageQueue::AppletMessageQueue() {
     auto& kernel = Core::System::GetInstance().Kernel();
     on_new_message = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual,
@@ -549,9 +492,8 @@ void AppletMessageQueue::OperationModeChanged() {
     on_operation_mode_changed.writable->Signal();
 }
 
-ICommonStateGetter::ICommonStateGetter(Core::System& system,
-                                       std::shared_ptr<AppletMessageQueue> msg_queue)
-    : ServiceFramework("ICommonStateGetter"), system(system), msg_queue(std::move(msg_queue)) {
+ICommonStateGetter::ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_queue)
+    : ServiceFramework("ICommonStateGetter"), msg_queue(std::move(msg_queue)) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},
@@ -584,7 +526,7 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system,
         {63, nullptr, "GetHdcpAuthenticationStateChangeEvent"},
         {64, nullptr, "SetTvPowerStateMatchingMode"},
         {65, nullptr, "GetApplicationIdByContentActionName"},
-        {66, &ICommonStateGetter::SetCpuBoostMode, "SetCpuBoostMode"},
+        {66, nullptr, "SetCpuBoostMode"},
         {80, nullptr, "PerformSystemButtonPressingIfInFocus"},
         {90, nullptr, "SetPerformanceConfigurationChangedNotification"},
         {91, nullptr, "GetCurrentPerformanceConfiguration"},
@@ -665,16 +607,6 @@ void ICommonStateGetter::GetDefaultDisplayResolution(Kernel::HLERequestContext&
     }
 }
 
-void ICommonStateGetter::SetCpuBoostMode(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called, forwarding to APM:SYS");
-
-    const auto& sm = system.ServiceManager();
-    const auto apm_sys = sm.GetService<APM::APM_Sys>("apm:sys");
-    ASSERT(apm_sys != nullptr);
-
-    apm_sys->SetCpuBoostMode(ctx);
-}
-
 IStorage::IStorage(std::vector<u8> buffer)
     : ServiceFramework("IStorage"), buffer(std::move(buffer)) {
     // clang-format off
@@ -703,11 +635,13 @@ void ICommonStateGetter::GetOperationMode(Kernel::HLERequestContext& ctx) {
 }
 
 void ICommonStateGetter::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called");
+    const bool use_docked_mode{Settings::values.use_docked_mode};
+    LOG_DEBUG(Service_AM, "called, use_docked_mode={}", use_docked_mode);
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(system.GetAPMController().GetCurrentPerformanceMode());
+    rb.Push(static_cast<u32>(use_docked_mode ? APM::PerformanceMode::Docked
+                                             : APM::PerformanceMode::Handheld));
 }
 
 class ILibraryAppletAccessor final : public ServiceFramework<ILibraryAppletAccessor> {
@@ -937,9 +871,7 @@ void IStorageAccessor::Read(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
-ILibraryAppletCreator::ILibraryAppletCreator(u64 current_process_title_id)
-    : ServiceFramework("ILibraryAppletCreator"),
-      current_process_title_id(current_process_title_id) {
+ILibraryAppletCreator::ILibraryAppletCreator() : ServiceFramework("ILibraryAppletCreator") {
     static const FunctionInfo functions[] = {
         {0, &ILibraryAppletCreator::CreateLibraryApplet, "CreateLibraryApplet"},
         {1, nullptr, "TerminateAllLibraryApplets"},
@@ -962,7 +894,7 @@ void ILibraryAppletCreator::CreateLibraryApplet(Kernel::HLERequestContext& ctx)
               static_cast<u32>(applet_id), applet_mode);
 
     const auto& applet_manager{Core::System::GetInstance().GetAppletManager()};
-    const auto applet = applet_manager.GetApplet(applet_id, current_process_title_id);
+    const auto applet = applet_manager.GetApplet(applet_id);
 
     if (applet == nullptr) {
         LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", static_cast<u32>(applet_id));
@@ -1286,13 +1218,13 @@ void IApplicationFunctions::GetSaveDataSize(Kernel::HLERequestContext& ctx) {
 }
 
 void InstallInterfaces(SM::ServiceManager& service_manager,
-                       std::shared_ptr<NVFlinger::NVFlinger> nvflinger, Core::System& system) {
+                       std::shared_ptr<NVFlinger::NVFlinger> nvflinger) {
     auto message_queue = std::make_shared<AppletMessageQueue>();
     message_queue->PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged); // Needed on
                                                                                       // game boot
 
-    std::make_shared<AppletAE>(nvflinger, message_queue, system)->InstallAsService(service_manager);
-    std::make_shared<AppletOE>(nvflinger, message_queue, system)->InstallAsService(service_manager);
+    std::make_shared<AppletAE>(nvflinger, message_queue)->InstallAsService(service_manager);
+    std::make_shared<AppletOE>(nvflinger, message_queue)->InstallAsService(service_manager);
     std::make_shared<IdleSys>()->InstallAsService(service_manager);
     std::make_shared<OMM>()->InstallAsService(service_manager);
     std::make_shared<SPSM>()->InstallAsService(service_manager);

src/core/hle/service/am/am.h

@@ -133,24 +133,16 @@ private:
     void SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx);
     void SetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
     void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
-    void SetAutoSleepDisabled(Kernel::HLERequestContext& ctx);
-    void IsAutoSleepDisabled(Kernel::HLERequestContext& ctx);
-    void GetAccumulatedSuspendedTickValue(Kernel::HLERequestContext& ctx);
-    void GetAccumulatedSuspendedTickChangedEvent(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     Kernel::EventPair launchable_event;
-    Kernel::EventPair accumulated_suspended_tick_changed_event;
-
     u32 idle_time_detection_extension = 0;
     u64 num_fatal_sections_entered = 0;
-    bool is_auto_sleep_disabled = false;
 };
 
 class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {
 public:
-    explicit ICommonStateGetter(Core::System& system,
-                                std::shared_ptr<AppletMessageQueue> msg_queue);
+    explicit ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_queue);
     ~ICommonStateGetter() override;
 
 private:
@@ -172,9 +164,7 @@ private:
     void GetPerformanceMode(Kernel::HLERequestContext& ctx);
     void GetBootMode(Kernel::HLERequestContext& ctx);
     void GetDefaultDisplayResolution(Kernel::HLERequestContext& ctx);
-    void SetCpuBoostMode(Kernel::HLERequestContext& ctx);
 
-    Core::System& system;
     std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 
@@ -208,15 +198,13 @@ private:
 
 class ILibraryAppletCreator final : public ServiceFramework<ILibraryAppletCreator> {
 public:
-    ILibraryAppletCreator(u64 current_process_title_id);
+    ILibraryAppletCreator();
     ~ILibraryAppletCreator() override;
 
 private:
     void CreateLibraryApplet(Kernel::HLERequestContext& ctx);
     void CreateStorage(Kernel::HLERequestContext& ctx);
     void CreateTransferMemoryStorage(Kernel::HLERequestContext& ctx);
-
-    u64 current_process_title_id;
 };
 
 class IApplicationFunctions final : public ServiceFramework<IApplicationFunctions> {
@@ -273,7 +261,7 @@ public:
 
 /// Registers all AM services with the specified service manager.
 void InstallInterfaces(SM::ServiceManager& service_manager,
-                       std::shared_ptr<NVFlinger::NVFlinger> nvflinger, Core::System& system);
+                       std::shared_ptr<NVFlinger::NVFlinger> nvflinger);
 
 } // namespace AM
 } // namespace Service

src/core/hle/service/am/applet_ae.cpp

@@ -4,7 +4,6 @@
 
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/process.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
@@ -14,10 +13,9 @@ namespace Service::AM {
 class ILibraryAppletProxy final : public ServiceFramework<ILibraryAppletProxy> {
 public:
     explicit ILibraryAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
-                                 std::shared_ptr<AppletMessageQueue> msg_queue,
-                                 Core::System& system)
+                                 std::shared_ptr<AppletMessageQueue> msg_queue)
         : ServiceFramework("ILibraryAppletProxy"), nvflinger(std::move(nvflinger)),
-          msg_queue(std::move(msg_queue)), system(system) {
+          msg_queue(std::move(msg_queue)) {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ILibraryAppletProxy::GetCommonStateGetter, "GetCommonStateGetter"},
@@ -42,7 +40,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ICommonStateGetter>(system, msg_queue);
+        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
     }
 
     void GetSelfController(Kernel::HLERequestContext& ctx) {
@@ -98,7 +96,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ILibraryAppletCreator>(system.CurrentProcess()->GetTitleID());
+        rb.PushIpcInterface<ILibraryAppletCreator>();
     }
 
     void GetApplicationFunctions(Kernel::HLERequestContext& ctx) {
@@ -111,15 +109,14 @@ private:
 
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
-    Core::System& system;
 };
 
 class ISystemAppletProxy final : public ServiceFramework<ISystemAppletProxy> {
 public:
     explicit ISystemAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
-                                std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system)
+                                std::shared_ptr<AppletMessageQueue> msg_queue)
         : ServiceFramework("ISystemAppletProxy"), nvflinger(std::move(nvflinger)),
-          msg_queue(std::move(msg_queue)), system(system) {
+          msg_queue(std::move(msg_queue)) {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ISystemAppletProxy::GetCommonStateGetter, "GetCommonStateGetter"},
@@ -146,7 +143,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ICommonStateGetter>(system, msg_queue);
+        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
     }
 
     void GetSelfController(Kernel::HLERequestContext& ctx) {
@@ -194,7 +191,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ILibraryAppletCreator>(system.CurrentProcess()->GetTitleID());
+        rb.PushIpcInterface<ILibraryAppletCreator>();
     }
 
     void GetHomeMenuFunctions(Kernel::HLERequestContext& ctx) {
@@ -222,7 +219,6 @@ private:
     }
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
-    Core::System& system;
 };
 
 void AppletAE::OpenSystemAppletProxy(Kernel::HLERequestContext& ctx) {
@@ -230,7 +226,7 @@ void AppletAE::OpenSystemAppletProxy(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISystemAppletProxy>(nvflinger, msg_queue, system);
+    rb.PushIpcInterface<ISystemAppletProxy>(nvflinger, msg_queue);
 }
 
 void AppletAE::OpenLibraryAppletProxy(Kernel::HLERequestContext& ctx) {
@@ -238,7 +234,7 @@ void AppletAE::OpenLibraryAppletProxy(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger, msg_queue, system);
+    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger, msg_queue);
 }
 
 void AppletAE::OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx) {
@@ -246,13 +242,13 @@ void AppletAE::OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger, msg_queue, system);
+    rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger, msg_queue);
 }
 
 AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
-                   std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system)
+                   std::shared_ptr<AppletMessageQueue> msg_queue)
     : ServiceFramework("appletAE"), nvflinger(std::move(nvflinger)),
-      msg_queue(std::move(msg_queue)), system(system) {
+      msg_queue(std::move(msg_queue)) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {100, &AppletAE::OpenSystemAppletProxy, "OpenSystemAppletProxy"},