+#!/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/

+#!/bin/bash -ex

+

+GITDATE="`git show -s --date=short --format='%ad' | sed 's/-//g'`"

+GITREV="`git show -s --format='%h'`"

+

+mkdir -p artifacts

+#!/bin/bash -ex

+

+# Run clang-format

+cd /yuzu

+chmod a+x ./.ci/scripts/format/script.sh

+./.ci/scripts/format/script.sh

+#!/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

+#!/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

+#!/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

+#!/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

+#!/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

+# 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)

+# 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')

+git config --global user.email "yuzu@yuzu-emu.org"

+git config --global user.name "yuzubot" \ No newline at end of file

+#!/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/"

+#!/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

+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()

+#!/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

+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'

+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' \ No newline at end of file

+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' \ No newline at end of file

+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'

+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 \ No newline at end of file

+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)'

+steps:

+ - task: DownloadPipelineArtifact@2

+ displayName: 'Download Windows Release'

+ inputs:

+ artifactName: 'yuzu-$(BuildName)-windows-mingw'

+ buildType: 'current'

+ targetPath: '$(Build.ArtifactStagingDirectory)'

+ - task: DownloadPipelineArtifact@2

+ displayName: 'Download Linux Release'

+ inputs:

+ artifactName: 'yuzu-$(BuildName)-linux'

+ buildType: 'current'

+ targetPath: '$(Build.ArtifactStagingDirectory)'

+ - task: DownloadPipelineArtifact@2

+ displayName: 'Download Release Point'

+ inputs:

+ artifactName: 'yuzu-$(BuildName)-release-point'

+ buildType: 'current'

+ targetPath: '$(Build.ArtifactStagingDirectory)'

+ - script: echo '##vso[task.setvariable variable=tagcommit]' && cat $(Build.ArtifactStagingDirectory)/tag-commit.sha

+ displayName: 'Calculate Release Point'

+ - task: GitHubRelease@0

+ inputs:

+ gitHubConnection: $(GitHubReleaseConnectionName)

+ repositoryName: '$(GitHubReleaseRepoName)'

+ action: 'create'

+ target: $(variables.tagcommit)

+ title: 'yuzu $(BuildName) #$(Build.BuildId)'

+ assets: '$(Build.ArtifactStagingDirectory)/*'

+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 \ No newline at end of file

+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')

+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) \ No newline at end of file

+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

+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 \ No newline at end of file

+u32 ProgramMetadata::GetSystemResourceSize() const {

+ return npdm_header.system_resource_size;

+}

+

+ u32 GetSystemResourceSize() const;

+ std::array<u8, 4> reserved_4;

+ u32_le system_resource_size;

+u64 Process::GetTotalPhysicalMemoryAvailableWithoutSystemResource() const {

+ return GetTotalPhysicalMemoryAvailable() - GetSystemResourceSize();

+ return vm_manager.GetCurrentHeapSize() + main_thread_stack_size + code_memory_size +

+ GetSystemResourceUsage();

+u64 Process::GetTotalPhysicalMemoryUsedWithoutSystemResource() const {

+ return GetTotalPhysicalMemoryUsed() - GetSystemResourceUsage();

+ system_resource_size = metadata.GetSystemResourceSize();

+ /// 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;

+ /// without the size of the personal system resource heap added to it.

+ u64 GetTotalPhysicalMemoryAvailableWithoutSystemResource() const;

+ /// without the size of the personal system resource heap added to it.

+ u64 GetTotalPhysicalMemoryUsedWithoutSystemResource() const;

+ /// 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;

+

+ SystemResourceSize = 16,

+ SystemResourceUsage = 17,

+ TotalPhysicalMemoryAvailableWithoutSystemResource = 21,

+ TotalPhysicalMemoryUsedWithoutSystemResource = 22,

+ case GetInfoType::SystemResourceSize:

+ case GetInfoType::SystemResourceUsage:

+ case GetInfoType::TotalPhysicalMemoryAvailableWithoutSystemResource:

+ case GetInfoType::TotalPhysicalMemoryUsedWithoutSystemResource: {

+ 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::TotalPhysicalMemoryAvailableWithoutSystemResource:

+ *result = process->GetTotalPhysicalMemoryAvailableWithoutSystemResource();

+ case GetInfoType::TotalPhysicalMemoryUsedWithoutSystemResource:

+ *result = process->GetTotalPhysicalMemoryUsedWithoutSystemResource();

+/// 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);

+}

+

+ {0x2C, SvcWrap<MapPhysicalMemory>, "MapPhysicalMemory"},

+ {0x2D, SvcWrap<UnmapPhysicalMemory>, "UnmapPhysicalMemory"},

+template <ResultCode func(Core::System&, u64, u64)>

+void SvcWrap(Core::System& system) {

+ FuncReturn(system, func(system, Param(system, 0), Param(system, 1)).raw);

+}

+

+#include "core/hle/kernel/process.h"

+#include "core/hle/kernel/resource_limit.h"

+ 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) {

+ return true;

+ }

+ MemoryState state, VMAPermission perm) {

+ final_vma.permissions = perm;

+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;

+}

+

+ ReprotectRange(src_addr, size, VMAPermission::None);

+ MergeAdjacentVMA(iter->second, next_vma->second);

+ MergeAdjacentVMA(prev_vma->second, iter->second);

+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;

+ }

+}

+

+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);

+}

+

+ std::size_t offset, u64 size, MemoryState state,

+ VMAPermission perm = VMAPermission::ReadWrite);

+ /// 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);

+

+ /**

+ * Merges two adjacent VMAs.

+ */

+ void MergeAdjacentVMA(VirtualMemoryArea& left, const VirtualMemoryArea& right);

+

+ /// 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;

+

+ // 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;

+

+ buffer_cache.h

+// Copyright 2019 yuzu Emulator Project

+// Licensed under GPLv2 or any later version

+// Refer to the license.txt file included.

+

+#pragma once

+

+#include <array>

+#include <memory>

+#include <mutex>

+#include <unordered_map>

+#include <unordered_set>

+#include <utility>

+#include <vector>

+

+#include "common/alignment.h"

+#include "common/common_types.h"

+#include "core/core.h"

+#include "video_core/memory_manager.h"

+#include "video_core/rasterizer_cache.h"

+

+namespace VideoCore {

+class RasterizerInterface;

+}

+

+namespace VideoCommon {

+

+template <typename BufferStorageType>

+class CachedBuffer final : public RasterizerCacheObject {

+public:

+ explicit CachedBuffer(VAddr cpu_addr, u8* host_ptr)

+ : RasterizerCacheObject{host_ptr}, host_ptr{host_ptr}, cpu_addr{cpu_addr} {}

+ ~CachedBuffer() override = default;

+

+ VAddr GetCpuAddr() const override {

+ return cpu_addr;

+ }

+

+ std::size_t GetSizeInBytes() const override {

+ return size;

+ }

+

+ u8* GetWritableHostPtr() const {

+ return host_ptr;

+ }

+

+ std::size_t GetSize() const {

+ return size;

+ }

+

+ std::size_t GetCapacity() const {

+ return capacity;

+ }

+

+ bool IsInternalized() const {

+ return is_internal;

+ }

+

+ const BufferStorageType& GetBuffer() const {

+ return buffer;

+ }

+

+ void SetSize(std::size_t new_size) {

+ size = new_size;

+ }

+

+ void SetInternalState(bool is_internal_) {

+ is_internal = is_internal_;

+ }

+

+ BufferStorageType ExchangeBuffer(BufferStorageType buffer_, std::size_t new_capacity) {

+ capacity = new_capacity;

+ std::swap(buffer, buffer_);

+ return buffer_;

+ }

+

+private:

+ u8* host_ptr{};

+ VAddr cpu_addr{};

+ std::size_t size{};

+ std::size_t capacity{};

+ bool is_internal{};

+ BufferStorageType buffer;

+};

+

+template <typename BufferStorageType, typename BufferType, typename StreamBuffer>

+class BufferCache : public RasterizerCache<std::shared_ptr<CachedBuffer<BufferStorageType>>> {

+public:

+ using Buffer = std::shared_ptr<CachedBuffer<BufferStorageType>>;

+ using BufferInfo = std::pair<const BufferType*, u64>;

+

+ explicit BufferCache(VideoCore::RasterizerInterface& rasterizer, Core::System& system,

+ std::unique_ptr<StreamBuffer> stream_buffer)

+ : RasterizerCache<Buffer>{rasterizer}, system{system},

+ stream_buffer{std::move(stream_buffer)}, stream_buffer_handle{

+ this->stream_buffer->GetHandle()} {}

+ ~BufferCache() = default;

+

+ void Unregister(const Buffer& entry) override {

+ std::lock_guard lock{RasterizerCache<Buffer>::mutex};

+ if (entry->IsInternalized()) {

+ internalized_entries.erase(entry->GetCacheAddr());

+ }

+ ReserveBuffer(entry);

+ RasterizerCache<Buffer>::Unregister(entry);

+ }

+

+ void TickFrame() {

+ marked_for_destruction_index =

+ (marked_for_destruction_index + 1) % marked_for_destruction_ring_buffer.size();

+ MarkedForDestruction().clear();

+ }

+

+ BufferInfo UploadMemory(GPUVAddr gpu_addr, std::size_t size, std::size_t alignment = 4,

+ bool internalize = false, bool is_written = false) {

+ std::lock_guard lock{RasterizerCache<Buffer>::mutex};

+

+ auto& memory_manager = system.GPU().MemoryManager();

+ const auto host_ptr = memory_manager.GetPointer(gpu_addr);

+ if (!host_ptr) {

+ return {GetEmptyBuffer(size), 0};

+ }

+ const auto cache_addr = ToCacheAddr(host_ptr);

+

+ // Cache management is a big overhead, so only cache entries with a given size.

+ // TODO: Figure out which size is the best for given games.

+ constexpr std::size_t max_stream_size = 0x800;

+ if (!internalize && size < max_stream_size &&

+ internalized_entries.find(cache_addr) == internalized_entries.end()) {

+ return StreamBufferUpload(host_ptr, size, alignment);

+ }

+

+ auto entry = RasterizerCache<Buffer>::TryGet(cache_addr);

+ if (!entry) {

+ return FixedBufferUpload(gpu_addr, host_ptr, size, internalize, is_written);

+ }

+

+ if (entry->GetSize() < size) {

+ IncreaseBufferSize(entry, size);

+ }

+ if (is_written) {

+ entry->MarkAsModified(true, *this);

+ }

+ return {ToHandle(entry->GetBuffer()), 0};

+ }

+

+ /// Uploads from a host memory. Returns the OpenGL buffer where it's located and its offset.

+ BufferInfo UploadHostMemory(const void* raw_pointer, std::size_t size,

+ std::size_t alignment = 4) {

+ std::lock_guard lock{RasterizerCache<Buffer>::mutex};

+ return StreamBufferUpload(raw_pointer, size, alignment);

+ }

+

+ void Map(std::size_t max_size) {

+ std::tie(buffer_ptr, buffer_offset_base, invalidated) = stream_buffer->Map(max_size, 4);

+ buffer_offset = buffer_offset_base;

+ }

+

+ /// Finishes the upload stream, returns true on bindings invalidation.

+ bool Unmap() {

+ stream_buffer->Unmap(buffer_offset - buffer_offset_base);

+ return std::exchange(invalidated, false);

+ }

+

+ virtual const BufferType* GetEmptyBuffer(std::size_t size) = 0;

+

+protected:

+ void FlushObjectInner(const Buffer& entry) override {

+ DownloadBufferData(entry->GetBuffer(), 0, entry->GetSize(), entry->GetWritableHostPtr());

+ }

+

+ virtual BufferStorageType CreateBuffer(std::size_t size) = 0;

+

+ virtual const BufferType* ToHandle(const BufferStorageType& storage) = 0;

+

+ virtual void UploadBufferData(const BufferStorageType& buffer, std::size_t offset,

+ std::size_t size, const u8* data) = 0;

+

+ virtual void DownloadBufferData(const BufferStorageType& buffer, std::size_t offset,

+ std::size_t size, u8* data) = 0;

+

+ virtual void CopyBufferData(const BufferStorageType& src, const BufferStorageType& dst,

+ std::size_t src_offset, std::size_t dst_offset,

+ std::size_t size) = 0;

+

+private:

+ BufferInfo StreamBufferUpload(const void* raw_pointer, std::size_t size,

+ std::size_t alignment) {

+ AlignBuffer(alignment);

+ const std::size_t uploaded_offset = buffer_offset;

+ std::memcpy(buffer_ptr, raw_pointer, size);

+

+ buffer_ptr += size;

+ buffer_offset += size;

+ return {&stream_buffer_handle, uploaded_offset};

+ }

+

+ BufferInfo FixedBufferUpload(GPUVAddr gpu_addr, u8* host_ptr, std::size_t size,

+ bool internalize, bool is_written) {

+ auto& memory_manager = Core::System::GetInstance().GPU().MemoryManager();

+ const auto cpu_addr = memory_manager.GpuToCpuAddress(gpu_addr);

+ ASSERT(cpu_addr);

+

+ auto entry = GetUncachedBuffer(*cpu_addr, host_ptr);

+ entry->SetSize(size);

+ entry->SetInternalState(internalize);

+ RasterizerCache<Buffer>::Register(entry);

+

+ if (internalize) {

+ internalized_entries.emplace(ToCacheAddr(host_ptr));

+ }

+ if (is_written) {

+ entry->MarkAsModified(true, *this);

+ }

+

+ if (entry->GetCapacity() < size) {

+ MarkedForDestruction().push_back(entry->ExchangeBuffer(CreateBuffer(size), size));

+ }

+

+ UploadBufferData(entry->GetBuffer(), 0, size, host_ptr);

+ return {ToHandle(entry->GetBuffer()), 0};

+ }

+

+ void IncreaseBufferSize(Buffer& entry, std::size_t new_size) {

+ const std::size_t old_size = entry->GetSize();

+ if (entry->GetCapacity() < new_size) {

+ const auto& old_buffer = entry->GetBuffer();

+ auto new_buffer = CreateBuffer(new_size);

+

+ // Copy bits from the old buffer to the new buffer.

+ CopyBufferData(old_buffer, new_buffer, 0, 0, old_size);

+ MarkedForDestruction().push_back(

+ entry->ExchangeBuffer(std::move(new_buffer), new_size));

+

+ // This buffer could have been used

+ invalidated = true;

+ }

+ // Upload the new bits.

+ const std::size_t size_diff = new_size - old_size;

+ UploadBufferData(entry->GetBuffer(), old_size, size_diff, entry->GetHostPtr() + old_size);

+

+ // Update entry's size in the object and in the cache.

+ Unregister(entry);

+

+ entry->SetSize(new_size);

+ RasterizerCache<Buffer>::Register(entry);

+ }

+

+ Buffer GetUncachedBuffer(VAddr cpu_addr, u8* host_ptr) {

+ if (auto entry = TryGetReservedBuffer(host_ptr)) {

+ return entry;

+ }

+ return std::make_shared<CachedBuffer<BufferStorageType>>(cpu_addr, host_ptr);

+ }

+

+ Buffer TryGetReservedBuffer(u8* host_ptr) {

+ const auto it = buffer_reserve.find(ToCacheAddr(host_ptr));

+ if (it == buffer_reserve.end()) {

+ return {};

+ }

+ auto& reserve = it->second;

+ auto entry = reserve.back();

+ reserve.pop_back();

+ return entry;

+ }

+

+ void ReserveBuffer(Buffer entry) {

+ buffer_reserve[entry->GetCacheAddr()].push_back(std::move(entry));

+ }

+

+ void AlignBuffer(std::size_t alignment) {

+ // Align the offset, not the mapped pointer

+ const std::size_t offset_aligned = Common::AlignUp(buffer_offset, alignment);

+ buffer_ptr += offset_aligned - buffer_offset;

+ buffer_offset = offset_aligned;

+ }

+

+ std::vector<BufferStorageType>& MarkedForDestruction() {

+ return marked_for_destruction_ring_buffer[marked_for_destruction_index];

+ }

+

+ Core::System& system;

+

+ std::unique_ptr<StreamBuffer> stream_buffer;

+ BufferType stream_buffer_handle{};

+

+ bool invalidated = false;

+

+ u8* buffer_ptr = nullptr;

+ u64 buffer_offset = 0;

+ u64 buffer_offset_base = 0;

+

+ std::size_t marked_for_destruction_index = 0;

+ std::array<std::vector<BufferStorageType>, 4> marked_for_destruction_ring_buffer;

+

+ std::unordered_set<CacheAddr> internalized_entries;

+ std::unordered_map<CacheAddr, std::vector<Buffer>> buffer_reserve;

+};

+

+} // namespace VideoCommon

+ static constexpr std::size_t MaxConstBufferSize = 0x10000;

+ LayerViewportPointSize = 6,

+ BitField<59, 1, u64> fp32_flag;

+ INST("1101-01---------", Id::TLDS, Type::Texture, "TLDS"),

+ memory_manager = std::make_unique<Tegra::MemoryManager>(system, rasterizer);

+#include "common/microprofile.h"

+MICROPROFILE_DEFINE(MacroInterp, "GPU", "Execute macro interpreter", MP_RGB(128, 128, 192));

+

+ MICROPROFILE_SCOPE(MacroInterp);

+#include "core/core.h"

+#include "core/hle/kernel/process.h"

+#include "core/hle/kernel/vm_manager.h"

+MemoryManager::MemoryManager(Core::System& system, VideoCore::RasterizerInterface& rasterizer)

+ : rasterizer{rasterizer}, system{system} {

+ ASSERT(system.CurrentProcess()

+ ->VMManager()

+ .SetMemoryAttribute(cpu_addr, size, Kernel::MemoryAttribute::DeviceMapped,

+ Kernel::MemoryAttribute::DeviceMapped)

+ .IsSuccess());

+ ASSERT(system.CurrentProcess()

+ ->VMManager()

+ .SetMemoryAttribute(cpu_addr, size, Kernel::MemoryAttribute::DeviceMapped,

+ Kernel::MemoryAttribute::DeviceMapped)

+ .IsSuccess());

+ const auto cpu_addr = GpuToCpuAddress(gpu_addr);

+ ASSERT(cpu_addr);

+ ASSERT(system.CurrentProcess()

+ ->VMManager()

+ .SetMemoryAttribute(cpu_addr.value(), size, Kernel::MemoryAttribute::DeviceMapped,

+ Kernel::MemoryAttribute::None)

+ .IsSuccess());

+namespace Core {

+class System;

+}

+

+ explicit MemoryManager(Core::System& system, VideoCore::RasterizerInterface& rasterizer);

+

+ Core::System& system;

+ /// Notify rasterizer that a frame is about to finish

+ virtual void TickFrame() = 0;

+

+#include <glad/glad.h>

+

+#include "common/assert.h"

+#include "video_core/renderer_opengl/gl_resource_manager.h"

+OGLBufferCache::OGLBufferCache(RasterizerOpenGL& rasterizer, Core::System& system,

+ std::size_t stream_size)

+ : VideoCommon::BufferCache<OGLBuffer, GLuint, OGLStreamBuffer>{

+ rasterizer, system, std::make_unique<OGLStreamBuffer>(stream_size, true)} {}

+OGLBufferCache::~OGLBufferCache() = default;

+OGLBuffer OGLBufferCache::CreateBuffer(std::size_t size) {

+ OGLBuffer buffer;

+ buffer.Create();

+ glNamedBufferData(buffer.handle, static_cast<GLsizeiptr>(size), nullptr, GL_DYNAMIC_DRAW);

+ return buffer;

+const GLuint* OGLBufferCache::ToHandle(const OGLBuffer& buffer) {

+ return &buffer.handle;

+const GLuint* OGLBufferCache::GetEmptyBuffer(std::size_t) {

+ static const GLuint null_buffer = 0;

+ return &null_buffer;

+void OGLBufferCache::UploadBufferData(const OGLBuffer& buffer, std::size_t offset, std::size_t size,

+ const u8* data) {

+ glNamedBufferSubData(buffer.handle, static_cast<GLintptr>(offset),

+ static_cast<GLsizeiptr>(size), data);

+void OGLBufferCache::DownloadBufferData(const OGLBuffer& buffer, std::size_t offset,

+ std::size_t size, u8* data) {

+ glGetNamedBufferSubData(buffer.handle, static_cast<GLintptr>(offset),

+ static_cast<GLsizeiptr>(size), data);

+void OGLBufferCache::CopyBufferData(const OGLBuffer& src, const OGLBuffer& dst,

+ std::size_t src_offset, std::size_t dst_offset,

+ std::size_t size) {

+ glCopyNamedBufferSubData(src.handle, dst.handle, static_cast<GLintptr>(src_offset),

+ static_cast<GLintptr>(dst_offset), static_cast<GLsizeiptr>(size));

+#include "video_core/buffer_cache.h"

+namespace Core {

+class System;

+}

+

+class OGLStreamBuffer;

+class OGLBufferCache final : public VideoCommon::BufferCache<OGLBuffer, GLuint, OGLStreamBuffer> {

+ explicit OGLBufferCache(RasterizerOpenGL& rasterizer, Core::System& system,

+ std::size_t stream_size);

+ ~OGLBufferCache();

+ const GLuint* GetEmptyBuffer(std::size_t) override;

+ OGLBuffer CreateBuffer(std::size_t size) override;

+

+ const GLuint* ToHandle(const OGLBuffer& buffer) override;

+ void UploadBufferData(const OGLBuffer& buffer, std::size_t offset, std::size_t size,

+ const u8* data) override;

+ void DownloadBufferData(const OGLBuffer& buffer, std::size_t offset, std::size_t size,

+ u8* data) override;

+ void CopyBufferData(const OGLBuffer& src, const OGLBuffer& dst, std::size_t src_offset,

+ std::size_t dst_offset, std::size_t size) override;

+ shader_storage_alignment = GetInteger<std::size_t>(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT);

+ has_vertex_viewport_layer = GLAD_GL_ARB_shader_viewport_layer_array;

+ has_vertex_viewport_layer = true;

+ std::size_t GetShaderStorageBufferAlignment() const {

+ return shader_storage_alignment;

+ }

+

+ bool HasVertexViewportLayer() const {

+ return has_vertex_viewport_layer;

+ }

+

+ std::size_t shader_storage_alignment{};

+ bool has_vertex_viewport_layer{};

+#include "video_core/memory_manager.h"

+static std::size_t GetConstBufferSize(const Tegra::Engines::ConstBufferInfo& buffer,

+ const GLShader::ConstBufferEntry& entry) {

+ if (!entry.IsIndirect()) {

+ return entry.GetSize();

+ }

+

+ if (buffer.size > Maxwell::MaxConstBufferSize) {

+ LOG_WARNING(Render_OpenGL, "Indirect constbuffer size {} exceeds maximum {}", buffer.size,

+ Maxwell::MaxConstBufferSize);

+ return Maxwell::MaxConstBufferSize;

+ }

+

+ return buffer.size;

+}

+

+ system{system}, screen_info{info}, buffer_cache{*this, system, STREAM_BUFFER_SIZE} {

+ const auto [vertex_buffer, vertex_buffer_offset] = buffer_cache.UploadMemory(start, size);

+ vertex_array_pushbuffer.SetVertexBuffer(index, vertex_buffer, vertex_buffer_offset,

+ vertex_array.stride);

+GLintptr RasterizerOpenGL::SetupIndexBuffer() {

+ if (accelerate_draw != AccelDraw::Indexed) {

+ return 0;

+ }

+ MICROPROFILE_SCOPE(OpenGL_Index);

+ const auto& regs = system.GPU().Maxwell3D().regs;

+ const std::size_t size = CalculateIndexBufferSize();

+ const auto [buffer, offset] = buffer_cache.UploadMemory(regs.index_array.IndexStart(), size);

+ vertex_array_pushbuffer.SetIndexBuffer(buffer);

+ return offset;

+}

+

+DrawParameters RasterizerOpenGL::SetupDraw(GLintptr index_buffer_offset) {

+ params.index_buffer_offset = index_buffer_offset;

+ const auto [buffer, offset] =

+ bind_ubo_pushbuffer.Push(buffer, offset, static_cast<GLsizeiptr>(sizeof(ubo)));

+ buffer_size += Maxwell::MaxConstBuffers *

+ (Maxwell::MaxConstBufferSize + device.GetUniformBufferAlignment());

+ // Prepare the vertex array.

+ buffer_cache.Map(buffer_size);

+ // Prepare vertex array format.

+ vertex_array_pushbuffer.Setup(vao);

+

+ // Upload vertex and index data.

+ const GLintptr index_buffer_offset = SetupIndexBuffer();

+ // Setup draw parameters. It will automatically choose what glDraw* method to use.

+ const DrawParameters params = SetupDraw(index_buffer_offset);

+

+ // Prepare packed bindings.

+ bind_ubo_pushbuffer.Setup(0);

+ bind_ssbo_pushbuffer.Setup(0);

+

+ // Setup shaders and their used resources.

+ // Signal the buffer cache that we are not going to upload more things.

+ const bool invalidate = buffer_cache.Unmap();

+

+ // Now that we are no longer uploading data, we can safely bind the buffers to OpenGL.

+ vertex_array_pushbuffer.Bind();

+ bind_ubo_pushbuffer.Bind();

+ bind_ssbo_pushbuffer.Bind();

+

+ if (invalidate) {

+ // As all cached buffers are invalidated, we need to recheck their state.

+ gpu.dirty_flags.vertex_array.set();

+ }

+ buffer_cache.FlushRegion(addr, size);

+void RasterizerOpenGL::TickFrame() {

+ buffer_cache.TickFrame();

+}

+

+ for (const auto& entry : shader->GetShaderEntries().const_buffers) {

+ bind_ubo_pushbuffer.Push(buffer_cache.GetEmptyBuffer(sizeof(float)), 0, sizeof(float));

+ const std::size_t size = Common::AlignUp(GetConstBufferSize(buffer, entry), sizeof(GLvec4));

+ const auto alignment = device.GetUniformBufferAlignment();

+ const auto [cbuf, offset] = buffer_cache.UploadMemory(buffer.address, size, alignment);

+ bind_ubo_pushbuffer.Push(cbuf, offset, size);

+ auto& gpu{system.GPU()};

+ auto& memory_manager{gpu.MemoryManager()};

+ const auto cbufs{gpu.Maxwell3D().state.shader_stages[static_cast<std::size_t>(stage)]};

+ const auto alignment{device.GetShaderStorageBufferAlignment()};

+

+ for (const auto& entry : shader->GetShaderEntries().global_memory_entries) {

+ const auto addr{cbufs.const_buffers[entry.GetCbufIndex()].address + entry.GetCbufOffset()};

+ const auto actual_addr{memory_manager.Read<u64>(addr)};

+ const auto size{memory_manager.Read<u32>(addr + 8)};

+

+ const auto [ssbo, buffer_offset] =

+ buffer_cache.UploadMemory(actual_addr, size, alignment, true, entry.IsWritten());

+ bind_ssbo_pushbuffer.Push(ssbo, buffer_offset, static_cast<GLsizeiptr>(size));

+ void TickFrame() override;

+ VertexArrayPushBuffer vertex_array_pushbuffer;

+ GLintptr SetupIndexBuffer();

+

+ DrawParameters SetupDraw(GLintptr index_buffer_offset);

+ "#extension GL_ARB_separate_shader_objects : enable\n";

+ if (entries.shader_viewport_layer_array) {

+ source += "#extension GL_ARB_shader_viewport_layer_array : enable\n";

+ }

+ source += fmt::format("\n#define EMULATION_UBO_BINDING {}\n", base_bindings.cbuf++);

+#include "common/logging/log.h"

+ static_cast<u32>(Maxwell::MaxConstBufferSize) / (4 * sizeof(float));

+ entries.shader_viewport_layer_array =

+ stage == ShaderStage::Vertex && (ir.UsesLayer() || ir.UsesViewportIndex());

+ for (const auto attribute : ir.GetOutputAttributes()) {

+ if (attribute == Attribute::Index::ClipDistances0123 ||

+ attribute == Attribute::Index::ClipDistances4567) {

+ break;

+ if (stage != ShaderStage::Vertex || device.HasVertexViewportLayer()) {

+ if (ir.UsesLayer()) {

+ code.AddLine("int gl_Layer;");

+ }

+ if (ir.UsesViewportIndex()) {

+ code.AddLine("int gl_ViewportIndex;");

+ }

+ } else if ((ir.UsesLayer() || ir.UsesViewportIndex()) && stage == ShaderStage::Vertex &&

+ !device.HasVertexViewportLayer()) {

+ LOG_ERROR(

+ Render_OpenGL,

+ "GL_ARB_shader_viewport_layer_array is not available and its required by a shader");

+ }

+

+ if (ir.UsesPointSize()) {

+ code.AddLine("float gl_PointSize;");

+ }

+ std::optional<std::pair<std::string, bool>> GetOutputAttribute(const AbufNode* abuf) {

+ switch (const auto attribute = abuf->GetIndex()) {

+ case Attribute::Index::Position:

+ return std::make_pair("gl_Position"s + GetSwizzle(abuf->GetElement()), false);

+ case Attribute::Index::LayerViewportPointSize:

+ switch (abuf->GetElement()) {

+ case 0:

+ UNIMPLEMENTED();

+ return {};

+ case 1:

+ if (stage == ShaderStage::Vertex && !device.HasVertexViewportLayer()) {

+ return {};

+ }

+ return std::make_pair("gl_Layer", true);

+ case 2:

+ if (stage == ShaderStage::Vertex && !device.HasVertexViewportLayer()) {

+ return {};

+ }

+ return std::make_pair("gl_ViewportIndex", true);

+ case 3:

+ UNIMPLEMENTED_MSG("Requires some state changes for gl_PointSize to work in shader");

+ return std::make_pair("gl_PointSize", false);

+ }

+ return {};

+ case Attribute::Index::ClipDistances0123:

+ return std::make_pair(fmt::format("gl_ClipDistance[{}]", abuf->GetElement()), false);

+ case Attribute::Index::ClipDistances4567:

+ return std::make_pair(fmt::format("gl_ClipDistance[{}]", abuf->GetElement() + 4),

+ false);

+ default:

+ if (IsGenericAttribute(attribute)) {

+ return std::make_pair(

+ GetOutputAttribute(attribute) + GetSwizzle(abuf->GetElement()), false);

+ }

+ UNIMPLEMENTED_MSG("Unhandled output attribute: {}", static_cast<u32>(attribute));

+ return {};

+ }

+ }

+

+ bool is_integer = false;

+

+ const auto result = GetOutputAttribute(abuf);

+ if (!result) {

+ return {};

+ }

+ target = result->first;

+ is_integer = result->second;

+ if (is_integer) {

+ code.AddLine("{} = ftoi({});", target, Visit(src));

+ } else {

+ code.AddLine("{} = {};", target, Visit(src));

+ }

+ bool shader_viewport_layer_array{};

+ bool shader_viewport_layer_array{};

+ if (!LoadObjectFromPrecompiled(shader_viewport_layer_array)) {

+ return {};

+ }

+ entry.entries.shader_viewport_layer_array = shader_viewport_layer_array;

+

+ if (!SaveObjectToPrecompiled(entries.shader_viewport_layer_array)) {

+ return false;

+ }

+

+#include "common/microprofile.h"

+MICROPROFILE_DEFINE(OpenGL_State, "OpenGL", "State Change", MP_RGB(192, 128, 128));

+

+ MICROPROFILE_SCOPE(OpenGL_State);

+MICROPROFILE_DEFINE(OpenGL_Texture_Buffer_Copy, "OpenGL", "Texture Buffer Copy",

+ MP_RGB(128, 192, 128));

+ MICROPROFILE_SCOPE(OpenGL_Texture_Buffer_Copy);

+ rasterizer->TickFrame();

+

+VertexArrayPushBuffer::VertexArrayPushBuffer() = default;

+

+VertexArrayPushBuffer::~VertexArrayPushBuffer() = default;

+

+void VertexArrayPushBuffer::Setup(GLuint vao_) {

+ vao = vao_;

+ index_buffer = nullptr;

+ vertex_buffers.clear();

+}

+

+void VertexArrayPushBuffer::SetIndexBuffer(const GLuint* buffer) {

+ index_buffer = buffer;

+}

+

+void VertexArrayPushBuffer::SetVertexBuffer(GLuint binding_index, const GLuint* buffer,

+ GLintptr offset, GLsizei stride) {

+ vertex_buffers.push_back(Entry{binding_index, buffer, offset, stride});

+}

+

+void VertexArrayPushBuffer::Bind() {

+ if (index_buffer) {

+ glVertexArrayElementBuffer(vao, *index_buffer);

+ }

+

+ // TODO(Rodrigo): Find a way to ARB_multi_bind this

+ for (const auto& entry : vertex_buffers) {

+ glVertexArrayVertexBuffer(vao, entry.binding_index, *entry.buffer, entry.offset,

+ entry.stride);

+ }

+}

+

+ buffer_pointers.clear();

+void BindBuffersRangePushBuffer::Push(const GLuint* buffer, GLintptr offset, GLsizeiptr size) {

+ buffer_pointers.push_back(buffer);

+void BindBuffersRangePushBuffer::Bind() {

+ // Ensure sizes are valid.

+ const std::size_t count{buffer_pointers.size()};

+

+ // Dereference buffers.

+ buffers.resize(count);

+ std::transform(buffer_pointers.begin(), buffer_pointers.end(), buffers.begin(),

+ [](const GLuint* pointer) { return *pointer; });

+

+class VertexArrayPushBuffer final {

+ explicit VertexArrayPushBuffer();

+ ~VertexArrayPushBuffer();

+

+ void Setup(GLuint vao_);

+

+ void SetIndexBuffer(const GLuint* buffer);

+

+ void SetVertexBuffer(GLuint binding_index, const GLuint* buffer, GLintptr offset,

+ GLsizei stride);

+

+ void Bind();

+

+private:

+ struct Entry {

+ GLuint binding_index{};

+ const GLuint* buffer{};

+ GLintptr offset{};

+ GLsizei stride{};

+ };

+

+ GLuint vao{};

+ const GLuint* index_buffer{};

+ std::vector<Entry> vertex_buffers;

+};

+

+class BindBuffersRangePushBuffer final {

+public:

+ explicit BindBuffersRangePushBuffer(GLenum target);

+ void Push(const GLuint* buffer, GLintptr offset, GLsizeiptr size);

+ void Bind();

+ GLenum target{};

+ GLuint first{};

+ std::vector<const GLuint*> buffer_pointers;

+

+ if (index == Attribute::Index::ClipDistances0123 ||

+ index == Attribute::Index::ClipDistances4567) {

+ if (ir.UsesPointSize()) {

+ MemberDecorateBuiltIn(spv::BuiltIn::PointSize, "point_size", ir.UsesPointSize());

+ case Attribute::Index::LayerViewportPointSize:

+ UNIMPLEMENTED_IF(abuf->GetElement() != 3);

+ const auto [base_image, cbuf_index, cbuf_offset]{

+ const auto [base_address, index, offset] =

+ TrackCbuf(addr_register, global_code, static_cast<s64>(global_code.size()));

+ ASSERT(base_address != nullptr);

+

+ bb.push_back(Comment(fmt::format("Base address is c[0x{:x}][0x{:x}]", index, offset)));

+

+ const GlobalMemoryBase descriptor{index, offset};

+ const Node4 components = GetTldsCode(instr, texture_type, is_array);

+

+ if (instr.tlds.fp32_flag) {

+ WriteTexsInstructionFloat(bb, instr, components);

+ } else {

+ WriteTexsInstructionHalfFloat(bb, instr, components);

+ }

+ const auto [base_sampler, cbuf_index, cbuf_offset] =

+ ASSERT(base_sampler != nullptr);

+ const Node final_offset = [&]() {

+ // Attempt to inline constant buffer without a variable offset. This is done to allow

+ // tracking LDC calls.

+ if (const auto gpr = std::get_if<GprNode>(&*node)) {

+ if (gpr->GetIndex() == Register::ZeroIndex) {

+ return Immediate(offset);

+ }

+ }

+ return Operation(OperationCode::UAdd, NO_PRECISE, node, Immediate(offset));

+ }();

+ if (index == Attribute::Index::LayerViewportPointSize) {

+ switch (element) {

+ case 0:

+ UNIMPLEMENTED();

+ break;

+ case 1:

+ uses_layer = true;

+ break;

+ case 2:

+ uses_viewport_index = true;

+ break;

+ case 3:

+ uses_point_size = true;

+ break;

+ }

+ }

+ bool UsesLayer() const {

+ return uses_layer;

+ }

+

+ bool UsesViewportIndex() const {

+ return uses_viewport_index;

+ }

+

+ bool UsesPointSize() const {

+ return uses_point_size;

+ }

+

+ std::tuple<Node, u32, u32> TrackCbuf(Node tracked, const NodeBlock& code, s64 cursor) const;

+ bool uses_layer{};

+ bool uses_viewport_index{};

+ bool uses_point_size{};

+} // Anonymous namespace

+std::tuple<Node, u32, u32> ShaderIR::TrackCbuf(Node tracked, const NodeBlock& code,

+ s64 cursor) const {

+ // Constant buffer found, test if it's an immediate

+ const auto offset = cbuf->GetOffset();

+ if (const auto immediate = std::get_if<ImmediateNode>(&*offset)) {

+ return {tracked, cbuf->GetIndex(), immediate->GetValue()};

+ }

+ return {};

+ return {};

+ return {};

+ if (auto found = TrackCbuf((*operation)[i], code, cursor); std::get<0>(found)) {

+ // Cbuf found in operand.

+ return {};

+ return {};

+ if (std::tie(params.height, params.pitch) == std::tie(rhs.height, rhs.pitch)) {

+ if (params.width == rhs.width) {

+ return MatchStructureResult::FullMatch;

+ } else {

+ return MatchStructureResult::SemiMatch;

+ }

+ void MarkAsRenderTarget(const bool is_target, const u32 index) {

+ this->index = index;

+ u32 GetRenderTarget() const {

+ return index;

+ }

+

+ static constexpr u32 NO_RT = 0xFFFFFFFF;

+

+ u32 index{NO_RT};

+ if (is_tiled) {

+ return Tegra::Texture::CalculateSize(!as_host_size, GetBytesPerPixel(), width, height,

+ depth, GetMipBlockHeight(level),

+ GetMipBlockDepth(level));

+ } else if (as_host_size || IsBuffer()) {

+ return GetBytesPerPixel() * width * height * depth;

+ } else {

+ // Linear Texture Case

+ return pitch * height * depth;

+ }

+ depth_buffer.target->MarkAsRenderTarget(false, NO_RT);

+ depth_buffer.target->MarkAsRenderTarget(true, DEPTH_RT);

+ render_targets[index].target->MarkAsRenderTarget(false, NO_RT);

+ render_targets[index].target->MarkAsRenderTarget(true, static_cast<u32>(index));

+ depth_buffer.target->MarkAsRenderTarget(false, NO_RT);

+ render_targets[index].target->MarkAsRenderTarget(false, NO_RT);

+ void ManageRenderTargetUnregister(TSurface& surface) {

+ auto& maxwell3d = system.GPU().Maxwell3D();

+ const u32 index = surface->GetRenderTarget();

+ if (index == DEPTH_RT) {

+ maxwell3d.dirty_flags.zeta_buffer = true;

+ } else {

+ maxwell3d.dirty_flags.color_buffer.set(index, true);

+ }

+ }

+

+ if (!guard_render_targets && surface->IsRenderTarget()) {

+ ManageRenderTargetUnregister(surface);

+ }

+ static constexpr u32 DEPTH_RT = 8;

+ static constexpr u32 NO_RT = 0xFFFFFFFF;

+