ajm: reject invalid batch storage

Co-authored-by: BlackCAT <52720489+psnwd@users.noreply.github.com>

.coderabbit.yaml

@@ -0,0 +1,37 @@
+# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
+
+# Keep inherited review profiles, automatic reviews, tools, and pre-merge checks.
+inheritance: true
+
+reviews:
+  # Trim supplemental output and keep the remaining walkthrough collapsed.
+  high_level_summary: false
+  review_status: false
+  review_details: false
+  collapse_walkthrough: true
+  changed_files_summary: false
+  sequence_diagrams: false
+  estimate_code_review_effort: false
+  related_issues: false
+  related_prs: false
+  in_progress_fortune: false
+  poem: false
+  enable_prompt_for_ai_agents: false
+
+  # Hide standard finishing-touch controls; this also disables their commands.
+  finishing_touches:
+    docstrings:
+      enabled: false
+    unit_tests:
+      enabled: false
+    simplify:
+      enabled: false
+    autofix:
+      enabled: false
+    fix_ci:
+      enabled: false
+    resolve_merge_conflict:
+      enabled: false
+
+chat:
+  art: false

.github/ISSUE_TEMPLATE/kytyps5-game-emulation.yaml

@@ -1,6 +1,6 @@
-name: Game Emulation Bug Report
-description: Report KytyPS5 game boot, crash, freeze, rendering, audio, input, or gameplay behavior problems.
-title: "[GAME BUG]: "
+name: Game Emulation Status Report
+description: Submit a KytyPS5 game compatibility result, including boot, rendering, audio, input, or gameplay behavior.
+title: "[GAME STATUS]: "
 body:
   - type: markdown
     attributes:
@@ -10,6 +10,7 @@ body:
         Before submitting, please:
         - Search existing issues first.
         - Re-test with a clean game dump.
+        - Use the latest KytyPS5 build available to you.
         - Attach the complete log file instead of edited snippets.
 
   - type: markdown
@@ -44,6 +45,28 @@ body:
     validations:
       required: true
 
+  - type: dropdown
+    id: compatibility-status
+    attributes:
+      label: Compatibility status
+      description: Select the furthest point the game consistently reaches on this build.
+      options:
+        - "Doesn't boot"
+        - Logo
+        - Main menu
+        - In game
+    validations:
+      required: true
+
+  - type: markdown
+    attributes:
+      value: |
+        **Status guide**
+        - **Doesn't boot:** The game does not show its first logo or startup screen.
+        - **Logo:** The game shows a logo or startup screen but does not reach the main menu.
+        - **Main menu:** The game reaches its menus but does not enter gameplay.
+        - **In game:** The game reaches controllable gameplay, even if bugs prevent completion.
+
   - type: input
     id: regression-builds
     attributes:
@@ -54,22 +77,22 @@ body:
   - type: markdown
     attributes:
       value: |
-        ## Problem details
+        ## Test result
 
   - type: textarea
     id: what-happened
     attributes:
-      label: What happened?
-      description: Describe the failure or incorrect behavior as directly as possible.
-      placeholder: "Example: The game reaches the main menu, then freezes after selecting Continue."
+      label: Result details
+      description: Describe what worked, what failed, and any visible or audible problems.
+      placeholder: "Example: The game reaches the main menu, then freezes after selecting Continue. Audio plays correctly until the freeze."
     validations:
       required: true
 
   - type: textarea
     id: steps-to-reproduce
     attributes:
-      label: Steps to reproduce
-      description: List the shortest path that triggers the problem from a fresh KytyPS5 start.
+      label: Steps to reproduce the result
+      description: List the shortest path to the reported status or failure from a fresh KytyPS5 start.
       placeholder: |
         1. Open KytyPS5.
         2. Boot the game.
@@ -81,7 +104,7 @@ body:
     id: expected-behavior
     attributes:
       label: Expected behavior
-      description: Explain what should happen at the same point in the game.
+      description: Explain what should happen at the same point in the game. If there is no known problem, write "No known issue".
       placeholder: "Example: The save should load and gameplay should continue normally."
     validations:
       required: true

.github/workflows/build.yml

@@ -1,4 +1,4 @@
-name: Build KytyPS5
+name: Build and Release KytyPS5
 
 on:
   workflow_dispatch:
@@ -6,8 +6,32 @@ on:
     branches: [ main, master ]
   pull_request:
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+env:
+  SCCACHE_GHA_ENABLED: "true"
+  KYTY_BUILD_ORIGIN: ${{ github.repository != 'KytyPS5/KytyPS5' && 'Fork' || github.event_name == 'push' && 'Official' || 'Source' }}
+  KYTY_BUILD_REPOSITORY: ${{ github.repository }}
+
 jobs:
-  build:
+  metadata:
+    name: Prepare build metadata
+    runs-on: ubuntu-latest
+    outputs:
+      release_tag: ${{ steps.release_tag.outputs.value }}
+
+    steps:
+      - name: Generate release tag
+        id: release_tag
+        shell: bash
+        run: |
+          echo "value=KytyPS5-$(date -u +'%Y-%m-%d')-${GITHUB_SHA::7}" >> "$GITHUB_OUTPUT"
+
+  windows:
+    name: Build KytyPS5 (Windows)
+    needs: metadata
     runs-on: windows-2022
 
     steps:
@@ -22,11 +46,31 @@ jobs:
       - name: Setup Ninja
         uses: seanmiddleditch/gha-setup-ninja@v5
 
-      - name: Install glslang
+      - name: Locate vcpkg
+        id: vcpkg
         shell: pwsh
         run: |
           $vcpkgRoot = Split-Path (Get-Command vcpkg).Source
-          vcpkg install glslang[tools,opt]:x64-windows
+          $portHash = (Get-FileHash "$vcpkgRoot\ports\glslang\vcpkg.json" -Algorithm SHA256).Hash
+          "root=$vcpkgRoot" |
+            Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
+          "port_hash=$($portHash.ToLowerInvariant())" |
+            Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
+
+      - name: Cache glslang
+        id: glslang_cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ steps.vcpkg.outputs.root }}\installed\x64-windows
+          key: glslang-${{ runner.os }}-${{ runner.arch }}-${{ steps.vcpkg.outputs.port_hash }}-tools-opt
+
+      - name: Install glslang
+        shell: pwsh
+        run: |
+          $vcpkgRoot = "${{ steps.vcpkg.outputs.root }}"
+          if ("${{ steps.glslang_cache.outputs.cache-hit }}" -ne "true") {
+            vcpkg install glslang[tools,opt]:x64-windows
+          }
           "$vcpkgRoot\installed\x64-windows\tools\glslang" |
             Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
 
@@ -39,6 +83,9 @@ jobs:
           arch: win64_msvc2022_64
           cache: true
 
+      - name: Setup sccache
+        uses: mozilla-actions/sccache-action@v0.0.11
+
       - name: Verify toolchain
         shell: cmd
         run: |
@@ -52,62 +99,421 @@ jobs:
       - name: Configure
         shell: cmd
         run: |
-          cmake -S src -B _Build/windows ^
+          cmake -S . -B _Build/windows ^
             -G Ninja ^
             -DCMAKE_BUILD_TYPE=Release ^
+            -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON ^
+            -DKYTY_BUILD_ORIGIN=%KYTY_BUILD_ORIGIN% ^
+            -DKYTY_BUILD_REPOSITORY=%KYTY_BUILD_REPOSITORY% ^
+            -DKYTY_RELEASE_TAG=${{ needs.metadata.outputs.release_tag }} ^
             -DCMAKE_C_COMPILER=clang-cl ^
             -DCMAKE_CXX_COMPILER=clang-cl ^
+            -DCMAKE_C_COMPILER_LAUNCHER=sccache ^
+            -DCMAKE_CXX_COMPILER_LAUNCHER=sccache ^
             -DCMAKE_PREFIX_PATH="%Qt6_DIR%"
 
       - name: Build
         shell: cmd
         run: |
-          cmake --build _Build/windows --target launcher --parallel
+          cmake --build _Build/windows --target launcher audio_out2_port_tests ime_dialog_tests virtual_memory_allocation_tests --parallel
+
+      - name: Test
+        shell: cmd
+        run: |
+          ctest --test-dir _Build/windows --output-on-failure -R "^(audio_out2_port|ime_dialog|virtual_memory_allocation)$"
 
       - name: Install
         shell: cmd
         run: |
           cmake --install _Build/windows --prefix _Build/windows/install
 
-      - name: Upload Artifacts
+      - name: Upload Windows artifacts
         uses: actions/upload-artifact@v4
         with:
-          name: KytyPS5
+          name: KytyPS5-Windows-x64
           path: _Build/windows/install/**
           if-no-files-found: error
 
+  macos:
+    name: Build KytyPS5 (macOS)
+    needs: metadata
+    runs-on: macos-15
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Select Xcode 26
+        shell: bash
+        run: |
+          xcode_path="$(ls -d /Applications/Xcode_26*.app | tail -n 1)"
+          test -n "$xcode_path"
+          sudo xcode-select --switch "$xcode_path/Contents/Developer"
+          xcodebuild -version
+
+      - name: Install build dependencies
+        shell: bash
+        run: brew install glslang ninja
+
+      - name: Install Qt 6.10.3
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: "6.10.3"
+          host: mac
+          target: desktop
+          arch: clang_64
+          cache: true
+
+      - name: Setup sccache
+        uses: mozilla-actions/sccache-action@v0.0.11
+
+      - name: Verify toolchain
+        shell: bash
+        run: |
+          git --version
+          cmake --version
+          ninja --version
+          clang++ --version
+          glslangValidator --version
+          echo "Host architecture: $(uname -m)"
+          echo "QT_ROOT_DIR=$QT_ROOT_DIR"
+
+      - name: Configure
+        shell: bash
+        run: |
+          cmake -S . -B _Build/macos \
+            -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON \
+            -DKYTY_BUILD_ORIGIN="$KYTY_BUILD_ORIGIN" \
+            -DKYTY_BUILD_REPOSITORY="$KYTY_BUILD_REPOSITORY" \
+            -DKYTY_RELEASE_TAG="${{ needs.metadata.outputs.release_tag }}" \
+            -DCMAKE_OSX_ARCHITECTURES=x86_64 \
+            -DCMAKE_C_COMPILER=clang \
+            -DCMAKE_CXX_COMPILER=clang++ \
+            -DCMAKE_C_COMPILER_LAUNCHER=sccache \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=sccache \
+            -DCMAKE_PREFIX_PATH="$QT_ROOT_DIR"
+
+      - name: Build
+        shell: bash
+        run: |
+          cmake --build _Build/macos \
+            --target launcher audio_out2_port_tests ime_dialog_tests virtual_memory_allocation_tests \
+            --parallel
+
+      - name: Test
+        shell: bash
+        run: |
+          ctest --test-dir _Build/macos --output-on-failure \
+            -R '^(audio_out2_port|ime_dialog|virtual_memory_allocation)$'
+
+      - name: Install
+        shell: bash
+        run: |
+          cmake --install _Build/macos --prefix _Build/macos/install
+
+      - name: Bundle MoltenVK
+        shell: bash
+        env:
+          MOLTENVK_VERSION: v1.4.2
+          MOLTENVK_SHA256: f95765a6229cb7b915990a2890ce12ebe36a730b021545d3d52ae69ce4c4024e
+        run: |
+          archive="$RUNNER_TEMP/MoltenVK-macos.tar"
+          package="$RUNNER_TEMP/MoltenVK"
+          install_dir="_Build/macos/install"
+          app_dir="$install_dir/KytyPS5.app"
+          moltenvk="$install_dir/libMoltenVK.dylib"
+          curl --fail --location --retry 3 \
+            --output "$archive" \
+            "https://github.com/KhronosGroup/MoltenVK/releases/download/$MOLTENVK_VERSION/MoltenVK-macos.tar"
+          echo "$MOLTENVK_SHA256  $archive" | shasum -a 256 --check
+          tar -xf "$archive" -C "$RUNNER_TEMP"
+          test -d "$app_dir"
+          install -m 755 \
+            "$package/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib" \
+            "$moltenvk"
+          install -m 644 "$package/LICENSE" "$install_dir/LICENSE.MoltenVK"
+          codesign --force --sign - --timestamp=none "$moltenvk"
+          install -d -m 755 "$app_dir/Contents/Frameworks" "$app_dir/Contents/Resources"
+          install -m 755 "$moltenvk" "$app_dir/Contents/Frameworks/libMoltenVK.dylib"
+          install -m 644 "$package/LICENSE" "$app_dir/Contents/Resources/LICENSE.MoltenVK"
+          codesign --force --sign - --timestamp=none "$app_dir"
+
+      - name: Verify artifacts
+        shell: bash
+        run: |
+          install_dir="_Build/macos/install"
+          app_dir="$install_dir/KytyPS5.app"
+          test -d "$app_dir"
+          for binary in \
+            "$install_dir/kyty_emulator" \
+            "$install_dir/libMoltenVK.dylib" \
+            "$app_dir/Contents/MacOS/KytyPS5" \
+            "$app_dir/Contents/MacOS/kyty_emulator" \
+            "$app_dir/Contents/Frameworks/libMoltenVK.dylib"; do
+            file "$binary"
+            lipo "$binary" -verify_arch x86_64
+          done
+          for binary in \
+            "$install_dir/kyty_emulator" \
+            "$install_dir/libMoltenVK.dylib" \
+            "$app_dir/Contents/MacOS/KytyPS5" \
+            "$app_dir/Contents/MacOS/kyty_emulator" \
+            "$app_dir/Contents/Frameworks/libMoltenVK.dylib"; do
+            codesign --verify --strict "$binary"
+          done
+          codesign --verify --deep --strict --verbose=2 "$app_dir"
+
+      - name: Package macOS artifacts
+        shell: bash
+        run: |
+          install_dir="_Build/macos/install"
+          archive="$RUNNER_TEMP/KytyPS5-macOS-x86_64.zip"
+          (
+            cd "$install_dir"
+            zip -qry "$archive" .
+          )
+          unzip -t "$archive"
+
+      - name: Upload macOS artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: KytyPS5-macOS-x86_64
+          path: ${{ runner.temp }}/KytyPS5-macOS-x86_64.zip
+          if-no-files-found: error
+
+  linux:
+    name: Build KytyPS5 (Linux)
+    needs: metadata
+    runs-on: ubuntu-24.04
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install build dependencies
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo apt-get install --no-install-recommends --yes \
+            clang \
+            glslang-tools \
+            libasound2-dev \
+            libdbus-1-dev \
+            libgl1-mesa-dev \
+            libpulse-dev \
+            libudev-dev \
+            libwayland-dev \
+            libx11-dev \
+            libxcursor-dev \
+            libxext-dev \
+            libxfixes-dev \
+            libxi-dev \
+            libxkbcommon-dev \
+            libxrandr-dev \
+            libxss-dev \
+            lld \
+            ninja-build \
+            pkg-config \
+            wayland-protocols
+
+      - name: Install Qt 6.10.3
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: "6.10.3"
+          host: linux
+          target: desktop
+          arch: linux_gcc_64
+          cache: true
+
+      - name: Setup sccache
+        uses: mozilla-actions/sccache-action@v0.0.11
+
+      - name: Verify toolchain
+        shell: bash
+        run: |
+          git --version
+          cmake --version
+          ninja --version
+          clang++ --version
+          ld.lld --version
+          glslangValidator --version
+          echo "Qt6_DIR=$Qt6_DIR"
+
+      - name: Configure
+        shell: bash
+        run: |
+          mkdir -p _Build
+          cmake -S . -B _Build/linux \
+            -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON \
+            -DKYTY_BUILD_ORIGIN="$KYTY_BUILD_ORIGIN" \
+            -DKYTY_BUILD_REPOSITORY="$KYTY_BUILD_REPOSITORY" \
+            -DKYTY_RELEASE_TAG="${{ needs.metadata.outputs.release_tag }}" \
+            -DCMAKE_C_COMPILER=clang \
+            -DCMAKE_CXX_COMPILER=clang++ \
+            -DCMAKE_C_COMPILER_LAUNCHER=sccache \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=sccache \
+            -DCMAKE_PREFIX_PATH="$Qt6_DIR" 2>&1 | tee _Build/configure.log
+          exit "${PIPESTATUS[0]}"
+
+      - name: Verify SDL2 backends
+        shell: bash
+        run: |
+          status=0
+          for feature in SDL_ALSA SDL_PULSEAUDIO SDL_WAYLAND SDL_X11 SDL_LIBUDEV SDL_DBUS; do
+            if grep -qE "^--   ${feature} +\\(Wanted: ON\\): ON" _Build/configure.log; then
+              echo "ok   ${feature}"
+            else
+              echo "FAIL ${feature} is not enabled"
+              status=1
+            fi
+          done
+          exit "$status"
+
+      - name: Build
+        shell: bash
+        run: |
+          cmake --build _Build/linux \
+            --target launcher page_manager_tests memory_tracker_tests \
+              audio_out2_port_tests ime_dialog_tests virtual_memory_allocation_tests \
+            --parallel
+
+      - name: Test
+        shell: bash
+        run: |
+          ctest --test-dir _Build/linux --output-on-failure \
+            -R '^(audio_out2_port|ime_dialog|page_manager|memory_tracker|virtual_memory_allocation)$'
+
+      - name: Install
+        shell: bash
+        run: |
+          cmake --install _Build/linux --prefix _Build/linux/install
+
+      - name: Verify artifacts
+        shell: bash
+        run: |
+          file _Build/linux/install/launcher
+          file _Build/linux/install/kyty_emulator
+          file _Build/linux/install/kyty_emulator | grep -q "ELF 64-bit LSB .*x86-64"
+          ldd _Build/linux/install/kyty_emulator > /dev/null
+          readelf -d _Build/linux/install/launcher | grep -q 'RPATH.*\$ORIGIN/lib'
+          while IFS= read -r -d '' binary; do
+            while read -r dependency; do
+              test -e "_Build/linux/install/lib/$dependency"
+            done < <(
+              readelf -d "$binary" |
+                sed -n 's/.*Shared library: \[\(libQt6[^]]*\|libicu[^]]*\)\].*/\1/p'
+            )
+          done < <(
+            find _Build/linux/install/launcher _Build/linux/install/plugins \
+              -type f \( -name launcher -o -name '*.so' \) -print0
+          )
+          _Build/linux/install/kyty_emulator --help > /dev/null
+
+      - name: Upload Linux artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: KytyPS5-Linux-x86_64
+          path: _Build/linux/install/**
+          if-no-files-found: error
+
   release:
-    if: github.event_name == 'push'
-    needs: build
+    name: Release KytyPS5
+    if: >-
+      always() &&
+      github.event_name == 'push' &&
+      github.repository == 'KytyPS5/KytyPS5' &&
+      (needs.windows.result == 'success' ||
+       needs.macos.result == 'success' ||
+       needs.linux.result == 'success')
+    needs: [metadata, windows, macos, linux]
     runs-on: ubuntu-latest
     permissions:
       contents: write
+    env:
+      RELEASE_NAME: ${{ needs.metadata.outputs.release_tag }}
 
     steps:
-      - name: Download build
+      - name: Download Windows build
+        if: needs.windows.result == 'success'
         uses: actions/download-artifact@v4
         with:
-          name: KytyPS5
-          path: KytyPS5
+          name: KytyPS5-Windows-x64
+          path: artifacts/KytyPS5-Windows-x64
 
-      - name: Set release name
+      - name: Download macOS build
+        if: needs.macos.result == 'success'
+        uses: actions/download-artifact@v4
+        with:
+          name: KytyPS5-macOS-x86_64
+          path: artifacts/KytyPS5-macOS-x86_64
+
+      - name: Download Linux build
+        if: needs.linux.result == 'success'
+        uses: actions/download-artifact@v4
+        with:
+          name: KytyPS5-Linux-x86_64
+          path: artifacts/KytyPS5-Linux-x86_64
+
+      - name: Package Windows build
+        if: needs.windows.result == 'success'
         shell: bash
         run: |
-          echo "RELEASE_NAME=KytyPS5-$(date -u +'%Y-%m-%d')-${GITHUB_SHA::7}" >> "$GITHUB_ENV"
+          windows_dir="artifacts/KytyPS5-Windows-x64"
+          test -d "$windows_dir"
+          (
+            cd "$windows_dir"
+            zip -r "$GITHUB_WORKSPACE/$RELEASE_NAME-Windows-x64.zip" .
+          )
 
-      - name: Package build
+      - name: Package macOS build
+        if: needs.macos.result == 'success'
         shell: bash
-        run: zip -r "$RELEASE_NAME.zip" KytyPS5
+        run: |
+          macos_archive="artifacts/KytyPS5-macOS-x86_64/KytyPS5-macOS-x86_64.zip"
+          test -f "$macos_archive"
+          cp "$macos_archive" "$RELEASE_NAME-macOS-x86_64.zip"
+
+      - name: Package Linux build
+        if: needs.linux.result == 'success'
+        shell: bash
+        run: |
+          linux_dir="artifacts/KytyPS5-Linux-x86_64"
+          test -d "$linux_dir"
+          chmod a+x \
+            "$linux_dir/launcher" \
+            "$linux_dir/kyty_emulator"
+          tar -C "$linux_dir" -czf \
+            "$GITHUB_WORKSPACE/$RELEASE_NAME-Linux-x86_64.tar.gz" .
 
       - name: Create release
         shell: bash
         env:
           GH_TOKEN: ${{ github.token }}
         run: |
+          assets=()
+          for artifact in \
+            "$RELEASE_NAME-Windows-x64.zip" \
+            "$RELEASE_NAME-macOS-x86_64.zip" \
+            "$RELEASE_NAME-Linux-x86_64.tar.gz"; do
+            if [[ -f "$artifact" ]]; then
+              assets+=("$artifact")
+            fi
+          done
+          test "${#assets[@]}" -gt 0
           if gh release view "$RELEASE_NAME" --repo "$GITHUB_REPOSITORY" > /dev/null 2>&1; then
-            gh release upload "$RELEASE_NAME" "$RELEASE_NAME.zip" --clobber --repo "$GITHUB_REPOSITORY"
+            gh release upload "$RELEASE_NAME" "${assets[@]}" \
+              --clobber \
+              --repo "$GITHUB_REPOSITORY"
           else
-            gh release create "$RELEASE_NAME" "$RELEASE_NAME.zip" \
+            gh release create "$RELEASE_NAME" "${assets[@]}" \
               --generate-notes \
               --repo "$GITHUB_REPOSITORY" \
               --target "$GITHUB_SHA" \

.gitignore

@@ -2,4 +2,7 @@
 .vs/
 .idea/
 build/
-_Build/vscode-clang/
+_Build/vscode-clang/
+_Build/
+cmake-build-debug/
+_PipelineCache/

.gitmodules

@@ -22,7 +22,7 @@
 	url = https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git
 [submodule "3rdparty/ffmpeg-core"]
 	path = 3rdparty/ffmpeg-core
-	url = https://github.com/shadps4-emu/ext-ffmpeg-core.git
+	url = https://github.com/KytyPS5/ext-ffmpeg-core.git
 	shallow = true
 [submodule "3rdparty/fmt"]
 	path = 3rdparty/fmt
@@ -39,3 +39,6 @@
 [submodule "3rdparty/nlohmann_json"]
 	path = 3rdparty/nlohmann_json
 	url = https://github.com/nlohmann/json.git
+[submodule "3rdparty/imgui"]
+	path = 3rdparty/imgui
+	url = https://github.com/ocornut/imgui.git

.vscode/launch.json

@@ -10,7 +10,14 @@
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}\\_Build\\vscode-clang\\launcher",
             "environment": [],
-            "externalConsole": false
+            "externalConsole": false,
+            "linux": {
+                "type": "cppdbg",
+                "program": "${workspaceFolder}/_Build/vscode-clang/launcher/launcher",
+                "cwd": "${workspaceFolder}/_Build/vscode-clang/launcher",
+                "MIMode": "gdb",
+                "miDebuggerPath": "/usr/bin/gdb"
+            }
         },
         {
             "name": "Debug kyty_emulator",
@@ -25,13 +32,40 @@
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}\\_Build\\vscode-clang",
             "environment": [],
-            "externalConsole": true
+            "externalConsole": true,
+            "linux": {
+                "type": "cppdbg",
+                "program": "${workspaceFolder}/_Build/vscode-clang/kyty_emulator",
+                "cwd": "${workspaceFolder}/_Build/vscode-clang",
+                "externalConsole": false,
+                "MIMode": "gdb",
+                "miDebuggerPath": "/usr/bin/gdb",
+                "setupCommands": [
+                    {
+                        "description": "Pass Kyty's internal signals to its handlers",
+                        "text": "handle SIG37 SIGSEGV SIGBUS SIGILL nostop noprint pass",
+                        "ignoreFailures": false
+                    }
+                ]
+            }
         },
         {
             "name": "Attach to running kyty_emulator",
             "type": "cppvsdbg",
             "request": "attach",
-            "processId": "${command:pickProcess}"
+            "processId": "${command:pickProcess}",
+            "linux": {
+                "type": "cppdbg",
+                "MIMode": "gdb",
+                "miDebuggerPath": "/usr/bin/gdb",
+                "setupCommands": [
+                    {
+                        "description": "Pass Kyty's internal signals to its handlers",
+                        "text": "handle SIG37 SIGSEGV SIGBUS SIGILL nostop noprint pass",
+                        "ignoreFailures": false
+                    }
+                ]
+            }
         }
     ]
 }

.vscode/settings.json

@@ -1,16 +1,18 @@
 {
-    "cmake.sourceDirectory": "${workspaceFolder}/src",
+    "cmake.sourceDirectory": "${workspaceFolder}",
     "cmake.buildDirectory": "${workspaceFolder}/_Build/vscode-clang",
     "cmake.generator": "Ninja",
+    "cmake.useVsDeveloperEnvironment": "always",
     "cmake.environment": {
         "CC": "clang-cl",
-        "CXX": "clang-cl",
-        "PATH": "${env:ProgramFiles}/Microsoft Visual Studio/18/Community/VC/Tools/Llvm/x64/bin;${env:ProgramFiles}/Microsoft Visual Studio/18/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/Ninja;${env:PATH}"
+        "CXX": "clang-cl"
     },
     "cmake.configureSettings": {
         "CMAKE_C_COMPILER": "clang-cl",
         "CMAKE_CXX_COMPILER": "clang-cl",
         "CMAKE_PREFIX_PATH": "C:/Qt/6.11.0/msvc2022_64"
-    }
+    },
+    "C_Cpp.default.intelliSenseMode": "windows-clang-x64",
+    "C_Cpp.default.compileCommands": "${workspaceFolder}/_Build/vscode-clang/compile_commands.json",
+    "C_Cpp.default.cppStandard": "c++20"
 }
-

3rdparty/CMakeLists.txt

@@ -2,6 +2,32 @@ set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
 
 add_subdirectory(cpuinfo)
 
+# The Windows guest red-zone patcher needs a decoder/encoder and a small
+# trampoline assembler. Pin the same revisions used by shadPS4's implementation.
+include(FetchContent)
+
+set(XBYAK_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+FetchContent_Declare(
+	xbyak
+	GIT_REPOSITORY https://github.com/herumi/xbyak.git
+	GIT_TAG 44a72f369268f7d552650891b296693e91db86bb
+	GIT_SHALLOW FALSE
+)
+
+set(ZYDIS_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+set(ZYDIS_BUILD_TOOLS OFF CACHE BOOL "" FORCE)
+set(ZYDIS_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(ZYDIS_BUILD_DOXYGEN OFF CACHE BOOL "" FORCE)
+FetchContent_Declare(
+	zydis
+	GIT_REPOSITORY https://github.com/zyantific/zydis.git
+	GIT_TAG 120e0e705f8e3b507dc49377ac2879979f0d545c
+	GIT_SUBMODULES_RECURSE TRUE
+	GIT_SHALLOW FALSE
+)
+
+FetchContent_MakeAvailable(xbyak zydis)
+
 set(SDL_SHARED OFF CACHE BOOL "" FORCE)
 add_subdirectory(SDL2)
 
@@ -11,6 +37,25 @@ target_include_directories(Vulkan-Headers INTERFACE
 	"${CMAKE_CURRENT_SOURCE_DIR}/Vulkan-Headers/include"
 )
 
+add_library(imgui STATIC
+	imgui/imgui.cpp
+	imgui/imgui_draw.cpp
+	imgui/imgui_tables.cpp
+	imgui/imgui_widgets.cpp
+	imgui/backends/imgui_impl_vulkan.cpp
+)
+target_include_directories(imgui PUBLIC
+	"${CMAKE_CURRENT_SOURCE_DIR}/imgui"
+	"${CMAKE_CURRENT_SOURCE_DIR}/imgui/backends"
+)
+target_compile_definitions(imgui PRIVATE IMGUI_IMPL_VULKAN_NO_PROTOTYPES)
+target_link_libraries(imgui PUBLIC Vulkan::Headers)
+if(MSVC)
+	target_compile_options(imgui PRIVATE /W0)
+else()
+	target_compile_options(imgui PRIVATE -w)
+endif()
+
 set(SPIRV_SKIP_TESTS ON CACHE BOOL "" FORCE)
 set(SPIRV_SKIP_EXECUTABLES ON CACHE BOOL "" FORCE)
 set(SKIP_SPIRV_TOOLS_INSTALL ON CACHE BOOL "" FORCE)
@@ -44,7 +89,17 @@ set(SPDLOG_NO_EXCEPTIONS ON CACHE BOOL "" FORCE)
 add_subdirectory(spdlog EXCLUDE_FROM_ALL)
 
 if (NOT TARGET FFmpeg::ffmpeg)
-	if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64)$")
+	# On macOS the target arch is driven by CMAKE_OSX_ARCHITECTURES, not the host
+	# CMAKE_SYSTEM_PROCESSOR (which reports arm64 even for an x86_64/Rosetta build).
+	if(APPLE AND CMAKE_OSX_ARCHITECTURES)
+		if(CMAKE_OSX_ARCHITECTURES MATCHES "^(x86_64)$")
+			set(ARCHITECTURE x86_64)
+		elseif(CMAKE_OSX_ARCHITECTURES MATCHES "^(arm64)$")
+			set(ARCHITECTURE arm64)
+		else()
+			set(ARCHITECTURE x86_64 arm64) # universal
+		endif()
+	elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64)$")
 		set(ARCHITECTURE arm64)
 	else()
 		set(ARCHITECTURE x86_64)

3rdparty/cpuinfo/CMakeLists.txt

@@ -5,7 +5,14 @@ set(cpuinfo_src
 	deps/clog/src/clog.c
 )
 
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(i[3-6]86|AMD64|x86(_64)?)$")
+# On Apple the target arch is driven by CMAKE_OSX_ARCHITECTURES, not the host
+# CMAKE_SYSTEM_PROCESSOR (which is arm64 even for an x86_64/Rosetta build).
+set(CPUINFO_TARGET_PROC "${CMAKE_SYSTEM_PROCESSOR}")
+if(APPLE AND CMAKE_OSX_ARCHITECTURES)
+	list(GET CMAKE_OSX_ARCHITECTURES 0 CPUINFO_TARGET_PROC)
+endif()
+
+if(CPUINFO_TARGET_PROC MATCHES "^(i[3-6]86|AMD64|x86(_64)?)$")
 	list(APPEND cpuinfo_src
 		src/x86/init.c
 		src/x86/info.c
@@ -19,11 +26,13 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(i[3-6]86|AMD64|x86(_64)?)$")
 		src/x86/cache/deterministic.c)
 	if(LINUX OR ANDROID)
 		list(APPEND cpuinfo_src src/x86/linux/init.c src/x86/linux/cpuinfo.c)
+	elseif(APPLE)
+		list(APPEND cpuinfo_src src/x86/mach/init.c src/mach/topology.c)
 	else()
 		list(APPEND cpuinfo_src src/x86/windows/init.c)
 	endif()
-	
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(armv[5-8].*|aarch64|arm64)$")
+
+elseif(CPUINFO_TARGET_PROC MATCHES "^(armv[5-8].*|aarch64|arm64)$")
 	list(APPEND cpuinfo_src src/arm/uarch.c src/arm/cache.c)
 	
 	if(LINUX OR ANDROID)

3rdparty/renderdoc/renderdoc_app.h

@@ -0,0 +1,875 @@
+/******************************************************************************
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2026 Baldur Karlsson
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ ******************************************************************************/
+
+#pragma once
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// Documentation for the API is available at https://renderdoc.org/docs/in_application_api.html
+//
+
+#if !defined(RENDERDOC_NO_STDINT)
+#include <stdint.h>
+#endif
+
+#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
+#define RENDERDOC_CC __cdecl
+#elif defined(__linux__) || defined(__FreeBSD__) || defined(__sun__) || defined(__OpenBSD__)
+#define RENDERDOC_CC
+#elif defined(__APPLE__)
+#define RENDERDOC_CC
+#else
+#error "Unknown platform"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// Constants not used directly in below API
+
+// This is a GUID/magic value used for when applications pass a path where shader debug
+// information can be found to match up with a stripped shader.
+// the define can be used like so: const GUID RENDERDOC_ShaderDebugMagicValue =
+// RENDERDOC_ShaderDebugMagicValue_value
+#define RENDERDOC_ShaderDebugMagicValue_struct                                \
+  {                                                                           \
+    0xeab25520, 0x6670, 0x4865, 0x84, 0x29, 0x6c, 0x8, 0x51, 0x54, 0x00, 0xff \
+  }
+
+// as an alternative when you want a byte array (assuming x86 endianness):
+#define RENDERDOC_ShaderDebugMagicValue_bytearray                                                 \
+  {                                                                                               \
+    0x20, 0x55, 0xb2, 0xea, 0x70, 0x66, 0x65, 0x48, 0x84, 0x29, 0x6c, 0x8, 0x51, 0x54, 0x00, 0xff \
+  }
+
+// truncated version when only a uint64_t is available (e.g. Vulkan tags):
+#define RENDERDOC_ShaderDebugMagicValue_truncated 0x48656670eab25520ULL
+
+// this is a magic value for vulkan user tags to indicate which dispatchable API objects are which
+// for object annotations
+#define RENDERDOC_APIObjectAnnotationHelper 0xfbb3b337b664d0adULL
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// RenderDoc capture options
+//
+
+typedef enum RENDERDOC_CaptureOption
+{
+  // Allow the application to enable vsync
+  //
+  // Default - enabled
+  //
+  // 1 - The application can enable or disable vsync at will
+  // 0 - vsync is force disabled
+  eRENDERDOC_Option_AllowVSync = 0,
+
+  // Allow the application to enable fullscreen
+  //
+  // Default - enabled
+  //
+  // 1 - The application can enable or disable fullscreen at will
+  // 0 - fullscreen is force disabled
+  eRENDERDOC_Option_AllowFullscreen = 1,
+
+  // Record API debugging events and messages
+  //
+  // Default - disabled
+  //
+  // 1 - Enable built-in API debugging features and records the results into
+  //     the capture, which is matched up with events on replay
+  // 0 - no API debugging is forcibly enabled
+  eRENDERDOC_Option_APIValidation = 2,
+  eRENDERDOC_Option_DebugDeviceMode = 2,    // deprecated name of this enum
+
+  // Capture CPU callstacks for API events
+  //
+  // Default - disabled
+  //
+  // 1 - Enables capturing of callstacks
+  // 0 - no callstacks are captured
+  eRENDERDOC_Option_CaptureCallstacks = 3,
+
+  // When capturing CPU callstacks, only capture them from actions.
+  // This option does nothing without the above option being enabled
+  //
+  // Default - disabled
+  //
+  // 1 - Only captures callstacks for actions.
+  //     Ignored if CaptureCallstacks is disabled
+  // 0 - Callstacks, if enabled, are captured for every event.
+  eRENDERDOC_Option_CaptureCallstacksOnlyDraws = 4,
+  eRENDERDOC_Option_CaptureCallstacksOnlyActions = 4,
+
+  // Specify a delay in seconds to wait for a debugger to attach, after
+  // creating or injecting into a process, before continuing to allow it to run.
+  //
+  // 0 indicates no delay, and the process will run immediately after injection
+  //
+  // Default - 0 seconds
+  //
+  eRENDERDOC_Option_DelayForDebugger = 5,
+
+  // Verify buffer access. This includes checking the memory returned by a Map() call to
+  // detect any out-of-bounds modification, as well as initialising buffers with undefined contents
+  // to a marker value to catch use of uninitialised memory.
+  //
+  // NOTE: This option is only valid for OpenGL and D3D11. Explicit APIs such as D3D12 and Vulkan do
+  // not do the same kind of interception & checking and undefined contents are really undefined.
+  //
+  // Default - disabled
+  //
+  // 1 - Verify buffer access
+  // 0 - No verification is performed, and overwriting bounds may cause crashes or corruption in
+  //     RenderDoc.
+  eRENDERDOC_Option_VerifyBufferAccess = 6,
+
+  // The old name for eRENDERDOC_Option_VerifyBufferAccess was eRENDERDOC_Option_VerifyMapWrites.
+  // This option now controls the filling of uninitialised buffers with 0xdddddddd which was
+  // previously always enabled
+  eRENDERDOC_Option_VerifyMapWrites = eRENDERDOC_Option_VerifyBufferAccess,
+
+  // Hooks any system API calls that create child processes, and injects
+  // RenderDoc into them recursively with the same options.
+  //
+  // Default - disabled
+  //
+  // 1 - Hooks into spawned child processes
+  // 0 - Child processes are not hooked by RenderDoc
+  eRENDERDOC_Option_HookIntoChildren = 7,
+
+  // By default RenderDoc only includes resources in the final capture necessary
+  // for that frame, this allows you to override that behaviour.
+  //
+  // Default - disabled
+  //
+  // 1 - all live resources at the time of capture are included in the capture
+  //     and available for inspection
+  // 0 - only the resources referenced by the captured frame are included
+  eRENDERDOC_Option_RefAllResources = 8,
+
+  // **NOTE**: As of RenderDoc v1.1 this option has been deprecated. Setting or
+  // getting it will be ignored, to allow compatibility with older versions.
+  // In v1.1 the option acts as if it's always enabled.
+  //
+  // By default RenderDoc skips saving initial states for resources where the
+  // previous contents don't appear to be used, assuming that writes before
+  // reads indicate previous contents aren't used.
+  //
+  // Default - disabled
+  //
+  // 1 - initial contents at the start of each captured frame are saved, even if
+  //     they are later overwritten or cleared before being used.
+  // 0 - unless a read is detected, initial contents will not be saved and will
+  //     appear as black or empty data.
+  eRENDERDOC_Option_SaveAllInitials = 9,
+
+  // In APIs that allow for the recording of command lists to be replayed later,
+  // RenderDoc may choose to not capture command lists before a frame capture is
+  // triggered, to reduce overheads. This means any command lists recorded once
+  // and replayed many times will not be available and may cause a failure to
+  // capture.
+  //
+  // NOTE: This is only true for APIs where multithreading is difficult or
+  // discouraged. Newer APIs like Vulkan and D3D12 will ignore this option
+  // and always capture all command lists since the API is heavily oriented
+  // around it and the overheads have been reduced by API design.
+  //
+  // 1 - All command lists are captured from the start of the application
+  // 0 - Command lists are only captured if their recording begins during
+  //     the period when a frame capture is in progress.
+  eRENDERDOC_Option_CaptureAllCmdLists = 10,
+
+  // Mute API debugging output when the API validation mode option is enabled
+  //
+  // Default - enabled
+  //
+  // 1 - Mute any API debug messages from being displayed or passed through
+  // 0 - API debugging is displayed as normal
+  eRENDERDOC_Option_DebugOutputMute = 11,
+
+  // Option to allow vendor extensions to be used even when they may be
+  // incompatible with RenderDoc and cause corrupted replays or crashes.
+  //
+  // Default - inactive
+  //
+  // No values are documented, this option should only be used when absolutely
+  // necessary as directed by a RenderDoc developer.
+  eRENDERDOC_Option_AllowUnsupportedVendorExtensions = 12,
+
+  // Define a soft memory limit which some APIs may aim to keep overhead under where
+  // possible. Anything above this limit will where possible be saved directly to disk during
+  // capture.
+  // This will cause increased disk space use (which may cause a capture to fail if disk space is
+  // exhausted) as well as slower capture times.
+  //
+  // Not all memory allocations may be deferred like this so it is not a guarantee of a memory
+  // limit.
+  //
+  // Units are in MBs, suggested values would range from 200MB to 1000MB.
+  //
+  // Default - 0 Megabytes
+  eRENDERDOC_Option_SoftMemoryLimit = 13,
+} RENDERDOC_CaptureOption;
+
+// Sets an option that controls how RenderDoc behaves on capture.
+//
+// Returns 1 if the option and value are valid
+// Returns 0 if either is invalid and the option is unchanged
+typedef int(RENDERDOC_CC *pRENDERDOC_SetCaptureOptionU32)(RENDERDOC_CaptureOption opt, uint32_t val);
+typedef int(RENDERDOC_CC *pRENDERDOC_SetCaptureOptionF32)(RENDERDOC_CaptureOption opt, float val);
+
+// Gets the current value of an option as a uint32_t
+//
+// If the option is invalid, 0xffffffff is returned
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetCaptureOptionU32)(RENDERDOC_CaptureOption opt);
+
+// Gets the current value of an option as a float
+//
+// If the option is invalid, -FLT_MAX is returned
+typedef float(RENDERDOC_CC *pRENDERDOC_GetCaptureOptionF32)(RENDERDOC_CaptureOption opt);
+
+typedef enum RENDERDOC_InputButton
+{
+  // '0' - '9' matches ASCII values
+  eRENDERDOC_Key_0 = 0x30,
+  eRENDERDOC_Key_1 = 0x31,
+  eRENDERDOC_Key_2 = 0x32,
+  eRENDERDOC_Key_3 = 0x33,
+  eRENDERDOC_Key_4 = 0x34,
+  eRENDERDOC_Key_5 = 0x35,
+  eRENDERDOC_Key_6 = 0x36,
+  eRENDERDOC_Key_7 = 0x37,
+  eRENDERDOC_Key_8 = 0x38,
+  eRENDERDOC_Key_9 = 0x39,
+
+  // 'A' - 'Z' matches ASCII values
+  eRENDERDOC_Key_A = 0x41,
+  eRENDERDOC_Key_B = 0x42,
+  eRENDERDOC_Key_C = 0x43,
+  eRENDERDOC_Key_D = 0x44,
+  eRENDERDOC_Key_E = 0x45,
+  eRENDERDOC_Key_F = 0x46,
+  eRENDERDOC_Key_G = 0x47,
+  eRENDERDOC_Key_H = 0x48,
+  eRENDERDOC_Key_I = 0x49,
+  eRENDERDOC_Key_J = 0x4A,
+  eRENDERDOC_Key_K = 0x4B,
+  eRENDERDOC_Key_L = 0x4C,
+  eRENDERDOC_Key_M = 0x4D,
+  eRENDERDOC_Key_N = 0x4E,
+  eRENDERDOC_Key_O = 0x4F,
+  eRENDERDOC_Key_P = 0x50,
+  eRENDERDOC_Key_Q = 0x51,
+  eRENDERDOC_Key_R = 0x52,
+  eRENDERDOC_Key_S = 0x53,
+  eRENDERDOC_Key_T = 0x54,
+  eRENDERDOC_Key_U = 0x55,
+  eRENDERDOC_Key_V = 0x56,
+  eRENDERDOC_Key_W = 0x57,
+  eRENDERDOC_Key_X = 0x58,
+  eRENDERDOC_Key_Y = 0x59,
+  eRENDERDOC_Key_Z = 0x5A,
+
+  // leave the rest of the ASCII range free
+  // in case we want to use it later
+  eRENDERDOC_Key_NonPrintable = 0x100,
+
+  eRENDERDOC_Key_Divide,
+  eRENDERDOC_Key_Multiply,
+  eRENDERDOC_Key_Subtract,
+  eRENDERDOC_Key_Plus,
+
+  eRENDERDOC_Key_F1,
+  eRENDERDOC_Key_F2,
+  eRENDERDOC_Key_F3,
+  eRENDERDOC_Key_F4,
+  eRENDERDOC_Key_F5,
+  eRENDERDOC_Key_F6,
+  eRENDERDOC_Key_F7,
+  eRENDERDOC_Key_F8,
+  eRENDERDOC_Key_F9,
+  eRENDERDOC_Key_F10,
+  eRENDERDOC_Key_F11,
+  eRENDERDOC_Key_F12,
+
+  eRENDERDOC_Key_Home,
+  eRENDERDOC_Key_End,
+  eRENDERDOC_Key_Insert,
+  eRENDERDOC_Key_Delete,
+  eRENDERDOC_Key_PageUp,
+  eRENDERDOC_Key_PageDn,
+
+  eRENDERDOC_Key_Backspace,
+  eRENDERDOC_Key_Tab,
+  eRENDERDOC_Key_PrtScrn,
+  eRENDERDOC_Key_Pause,
+
+  eRENDERDOC_Key_Max,
+} RENDERDOC_InputButton;
+
+// Sets which key or keys can be used to toggle focus between multiple windows
+//
+// If keys is NULL or num is 0, toggle keys will be disabled
+typedef void(RENDERDOC_CC *pRENDERDOC_SetFocusToggleKeys)(RENDERDOC_InputButton *keys, int num);
+
+// Sets which key or keys can be used to capture the next frame
+//
+// If keys is NULL or num is 0, captures keys will be disabled
+typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureKeys)(RENDERDOC_InputButton *keys, int num);
+
+typedef enum RENDERDOC_OverlayBits
+{
+  // This single bit controls whether the overlay is enabled or disabled globally
+  eRENDERDOC_Overlay_Enabled = 0x1,
+
+  // Show the average framerate over several seconds as well as min/max
+  eRENDERDOC_Overlay_FrameRate = 0x2,
+
+  // Show the current frame number
+  eRENDERDOC_Overlay_FrameNumber = 0x4,
+
+  // Show a list of recent captures, and how many captures have been made
+  eRENDERDOC_Overlay_CaptureList = 0x8,
+
+  // Default values for the overlay mask
+  eRENDERDOC_Overlay_Default = (eRENDERDOC_Overlay_Enabled | eRENDERDOC_Overlay_FrameRate |
+                                eRENDERDOC_Overlay_FrameNumber | eRENDERDOC_Overlay_CaptureList),
+
+  // Enable all bits
+  eRENDERDOC_Overlay_All = 0x7ffffff,
+
+  // Disable all bits
+  eRENDERDOC_Overlay_None = 0,
+} RENDERDOC_OverlayBits;
+
+// returns the overlay bits that have been set
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetOverlayBits)(void);
+// sets the overlay bits with an and & or mask
+typedef void(RENDERDOC_CC *pRENDERDOC_MaskOverlayBits)(uint32_t And, uint32_t Or);
+
+// this function will attempt to remove RenderDoc's hooks in the application.
+//
+// Note: that this can only work correctly if done immediately after
+// the module is loaded, before any API work happens. RenderDoc will remove its
+// injected hooks and shut down. Behaviour is undefined if this is called
+// after any API functions have been called, and there is still no guarantee of
+// success.
+typedef void(RENDERDOC_CC *pRENDERDOC_RemoveHooks)(void);
+
+// DEPRECATED: compatibility for code compiled against pre-1.4.1 headers.
+typedef pRENDERDOC_RemoveHooks pRENDERDOC_Shutdown;
+
+// This function will unload RenderDoc's crash handler.
+//
+// If you use your own crash handler and don't want RenderDoc's handler to
+// intercede, you can call this function to unload it and any unhandled
+// exceptions will pass to the next handler.
+typedef void(RENDERDOC_CC *pRENDERDOC_UnloadCrashHandler)(void);
+
+// Sets the capture file path template
+//
+// pathtemplate is a UTF-8 string that gives a template for how captures will be named
+// and where they will be saved.
+//
+// Any extension is stripped off the path, and captures are saved in the directory
+// specified, and named with the filename and the frame number appended. If the
+// directory does not exist it will be created, including any parent directories.
+//
+// If pathtemplate is NULL, the template will remain unchanged
+//
+// Example:
+//
+// SetCaptureFilePathTemplate("my_captures/example");
+//
+// Capture #1 -> my_captures/example_frame123.rdc
+// Capture #2 -> my_captures/example_frame456.rdc
+typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureFilePathTemplate)(const char *pathtemplate);
+
+// returns the current capture path template, see SetCaptureFileTemplate above, as a UTF-8 string
+typedef const char *(RENDERDOC_CC *pRENDERDOC_GetCaptureFilePathTemplate)(void);
+
+// DEPRECATED: compatibility for code compiled against pre-1.1.2 headers.
+typedef pRENDERDOC_SetCaptureFilePathTemplate pRENDERDOC_SetLogFilePathTemplate;
+typedef pRENDERDOC_GetCaptureFilePathTemplate pRENDERDOC_GetLogFilePathTemplate;
+
+// returns the number of captures that have been made
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetNumCaptures)(void);
+
+// This function returns the details of a capture, by index. New captures are added
+// to the end of the list.
+//
+// filename will be filled with the absolute path to the capture file, as a UTF-8 string
+// pathlength will be written with the length in bytes of the filename string
+// timestamp will be written with the time of the capture, in seconds since the Unix epoch
+//
+// Any of the parameters can be NULL and they'll be skipped.
+//
+// The function will return 1 if the capture index is valid, or 0 if the index is invalid
+// If the index is invalid, the values will be unchanged
+//
+// Note: when captures are deleted in the UI they will remain in this list, so the
+// capture path may not exist anymore.
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_GetCapture)(uint32_t idx, char *filename,
+                                                      uint32_t *pathlength, uint64_t *timestamp);
+
+// Sets the comments associated with a capture file. These comments are displayed in the
+// UI program when opening.
+//
+// filePath should be a path to the capture file to add comments to. If set to NULL or ""
+// the most recent capture file created made will be used instead.
+// comments should be a NULL-terminated UTF-8 string to add as comments.
+//
+// Any existing comments will be overwritten.
+typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureFileComments)(const char *filePath,
+                                                              const char *comments);
+
+// returns 1 if the RenderDoc UI is connected to this application, 0 otherwise
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_IsTargetControlConnected)(void);
+
+// DEPRECATED: compatibility for code compiled against pre-1.1.1 headers.
+// This was renamed to IsTargetControlConnected in API 1.1.1, the old typedef is kept here for
+// backwards compatibility with old code, it is castable either way since it's ABI compatible
+// as the same function pointer type.
+typedef pRENDERDOC_IsTargetControlConnected pRENDERDOC_IsRemoteAccessConnected;
+
+// This function will launch the Replay UI associated with the RenderDoc library injected
+// into the running application.
+//
+// if connectTargetControl is 1, the Replay UI will be launched with a command line parameter
+// to connect to this application
+// cmdline is the rest of the command line, as a UTF-8 string. E.g. a captures to open
+// if cmdline is NULL, the command line will be empty.
+//
+// returns the PID of the replay UI if successful, 0 if not successful.
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_LaunchReplayUI)(uint32_t connectTargetControl,
+                                                          const char *cmdline);
+
+// RenderDoc can return a higher version than requested if it's backwards compatible,
+// this function returns the actual version returned. If a parameter is NULL, it will be
+// ignored and the others will be filled out.
+typedef void(RENDERDOC_CC *pRENDERDOC_GetAPIVersion)(int *major, int *minor, int *patch);
+
+// Requests that the replay UI show itself (if hidden or not the current top window). This can be
+// used in conjunction with IsTargetControlConnected and LaunchReplayUI to intelligently handle
+// showing the UI after making a capture.
+//
+// This will return 1 if the request was successfully passed on, though it's not guaranteed that
+// the UI will be on top in all cases depending on OS rules. It will return 0 if there is no current
+// target control connection to make such a request, or if there was another error
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_ShowReplayUI)(void);
+
+//////////////////////////////////////////////////////////////////////////
+// Capturing functions
+//
+
+// A device pointer is a pointer to the API's root handle.
+//
+// This would be an ID3D11Device, HGLRC/GLXContext, ID3D12Device, etc
+typedef void *RENDERDOC_DevicePointer;
+
+// A window handle is the OS's native window handle
+//
+// This would be an HWND, GLXDrawable, etc
+typedef void *RENDERDOC_WindowHandle;
+
+// A helper macro for Vulkan, where the device handle cannot be used directly.
+//
+// Passing the VkInstance to this macro will return the RENDERDOC_DevicePointer to use.
+//
+// Specifically, the value needed is the dispatch table pointer, which sits as the first
+// pointer-sized object in the memory pointed to by the VkInstance. Thus we cast to a void** and
+// indirect once.
+#define RENDERDOC_DEVICEPOINTER_FROM_VKINSTANCE(inst) (*((void **)(inst)))
+
+// This sets the RenderDoc in-app overlay in the API/window pair as 'active' and it will
+// respond to keypresses. Neither parameter can be NULL
+typedef void(RENDERDOC_CC *pRENDERDOC_SetActiveWindow)(RENDERDOC_DevicePointer device,
+                                                       RENDERDOC_WindowHandle wndHandle);
+
+// capture the next frame on whichever window and API is currently considered active
+typedef void(RENDERDOC_CC *pRENDERDOC_TriggerCapture)(void);
+
+// capture the next N frames on whichever window and API is currently considered active
+typedef void(RENDERDOC_CC *pRENDERDOC_TriggerMultiFrameCapture)(uint32_t numFrames);
+
+// When choosing either a device pointer or a window handle to capture, you can pass NULL.
+// Passing NULL specifies a 'wildcard' match against anything. This allows you to specify
+// any API rendering to a specific window, or a specific API instance rendering to any window,
+// or in the simplest case of one window and one API, you can just pass NULL for both.
+//
+// In either case, if there are two or more possible matching (device,window) pairs it
+// is undefined which one will be captured.
+//
+// Note: for headless rendering you can pass NULL for the window handle and either specify
+// a device pointer or leave it NULL as above.
+
+// Immediately starts capturing API calls on the specified device pointer and window handle.
+//
+// If there is no matching thing to capture (e.g. no supported API has been initialised),
+// this will do nothing.
+//
+// The results are undefined (including crashes) if two captures are started overlapping,
+// even on separate devices and/oror windows.
+typedef void(RENDERDOC_CC *pRENDERDOC_StartFrameCapture)(RENDERDOC_DevicePointer device,
+                                                         RENDERDOC_WindowHandle wndHandle);
+
+// Returns whether or not a frame capture is currently ongoing anywhere.
+//
+// This will return 1 if a capture is ongoing, and 0 if there is no capture running
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_IsFrameCapturing)(void);
+
+// Ends capturing immediately.
+//
+// This will return 1 if the capture succeeded, and 0 if there was an error capturing.
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_EndFrameCapture)(RENDERDOC_DevicePointer device,
+                                                           RENDERDOC_WindowHandle wndHandle);
+
+// Ends capturing immediately and discard any data stored without saving to disk.
+//
+// This will return 1 if the capture was discarded, and 0 if there was an error or no capture
+// was in progress
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_DiscardFrameCapture)(RENDERDOC_DevicePointer device,
+                                                               RENDERDOC_WindowHandle wndHandle);
+
+// Only valid to be called between a call to StartFrameCapture and EndFrameCapture. Gives a custom
+// title to the capture produced which will be displayed in the UI.
+//
+// If multiple captures are ongoing, this title will be applied to the first capture to end after
+// this call. The second capture to end will have no title, unless this function is called again.
+//
+// Calling this function has no effect if no capture is currently running, and if it is called
+// multiple times only the last title will be used.
+typedef void(RENDERDOC_CC *pRENDERDOC_SetCaptureTitle)(const char *title);
+
+// Annotations API:
+//
+// These functions allow you to specify annotations either on a per-command level, or a per-object
+// level.
+//
+// Basic types of annotations are supported, as well as vector versions and references to API objects.
+//
+// The annotations are stored as keys, with the key being a dot-separated path allowing arbitrary
+// nesting and user organisation. The keys are sorted in human order so `foo.2.bar` will be displayed
+// before `foo.10.bar` to allow creation of arrays if desired.
+//
+// Deleting an annotation can be done by assigning an empty value to it.
+
+// the type of an annotation value, or Empty to delete an annotation
+typedef enum RENDERDOC_AnnotationType
+{
+  eRENDERDOC_Empty,
+  eRENDERDOC_Bool,
+  eRENDERDOC_Int32,
+  eRENDERDOC_UInt32,
+  eRENDERDOC_Int64,
+  eRENDERDOC_UInt64,
+  eRENDERDOC_Float,
+  eRENDERDOC_Double,
+  eRENDERDOC_String,
+  eRENDERDOC_APIObject,
+  eRENDERDOC_AnnotationMax = 0x7FFFFFFF,
+} RENDERDOC_AnnotationType;
+
+// a union with vector annotation value data
+typedef union RENDERDOC_AnnotationVectorValue
+{
+  bool boolean[4];
+  int32_t int32[4];
+  int64_t int64[4];
+  uint32_t uint32[4];
+  uint64_t uint64[4];
+  float float32[4];
+  double float64[4];
+} RENDERDOC_AnnotationVectorValue;
+
+// a union with scalar annotation value data
+typedef union RENDERDOC_AnnotationValue
+{
+  bool boolean;
+  int32_t int32;
+  int64_t int64;
+  uint32_t uint32;
+  uint64_t uint64;
+  float float32;
+  double float64;
+
+  RENDERDOC_AnnotationVectorValue vector;
+
+  const char *string;
+  void *apiObject;
+} RENDERDOC_AnnotationValue;
+
+// a struct for specifying a GL object, as we don't have pointers we can use so instead we specify a
+// pointer to this struct giving both the type and the name
+typedef struct RENDERDOC_GLResourceReference
+{
+  // this is the same GLenum identifier as passed to glObjectLabel
+  uint32_t identifier;
+  uint32_t name;
+} GLResourceReference;
+
+// simple C++ helpers to avoid the need for a temporary objects for value passing and GL object specification
+#ifdef __cplusplus
+struct RDGLObjectHelper
+{
+  RENDERDOC_GLResourceReference gl;
+
+  RDGLObjectHelper(uint32_t identifier, uint32_t name)
+  {
+    gl.identifier = identifier;
+    gl.name = name;
+  }
+
+  operator RENDERDOC_GLResourceReference *() { return &gl; }
+};
+
+struct RDAnnotationHelper
+{
+  RENDERDOC_AnnotationValue val;
+
+  RDAnnotationHelper(bool b) { val.boolean = b; }
+  RDAnnotationHelper(int32_t i) { val.int32 = i; }
+  RDAnnotationHelper(int64_t i) { val.int64 = i; }
+  RDAnnotationHelper(uint32_t i) { val.uint32 = i; }
+  RDAnnotationHelper(uint64_t i) { val.uint64 = i; }
+  RDAnnotationHelper(float f) { val.float32 = f; }
+  RDAnnotationHelper(double d) { val.float64 = d; }
+  RDAnnotationHelper(const char *s) { val.string = s; }
+
+  operator RENDERDOC_AnnotationValue *() { return &val; }
+};
+#endif
+
+// The device is specified in the same way as other API calls that take a RENDERDOC_DevicePointer
+// to specify the device.
+//
+// The object or queue/commandbuffer will depend on the graphics API in question.
+//
+// Return value:
+// 0 - The annotation was applied successfully.
+// 1 - The device is unknown/invalid
+// 2 - The device is valid but the annotation is not supported for API-specific reasons, such as an
+//     unrecognised or invalid object or queue/commandbuffer
+// 3 - The call is ill-formed or invalid e.g. empty is specified with a value pointer, or non-empty
+//     is specified with a NULL value pointer
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_SetObjectAnnotation)(RENDERDOC_DevicePointer device,
+                                                               void *object, const char *key,
+                                                               RENDERDOC_AnnotationType valueType,
+                                                               uint32_t valueVectorWidth,
+                                                               const RENDERDOC_AnnotationValue *value);
+
+typedef uint32_t(RENDERDOC_CC *pRENDERDOC_SetCommandAnnotation)(
+    RENDERDOC_DevicePointer device, void *queueOrCommandBuffer, const char *key,
+    RENDERDOC_AnnotationType valueType, uint32_t valueVectorWidth,
+    const RENDERDOC_AnnotationValue *value);
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// RenderDoc API versions
+//
+
+// RenderDoc uses semantic versioning (http://semver.org/).
+//
+// MAJOR version is incremented when incompatible API changes happen.
+// MINOR version is incremented when functionality is added in a backwards-compatible manner.
+// PATCH version is incremented when backwards-compatible bug fixes happen.
+//
+// Note that this means the API returned can be higher than the one you might have requested.
+// e.g. if you are running against a newer RenderDoc that supports 1.0.1, it will be returned
+// instead of 1.0.0. You can check this with the GetAPIVersion entry point
+typedef enum RENDERDOC_Version
+{
+  eRENDERDOC_API_Version_1_0_0 = 10000,    // RENDERDOC_API_1_0_0 = 1 00 00
+  eRENDERDOC_API_Version_1_0_1 = 10001,    // RENDERDOC_API_1_0_1 = 1 00 01
+  eRENDERDOC_API_Version_1_0_2 = 10002,    // RENDERDOC_API_1_0_2 = 1 00 02
+  eRENDERDOC_API_Version_1_1_0 = 10100,    // RENDERDOC_API_1_1_0 = 1 01 00
+  eRENDERDOC_API_Version_1_1_1 = 10101,    // RENDERDOC_API_1_1_1 = 1 01 01
+  eRENDERDOC_API_Version_1_1_2 = 10102,    // RENDERDOC_API_1_1_2 = 1 01 02
+  eRENDERDOC_API_Version_1_2_0 = 10200,    // RENDERDOC_API_1_2_0 = 1 02 00
+  eRENDERDOC_API_Version_1_3_0 = 10300,    // RENDERDOC_API_1_3_0 = 1 03 00
+  eRENDERDOC_API_Version_1_4_0 = 10400,    // RENDERDOC_API_1_4_0 = 1 04 00
+  eRENDERDOC_API_Version_1_4_1 = 10401,    // RENDERDOC_API_1_4_1 = 1 04 01
+  eRENDERDOC_API_Version_1_4_2 = 10402,    // RENDERDOC_API_1_4_2 = 1 04 02
+  eRENDERDOC_API_Version_1_5_0 = 10500,    // RENDERDOC_API_1_5_0 = 1 05 00
+  eRENDERDOC_API_Version_1_6_0 = 10600,    // RENDERDOC_API_1_6_0 = 1 06 00
+  eRENDERDOC_API_Version_1_7_0 = 10700,    // RENDERDOC_API_1_7_0 = 1 07 00
+} RENDERDOC_Version;
+
+// API version changelog:
+//
+// 1.0.0 - initial release
+// 1.0.1 - Bugfix: IsFrameCapturing() was returning false for captures that were triggered
+//         by keypress or TriggerCapture, instead of Start/EndFrameCapture.
+// 1.0.2 - Refactor: Renamed eRENDERDOC_Option_DebugDeviceMode to eRENDERDOC_Option_APIValidation
+// 1.1.0 - Add feature: TriggerMultiFrameCapture(). Backwards compatible with 1.0.x since the new
+//         function pointer is added to the end of the struct, the original layout is identical
+// 1.1.1 - Refactor: Renamed remote access to target control (to better disambiguate from remote
+//         replay/remote server concept in replay UI)
+// 1.1.2 - Refactor: Renamed "log file" in function names to just capture, to clarify that these
+//         are captures and not debug logging files. This is the first API version in the v1.0
+//         branch.
+// 1.2.0 - Added feature: SetCaptureFileComments() to add comments to a capture file that will be
+//         displayed in the UI program on load.
+// 1.3.0 - Added feature: New capture option eRENDERDOC_Option_AllowUnsupportedVendorExtensions
+//         which allows users to opt-in to allowing unsupported vendor extensions to function.
+//         Should be used at the user's own risk.
+//         Refactor: Renamed eRENDERDOC_Option_VerifyMapWrites to
+//         eRENDERDOC_Option_VerifyBufferAccess, which now also controls initialisation to
+//         0xdddddddd of uninitialised buffer contents.
+// 1.4.0 - Added feature: DiscardFrameCapture() to discard a frame capture in progress and stop
+//         capturing without saving anything to disk.
+// 1.4.1 - Refactor: Renamed Shutdown to RemoveHooks to better clarify what is happening
+// 1.4.2 - Refactor: Renamed 'draws' to 'actions' in callstack capture option.
+// 1.5.0 - Added feature: ShowReplayUI() to request that the replay UI show itself if connected
+// 1.6.0 - Added feature: SetCaptureTitle() which can be used to set a title for a
+//         capture made with StartFrameCapture() or EndFrameCapture()
+// 1.7.0 - Added feature: SetObjectAnnotation() / SetCommandAnnotation() for adding rich
+//         annotations to objects and command streams
+
+typedef struct RENDERDOC_API_1_7_0
+{
+  pRENDERDOC_GetAPIVersion GetAPIVersion;
+
+  pRENDERDOC_SetCaptureOptionU32 SetCaptureOptionU32;
+  pRENDERDOC_SetCaptureOptionF32 SetCaptureOptionF32;
+
+  pRENDERDOC_GetCaptureOptionU32 GetCaptureOptionU32;
+  pRENDERDOC_GetCaptureOptionF32 GetCaptureOptionF32;
+
+  pRENDERDOC_SetFocusToggleKeys SetFocusToggleKeys;
+  pRENDERDOC_SetCaptureKeys SetCaptureKeys;
+
+  pRENDERDOC_GetOverlayBits GetOverlayBits;
+  pRENDERDOC_MaskOverlayBits MaskOverlayBits;
+
+  // Shutdown was renamed to RemoveHooks in 1.4.1.
+  // These unions allow old code to continue compiling without changes
+  union
+  {
+    pRENDERDOC_Shutdown Shutdown;
+    pRENDERDOC_RemoveHooks RemoveHooks;
+  };
+  pRENDERDOC_UnloadCrashHandler UnloadCrashHandler;
+
+  // Get/SetLogFilePathTemplate was renamed to Get/SetCaptureFilePathTemplate in 1.1.2.
+  // These unions allow old code to continue compiling without changes
+  union
+  {
+    // deprecated name
+    pRENDERDOC_SetLogFilePathTemplate SetLogFilePathTemplate;
+    // current name
+    pRENDERDOC_SetCaptureFilePathTemplate SetCaptureFilePathTemplate;
+  };
+  union
+  {
+    // deprecated name
+    pRENDERDOC_GetLogFilePathTemplate GetLogFilePathTemplate;
+    // current name
+    pRENDERDOC_GetCaptureFilePathTemplate GetCaptureFilePathTemplate;
+  };
+
+  pRENDERDOC_GetNumCaptures GetNumCaptures;
+  pRENDERDOC_GetCapture GetCapture;
+
+  pRENDERDOC_TriggerCapture TriggerCapture;
+
+  // IsRemoteAccessConnected was renamed to IsTargetControlConnected in 1.1.1.
+  // This union allows old code to continue compiling without changes
+  union
+  {
+    // deprecated name
+    pRENDERDOC_IsRemoteAccessConnected IsRemoteAccessConnected;
+    // current name
+    pRENDERDOC_IsTargetControlConnected IsTargetControlConnected;
+  };
+  pRENDERDOC_LaunchReplayUI LaunchReplayUI;
+
+  pRENDERDOC_SetActiveWindow SetActiveWindow;
+
+  pRENDERDOC_StartFrameCapture StartFrameCapture;
+  pRENDERDOC_IsFrameCapturing IsFrameCapturing;
+  pRENDERDOC_EndFrameCapture EndFrameCapture;
+
+  // new function in 1.1.0
+  pRENDERDOC_TriggerMultiFrameCapture TriggerMultiFrameCapture;
+
+  // new function in 1.2.0
+  pRENDERDOC_SetCaptureFileComments SetCaptureFileComments;
+
+  // new function in 1.4.0
+  pRENDERDOC_DiscardFrameCapture DiscardFrameCapture;
+
+  // new function in 1.5.0
+  pRENDERDOC_ShowReplayUI ShowReplayUI;
+
+  // new function in 1.6.0
+  pRENDERDOC_SetCaptureTitle SetCaptureTitle;
+
+  // new functions in 1.7.0
+  pRENDERDOC_SetObjectAnnotation SetObjectAnnotation;
+  pRENDERDOC_SetCommandAnnotation SetCommandAnnotation;
+} RENDERDOC_API_1_7_0;
+
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_0_0;
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_0_1;
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_0_2;
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_1_0;
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_1_1;
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_1_2;
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_2_0;
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_3_0;
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_4_0;
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_4_1;
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_4_2;
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_5_0;
+typedef RENDERDOC_API_1_7_0 RENDERDOC_API_1_6_0;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// RenderDoc API entry point
+//
+// This entry point can be obtained via GetProcAddress/dlsym if RenderDoc is available.
+//
+// The name is the same as the typedef - "RENDERDOC_GetAPI"
+//
+// This function is not thread safe, and should not be called on multiple threads at once.
+// Ideally, call this once as early as possible in your application's startup, before doing
+// any API work, since some configuration functionality etc has to be done also before
+// initialising any APIs.
+//
+// Parameters:
+//   version is a single value from the RENDERDOC_Version above.
+//
+//   outAPIPointers will be filled out with a pointer to the corresponding struct of function
+//   pointers.
+//
+// Returns:
+//   1 - if the outAPIPointers has been filled with a pointer to the API struct requested
+//   0 - if the requested version is not supported or the arguments are invalid.
+//
+typedef int(RENDERDOC_CC *pRENDERDOC_GetAPI)(RENDERDOC_Version version, void **outAPIPointers);
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif

CMakeLists.txt

@@ -0,0 +1,679 @@
+cmake_minimum_required(VERSION 3.12...4.3)
+
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 4.0)
+	set(CMAKE_POLICY_VERSION_MINIMUM 3.5 CACHE STRING "Minimum policy version for bundled dependencies")
+endif()
+
+get_property(KYTY_GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if(NOT KYTY_GENERATOR_IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
+	set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build" FORCE)
+	set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS Debug Release RelWithDebInfo MinSizeRel)
+endif()
+
+project(Kyty)
+
+set(KYTY_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
+set(KYTY_TESTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests")
+set(KYTY_THIRD_PARTY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty")
+
+if(CMAKE_SYSTEM_NAME MATCHES ".*Linux")
+	set(LINUX TRUE)
+endif()
+
+if (NOT (WIN32 OR LINUX OR APPLE))
+    message(FATAL_ERROR "only Windows, Linux, and macOS builds are supported")
+endif()
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_SCAN_FOR_MODULES OFF)
+
+include("${KYTY_SOURCE_DIR}/utils.cmake")
+include(CTest)
+
+option(KYTY_ENABLE_CLANG_TIDY "Run clang-tidy checks during builds" OFF)
+
+set(KYTY_BUILD_ORIGIN "Source" CACHE STRING "Build provenance shown in diagnostics")
+set_property(CACHE KYTY_BUILD_ORIGIN PROPERTY STRINGS Source Official Fork)
+if(NOT KYTY_BUILD_ORIGIN STREQUAL "Source" AND NOT KYTY_BUILD_ORIGIN STREQUAL "Official" AND
+   NOT KYTY_BUILD_ORIGIN STREQUAL "Fork")
+	message(FATAL_ERROR "KYTY_BUILD_ORIGIN must be Source, Official, or Fork")
+endif()
+
+set(KYTY_RELEASE_TAG "" CACHE STRING "Release tag embedded in official builds")
+set(KYTY_BUILD_REPOSITORY "" CACHE STRING "GitHub repository embedded in fork builds")
+set(KYTY_OFFICIAL_BUILD OFF)
+set(KYTY_FORK_BUILD OFF)
+if(KYTY_BUILD_ORIGIN STREQUAL "Official")
+	if(KYTY_RELEASE_TAG STREQUAL "")
+		message(FATAL_ERROR "Official builds require KYTY_RELEASE_TAG")
+	endif()
+	set(KYTY_OFFICIAL_BUILD ON)
+elseif(KYTY_BUILD_ORIGIN STREQUAL "Fork")
+	if(KYTY_BUILD_REPOSITORY STREQUAL "")
+		message(FATAL_ERROR "Fork builds require KYTY_BUILD_REPOSITORY")
+	endif()
+	set(KYTY_FORK_BUILD ON)
+endif()
+
+set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+
+include(TestBigEndian)
+
+if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
+	message(FATAL_ERROR "only 64-bit builds are supported")
+endif()
+
+test_big_endian(BIG_ENDIAN)
+if(BIG_ENDIAN)
+	set(KYTY_ENDIAN KYTY_ENDIAN_BIG)
+else()
+	set(KYTY_ENDIAN KYTY_ENDIAN_LITTLE)
+endif()
+
+if(CMAKE_BUILD_TYPE MATCHES Debug)
+	set(KYTY_BUILD KYTY_BUILD_DEBUG)
+else()
+	set(KYTY_BUILD KYTY_BUILD_RELEASE)
+endif()
+
+if(LINUX OR APPLE)
+	# macOS rides the POSIX/Linux code paths until it gets a dedicated platform
+	set(KYTY_PLATFORM KYTY_PLATFORM_LINUX)
+else()
+	set(KYTY_PLATFORM KYTY_PLATFORM_WINDOWS)
+endif()
+
+set(CLANG FALSE)
+set(GCC FALSE)
+set(KYTY_CLANG_CL FALSE)
+get_filename_component(KYTY_CXX_COMPILER_NAME "${CMAKE_CXX_COMPILER}" NAME_WE)
+string(TOLOWER "${KYTY_CXX_COMPILER_NAME}" KYTY_CXX_COMPILER_NAME)
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "^(Apple)?Clang$")
+	set(CLANG TRUE)
+	set(KYTY_COMPILER CLANG)
+	if(WIN32 AND KYTY_CXX_COMPILER_NAME STREQUAL "clang-cl")
+		set(KYTY_CLANG_CL TRUE)
+		set(KYTY_LINKER LLD_LINK)
+	elseif(APPLE)
+		set(KYTY_LINKER LD64) # Apple's default linker; lld flags don't apply
+	else()
+		set(KYTY_LINKER LLD)
+	endif()
+	if ((CMAKE_AR MATCHES "llvm") AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0.0) AND (CMAKE_CXX_COMPILER MATCHES "winlibs"))
+		string(REPLACE "llvm-ar.exe" "ar.exe" CMAKE_AR ${CMAKE_AR}) # llvm-ar.exe 11.0.0 from winlibs is broken
+	endif()
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+	set(GCC TRUE)
+	set(KYTY_COMPILER GCC)
+	set(KYTY_LINKER LD)
+else()
+	message(FATAL_ERROR "only Clang and GCC are supported; found ${CMAKE_CXX_COMPILER_ID}")
+endif()
+
+set(KYTY_PROJECT_NAME "Emulator" CACHE STRING "Project name suffix")
+
+string(TOLOWER ${KYTY_COMPILER} KYTY_COMPILER_ID)
+string(TOLOWER ${KYTY_LINKER} KYTY_LINKER_ID)
+
+if (CLANG AND (KYTY_LINKER STREQUAL LLD))
+	set(KYTY_LD_OPTIONS "-fuse-ld=lld")
+endif()
+
+if (KYTY_LINKER STREQUAL LD AND NOT LINUX)
+	set(KYTY_LD_OPTIONS "-Wl,--image-base=0x100000000000")
+endif()
+
+project(Kyty${KYTY_PROJECT_NAME}${CMAKE_BUILD_TYPE}${KYTY_COMPILER} VERSION 0.3.0)
+
+include_directories(
+	${KYTY_THIRD_PARTY_DIR}/gtest/include
+	${KYTY_THIRD_PARTY_DIR}/gtest
+	${KYTY_THIRD_PARTY_DIR}/fmt/include
+	${KYTY_THIRD_PARTY_DIR}/magic_enum/include/magic_enum
+	${PROJECT_BINARY_DIR}
+	${KYTY_SOURCE_DIR}
+)
+
+set(KYTY_VERSION "${PROJECT_VERSION}")
+
+configure_file(
+  ${KYTY_SOURCE_DIR}/cmake_config.h.in
+  ${PROJECT_BINARY_DIR}/cmake_config.h
+  )
+
+find_package(Git)
+
+add_custom_target(KytyGitVersion
+	COMMAND ${CMAKE_COMMAND}
+		-D INPUT_FILE=${KYTY_SOURCE_DIR}/kytyGitVersion.h.in
+		-D OUTPUT_FILE=${PROJECT_BINARY_DIR}/kytyGitVersion.h
+		-D GIT_EXECUTABLE=${GIT_EXECUTABLE}
+		-D GIT_WORKING_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}
+		-P ${KYTY_SOURCE_DIR}/generate_version.cmake
+	BYPRODUCTS ${PROJECT_BINARY_DIR}/kytyGitVersion.h
+	COMMENT "Generate kytyGitVersion.h"
+)
+
+add_library(kyty_git_version INTERFACE)
+add_dependencies(kyty_git_version KytyGitVersion)
+
+if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0.0)
+	list(APPEND KYTY_IWYU
+		kyty_emulator
+		common
+		#launcher
+	)
+	list(APPEND KYTY_CLANG_TIDY
+		kyty_emulator
+		#common
+		launcher
+	)
+endif()
+
+option(KYTY_BUILD_LAUNCHER "Build Qt launcher" ON)
+
+config_compiler_and_linker()
+
+add_subdirectory("${KYTY_THIRD_PARTY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/3rdparty")
+add_subdirectory("${KYTY_SOURCE_DIR}/common" "${CMAKE_CURRENT_BINARY_DIR}/common")
+
+file(GLOB kyty_emulator_src CONFIGURE_DEPENDS
+	"${KYTY_SOURCE_DIR}/libs/*.cpp"
+	"${KYTY_SOURCE_DIR}/libs/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/command_processor/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/command_processor/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/cache/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/cache/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/image/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/image/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/pipeline/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/pipeline/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/frontend/cfg/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/frontend/cfg/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/frontend/decode/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/frontend/decode/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/frontend/translate/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/frontend/translate/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/backend/spirv/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/backend/spirv/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/opcodes/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/opcodes/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/opcodes/*.inc"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/presentation/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/presentation/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/presentation/window/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/presentation/window/*.h"
+	"${KYTY_SOURCE_DIR}/kernel/*.cpp"
+	"${KYTY_SOURCE_DIR}/kernel/*.h"
+	"${KYTY_SOURCE_DIR}/loader/*.cpp"
+	"${KYTY_SOURCE_DIR}/loader/*.h"
+)
+
+find_program(KYTY_GLSLANG_VALIDATOR glslangValidator REQUIRED)
+set(gpu_tiler_shader_dir "${KYTY_SOURCE_DIR}/graphics/host_gpu/shaders")
+set(gpu_tiler_generated_dir "${PROJECT_BINARY_DIR}/gpu_tiler_shaders")
+set(gpu_tiler_shader_names
+	standard256
+	standard4
+	standard4_3d
+	standard64
+	standard64_3d
+	prt
+	prt_3d
+	render_target
+	depth
+	promote_d16
+	demote_d16
+	swap_bgra16
+)
+file(GLOB gpu_tiler_shader_includes CONFIGURE_DEPENDS "${gpu_tiler_shader_dir}/gpu_tiler_*.inc")
+foreach(shader_name IN LISTS gpu_tiler_shader_names)
+	set(shader_source "${gpu_tiler_shader_dir}/gpu_tiler_${shader_name}.comp")
+	set(shader_spv "${gpu_tiler_generated_dir}/gpu_tiler_${shader_name}.spv")
+	set(shader_header "${gpu_tiler_generated_dir}/gpu_tiler_${shader_name}_spv.h")
+	string(TOUPPER "GPU_TILER_${shader_name}_SPV" shader_symbol)
+	add_custom_command(
+		OUTPUT "${shader_header}"
+		COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_tiler_generated_dir}"
+		COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.3 -Os
+		        "-I${gpu_tiler_shader_dir}" -o "${shader_spv}" "${shader_source}"
+		COMMAND ${CMAKE_COMMAND} -DINPUT=${shader_spv} -DOUTPUT=${shader_header}
+		        -DSYMBOL=${shader_symbol} -P "${KYTY_SOURCE_DIR}/embed_spirv.cmake"
+		DEPENDS "${shader_source}" ${gpu_tiler_shader_includes}
+		VERBATIM
+	)
+	list(APPEND gpu_tiler_shader_headers "${shader_header}")
+endforeach()
+
+set(fault_buffer_shader_source "${gpu_tiler_shader_dir}/fault_buffer_process.comp")
+set(fault_buffer_shader_spv "${gpu_tiler_generated_dir}/fault_buffer_process.spv")
+set(fault_buffer_shader_header "${gpu_tiler_generated_dir}/fault_buffer_process_spv.h")
+add_custom_command(
+	OUTPUT "${fault_buffer_shader_header}"
+	COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_tiler_generated_dir}"
+	COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.3 -Os
+	        -DCACHING_PAGEBITS=14 -DMAX_PAGE_FAULTS=1024
+	        -o "${fault_buffer_shader_spv}" "${fault_buffer_shader_source}"
+	COMMAND ${CMAKE_COMMAND} -DINPUT=${fault_buffer_shader_spv} -DOUTPUT=${fault_buffer_shader_header}
+	        -DSYMBOL=FAULT_BUFFER_PROCESS_SPV -P "${KYTY_SOURCE_DIR}/embed_spirv.cmake"
+	DEPENDS "${fault_buffer_shader_source}"
+	VERBATIM
+)
+list(APPEND kyty_emulator_src "${fault_buffer_shader_header}")
+list(APPEND kyty_emulator_src ${gpu_tiler_shader_headers})
+
+set(gpu_blit_generated_dir "${PROJECT_BINARY_DIR}/gpu_blit_shaders")
+set(gpu_blit_shader_sources
+	"${gpu_tiler_shader_dir}/gpu_blit_fs_triangle.vert"
+	"${gpu_tiler_shader_dir}/gpu_blit_color_to_ms_depth.frag"
+)
+foreach(shader_source IN LISTS gpu_blit_shader_sources)
+	get_filename_component(shader_name "${shader_source}" NAME_WE)
+	set(shader_spv "${gpu_blit_generated_dir}/${shader_name}.spv")
+	set(shader_header "${gpu_blit_generated_dir}/${shader_name}_spv.h")
+	string(TOUPPER "${shader_name}_SPV" shader_symbol)
+	add_custom_command(
+		OUTPUT "${shader_header}"
+		COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_blit_generated_dir}"
+		COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.3 -Os
+		        "-I${gpu_tiler_shader_dir}" -o "${shader_spv}" "${shader_source}"
+		COMMAND ${CMAKE_COMMAND} -DINPUT=${shader_spv} -DOUTPUT=${shader_header}
+		        -DSYMBOL=${shader_symbol} -P "${KYTY_SOURCE_DIR}/embed_spirv.cmake"
+		DEPENDS "${shader_source}"
+		VERBATIM
+	)
+	list(APPEND gpu_blit_shader_headers "${shader_header}")
+endforeach()
+list(APPEND kyty_emulator_src ${gpu_blit_shader_headers})
+
+list(APPEND kyty_emulator_src
+	"${KYTY_SOURCE_DIR}/emulator.h"
+	"${KYTY_SOURCE_DIR}/emulator.cpp"
+)
+list(REMOVE_DUPLICATES kyty_emulator_src)
+
+if (KYTY_CLANG_CL)
+	set_source_files_properties(${kyty_emulator_src} PROPERTIES COMPILE_FLAGS "-Wno-pragma-pack -Wno-deprecated-declarations -D_TIMESPEC_DEFINED")
+endif()
+
+set(kyty_emulator_link_libraries common Vulkan::Headers spirv-tools-opt spirv-tools SDL2-static imgui xxhash FFmpeg::ffmpeg fmt::fmt nlohmann_json::nlohmann_json LibAtrac9 kyty_git_version Zydis::Zydis xbyak::xbyak)
+
+# Linux system libraries.
+if(LINUX)
+	find_package(Threads REQUIRED)
+	list(APPEND kyty_emulator_link_libraries m ${CMAKE_DL_LIBS} Threads::Threads)
+endif()
+
+set(inc_headers
+	${KYTY_SOURCE_DIR}
+	${KYTY_THIRD_PARTY_DIR}/SDL2/include
+	${KYTY_THIRD_PARTY_DIR}/VulkanMemoryAllocator/include
+	${KYTY_THIRD_PARTY_DIR}/SPIRV-Tools/include
+	${KYTY_THIRD_PARTY_DIR}/SPIRV-Headers/include
+	${KYTY_THIRD_PARTY_DIR}/fmt/include
+	${KYTY_THIRD_PARTY_DIR}/xxhash
+	${KYTY_THIRD_PARTY_DIR}/cpuinfo/include
+	${KYTY_THIRD_PARTY_DIR}/renderdoc
+	${KYTY_THIRD_PARTY_DIR}/stb
+)
+
+if (KYTY_CLANG_CL)
+	list(APPEND kyty_emulator_link_libraries winpthread)
+	list(APPEND inc_headers
+		${KYTY_THIRD_PARTY_DIR}/winpthread/include
+	)
+endif()
+
+list(APPEND check_headers
+	${KYTY_SOURCE_DIR}
+)
+
+function(add_kyty_full_emulator_test target source)
+	add_executable(${target} EXCLUDE_FROM_ALL ${source} ${kyty_emulator_src})
+	target_link_libraries(${target} ${kyty_emulator_link_libraries})
+	target_include_directories(${target} PRIVATE ${inc_headers})
+	if (WIN32)
+		target_link_libraries(${target} iphlpapi)
+	endif()
+	if (KYTY_CLANG_CL)
+		target_link_libraries(${target} onecore)
+		add_custom_command(TARGET ${target} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" $<TARGET_FILE_DIR:${target}>/libwinpthread-1.dll)
+	endif()
+	# The macOS x86_64 guest address space needs its .zerofill segments anchored
+	# by linker flags, or the kernel kills the binary on load (posix_spawn EIO).
+	configure_macos_guest_address_space(${target})
+endfunction()
+
+function(configure_macos_guest_address_space target)
+	if(APPLE AND (CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64" OR
+			(NOT CMAKE_OSX_ARCHITECTURES AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64)$")))
+		target_sources(${target} PRIVATE "${KYTY_SOURCE_DIR}/kernel/macosGuestAddressSpace.cpp")
+		target_compile_definitions(${target} PRIVATE KYTY_LINKED_GUEST_ADDRESS_SPACE=1)
+		target_link_options(${target} PRIVATE
+			-Wl,-ld_classic,-no_pie,-no_fixup_chains,-no_huge,-pagezero_size,0x40000,-segaddr,SYSTEM_MANAGED,0x40000,-segaddr,SYSTEM_RESERVED,0x7ffffc000,-segaddr,USER_AREA,0x7000000000,-image_base,0x700000000000)
+	endif()
+endfunction()
+
+add_kyty_full_emulator_test(shader_cfg_tests "${KYTY_TESTS_DIR}/shaderCfgTests.cpp")
+
+add_executable(scalar_provenance_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ScalarProvenanceTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ReadLaneElimination.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/SrtWalker.cpp"
+)
+target_link_libraries(scalar_provenance_tests fmt::fmt)
+target_include_directories(scalar_provenance_tests PRIVATE ${inc_headers})
+
+add_executable(page_manager_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/PageManagerTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/pageManager.cpp"
+)
+target_link_libraries(page_manager_tests common)
+target_include_directories(page_manager_tests PRIVATE ${inc_headers})
+
+add_executable(bit_array_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/BitArrayTests.cpp"
+)
+target_include_directories(bit_array_tests PRIVATE ${inc_headers})
+
+add_executable(ime_dialog_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ImeDialogTests.cpp"
+	"${KYTY_SOURCE_DIR}/libs/imeCommon.cpp"
+	"${KYTY_SOURCE_DIR}/libs/imeDialog.cpp"
+)
+target_include_directories(ime_dialog_tests PRIVATE ${inc_headers})
+
+add_executable(memory_tracker_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/MemoryTrackerTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/pageManager.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/memoryTracker.cpp"
+)
+target_link_libraries(memory_tracker_tests fmt::fmt common)
+target_include_directories(memory_tracker_tests PRIVATE ${inc_headers})
+
+add_executable(shader_vertex_metadata_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ShaderVertexMetadataTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/shaderVertexMetadata.cpp"
+)
+target_include_directories(shader_vertex_metadata_tests PRIVATE ${inc_headers})
+
+add_executable(resource_materialization_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ResourceMaterializationTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/gpu_format.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ResourceMaterialization.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/SrtWalker.cpp"
+)
+target_link_libraries(resource_materialization_tests fmt::fmt)
+target_include_directories(resource_materialization_tests PRIVATE ${inc_headers})
+
+add_executable(resource_tracking_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ResourceTrackingTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/gpu_format.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/shaderPixelParameter.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/SrtWalker.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ResourceTracking.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ResourceMaterialization.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/ShaderInfoCollection.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/passes/BindingLayout.cpp"
+)
+target_link_libraries(resource_tracking_tests fmt::fmt)
+target_include_directories(resource_tracking_tests PRIVATE ${inc_headers})
+
+add_executable(audio_out2_port_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/AudioOut2PortTests.cpp"
+	"${KYTY_SOURCE_DIR}/libs/libAudio2.cpp"
+	"${KYTY_SOURCE_DIR}/loader/timer.cpp"
+)
+target_link_libraries(audio_out2_port_tests common fmt::fmt)
+target_include_directories(audio_out2_port_tests PRIVATE ${inc_headers})
+
+add_executable(event_queue_lifetime_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/EventQueueLifetimeTests.cpp"
+	"${KYTY_SOURCE_DIR}/kernel/eventQueue.cpp"
+	"${KYTY_SOURCE_DIR}/loader/timer.cpp"
+)
+target_link_libraries(event_queue_lifetime_tests common fmt::fmt)
+target_include_directories(event_queue_lifetime_tests PRIVATE ${inc_headers})
+
+add_kyty_full_emulator_test(kernel_file_system_tests
+	"${KYTY_TESTS_DIR}/KernelFileSystemTests.cpp")
+
+add_executable(sync_on_address_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/SyncOnAddressTests.cpp"
+	"${KYTY_SOURCE_DIR}/kernel/syncOnAddress.cpp"
+)
+target_link_libraries(sync_on_address_tests common)
+target_include_directories(sync_on_address_tests PRIVATE ${inc_headers})
+
+add_executable(image_page_table_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ImagePageTableTests.cpp"
+)
+target_link_libraries(image_page_table_tests common fmt::fmt)
+target_include_directories(image_page_table_tests PRIVATE ${inc_headers})
+
+add_kyty_full_emulator_test(shader_recompiler_compute_tests "${KYTY_TESTS_DIR}/ShaderRecompilerComputeTests.cpp")
+
+set(gpu_test_generated_dir "${PROJECT_BINARY_DIR}/gpu_test_shaders")
+set(gpu_test_ms_depth_source
+	"${gpu_tiler_shader_dir}/gpu_test_ms_depth.comp")
+set(gpu_test_ms_depth_spv
+	"${gpu_test_generated_dir}/gpu_test_ms_depth.spv")
+set(gpu_test_ms_depth_header
+	"${gpu_test_generated_dir}/gpu_test_ms_depth_spv.h")
+add_custom_command(
+	OUTPUT "${gpu_test_ms_depth_header}"
+	COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_test_generated_dir}"
+	COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.3 -Os
+	        -o "${gpu_test_ms_depth_spv}" "${gpu_test_ms_depth_source}"
+	COMMAND ${CMAKE_COMMAND} -DINPUT=${gpu_test_ms_depth_spv}
+	        -DOUTPUT=${gpu_test_ms_depth_header} -DSYMBOL=GPU_TEST_MS_DEPTH_SPV
+	        -P "${KYTY_SOURCE_DIR}/embed_spirv.cmake"
+	DEPENDS "${gpu_test_ms_depth_source}"
+	VERBATIM
+)
+target_sources(shader_recompiler_compute_tests PRIVATE
+	"${gpu_test_ms_depth_header}")
+
+add_kyty_full_emulator_test(virtual_memory_allocation_tests "${KYTY_TESTS_DIR}/VirtualMemoryAllocationTests.cpp")
+target_compile_definitions(virtual_memory_allocation_tests PRIVATE
+	KYTY_VIRTUAL_MEMORY_ALLOCATION_TESTS=1)
+
+# These tests use exceptions.
+if(NOT KYTY_CLANG_CL)
+	foreach(kyty_exception_test scalar_provenance_tests resource_tracking_tests
+			virtual_memory_allocation_tests)
+		target_compile_options(${kyty_exception_test} PRIVATE -fexceptions)
+	endforeach()
+endif()
+
+if(BUILD_TESTING)
+	add_test(NAME emulator_user_name_cli
+	         COMMAND $<TARGET_FILE:kyty_emulator> --help --user-name 1234567890123456)
+	add_test(NAME emulator_user_name_too_long
+	         COMMAND $<TARGET_FILE:kyty_emulator> --help --user-name 12345678901234567)
+	set_tests_properties(emulator_user_name_too_long PROPERTIES WILL_FAIL TRUE)
+	add_test(NAME emulator_present_mode_cli
+	         COMMAND $<TARGET_FILE:kyty_emulator> --help --present-mode Immediate)
+	add_test(NAME emulator_present_mode_invalid
+	         COMMAND $<TARGET_FILE:kyty_emulator> --help --present-mode Invalid)
+	set_tests_properties(emulator_present_mode_invalid PROPERTIES WILL_FAIL TRUE)
+	add_test(NAME ime_dialog COMMAND $<TARGET_FILE:ime_dialog_tests>)
+	add_test(NAME shader_cfg COMMAND $<TARGET_FILE:shader_cfg_tests>)
+	add_test(NAME scalar_provenance COMMAND $<TARGET_FILE:scalar_provenance_tests>)
+	add_test(NAME image_page_table COMMAND $<TARGET_FILE:image_page_table_tests>)
+	add_test(NAME memory_tracker COMMAND $<TARGET_FILE:memory_tracker_tests>)
+	add_test(NAME page_manager COMMAND $<TARGET_FILE:page_manager_tests>)
+	add_test(NAME bit_array COMMAND $<TARGET_FILE:bit_array_tests>)
+	add_test(NAME shader_vertex_metadata COMMAND $<TARGET_FILE:shader_vertex_metadata_tests>)
+	add_test(NAME resource_materialization COMMAND $<TARGET_FILE:resource_materialization_tests>)
+	add_test(NAME resource_tracking COMMAND $<TARGET_FILE:resource_tracking_tests>)
+	add_test(NAME event_queue_lifetime COMMAND $<TARGET_FILE:event_queue_lifetime_tests>)
+	add_test(NAME kernel_file_system COMMAND $<TARGET_FILE:kernel_file_system_tests>)
+	add_test(NAME sync_on_address COMMAND $<TARGET_FILE:sync_on_address_tests>)
+	add_test(NAME audio_out2_port COMMAND $<TARGET_FILE:audio_out2_port_tests>)
+	add_test(NAME shader_recompiler_compute COMMAND $<TARGET_FILE:shader_recompiler_compute_tests>)
+	add_test(NAME shader_recompiler_alignbyte
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --alignbyte-only)
+	add_test(NAME graphics_pipeline_rasterization
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --polygon-mode-only)
+	add_test(NAME graphics_draw_offsets
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --draw-offset-only)
+	add_test(NAME virtual_memory_allocation
+		COMMAND $<TARGET_FILE:virtual_memory_allocation_tests>)
+	add_test(NAME guest_red_zone_patcher
+		COMMAND $<TARGET_FILE:virtual_memory_allocation_tests> --red-zone-patcher-only)
+	add_test(NAME command_scheduler_timeline
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --scheduler-only)
+	add_test(NAME stream_buffer_ring
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --stream-buffer-only)
+	add_test(NAME gpu_command_lane
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --gpu-command-lane-only)
+	add_test(NAME pm4_context_state
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --context-state-only)
+	add_test(NAME gpu_tiler
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --gpu-tiler-only)
+
+	add_test(NAME texture_cache_layered_image
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --layered-image-only)
+	add_test(NAME host_image_allocation
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --host-image-allocation-only)
+	add_test(NAME texture_cache_image_views
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --image-view-cache-only)
+	add_test(NAME texture_cache_storage_sampled
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --storage-sampled-only)
+	add_test(NAME texture_cache_depth_readback
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --depth-readback-only)
+	add_test(NAME compute_meta_clear_classification
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --compute-meta-clear-only)
+	add_test(NAME buffer_cache_dirty_gc
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --buffer-cache-gc-only)
+
+	if(WIN32)
+		# These tests still depend on the Windows multisample-depth path.
+		add_test(NAME texture_cache_image_overlap
+			COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --image-overlap-only)
+		add_test(NAME texture_cache_htile_clear
+			COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --htile-clear-only)
+		add_test(NAME buffer_cache_ranges
+			COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --buffer-cache-range-only)
+	endif()
+
+	add_custom_target(kyty_tests DEPENDS
+		ime_dialog_tests
+		shader_cfg_tests
+		scalar_provenance_tests
+		image_page_table_tests
+		memory_tracker_tests
+		page_manager_tests
+		bit_array_tests
+		shader_vertex_metadata_tests
+		resource_materialization_tests
+		resource_tracking_tests
+		event_queue_lifetime_tests
+		kernel_file_system_tests
+		sync_on_address_tests
+		shader_recompiler_compute_tests
+		virtual_memory_allocation_tests
+		audio_out2_port_tests
+	)
+endif()
+
+# Test Darwin signal-context restoration for SSE4a instructions.
+if(APPLE AND (CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64" OR
+		(NOT CMAKE_OSX_ARCHITECTURES AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64)$")))
+	add_executable(macos_sse4a_tests EXCLUDE_FROM_ALL
+		"${KYTY_TESTS_DIR}/macosSse4aTests.cpp"
+		"${KYTY_SOURCE_DIR}/loader/x64InstructionEmulator.cpp"
+	)
+	target_link_libraries(macos_sse4a_tests common fmt::fmt Zydis::Zydis)
+	target_include_directories(macos_sse4a_tests PRIVATE ${inc_headers})
+	if(BUILD_TESTING)
+		add_test(NAME macos_sse4a COMMAND $<TARGET_FILE:macos_sse4a_tests>)
+		set_tests_properties(macos_sse4a PROPERTIES TIMEOUT 15)
+		add_dependencies(kyty_tests macos_sse4a_tests)
+	endif()
+endif()
+
+add_executable(kyty_emulator "${KYTY_SOURCE_DIR}/main.cpp" ${kyty_emulator_src})
+configure_macos_guest_address_space(kyty_emulator)
+
+target_link_libraries(kyty_emulator ${kyty_emulator_link_libraries})
+if (WIN32)
+	target_link_libraries(kyty_emulator opengl32)
+	target_link_libraries(kyty_emulator iphlpapi)
+	target_link_libraries(kyty_emulator setupapi)
+	target_link_libraries(kyty_emulator ws2_32)
+endif()
+if (KYTY_CLANG_CL)
+	target_link_libraries(kyty_emulator onecore)
+endif()
+if (CLANG AND NOT KYTY_CLANG_CL)
+	target_link_libraries(kyty_emulator pthread)
+endif()
+# dlopen/dlsym/dladdr for RenderDoc.
+target_link_libraries(kyty_emulator ${CMAKE_DL_LIBS})
+target_include_directories(kyty_emulator PRIVATE ${inc_headers})
+
+clang_tidy_check(kyty_emulator "" "${check_headers}" "${inc_headers}")
+
+include_what_you_use(kyty_emulator "${inc_headers}")
+
+set(KYTY_EMULATOR_MAP_NAME "kyty_emulator_${KYTY_COMPILER_ID}_${KYTY_LINKER_ID}.map")
+
+set(KYTY_EMULATOR_MAP_LINK_PATH "${CMAKE_CURRENT_BINARY_DIR}/${KYTY_EMULATOR_MAP_NAME}")
+set(KYTY_EMULATOR_PDB_LINK_PATH "${CMAKE_CURRENT_BINARY_DIR}/kyty_emulator.pdb")
+
+if(KYTY_CLANG_CL)
+	target_link_options(kyty_emulator PRIVATE
+		"/DYNAMICBASE:NO"
+		"/DEBUG:FULL"
+		"/PDB:${KYTY_EMULATOR_PDB_LINK_PATH}"
+		"/lldmap:${KYTY_EMULATOR_MAP_LINK_PATH}"
+	)
+	add_custom_command(TARGET kyty_emulator POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" $<TARGET_FILE_DIR:kyty_emulator>/libwinpthread-1.dll)
+elseif(WIN32 OR LINUX)
+	set_target_properties(kyty_emulator PROPERTIES LINK_FLAGS "${KYTY_LD_OPTIONS} -Wl,-Map=${KYTY_EMULATOR_MAP_LINK_PATH}")
+endif()
+
+if(APPLE)
+	# The emulator writes x86-64 trampolines/PLT stubs into memory and executes them, and
+	# runs guest code under Rosetta. That requires the JIT / unsigned-executable-memory
+	# entitlements, so re-sign the binary after every link (an unsigned/relinked binary
+	# reverts to the hardened defaults and aborts when it first executes written code).
+	add_custom_command(TARGET kyty_emulator POST_BUILD
+		COMMAND codesign -s - --force --options runtime
+			--entitlements "${KYTY_SOURCE_DIR}/macos_jit.entitlements"
+			$<TARGET_FILE:kyty_emulator>
+		COMMENT "Codesign kyty_emulator with JIT entitlements (macOS)")
+endif()
+
+install(TARGETS kyty_emulator DESTINATION .)
+if(KYTY_BUILD_LAUNCHER)
+	add_subdirectory("${KYTY_SOURCE_DIR}/launcher" "${CMAKE_CURRENT_BINARY_DIR}/launcher")
+endif()
+if(KYTY_CLANG_CL)
+	install(FILES "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" DESTINATION .)
+endif()

README.md

@@ -1,13 +1,16 @@
 # KytyPS5
 
-[![Platform](https://img.shields.io/badge/platform-Windows%20x64-0078D4.svg)](#system-requirements)
+[![Build KytyPS5 (Windows)](https://img.shields.io/github/actions/workflow/status/KytyPS5/KytyPS5/build.yml?branch=main&event=push&label=Build%20KytyPS5%20%28Windows%29)](https://github.com/KytyPS5/KytyPS5/actions/workflows/build.yml)
+[![Build KytyPS5 (Linux)](https://img.shields.io/github/actions/workflow/status/KytyPS5/KytyPS5/build.yml?branch=main&event=push&label=Build%20KytyPS5%20%28Linux%29)](https://github.com/KytyPS5/KytyPS5/actions/workflows/build.yml)
+[![Build KytyPS5 (macOS)](https://img.shields.io/github/actions/workflow/status/KytyPS5/KytyPS5/build.yml?branch=main&event=push&label=Build%20KytyPS5%20%28macOS%29)](https://github.com/KytyPS5/KytyPS5/actions/workflows/build.yml)
+[![Platform](https://img.shields.io/badge/platform-Windows%20x64%20%7C%20Linux%20x64%20%7C%20macOS%20x86__64-0078D4.svg)](#system-requirements)
 [![Status](https://img.shields.io/badge/status-early%20development-orange.svg)](#current-status)
 [![License](https://img.shields.io/badge/license-GPL--2.0-blue.svg)](LICENSE)
 
-KytyPS5 is a free and open-source PlayStation 5 emulator written in C++ for Windows. It is based on
-a heavily modified version of [Kyty](https://github.com/InoriRus/Kyty). The project is in an early
-stage of development, so compatibility is limited and behavior may change significantly between
-builds.
+KytyPS5 is a free and open-source PlayStation 5 emulator written in C++ for Windows and Linux,
+with experimental macOS support. It is based on a heavily modified version of
+[Kyty](https://github.com/InoriRus/Kyty). The project is in an early stage of development, so
+compatibility is limited and behavior may change significantly between builds.
 
 > [!IMPORTANT]
 > KytyPS5 is not affiliated with Sony Interactive Entertainment or PlayStation. The project does
@@ -21,7 +24,15 @@ KytyPS5 can boot 2D games and a selection of 3D games, including titles built wi
 
 Development is focused on compatibility and boot reliability.
 
-Linux support is planned, but Windows is the only supported platform at this time.
+Windows is the primary platform and receives the most testing. Linux builds and runs; see
+[Building on Linux](#building-on-linux).
+
+macOS support is experimental. The emulator is built for x86-64 and runs on Apple Silicon under
+Rosetta 2, with Vulkan provided by MoltenVK. A small number of titles have been verified in-game
+on Apple Silicon hardware; see [Building on macOS](#building-on-macos).
+
+Community game test results are available in the
+[KytyPS5 Compatibility List](https://kytyps5.github.io/).
 
 ## Bugs and Issues
 
@@ -43,31 +54,50 @@ graphical glitches, low compatibility, and poor performance.
   </tr>
   <tr>
     <td align="center">
-      <strong>Minecraft Legends</strong><br>
-      <img src="docs/screenshots/ps5-04.png" width="300" alt="Minecraft Legends running in KytyPS5">
+      <strong>Neptunia ReVerse</strong><br>
+      <img src="docs/screenshots/ps5-04.png" width="300" alt="Neptunia ReVerse running in KytyPS5">
     </td>
     <td align="center">
       <strong>SILENT HILL: The Short Message</strong><br>
       <img src="docs/screenshots/ps5-05.png" width="300" alt="SILENT HILL: The Short Message running in KytyPS5">
     </td>
   </tr>
+  <tr>
+    <td align="center">
+      <strong>Hellboy</strong><br>
+      <img src="docs/screenshots/ps5-02.png" width="300" alt="Hellboy running in KytyPS5">
+    </td>
+    <td align="center">
+      <strong>Paleo Pines</strong><br>
+      <img src="docs/screenshots/ps5-06.png" width="300" alt="Paleo Pines running in KytyPS5">
+    </td>
+  </tr>
 </table>
 
+<p align="center"><em>And many more...</em></p>
+
 ## Contributing
 
 Testing games and submitting detailed bug reports are useful ways to contribute. Search existing
 issues first, then use the **Game Emulation Bug Report** template and attach the complete log file.
 
-Code contributions should be focused, build successfully on Windows, and include relevant tests
-where practical. Because KytyPS5 is still evolving quickly, consider opening an issue before
+Code contributions should be focused, build successfully on the platforms they touch, and include
+relevant tests where practical. Windows is the primary target, so a change that alters shared code
+should not regress it; changes confined to a platform's own code paths only need to build there. Because KytyPS5 is still evolving quickly, consider opening an issue before
 starting a large change.
 
 ### Formatting
 
 Set up the clang-format hook after cloning:
 
-```powershell
-python -m pip install pre-commit
+Install `pre-commit` using the method appropriate for your platform:
+
+- **Arch Linux / CachyOS:** `sudo pacman -S pre-commit`
+- **Other Linux / macOS / Windows:** `python -m pip install pre-commit`
+
+Then install the Git hook:
+
+```bash
 python -m pre_commit install --install-hooks
 ```
 
@@ -94,11 +124,12 @@ the Vulkan/SPIR-V validation rules.
 
 ### System requirements
 
-- Windows 10 version 1803
-- A 64-bit x86 processor
-- A Vulkan 1.3-capable GPU with current drivers
+- Windows 10 version 1803, a current Linux distribution, or macOS on Apple Silicon
+- A 64-bit x86 processor (on macOS, an Apple Silicon processor with Rosetta 2)
+- A Vulkan 1.3-capable GPU with current drivers (on macOS, Vulkan is provided by the bundled
+  MoltenVK)
 
-### Build requirements
+### Build requirements (Windows)
 
 - Git
 - CMake 3.12 or newer
@@ -106,6 +137,7 @@ the Vulkan/SPIR-V validation rules.
 - Visual Studio 2022 or Build Tools 2022 with the **Desktop development with C++** workload and
   **C++ Clang tools for Windows** component
 - Qt 6 for MSVC 2022 64-bit, including Concurrent, Network, and Widgets
+- [glslang](https://github.com/KhronosGroup/glslang/releases) (`glslangValidator`) on `PATH`
 
 The Microsoft C++ compiler (`cl.exe`) is not supported; use `clang-cl`.
 
@@ -119,7 +151,7 @@ git submodule update --init --recursive
 Configure the project. Replace the Qt path with the version installed on your system:
 
 ```powershell
-cmake -S src -B _Build/windows -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_PREFIX_PATH="C:/Qt/6.x.x/msvc2022_64"
+cmake -S . -B _Build/windows -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_PREFIX_PATH="C:/Qt/6.x.x/msvc2022_64"
 ```
 
 Build the launcher and stage a runnable installation:
@@ -132,11 +164,128 @@ cmake --install _Build/windows --prefix _Build/windows/install
 The finished application and its runtime dependencies will be placed in
 `_Build/windows/install`.
 
+### Building on Linux
+
+Install the toolchain and the libraries the bundled SDL2 needs. Without the audio, Wayland and
+udev development packages SDL2 quietly configures itself without those backends, and the resulting
+build has no working sound and no gamepad hotplug:
+
+```bash
+sudo apt-get install --no-install-recommends \
+  clang lld ninja-build cmake git glslang-tools pkg-config \
+  libgl1-mesa-dev libx11-dev libxcursor-dev libxext-dev libxfixes-dev \
+  libxi-dev libxrandr-dev libxss-dev libxkbcommon-dev \
+  libasound2-dev libpulse-dev libudev-dev libdbus-1-dev libwayland-dev wayland-protocols
+```
+
+Qt 6 (Concurrent, Network, Widgets) is also required — either the distribution packages
+(`qt6-base-dev`) or an official Qt installation.
+
+```bash
+git submodule update --init --recursive
+
+cmake -S . -B _Build/linux -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ \
+  -DCMAKE_PREFIX_PATH="$Qt6_DIR"
+
+cmake --build _Build/linux --target launcher --parallel
+cmake --install _Build/linux --prefix _Build/linux/install
+```
+
+The install step copies the Qt libraries and plugins next to the binaries, so
+`_Build/linux/install` runs without a matching system Qt. FFmpeg is linked statically
+from the pinned [KytyPS5 FFmpeg core](https://github.com/KytyPS5/ext-ffmpeg-core)
+release, including VP9 and WebM support. System FFmpeg packages are not required.
+
+As on Windows, the MSVC compiler is not used; Clang is required. `cl.exe` is rejected at configure
+time.
+
+The CMake source root is the repository root.
+
+### Building on NixOS
+
+A development shell provides Clang, CMake, Ninja, Qt 6, the Vulkan headers, and the SDL2 backend
+libraries. Enter it and configure exactly as on other Linux distributions; the shell exports
+`CMAKE_PREFIX_PATH` and `QT_PLUGIN_PATH`, so the `-DCMAKE_PREFIX_PATH="$Qt6_DIR"` argument is not
+needed:
+
+```bash
+nix-shell # or: nix develop
+git submodule update --init --recursive
+
+cmake -S . -B _Build/linux -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
+
+cmake --build _Build/linux --target launcher --parallel
+cmake --install _Build/linux --prefix _Build/linux/install
+```
+
+The configure step downloads the FFmpeg prebuilts and the `xbyak`/`zydis` sources, so it needs
+network access; a fully sandboxed `nix build` would require vendoring those inputs. A Vulkan 1.3
+driver must be available at runtime (on NixOS, `hardware.graphics.enable = true`).
+
+### Building on macOS
+
+macOS builds target x86-64 and run under Rosetta 2 on Apple Silicon, so the PS5's x86-64 game
+code executes through the same translation layer as the emulator itself. Prebuilt archives are
+attached to releases; the steps below are for building from source.
+
+Requirements:
+
+- An Apple Silicon Mac with Rosetta 2 installed (`softwareupdate --install-rosetta`)
+- Xcode (or the Command Line Tools)
+- Homebrew packages: `brew install cmake ninja glslang`
+- Qt 6 (Concurrent, Network, Widgets) with x86-64 support. The official Qt installation is
+  universal and works; Homebrew's Qt is arm64-only and will not link
+
+```bash
+git submodule update --init --recursive
+
+cmake -S . -B _Build/macos -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_OSX_ARCHITECTURES=x86_64 \
+  -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ \
+  -DCMAKE_PREFIX_PATH="$Qt6_DIR"
+
+cmake --build _Build/macos --target launcher --parallel
+cmake --install _Build/macos --prefix _Build/macos/install
+```
+
+The build re-signs `kyty_emulator` with the JIT entitlements it needs to execute translated
+guest code; no manual signing step is required. When the launcher is built, the install
+also produces `_Build/macos/install/KytyPS5.app` — double-click to launch the GUI.
+A flat `kyty_emulator` is kept for CLI usage.
+
+Vulkan comes from MoltenVK. Download `MoltenVK-macos.tar` from the
+[MoltenVK releases](https://github.com/KhronosGroup/MoltenVK/releases), then copy
+`MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib` next to the flat `kyty_emulator`
+(and, for the bundle, into `KytyPS5.app/Contents/Frameworks/`) and ad-hoc sign it:
+
+```bash
+codesign --force --sign - _Build/macos/install/libMoltenVK.dylib
+# For the bundle (if present):
+codesign --force --sign - _Build/macos/install/KytyPS5.app/Contents/Frameworks/libMoltenVK.dylib
+codesign --force --sign - _Build/macos/install/KytyPS5.app
+```
+
+Release archives already include a signed `libMoltenVK.dylib` (both flat and inside the bundle).
+
+### Regression tests
+
+Build every regression executable and run the registered tests with:
+
+```powershell
+cmake --build _Build/windows --target kyty_tests
+ctest --test-dir _Build/windows --output-on-failure
+```
+
+Use `_Build/linux` instead of `_Build/windows` for a Linux build.
+
 ### Visual Studio Code
 
 A ready-made Visual Studio Code setup is included in [`.vscode`](.vscode). It configures CMake
 Tools to build the project with Ninja and `clang-cl` and provides launch profiles for both
-`launcher.exe` and `kyty_emulator.exe`.
+`launcher.exe` and `kyty_emulator.exe`. It is Windows-only: VS Code settings cannot select a
+compiler per platform, so on Linux configure from the command line as shown above.
 
 Before using it:
 
@@ -158,6 +307,14 @@ To use the graphical launcher:
 .\_Build\windows\install\launcher.exe
 ```
 
+```bash
+./_Build/linux/install/launcher
+```
+
+```bash
+open _Build/macos/install/KytyPS5.app  # or double-click in Finder
+```
+
 On first launch, add one or more game folders in the global settings. The launcher searches those
 folders recursively for game directories containing `eboot.bin`. Select a detected game and run it
 from the game list.
@@ -168,7 +325,24 @@ The emulator can also be started directly with a legally obtained game directory
 .\_Build\windows\install\kyty_emulator.exe --game "D:\Games\ExampleGame"
 ```
 
-Run `kyty_emulator.exe --help` to see the available graphics, logging, validation, profiling, and
+```bash
+./_Build/linux/install/kyty_emulator --game "/games/ExampleGame"
+```
+
+On macOS, the adjacent flat or app-bundled `libMoltenVK.dylib` is found automatically; no
+environment variable is required:
+
+```bash
+./_Build/macos/install/kyty_emulator --game "/games/ExampleGame"
+```
+
+To override the Vulkan loader, set `SDL_VULKAN_LIBRARY`:
+
+```bash
+SDL_VULKAN_LIBRARY=/path/to/libMoltenVK.dylib ./kyty_emulator --game "/games/ExampleGame"
+```
+
+Run `kyty_emulator --help` to see the available graphics, logging, validation, profiling, and
 debugging options.
 
 ### AI Use

flake.lock

@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1789426278,
+        "narHash": "sha256-GnotcvKtbTMnoVx6G4E7ZdUX6487Dky74dqq3pU7iRk=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "efe6f071ede9d21c37462d2d6682d5e670099684",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,20 @@
+{
+  description = "KytyPS5 development shell";
+
+  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+
+  outputs = { self, nixpkgs }:
+    let
+      systems = [ "x86_64-linux" ];
+      forAllSystems = nixpkgs.lib.genAttrs systems;
+    in
+    {
+      devShells = forAllSystems (system:
+        let
+          pkgs = import nixpkgs { inherit system; };
+        in
+        {
+          default = import ./nix/devshell.nix { inherit pkgs; };
+        });
+    };
+}

nix/devshell.nix

@@ -0,0 +1,84 @@
+{ pkgs }:
+
+let
+  # Build-time dependencies. Every -dev package the bundled SDL2 probes for must
+  # be listed here, otherwise SDL2 quietly drops the audio/Wayland/udev backends.
+  buildDeps = with pkgs; [
+    qt6.qtbase # Concurrent, Network, Widgets (launcher)
+    vulkan-headers
+    vulkan-loader
+    vulkan-tools
+    vulkan-validation-layers
+    libglvnd
+    # X11 / input
+    libX11
+    libXcursor
+    libXext
+    libXfixes
+    libXi
+    libXrandr
+    libXScrnSaver
+    libxkbcommon
+    # Wayland
+    wayland
+    wayland-protocols
+    libdecor
+    # audio + device/dbus
+    alsa-lib
+    libpulseaudio
+    systemd # libudev
+    dbus
+  ];
+
+  # Libraries the built binaries need at runtime.
+  runtimeLibs = with pkgs; [
+    stdenv.cc.cc.lib # libstdc++ / libgcc_s
+    libgcc.lib
+    qt6.qtbase # libQt6Concurrent/Network/Widgets
+    vulkan-loader
+    libglvnd
+    alsa-lib
+    libpulseaudio
+    libX11
+    libXcursor
+    libXext
+    libXfixes
+    libXi
+    libXrandr
+    libXScrnSaver
+    libxkbcommon
+    wayland
+    libdecor
+    systemd
+    dbus
+  ];
+in
+pkgs.mkShell {
+  name = "kytyps5";
+
+  nativeBuildInputs = with pkgs; [
+    clang
+    lld
+    cmake
+    ninja
+    pkg-config
+    git
+    glslang # provides glslangValidator for the bundled shaders
+  ];
+
+  buildInputs = buildDeps;
+
+  shellHook = ''
+    export CMAKE_PREFIX_PATH="${pkgs.qt6.qtbase}:''${CMAKE_PREFIX_PATH:-}"
+    export QT_PLUGIN_PATH="${pkgs.qt6.qtbase}/lib/qt-6/plugins:${pkgs.qt6.qtbase}/lib/qt6/plugins:''${QT_PLUGIN_PATH:-}"
+    export LD_LIBRARY_PATH="${pkgs.lib.makeLibraryPath runtimeLibs}:''${LD_LIBRARY_PATH:-}"
+
+    if [ -z "''${KYTY_SHELL_QUIET:-}" ]; then
+      echo "KytyPS5 dev shell"
+      echo "  cmake -S . -B _Build/linux -G Ninja -DCMAKE_BUILD_TYPE=Release \\"
+      echo "    -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++"
+      echo "  cmake --build _Build/linux --target launcher --parallel"
+      echo "  cmake --install _Build/linux --prefix _Build/linux/install"
+    fi
+  '';
+}

shell.nix

@@ -0,0 +1,4 @@
+let
+  pkgs = import <nixpkgs> { };
+in
+import ./nix/devshell.nix { inherit pkgs; }

src/CMakeLists.txt

@@ -1,374 +0,0 @@
-cmake_minimum_required(VERSION 3.12...4.3)
-
-if(CMAKE_VERSION VERSION_GREATER_EQUAL 4.0)
-	set(CMAKE_POLICY_VERSION_MINIMUM 3.5 CACHE STRING "Minimum policy version for bundled dependencies")
-endif()
-
-project(Kyty)
-
-if(CMAKE_SYSTEM_NAME MATCHES ".*Linux")
-	set(LINUX TRUE)
-endif()
-
-if (NOT (WIN32 OR LINUX))
-    message(FATAL_ERROR "only Windows and Linux builds are supported")
-endif()
-
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
-
-include(utils.cmake)
-
-set(KYTY_THIRD_PARTY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../3rdparty")
-
-set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
-
-include(TestBigEndian)
-
-if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
-	message(FATAL_ERROR "only 64-bit builds are supported")
-endif()
-
-test_big_endian(BIG_ENDIAN)
-if(BIG_ENDIAN)
-	set(KYTY_ENDIAN KYTY_ENDIAN_BIG)
-else()
-	set(KYTY_ENDIAN KYTY_ENDIAN_LITTLE)
-endif()
-
-if(CMAKE_BUILD_TYPE MATCHES Debug)
-	set(KYTY_BUILD KYTY_BUILD_DEBUG)
-else()
-	set(KYTY_BUILD KYTY_BUILD_RELEASE)
-endif()
-
-if(LINUX)
-	set(KYTY_PLATFORM KYTY_PLATFORM_LINUX)	
-else()
-	set(KYTY_PLATFORM KYTY_PLATFORM_WINDOWS)
-endif()
-
-set(CLANG FALSE)
-set(GCC FALSE)
-set(KYTY_CLANG_CL FALSE)
-get_filename_component(KYTY_CXX_COMPILER_NAME "${CMAKE_CXX_COMPILER}" NAME_WE)
-string(TOLOWER "${KYTY_CXX_COMPILER_NAME}" KYTY_CXX_COMPILER_NAME)
-
-if(CMAKE_CXX_COMPILER_ID MATCHES "^(Apple)?Clang$")
-	set(CLANG TRUE)
-	set(KYTY_COMPILER CLANG)
-	if(WIN32 AND KYTY_CXX_COMPILER_NAME STREQUAL "clang-cl")
-		set(KYTY_CLANG_CL TRUE)
-		set(KYTY_LINKER LLD_LINK)
-	else()
-		set(KYTY_LINKER LLD)
-	endif()
-	if ((CMAKE_AR MATCHES "llvm") AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0.0) AND (CMAKE_CXX_COMPILER MATCHES "winlibs"))
-		string(REPLACE "llvm-ar.exe" "ar.exe" CMAKE_AR ${CMAKE_AR}) # llvm-ar.exe 11.0.0 from winlibs is broken
-	endif()
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-	set(GCC TRUE)
-	set(KYTY_COMPILER GCC)
-	set(KYTY_LINKER LD)
-else()
-	message(FATAL_ERROR "only Clang and GCC are supported; found ${CMAKE_CXX_COMPILER_ID}")
-endif()
-
-set(KYTY_PROJECT_NAME "Emulator" CACHE STRING "Project name suffix")
-
-string(TOLOWER ${KYTY_COMPILER} KYTY_COMPILER_ID)
-string(TOLOWER ${KYTY_LINKER} KYTY_LINKER_ID)
-
-if (CLANG AND (KYTY_LINKER STREQUAL LLD))
-	set(KYTY_LD_OPTIONS "-fuse-ld=lld")
-endif()
-
-if (KYTY_LINKER STREQUAL LD AND NOT LINUX)
-	set(KYTY_LD_OPTIONS "-Wl,--image-base=0x100000000000")
-endif()
-
-project(Kyty${KYTY_PROJECT_NAME}${CMAKE_BUILD_TYPE}${KYTY_COMPILER} VERSION 0.2.2)
-
-include_directories(	
-	${KYTY_THIRD_PARTY_DIR}/gtest/include
-	${KYTY_THIRD_PARTY_DIR}/gtest
-	${KYTY_THIRD_PARTY_DIR}/fmt/include
-	${KYTY_THIRD_PARTY_DIR}/magic_enum/include/magic_enum
-	${PROJECT_BINARY_DIR}
-	${CMAKE_CURRENT_SOURCE_DIR}
-)
-
-set(KYTY_VERSION "${PROJECT_VERSION}")
-
-configure_file(
-  ${PROJECT_SOURCE_DIR}/cmake_config.h.in
-  ${PROJECT_BINARY_DIR}/cmake_config.h
-  )
-
-find_package(Git)
-  
-add_custom_target( KytyGitVersion
-    COMMAND ${CMAKE_COMMAND} 
-	-D INPUT_FILE=${CMAKE_CURRENT_SOURCE_DIR}/kytyGitVersion.h.in
-    -D OUTPUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/kytyGitVersion.h
-	-D GIT_EXECUTABLE=${GIT_EXECUTABLE}
-	-P ${CMAKE_CURRENT_SOURCE_DIR}/generate_version.cmake
-	COMMENT "Generate kytyGitVersion.h"
-)
-
-if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0.0)
-	list(APPEND KYTY_IWYU 
-		kyty_emulator
-		common
-		#launcher
-	)
-	list(APPEND KYTY_CLANG_TYDY 
-		kyty_emulator
-		#common
-		launcher
-	)
-endif()
-
-option(KYTY_BUILD_LAUNCHER "Build Qt launcher" ON)
-  
-config_compiler_and_linker()  
-  
-add_subdirectory("${KYTY_THIRD_PARTY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/3rdparty")
-add_subdirectory(common)
-
-file(GLOB kyty_emulator_src CONFIGURE_DEPENDS
-	libs/*.cpp
-	libs/*.h
-	graphics/*.cpp
-	graphics/*.h
-	graphics/guest_gpu/*.cpp
-	graphics/guest_gpu/*.h
-	graphics/guest_gpu/command_processor/*.cpp
-	graphics/guest_gpu/command_processor/*.h
-	graphics/host_gpu/*.cpp
-	graphics/host_gpu/*.h
-	graphics/host_gpu/renderer/*.cpp
-	graphics/host_gpu/renderer/*.h
-	graphics/shader/*.cpp
-	graphics/shader/*.h
-	graphics/shader/recompiler/*.cpp
-	graphics/shader/recompiler/*.h
-	graphics/shader/recompiler/shaderIR/*.cpp
-	graphics/shader/recompiler/shaderIR/*.h
-	graphics/shader/recompiler/spirvEmitter/*.cpp
-	graphics/shader/recompiler/spirvEmitter/*.h
-	graphics/host_gpu/objects/*.cpp
-	graphics/host_gpu/objects/*.h
-	graphics/presentation/*.cpp
-	graphics/presentation/*.h
-	graphics/presentation/window/*.cpp
-	graphics/presentation/window/*.h
-	kernel/*.cpp
-	kernel/*.h
-	loader/*.cpp
-	loader/*.h
-)
-
-find_program(KYTY_GLSLANG_VALIDATOR glslangValidator REQUIRED)
-set(gpu_tiler_shader_dir "${CMAKE_CURRENT_SOURCE_DIR}/graphics/host_gpu/shaders")
-set(gpu_tiler_generated_dir "${PROJECT_BINARY_DIR}/gpu_tiler_shaders")
-set(gpu_tiler_shader_names
-	standard256
-	standard4
-	standard4_3d
-	standard64
-	standard64_3d
-	prt
-	prt_3d
-	render_target
-	depth
-)
-file(GLOB gpu_tiler_shader_includes CONFIGURE_DEPENDS "${gpu_tiler_shader_dir}/gpu_tiler_*.inc")
-foreach(shader_name IN LISTS gpu_tiler_shader_names)
-	set(shader_source "${gpu_tiler_shader_dir}/gpu_tiler_${shader_name}.comp")
-	set(shader_spv "${gpu_tiler_generated_dir}/gpu_tiler_${shader_name}.spv")
-	set(shader_header "${gpu_tiler_generated_dir}/gpu_tiler_${shader_name}_spv.h")
-	string(TOUPPER "GPU_TILER_${shader_name}_SPV" shader_symbol)
-	add_custom_command(
-		OUTPUT "${shader_header}"
-		COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_tiler_generated_dir}"
-		COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.0 -Os
-		        "-I${gpu_tiler_shader_dir}" -o "${shader_spv}" "${shader_source}"
-		COMMAND ${CMAKE_COMMAND} -DINPUT=${shader_spv} -DOUTPUT=${shader_header}
-		        -DSYMBOL=${shader_symbol} -P "${CMAKE_CURRENT_SOURCE_DIR}/embed_spirv.cmake"
-		DEPENDS "${shader_source}" ${gpu_tiler_shader_includes}
-		VERBATIM
-	)
-	list(APPEND gpu_tiler_shader_headers "${shader_header}")
-endforeach()
-list(APPEND kyty_emulator_src ${gpu_tiler_shader_headers})
-
-list(APPEND kyty_emulator_src
-	emulator.h
-	emulator.cpp
-)
-list(REMOVE_DUPLICATES kyty_emulator_src)
-
-if (KYTY_CLANG_CL)
-	set_source_files_properties(${kyty_emulator_src} PROPERTIES COMPILE_FLAGS "-Wno-pragma-pack -Wno-deprecated-declarations -D_TIMESPEC_DEFINED")
-endif()
-
-set(kyty_emulator_link_libraries common Vulkan::Headers spirv-tools-opt spirv-tools SDL2-static xxhash FFmpeg::ffmpeg fmt::fmt nlohmann_json::nlohmann_json LibAtrac9)
-
-set(inc_headers
-	${CMAKE_CURRENT_SOURCE_DIR}
-	${KYTY_THIRD_PARTY_DIR}/SDL2/include
-	${KYTY_THIRD_PARTY_DIR}/VulkanMemoryAllocator/include
-	${KYTY_THIRD_PARTY_DIR}/SPIRV-Tools/include
-	${KYTY_THIRD_PARTY_DIR}/fmt/include
-	${KYTY_THIRD_PARTY_DIR}/xxhash
-	${KYTY_THIRD_PARTY_DIR}/cpuinfo/include
-	${KYTY_THIRD_PARTY_DIR}/stb
-)
-
-if (KYTY_CLANG_CL)
-	list(APPEND kyty_emulator_link_libraries winpthread)
-	list(APPEND inc_headers 
-		${KYTY_THIRD_PARTY_DIR}/winpthread/include
-	)
-endif()
-
-list(APPEND check_headers
-	${CMAKE_CURRENT_SOURCE_DIR}
-)
-
-function(add_kyty_full_emulator_test target source)
-	add_executable(${target} EXCLUDE_FROM_ALL ${source} ${kyty_emulator_src})
-	target_link_libraries(${target} ${kyty_emulator_link_libraries})
-	target_include_directories(${target} PRIVATE ${inc_headers})
-	if (WIN32)
-		target_link_libraries(${target} iphlpapi)
-	endif()
-	if (KYTY_CLANG_CL)
-		target_link_libraries(${target} onecore)
-		add_custom_command(TARGET ${target} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" $<TARGET_FILE_DIR:${target}>/libwinpthread-1.dll)
-	endif()
-endfunction()
-
-add_kyty_full_emulator_test(shader_cfg_tests ../tests/shaderCfgTests.cpp)
-
-add_executable(scalar_provenance_tests EXCLUDE_FROM_ALL
-	../tests/ScalarProvenanceTests.cpp
-	graphics/host_gpu/hostMemory.cpp
-	graphics/shader/recompiler/ScalarProvenance.cpp
-	graphics/shader/recompiler/SrtWalker.cpp
-)
-target_link_libraries(scalar_provenance_tests fmt::fmt)
-target_include_directories(scalar_provenance_tests PRIVATE ${inc_headers})
-
-add_executable(page_manager_tests EXCLUDE_FROM_ALL
-	../tests/PageManagerTests.cpp
-	graphics/host_gpu/pageManager.cpp
-)
-target_include_directories(page_manager_tests PRIVATE ${inc_headers})
-
-add_executable(memory_tracker_tests EXCLUDE_FROM_ALL
-	../tests/MemoryTrackerTests.cpp
-	graphics/host_gpu/pageManager.cpp
-	graphics/host_gpu/memoryTracker.cpp
-)
-target_link_libraries(memory_tracker_tests fmt::fmt common)
-target_include_directories(memory_tracker_tests PRIVATE ${inc_headers})
-target_compile_definitions(memory_tracker_tests PRIVATE KYTY_MEMORY_TRACKER_TESTS=1)
-
-add_executable(shader_vertex_metadata_tests EXCLUDE_FROM_ALL
-	../tests/ShaderVertexMetadataTests.cpp
-	graphics/host_gpu/hostMemory.cpp
-	graphics/shader/shaderVertexMetadata.cpp
-)
-target_include_directories(shader_vertex_metadata_tests PRIVATE ${inc_headers})
-
-add_executable(shader_stage_runtime_tests EXCLUDE_FROM_ALL
-	../tests/ShaderStageRuntimeTests.cpp
-	graphics/guest_gpu/gpu_format.cpp
-	graphics/host_gpu/hostMemory.cpp
-	graphics/shader/shaderStageRuntime.cpp
-	graphics/shader/recompiler/ResourceMaterialization.cpp
-	graphics/shader/recompiler/ScalarProvenance.cpp
-	graphics/shader/recompiler/SrtWalker.cpp
-)
-target_link_libraries(shader_stage_runtime_tests fmt::fmt)
-target_include_directories(shader_stage_runtime_tests PRIVATE ${inc_headers})
-
-add_executable(resource_tracking_tests EXCLUDE_FROM_ALL
-	../tests/ResourceTrackingTests.cpp
-	graphics/guest_gpu/gpu_format.cpp
-	graphics/host_gpu/hostMemory.cpp
-	graphics/shader/recompiler/ScalarProvenance.cpp
-	graphics/shader/recompiler/SrtWalker.cpp
-	graphics/shader/recompiler/SrtPatcher.cpp
-	graphics/shader/recompiler/ResourceTracking.cpp
-	graphics/shader/recompiler/ResourceMaterialization.cpp
-	graphics/shader/recompiler/ShaderInfoCollection.cpp
-	graphics/shader/recompiler/BindingLayout.cpp
-)
-target_link_libraries(resource_tracking_tests fmt::fmt)
-target_include_directories(resource_tracking_tests PRIVATE ${inc_headers})
-
-add_executable(resource_mutex_tests EXCLUDE_FROM_ALL
-	../tests/ResourceMutexTests.cpp
-	graphics/host_gpu/renderer/resourceMutex.cpp
-)
-target_link_libraries(resource_mutex_tests common)
-target_include_directories(resource_mutex_tests PRIVATE ${inc_headers})
-
-add_executable(image_page_table_tests EXCLUDE_FROM_ALL
-	../tests/ImagePageTableTests.cpp
-)
-target_include_directories(image_page_table_tests PRIVATE ${inc_headers})
-
-add_kyty_full_emulator_test(shader_recompiler_compute_tests ../tests/ShaderRecompilerComputeTests.cpp)
-
-add_kyty_full_emulator_test(virtual_memory_allocation_tests ../tests/VirtualMemoryAllocationTests.cpp)
-target_compile_definitions(virtual_memory_allocation_tests PRIVATE
-	KYTY_VIRTUAL_MEMORY_ALLOCATION_TESTS=1)
-
-
-add_executable(kyty_emulator main.cpp ${kyty_emulator_src})
-
-target_link_libraries(kyty_emulator ${kyty_emulator_link_libraries})
-if (WIN32)
-	target_link_libraries(kyty_emulator opengl32)
-	target_link_libraries(kyty_emulator iphlpapi)
-	target_link_libraries(kyty_emulator setupapi)
-	target_link_libraries(kyty_emulator ws2_32)
-endif()
-if (KYTY_CLANG_CL)
-	target_link_libraries(kyty_emulator onecore)
-endif()
-if (CLANG AND NOT KYTY_CLANG_CL)
-	target_link_libraries(kyty_emulator pthread)
-endif()
-target_include_directories(kyty_emulator PRIVATE ${inc_headers})
-
-clang_tidy_check(kyty_emulator "" "${check_headers}" "${inc_headers}")
-
-include_what_you_use(kyty_emulator "${inc_headers}")
-
-set(KYTY_EMULATOR_MAP_NAME "kyty_emulator_${KYTY_COMPILER_ID}_${KYTY_LINKER_ID}.map")
-
-set(KYTY_EMULATOR_MAP_LINK_PATH "${CMAKE_CURRENT_BINARY_DIR}/${KYTY_EMULATOR_MAP_NAME}")
-set(KYTY_EMULATOR_PDB_LINK_PATH "${CMAKE_CURRENT_BINARY_DIR}/kyty_emulator.pdb")
-
-if(KYTY_CLANG_CL)
-	set_target_properties(kyty_emulator PROPERTIES LINK_FLAGS "/DYNAMICBASE:NO /DEBUG:FULL /PDB:${KYTY_EMULATOR_PDB_LINK_PATH} /lldmap:${KYTY_EMULATOR_MAP_LINK_PATH}")
-	add_custom_command(TARGET kyty_emulator POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" $<TARGET_FILE_DIR:kyty_emulator>/libwinpthread-1.dll)
-elseif(WIN32 OR LINUX)
-	set_target_properties(kyty_emulator PROPERTIES LINK_FLAGS "${KYTY_LD_OPTIONS} -Wl,-Map=${KYTY_EMULATOR_MAP_LINK_PATH}")
-endif()
-
-add_dependencies(kyty_emulator KytyGitVersion)
-
-install(TARGETS kyty_emulator DESTINATION .)
-if(KYTY_BUILD_LAUNCHER)
-	add_subdirectory(launcher)
-endif()
-if(KYTY_CLANG_CL)
-	install(FILES "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" DESTINATION .)
-endif()

src/cmake_config.h.in

@@ -1,4 +1,8 @@
 #define KYTY_VERSION "@KYTY_VERSION@"
+#define KYTY_BUILD_REPOSITORY "@KYTY_BUILD_REPOSITORY@"
+#define KYTY_RELEASE_TAG "@KYTY_RELEASE_TAG@"
+#cmakedefine KYTY_OFFICIAL_BUILD
+#cmakedefine KYTY_FORK_BUILD
 #define KYTY_ENDIAN @KYTY_ENDIAN@
 #define KYTY_PLATFORM @KYTY_PLATFORM@
 #define KYTY_COMPILER KYTY_COMPILER_@KYTY_COMPILER@

src/common/CMakeLists.txt

@@ -13,7 +13,7 @@ endif()
 add_library(common STATIC ${common_src} ${common_headers})
 
 target_include_directories(common
-	PUBLIC ${PROJECT_SOURCE_DIR}
+	PUBLIC ${KYTY_SOURCE_DIR}
 	PRIVATE
 		${KYTY_THIRD_PARTY_DIR}/cpuinfo/include
 )
@@ -24,6 +24,7 @@ target_link_libraries(common
 		Tracy::TracyClient
 	PRIVATE
 		cpuinfo
+		kyty_git_version
 		spdlog::spdlog
 )
 

src/common/alignment.h

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: 2014 Jannik Vogel <email@jannikvogel.de>
+// SPDX-License-Identifier: CC0-1.0
+
+#pragma once
+
+#include <cstddef>
+#include <type_traits>
+
+namespace Common {
+
+template <typename T>
+[[nodiscard]] constexpr T AlignUp(T value, std::size_t size) {
+	static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
+	auto mod{static_cast<T>(value % size)};
+	value -= mod;
+	return static_cast<T>(mod == T{0} ? value : value + size);
+}
+
+template <typename T>
+[[nodiscard]] constexpr T AlignDown(T value, std::size_t size) {
+	static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
+	return static_cast<T>(value - value % size);
+}
+
+} // namespace Common

src/common/assert.cpp

@@ -1,8 +1,8 @@
 #include "common/assert.h"
 
-#include "common/debug.h"
 #include "common/logging/log.h"
 #include "common/subsystems.h"
+#include "kytyGitVersion.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -11,30 +11,15 @@
 
 namespace Common {
 
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS && KYTY_BUILD == KYTY_BUILD_DEBUG &&                    \
-    KYTY_COMPILER == KYTY_COMPILER_CLANG
-constexpr int PRINT_STACK_FROM = 4;
-#else
-constexpr int PRINT_STACK_FROM = 2;
-#endif
-
 static std::string BuildFatalReport(const char* title, std::string_view text, const char* file,
                                     int line) {
-	DebugStack stack;
-	DebugStack::Trace(&stack);
-
-	std::string report = "--- Stack Trace ---\n";
-	for (int i = PRINT_STACK_FROM; i < stack.depth; i++) {
-		report += fmt::format("[{}] {:016x}\n", i - PRINT_STACK_FROM,
-		                      static_cast<uint64_t>(stack.GetAddr(i)));
-	}
-	report += fmt::format("{}\n{} in {}:{}\n", title, text, file, line);
-	return report;
+	return fmt::format("--- Build ---\n{}\n{}\n{} in {}:{}\n", KYTY_BUILD_LABEL, title, text, file,
+	                   line);
 }
 
 static int DbgReport(const char* title, std::string_view text, const char* file, int line) {
 	Log::WriteFatal(BuildFatalReport(title, text, file, line));
-	SubsystemsListSingleton::Instance()->ShutdownAll();
+	Subsystems::EmergencyShutdownActive();
 	return 1;
 }
 
@@ -58,6 +43,7 @@ int DbgExitHandler(const char* file, int line, fmt::text_style style, std::strin
 }
 
 void DbgExit(int status) {
+	Subsystems::EmergencyShutdownActive();
 	std::fflush(nullptr);
 	std::_Exit(status);
 }

src/common/assert.h

@@ -29,11 +29,7 @@ void DbgExit(int status);
 
 } // namespace Common
 
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS || KYTY_PLATFORM == KYTY_PLATFORM_LINUX
 #define EXIT_HALT() (Common::DbgExit(321), 1)
-#else
-#define EXIT_HALT() (std::_Exit(321), 1)
-#endif
 
 #ifndef KYTY_FINAL
 #define EXIT_IF(x)                                                                                 \

src/common/bitArray.h

@@ -0,0 +1,260 @@
+#ifndef EMULATOR_SRC_COMMON_BITARRAY_H_
+#define EMULATOR_SRC_COMMON_BITARRAY_H_
+
+#include <array>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <utility>
+
+namespace Common {
+
+template <size_t N>
+class BitArray final {
+	static_assert(N != 0, "BitArray size must be nonzero");
+	static_assert(N % 64 == 0, "BitArray size must be a multiple of 64 bits");
+
+	static constexpr size_t BITS_PER_WORD = 64;
+	static constexpr size_t WORD_COUNT    = N / BITS_PER_WORD;
+
+public:
+	using Range = std::pair<size_t, size_t>;
+
+	class Iterator final {
+	public:
+		using iterator_category = std::forward_iterator_tag;
+		using value_type        = Range;
+		using difference_type   = std::ptrdiff_t;
+		using pointer           = const Range*;
+		using reference         = const Range&;
+
+		Iterator(const BitArray& bits, size_t start)
+		    : m_bits(bits), m_range(bits.FirstRangeFrom(start)) {}
+
+		Iterator& operator++() {
+			m_range = m_bits.FirstRangeFrom(m_range.second);
+			return *this;
+		}
+
+		[[nodiscard]] bool operator==(const Iterator& other) const {
+			return &m_bits == &other.m_bits && m_range == other.m_range;
+		}
+
+		[[nodiscard]] bool operator!=(const Iterator& other) const { return !(*this == other); }
+
+		[[nodiscard]] reference operator*() const { return m_range; }
+		[[nodiscard]] pointer   operator->() const { return &m_range; }
+
+	private:
+		const BitArray& m_bits;
+		Range           m_range;
+	};
+
+	using const_iterator = Iterator;
+
+	constexpr BitArray() = default;
+
+	constexpr BitArray(const BitArray& other, size_t start, size_t end) {
+		if (start >= end || end > N) {
+			return;
+		}
+
+		const auto first_word = start / BITS_PER_WORD;
+		const auto last_word  = (end - 1) / BITS_PER_WORD;
+		const auto start_bit  = start % BITS_PER_WORD;
+		const auto end_bit    = (end - 1) % BITS_PER_WORD;
+		const auto start_mask = ~uint64_t {0} << start_bit;
+		const auto end_mask =
+		    end_bit == BITS_PER_WORD - 1 ? ~uint64_t {0} : (uint64_t {1} << (end_bit + 1)) - 1;
+
+		if (first_word == last_word) {
+			m_data[first_word] = other.m_data[first_word] & start_mask & end_mask;
+			return;
+		}
+
+		m_data[first_word] = other.m_data[first_word] & start_mask;
+		for (auto word = first_word + 1; word < last_word; word++) {
+			m_data[word] = other.m_data[word];
+		}
+		m_data[last_word] = other.m_data[last_word] & end_mask;
+	}
+
+	[[nodiscard]] constexpr bool Get(size_t index) const {
+		return (m_data[index / BITS_PER_WORD] & (uint64_t {1} << (index % BITS_PER_WORD))) != 0;
+	}
+
+	constexpr void Set(size_t index) {
+		m_data[index / BITS_PER_WORD] |= uint64_t {1} << (index % BITS_PER_WORD);
+	}
+
+	constexpr void Unset(size_t index) {
+		m_data[index / BITS_PER_WORD] &= ~(uint64_t {1} << (index % BITS_PER_WORD));
+	}
+
+	constexpr void SetRange(size_t start, size_t end) {
+		if (start >= end || end > N) {
+			return;
+		}
+
+		const auto first_word = start / BITS_PER_WORD;
+		const auto last_word  = (end - 1) / BITS_PER_WORD;
+		const auto start_bit  = start % BITS_PER_WORD;
+		const auto end_bit    = (end - 1) % BITS_PER_WORD;
+		const auto start_mask = ~uint64_t {0} << start_bit;
+		const auto end_mask =
+		    end_bit == BITS_PER_WORD - 1 ? ~uint64_t {0} : (uint64_t {1} << (end_bit + 1)) - 1;
+
+		if (first_word == last_word) {
+			m_data[first_word] |= start_mask & end_mask;
+			return;
+		}
+
+		m_data[first_word] |= start_mask;
+		for (auto word = first_word + 1; word < last_word; word++) {
+			m_data[word] = ~uint64_t {0};
+		}
+		m_data[last_word] |= end_mask;
+	}
+
+	constexpr void UnsetRange(size_t start, size_t end) {
+		if (start >= end || end > N) {
+			return;
+		}
+
+		const auto first_word = start / BITS_PER_WORD;
+		const auto last_word  = (end - 1) / BITS_PER_WORD;
+		const auto start_bit  = start % BITS_PER_WORD;
+		const auto end_bit    = (end - 1) % BITS_PER_WORD;
+		const auto start_mask = (uint64_t {1} << start_bit) - 1;
+		const auto end_mask =
+		    end_bit == BITS_PER_WORD - 1 ? uint64_t {0} : ~((uint64_t {1} << (end_bit + 1)) - 1);
+
+		if (first_word == last_word) {
+			m_data[first_word] &= start_mask | end_mask;
+			return;
+		}
+
+		m_data[first_word] &= start_mask;
+		for (auto word = first_word + 1; word < last_word; word++) {
+			m_data[word] = 0;
+		}
+		m_data[last_word] &= end_mask;
+	}
+
+	constexpr void Clear() { m_data.fill(0); }
+	constexpr void Fill() { m_data.fill(~uint64_t {0}); }
+
+	[[nodiscard]] constexpr bool None() const {
+		uint64_t combined = 0;
+		for (const auto word: m_data) {
+			combined |= word;
+		}
+		return combined == 0;
+	}
+
+	[[nodiscard]] constexpr bool Any() const { return !None(); }
+
+	[[nodiscard]] constexpr Range FirstRangeFrom(size_t start) const {
+		if (start >= N) {
+			return {N, N};
+		}
+
+		auto word_index = start / BITS_PER_WORD;
+		auto word       = m_data[word_index] & (~uint64_t {0} << (start % BITS_PER_WORD));
+		while (word == 0) {
+			word_index++;
+			if (word_index == WORD_COUNT) {
+				return {N, N};
+			}
+			word = m_data[word_index];
+		}
+
+		const auto first     = word_index * BITS_PER_WORD + std::countr_zero(word);
+		const auto first_bit = first % BITS_PER_WORD;
+		const auto first_ones =
+		    static_cast<size_t>(std::countr_one(m_data[word_index] >> first_bit));
+		if (first_bit + first_ones < BITS_PER_WORD) {
+			return {first, first + first_ones};
+		}
+
+		for (word_index++; word_index < WORD_COUNT; word_index++) {
+			word = m_data[word_index];
+			if (word != ~uint64_t {0}) {
+				return {first, word_index * BITS_PER_WORD + std::countr_one(word)};
+			}
+		}
+		return {first, N};
+	}
+
+	[[nodiscard]] constexpr Range FirstRange() const { return FirstRangeFrom(0); }
+
+	[[nodiscard]] constexpr Range LastRangeFrom(size_t end) const {
+		if (end == 0) {
+			return {0, 0};
+		}
+		if (end > N) {
+			end = N;
+		}
+
+		auto       word_index = (end - 1) / BITS_PER_WORD;
+		const auto end_bit    = (end - 1) % BITS_PER_WORD;
+		const auto end_mask =
+		    end_bit == BITS_PER_WORD - 1 ? ~uint64_t {0} : (uint64_t {1} << (end_bit + 1)) - 1;
+		auto word = m_data[word_index] & end_mask;
+		while (word == 0) {
+			if (word_index == 0) {
+				return {0, 0};
+			}
+			word = m_data[--word_index];
+		}
+
+		const auto empty_bits = static_cast<size_t>(std::countl_zero(word));
+		const auto ones       = static_cast<size_t>(std::countl_one(word << empty_bits));
+		const auto last       = (word_index + 1) * BITS_PER_WORD - empty_bits;
+		if (empty_bits + ones < BITS_PER_WORD) {
+			return {last - ones, last};
+		}
+
+		while (word_index != 0) {
+			word = m_data[--word_index];
+			if (word != ~uint64_t {0}) {
+				return {(word_index + 1) * BITS_PER_WORD - std::countl_one(word), last};
+			}
+		}
+		return {0, last};
+	}
+
+	[[nodiscard]] constexpr Range LastRange() const { return LastRangeFrom(N); }
+
+	[[nodiscard]] const_iterator begin() const { return Iterator(*this, 0); }
+	[[nodiscard]] const_iterator end() const { return Iterator(*this, N); }
+
+	constexpr BitArray& operator^=(const BitArray& other) {
+		for (size_t word = 0; word < WORD_COUNT; word++) {
+			m_data[word] ^= other.m_data[word];
+		}
+		return *this;
+	}
+
+	[[nodiscard]] constexpr BitArray operator^(const BitArray& other) const {
+		auto result = *this;
+		result ^= other;
+		return result;
+	}
+
+	[[nodiscard]] constexpr BitArray operator~() const {
+		auto result = *this;
+		for (auto& word: result.m_data) {
+			word = ~word;
+		}
+		return result;
+	}
+
+private:
+	std::array<uint64_t, WORD_COUNT> m_data {};
+};
+
+} // namespace Common
+
+#endif // EMULATOR_SRC_COMMON_BITARRAY_H_

src/common/byteBuffer.h

@@ -1,165 +0,0 @@
-#ifndef KYTY_COMMON_BYTEBUFFER_H_
-#define KYTY_COMMON_BYTEBUFFER_H_
-
-#include "common/assert.h"
-#include "common/common.h"
-
-#include <algorithm>
-#include <cstddef> // IWYU pragma: export
-#include <utility>
-#include <vector>
-
-namespace Common {
-
-using Byte = std::byte;
-
-class ByteBuffer {
-public:
-	using DataType = std::vector<Byte>;
-
-	static constexpr uint32_t INVALID_INDEX = static_cast<uint32_t>(-1);
-
-	using iterator       = DataType::iterator;
-	using const_iterator = DataType::const_iterator;
-
-	ByteBuffer()                  = default;
-	ByteBuffer(const ByteBuffer&) = default;
-	ByteBuffer(ByteBuffer&&)      = default;
-
-	ByteBuffer& operator=(const ByteBuffer&) = default;
-	ByteBuffer& operator=(ByteBuffer&&)      = default;
-
-	explicit ByteBuffer(uint32_t size): m_data(size) {}
-
-	ByteBuffer(std::initializer_list<uint8_t> list) {
-		for (const uint8_t& e: list) {
-			m_data.emplace_back(static_cast<Byte>(e));
-		}
-	}
-
-	explicit ByteBuffer(const void* buf, uint32_t size)
-	    : ByteBuffer(size) // @suppress("Ambiguous problem")
-	{
-		EXIT_IF(buf == nullptr && size != 0);
-
-		if (size != 0) {
-			std::memcpy(m_data.data(), buf, size);
-		}
-	}
-
-	[[nodiscard]] uint32_t Size() const { return static_cast<uint32_t>(m_data.size()); }
-	[[nodiscard]] bool     IsEmpty() const { return m_data.empty(); }
-
-	void Clear() { m_data.clear(); }
-
-	void Add(const Byte& val) { m_data.push_back(val); }
-	void Add(Byte&& val) { m_data.push_back(std::move(val)); }
-
-	void Add(const Byte* val, uint32_t num) {
-		EXIT_IF(val == nullptr && num != 0);
-		m_data.insert(m_data.end(), val, val + num);
-	}
-
-	void Add(const ByteBuffer& v) {
-		if (this == &v) {
-			const ByteBuffer copy(v);
-			Add(copy.GetDataConst(), copy.Size());
-			return;
-		}
-		Add(v.GetDataConst(), v.Size());
-	}
-
-	void InsertAt(uint32_t index, const Byte& val) {
-		EXIT_IF(index > Size());
-		m_data.insert(m_data.begin() + index, val);
-	}
-
-	void InsertAt(uint32_t index, Byte&& val) {
-		EXIT_IF(index > Size());
-		m_data.insert(m_data.begin() + index, std::move(val));
-	}
-
-	[[nodiscard]] uint32_t Find(const Byte& t) const {
-		const auto it = std::find(m_data.begin(), m_data.end(), t);
-		return (it == m_data.end() ? INVALID_INDEX
-		                           : static_cast<uint32_t>(std::distance(m_data.begin(), it)));
-	}
-
-	[[nodiscard]] bool Contains(const Byte& t) const { return Find(t) != INVALID_INDEX; }
-
-	bool Remove(const Byte& t) {
-		const auto it = std::find(m_data.begin(), m_data.end(), t);
-		if (it == m_data.end()) {
-			return false;
-		}
-		m_data.erase(it);
-		return true;
-	}
-
-	bool RemoveAt(uint32_t index, uint32_t count = 1) {
-		if (index >= Size() || count == 0) {
-			return false;
-		}
-
-		const uint32_t erase_count = std::min(count, Size() - index);
-		m_data.erase(m_data.begin() + index, m_data.begin() + index + erase_count);
-		return true;
-	}
-
-	[[nodiscard]] bool IndexValid(uint32_t index) const { return index < Size(); }
-
-	Byte& operator[](uint32_t index) {
-		EXIT_IF(index >= Size());
-		return m_data[index];
-	}
-
-	const Byte& operator[](uint32_t index) const {
-		EXIT_IF(index >= Size());
-		return m_data[index];
-	}
-
-	[[nodiscard]] const Byte& At(uint32_t index) const {
-		EXIT_IF(index >= Size());
-		return m_data[index];
-	}
-
-	Byte*                     GetData() { return m_data.data(); }
-	[[nodiscard]] const Byte* GetData() const { return m_data.data(); }
-	[[nodiscard]] const Byte* GetDataConst() const { return m_data.data(); }
-
-	void Sort() {
-		std::sort(m_data.begin(), m_data.end(), [](Byte a, Byte b) {
-			return std::to_integer<uint8_t>(a) < std::to_integer<uint8_t>(b);
-		});
-	}
-
-	template <typename OP>
-	void Sort(OP&& comp_func) {
-		std::sort(m_data.begin(), m_data.end(), std::forward<OP>(comp_func));
-	}
-
-	bool operator==(const ByteBuffer& s) const { return m_data == s.m_data; }
-	bool operator!=(const ByteBuffer& s) const { return !(*this == s); }
-
-	iterator begin() { return m_data.begin(); } // NOLINT(readability-identifier-naming)
-	iterator end() { return m_data.end(); }     // NOLINT(readability-identifier-naming)
-	[[nodiscard]] const_iterator begin() const {
-		return m_data.begin();
-	} // NOLINT(readability-identifier-naming)
-	[[nodiscard]] const_iterator end() const {
-		return m_data.end();
-	} // NOLINT(readability-identifier-naming)
-	[[nodiscard]] const_iterator cbegin() const {
-		return m_data.cbegin();
-	} // NOLINT(readability-identifier-naming)
-	[[nodiscard]] const_iterator cend() const {
-		return m_data.cend();
-	} // NOLINT(readability-identifier-naming)
-
-private:
-	DataType m_data;
-};
-
-} // namespace Common
-
-#endif /* KYTY_COMMON_BYTEBUFFER_H_ */

src/common/commonSubsystem.cpp

@@ -1,21 +0,0 @@
-#include "common/commonSubsystem.h"
-
-#include "common/byteBuffer.h" // IWYU pragma: associated
-#include "common/common.h"     // IWYU pragma: associated
-#include "common/debug.h"      // IWYU pragma: associated
-#include "common/hash.h"       // IWYU pragma: associated
-#include "common/magicEnum.h"  // IWYU pragma: associated
-#include "common/singleton.h"  // IWYU pragma: associated
-#include "common/virtualMemory.h"
-
-namespace Common {
-
-KYTY_SUBSYSTEM_INIT(Common) {
-	VirtualMemory::Init();
-}
-
-KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(Common) {}
-
-KYTY_SUBSYSTEM_DESTROY(Common) {}
-
-} // namespace Common

src/common/commonSubsystem.h

@@ -1,12 +0,0 @@
-#ifndef KYTY_COMMON_COMMON_SUBSYSTEM_H_
-#define KYTY_COMMON_COMMON_SUBSYSTEM_H_
-
-#include "common/subsystems.h"
-
-namespace Common {
-
-KYTY_SUBSYSTEM_DEFINE(Common);
-
-} // namespace Common
-
-#endif /* KYTY_COMMON_COMMON_SUBSYSTEM_H_ */

src/common/debug.cpp

@@ -1,20 +1,7 @@
 #include "common/debug.h"
 
-#include "common/platform/sysDbg.h"
-
 namespace Common {
 
-void DebugStack::Print(int from, [[maybe_unused]] bool with_name) const {
-	for (int i = from; i < depth; i++) {
-		printf("[%d] %016" PRIx64 "\n", i - from, static_cast<uint64_t>(GetAddr(i)));
-	}
-}
-
-void DebugStack::Trace(DebugStack* stack) {
-	stack->depth = DEBUG_MAX_STACK_DEPTH;
-	SysStackWalk(stack->stack.data(), &stack->depth);
-}
-
 std::string Debug::GetCompiler() {
 #if KYTY_COMPILER == KYTY_COMPILER_CLANG
 	return "clang";
@@ -37,8 +24,4 @@ std::string Debug::GetLinker() {
 #endif
 }
 
-std::string Debug::GetBitness() {
-	return "64";
-}
-
 } // namespace Common

src/common/debug.h

@@ -2,41 +2,16 @@
 #define KYTY_COMMON_DEBUG_H_
 
 #include "common/common.h"
-#include "common/stringUtils.h"
 
-#include <array>
+#include <string>
 
 namespace Common {
 
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS && KYTY_BUILD == KYTY_BUILD_DEBUG &&                    \
-    KYTY_COMPILER == KYTY_COMPILER_CLANG
-constexpr int DEBUG_MAX_STACK_DEPTH = 20;
-#else
-constexpr int DEBUG_MAX_STACK_DEPTH = 15;
-#endif
-
 namespace Debug {
 std::string GetCompiler();
 std::string GetLinker();
-std::string GetBitness();
 } // namespace Debug
 
-struct DebugStack {
-	int                                      depth {0};
-	std::array<void*, DEBUG_MAX_STACK_DEPTH> stack {};
-
-	[[nodiscard]] uintptr_t GetAddr(int i) const { return reinterpret_cast<uintptr_t>(stack[i]); }
-
-	void Print(int from, bool with_name = true) const;
-
-	void CopyTo(DebugStack* s) const {
-		std::memcpy(s->stack.data(), stack.data(), sizeof(void*) * depth);
-		s->depth = depth;
-	}
-
-	static void Trace(DebugStack* stack);
-};
-
 } // namespace Common
 
 #endif /* KYTY_COMMON_DEBUG_H_ */

src/common/emulatorConfig.cpp

@@ -9,18 +9,20 @@ namespace Config {
 
 static std::unique_ptr<ConfigOptions> g_config;
 
-KYTY_SUBSYSTEM_INIT(Config) {
+void Initialize() {
 	EXIT_IF(g_config != nullptr);
 
 	g_config = std::make_unique<ConfigOptions>();
 }
 
-KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(Config) {}
-
-KYTY_SUBSYSTEM_DESTROY(Config) {}
+void Shutdown() {
+	g_config.reset();
+}
 
 void Load(const ConfigOptions& cfg) {
 	EXIT_IF(g_config == nullptr);
+	EXIT_IF(cfg.user_name.empty() || cfg.user_name.size() > MAX_USER_NAME_LENGTH);
+	EXIT_IF(!IsConfiguredUserIdValid(cfg.user_id));
 
 	*g_config = cfg;
 }
@@ -33,10 +35,46 @@ uint32_t GetScreenHeight() {
 	return g_config->screen_height;
 }
 
+const std::string& GetUserName() {
+	return g_config->user_name;
+}
+
+int32_t GetUserId() {
+	return g_config->user_id;
+}
+
+const std::string& GetAudioInputDevice() {
+	return g_config->audio_input_device;
+}
+
+PresentMode GetPresentMode() {
+	return g_config->present_mode;
+}
+
+int32_t GetGpuIndex() {
+	return g_config->gpu_index;
+}
+
+bool FullscreenEnabled() {
+	return g_config->fullscreen_enabled;
+}
+
+bool VrEnabled() {
+	return g_config->vr_enabled;
+}
+
+bool AmdCpuEnabled() {
+	return g_config->amd_cpu_enabled;
+}
+
 uint32_t GetVblankFrequency() {
 	return std::clamp(g_config->vblank_frequency, 30u, 360u);
 }
 
+uint32_t GetConsoleLanguage() {
+	return g_config->console_language;
+}
+
 bool VulkanValidationEnabled() {
 	return g_config->vulkan_validation_enabled;
 }
@@ -49,7 +87,7 @@ ShaderOptimizationType GetShaderOptimizationType() {
 	return g_config->shader_optimization_type;
 }
 
-ShaderLogDirection GetShaderLogDirection() {
+LogDirection GetShaderLogDirection() {
 	return g_config->shader_log_direction;
 }
 
@@ -69,7 +107,7 @@ bool GraphicsDebugDumpEnabled() {
 	return g_config->graphics_debug_dump_enabled;
 }
 
-OutputDirection GetPrintfDirection() {
+LogDirection GetPrintfDirection() {
 	return g_config->printf_direction;
 }
 
@@ -77,20 +115,38 @@ std::filesystem::path GetPrintfOutputFile() {
 	return g_config->printf_output_file;
 }
 
-ProfilerDirection GetProfilerDirection() {
-	return g_config->profiler_direction;
+bool ProfilerEnabled() {
+	return g_config->profiler_enabled;
 }
 
 bool SpirvDebugPrintfEnabled() {
 	return g_config->spirv_debug_printf_enabled;
 }
 
+bool GpuAssistedValidationEnabled() {
+	return g_config->gpu_assisted_validation_enabled && g_config->vulkan_validation_enabled;
+}
+
 bool RenderDocEnabled() {
 	return g_config->renderdoc_enabled;
 }
 
-bool NggRectlistDrawEnabled() {
-	return g_config->ngg_rectlist_draw_enabled;
+bool ReadbackLinearImagesEnabled() {
+	return g_config->readback_linear_images;
+}
+
+bool PlayGoHackEnabled() {
+	return g_config->playgo_hack_enabled;
+}
+
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+bool RedZoneProtectionEnabled() {
+	return g_config->red_zone_protection_enabled;
+}
+#endif
+
+const Keymap& GetKeymap() {
+	return g_config->keymap;
 }
 
 } // namespace Config

src/common/emulatorConfig.h

@@ -2,52 +2,96 @@
 #define KYTY_COMMON_EMULATOR_CONFIG_H_
 
 #include "common/common.h"
-#include "common/subsystems.h"
 
+#include <cstddef>
 #include <filesystem>
+#include <string>
+#include <vector>
 
 namespace Config {
 
-KYTY_SUBSYSTEM_DEFINE(Config);
+void Initialize();
+void Shutdown();
+
+struct Lifecycle {
+	static constexpr const char* name       = "Config";
+	static constexpr auto        initialize = Config::Initialize;
+	static constexpr auto        shutdown   = Config::Shutdown;
+};
 
 enum class ShaderOptimizationType { None, Size, Performance };
 
-enum class ShaderLogDirection { Silent, Console, File };
+enum class LogDirection { Silent, Console, File };
 
-enum class ProfilerDirection { None, Network };
+enum class PresentMode { Fifo, Mailbox, Immediate };
 
-enum class OutputDirection { Silent, Console, File };
+using Keymap = std::vector<std::string>;
+
+constexpr uint32_t DEFAULT_CONSOLE_LANGUAGE = 1;
+constexpr uint32_t MAX_CONSOLE_LANGUAGE     = 29;
+constexpr std::size_t MAX_USER_NAME_LENGTH = 16;
+constexpr int32_t DEFAULT_USER_ID           = 1000;
+
+constexpr bool IsConfiguredUserIdValid(int32_t user_id) {
+	constexpr int32_t USER_ID_EVERYONE = 0xfe;
+	constexpr int32_t USER_ID_SYSTEM   = 0xff;
+	return user_id >= 0 && user_id != USER_ID_EVERYONE && user_id != USER_ID_SYSTEM;
+}
 
 struct ConfigOptions {
 	uint32_t               screen_width                = 1280;
 	uint32_t               screen_height               = 720;
+	std::string            user_name                   = "Kyty";
+	int32_t                user_id                     = DEFAULT_USER_ID;
+	std::string            audio_input_device;
+	PresentMode            present_mode                = PresentMode::Mailbox;
+	int32_t                gpu_index                   = -1;
+	bool                   fullscreen_enabled          = false;
+	bool                   vr_enabled                  = false;
+	bool                   amd_cpu_enabled             = false;
 	uint32_t               vblank_frequency            = 60;
+	uint32_t               console_language            = DEFAULT_CONSOLE_LANGUAGE;
 	bool                   vulkan_validation_enabled   = false;
 	bool                   shader_validation_enabled   = false;
 	ShaderOptimizationType shader_optimization_type    = ShaderOptimizationType::None;
-	ShaderLogDirection     shader_log_direction        = ShaderLogDirection::Silent;
+	LogDirection           shader_log_direction        = LogDirection::Silent;
 	std::filesystem::path  shader_log_folder           = "_Shaders";
 	bool                   command_buffer_dump_enabled = false;
 	std::filesystem::path  command_buffer_dump_folder  = "_Buffers";
 	bool                   graphics_debug_dump_enabled = false;
-	OutputDirection        printf_direction            = OutputDirection::Console;
+	LogDirection           printf_direction            = LogDirection::Silent;
 	std::filesystem::path  printf_output_file          = "_kyty.txt";
-	ProfilerDirection      profiler_direction          = ProfilerDirection::None;
+	bool                   profiler_enabled            = false;
 	bool                   spirv_debug_printf_enabled  = false;
+	bool                   gpu_assisted_validation_enabled = false;
 	bool                   renderdoc_enabled           = false;
-	bool                   ngg_rectlist_draw_enabled   = true;
+	bool                   readback_linear_images      = false;
+	bool                   playgo_hack_enabled         = false;
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+	bool red_zone_protection_enabled = false;
+#endif
+	Keymap keymap;
 };
 
 void Load(const ConfigOptions& cfg);
 
 uint32_t GetScreenWidth();
 uint32_t GetScreenHeight();
+const std::string& GetUserName();
+int32_t  GetUserId();
+const std::string& GetAudioInputDevice();
+PresentMode GetPresentMode();
+int32_t GetGpuIndex();
+bool     FullscreenEnabled();
+bool     VrEnabled();
+bool     AmdCpuEnabled();
 uint32_t GetVblankFrequency();
+uint32_t GetConsoleLanguage();
 bool     VulkanValidationEnabled();
 
 bool                   ShaderValidationEnabled();
 ShaderOptimizationType GetShaderOptimizationType();
-ShaderLogDirection     GetShaderLogDirection();
+LogDirection           GetShaderLogDirection();
 std::filesystem::path  GetShaderLogFolder();
 
 bool                  CommandBufferDumpEnabled();
@@ -55,15 +99,23 @@ std::filesystem::path GetCommandBufferDumpFolder();
 
 bool GraphicsDebugDumpEnabled();
 
-OutputDirection       GetPrintfDirection();
+LogDirection          GetPrintfDirection();
 std::filesystem::path GetPrintfOutputFile();
 
-ProfilerDirection GetProfilerDirection();
+bool ProfilerEnabled();
 
 bool SpirvDebugPrintfEnabled();
 
+bool GpuAssistedValidationEnabled();
+
 bool RenderDocEnabled();
-bool NggRectlistDrawEnabled();
+bool ReadbackLinearImagesEnabled();
+bool PlayGoHackEnabled();
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+bool RedZoneProtectionEnabled();
+#endif
+
+const Keymap& GetKeymap();
 
 } // namespace Config
 

src/common/file.cpp

@@ -25,9 +25,6 @@
 #ifdef CopyFile
 #undef CopyFile
 #endif
-#ifdef MoveFile
-#undef MoveFile
-#endif
 #endif
 
 namespace Common {
@@ -72,7 +69,7 @@ File::File(): m_p(std::make_unique<FilePrivate>()) {
 }
 
 File::~File() {
-	EXIT_IF(m_p->f != nullptr);
+	Close();
 }
 
 File::File(const std::filesystem::path& name): m_p(std::make_unique<FilePrivate>()) {
@@ -139,10 +136,6 @@ bool File::OpenInMem(void* buf, uint32_t buf_size) {
 	return true;
 }
 
-bool File::OpenInMem(ByteBuffer& buf) {
-	return OpenInMem(buf.GetData(), buf.Size());
-}
-
 bool File::CreateInMem() {
 	EXIT_IF(m_p->f != nullptr);
 
@@ -254,8 +247,8 @@ void File::Printf(const char* format, ...) {
 
 bool File::IsDirectoryExisting(const std::filesystem::path& path) {
 	auto path_str = PathToGenericString(path);
-	return SysFileIsDirectoryExisting(
-	    Common::EndsWith(path_str, "/") ? Common::RemoveLast(path_str, 1) : path_str);
+	return SysFileIsDirectoryExisting(path_str.ends_with("/") ? Common::RemoveLast(path_str, 1)
+	                                                          : path_str);
 }
 
 bool File::IsFileExisting(const std::filesystem::path& name) {
@@ -266,14 +259,14 @@ bool File::CreateDirectory(
     const std::filesystem::path& path) // @suppress("Member declaration not found")
 {
 	auto path_str = PathToGenericString(path);
-	return SysFileCreateDirectory(Common::EndsWith(path_str, "/") ? Common::RemoveLast(path_str, 1)
-	                                                              : path_str);
+	return SysFileCreateDirectory(path_str.ends_with("/") ? Common::RemoveLast(path_str, 1)
+	                                                      : path_str);
 }
 
 bool File::DeleteDirectory(const std::filesystem::path& path) {
 	auto path_str = PathToGenericString(path);
-	return SysFileDeleteDirectory(Common::EndsWith(path_str, "/") ? Common::RemoveLast(path_str, 1)
-	                                                              : path_str);
+	return SysFileDeleteDirectory(path_str.ends_with("/") ? Common::RemoveLast(path_str, 1)
+	                                                      : path_str);
 }
 
 bool File::CreateDirectories(const std::filesystem::path& path) {
@@ -286,7 +279,7 @@ bool File::CreateDirectories(const std::filesystem::path& path) {
 	for (uint32_t si = 0; si < list.size(); si++) {
 		const std::string& s = list[si];
 
-		if (si != 0 || Common::StartsWith(real_path, "/")) {
+		if (si != 0 || real_path.starts_with("/")) {
 			p += "/";
 		}
 
@@ -316,7 +309,7 @@ bool File::DeleteDirectories(const std::filesystem::path& path) {
 	for (uint32_t si = 0; si < list.size(); si++) {
 		const std::string& s = list[si];
 
-		if (si != 0 || Common::StartsWith(real_path, "/")) {
+		if (si != 0 || real_path.starts_with("/")) {
 			p += "/";
 		}
 
@@ -348,7 +341,7 @@ bool File::Flush() {
 	return SysFileFlush(*m_p->f);
 }
 
-ByteBuffer File::ReadWholeBuffer() {
+std::vector<std::byte> File::ReadWholeBuffer() {
 	EXIT_IF(IsInvalid());
 	EXIT_IF(Tell() != 0);
 
@@ -356,25 +349,14 @@ ByteBuffer File::ReadWholeBuffer() {
 
 	EXIT_IF((s >> 32u) != 0);
 
-	ByteBuffer buf(s);
+	const auto            read_size = static_cast<uint32_t>(s);
+	std::vector<std::byte> buf(read_size);
 
-	Read(buf.GetData(), s);
+	Read(buf.data(), read_size);
 
 	return buf;
 }
 
-ByteBuffer File::Read(uint32_t size) {
-	ByteBuffer buf(size);
-	uint32_t   b = 0;
-	Read(buf.GetData(), size, &b);
-	buf.RemoveAt(b, size - b);
-	return buf;
-}
-
-void File::Write(const ByteBuffer& buf, uint32_t* bytes_written) {
-	Write(buf.GetDataConst(), buf.Size(), bytes_written);
-}
-
 DateTime File::GetLastAccessTimeUTC(const std::filesystem::path& name) {
 	SysTimeStruct t {};
 	SysFileToSystemTimeUtc(SysFileGetLastAccessTimeUtc(name), t);
@@ -481,7 +463,7 @@ std::vector<File::FindInfo> File::FindFiles(const std::filesystem::path& path) {
 	auto     path_str = PathToGenericString(path);
 	uint32_t len      = static_cast<uint32_t>(path_str.size());
 
-	if (!Common::EndsWith(path_str, "/") && !Common::EndsWith(path_str, "\\")) {
+	if (!path_str.ends_with("/") && !path_str.ends_with("\\")) {
 		len++;
 	}
 
@@ -544,14 +526,14 @@ bool File::CopyFile(const std::filesystem::path& src,
 	return SysFileCopyFile(src, dst);
 }
 
-bool File::MoveFile(const std::filesystem::path& src,
-                    const std::filesystem::path& dst) // @suppress("Member declaration not found")
+bool File::RenameFile(const std::filesystem::path& src,
+                      const std::filesystem::path& dst) // @suppress("Member declaration not found")
 {
 	if (IsFileExisting(dst)) {
 		DeleteFile(dst); // @suppress("Invalid arguments")
 	}
 
-	return SysFileMoveFile(src, dst);
+	return SysFileRenameFile(src, dst);
 }
 
 void File::RemoveReadonly(const std::filesystem::path& name) {

src/common/file.h

@@ -1,10 +1,10 @@
 #ifndef KYTY_COMMON_FILE_H_
 #define KYTY_COMMON_FILE_H_
 
-#include "common/byteBuffer.h"
 #include "common/common.h"
 #include "common/dateTime.h"
 
+#include <cstddef>
 #include <filesystem>
 #include <memory>
 #include <string>
@@ -20,9 +20,6 @@
 #ifdef CopyFile
 #undef CopyFile
 #endif
-#ifdef MoveFile
-#undef MoveFile
-#endif
 #endif
 
 namespace Common {
@@ -54,7 +51,6 @@ public:
 	bool Create(const std::filesystem::path& name);
 	bool Open(const std::filesystem::path& name, Mode mode);
 	bool OpenInMem(void* buf, uint32_t buf_size);
-	bool OpenInMem(ByteBuffer& buf); // NOLINT(google-runtime-references)
 	bool CreateInMem();
 
 	void Close();
@@ -76,14 +72,12 @@ public:
 
 	void GetLastAccessAndWriteTimeUTC(DateTime* access, DateTime* write);
 
-	void       Read(void* data, uint32_t size, uint32_t* bytes_read = nullptr);
-	ByteBuffer Read(uint32_t size);
-	void       Write(const void* data, uint32_t size, uint32_t* bytes_written = nullptr);
-	void       Write(const ByteBuffer& buf, uint32_t* bytes_written = nullptr);
+	void Read(void* data, uint32_t size, uint32_t* bytes_read = nullptr);
+	void Write(const void* data, uint32_t size, uint32_t* bytes_written = nullptr);
 
 	void Printf(const char* format, ...) KYTY_FORMAT_PRINTF(2, 3);
 
-	ByteBuffer ReadWholeBuffer();
+	std::vector<std::byte> ReadWholeBuffer();
 
 	static uint64_t Size(const std::filesystem::path& name);
 
@@ -107,7 +101,7 @@ public:
 	static std::vector<FindInfo> FindFiles(const std::filesystem::path& path);
 	static std::vector<DirEntry> GetDirEntries(const std::filesystem::path& path);
 	static bool CopyFile(const std::filesystem::path& src, const std::filesystem::path& dst);
-	static bool MoveFile(const std::filesystem::path& src, const std::filesystem::path& dst);
+	static bool RenameFile(const std::filesystem::path& src, const std::filesystem::path& dst);
 	static void RemoveReadonly(const std::filesystem::path& name);
 
 	KYTY_CLASS_NO_COPY(File);

src/common/hash.h

@@ -54,103 +54,6 @@ inline uint32_t hash(const void* key, uint32_t key_len) {
 	return hash;
 }
 
-inline uint32_t hash8(uint8_t key) {
-	uint32_t hash = 0;
-
-	uint8_t* ptr = &key;
-
-	hash += ptr[0];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-
-	hash += (hash << 3u);
-	hash ^= (hash >> 11u);
-	hash += (hash << 15u);
-
-	return hash;
-}
-
-inline uint32_t hash16(uint16_t key) {
-	uint32_t hash = 0;
-
-	auto* ptr = reinterpret_cast<uint8_t*>(&key);
-
-	hash += ptr[0];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-	hash += ptr[1];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-
-	hash += (hash << 3u);
-	hash ^= (hash >> 11u);
-	hash += (hash << 15u);
-
-	return hash;
-}
-
-inline uint32_t hash32(uint32_t key) {
-	uint32_t hash = 0;
-
-	auto* ptr = reinterpret_cast<uint8_t*>(&key);
-
-	hash += ptr[0];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-	hash += ptr[1];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-	hash += ptr[2];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-	hash += ptr[3];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-
-	hash += (hash << 3u);
-	hash ^= (hash >> 11u);
-	hash += (hash << 15u);
-
-	return hash;
-}
-
-inline uint32_t hash64(uint64_t key) {
-	uint32_t hash = 0;
-
-	auto* ptr = reinterpret_cast<uint8_t*>(&key);
-
-	hash += ptr[0];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-	hash += ptr[1];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-	hash += ptr[2];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-	hash += ptr[3];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-	hash += ptr[4];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-	hash += ptr[5];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-	hash += ptr[6];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-	hash += ptr[7];
-	hash += (hash << 10u);
-	hash ^= (hash >> 6u);
-
-	hash += (hash << 3u);
-	hash ^= (hash >> 11u);
-	hash += (hash << 15u);
-
-	return hash;
-}
-
 } // namespace Common
 
 #endif /* KYTY_COMMON_HASH_H_ */

src/common/hostException.cpp

@@ -2,10 +2,20 @@
 
 #include <atomic>
 #include <cstdio>
-#include <cstdlib>
 
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 #include <windows.h> // IWYU pragma: keep
+#else
+#include <algorithm>
+#include <csignal>
+#include <cstdlib>
+#include <initializer_list>
+#include <unistd.h>
+#if defined(__APPLE__)
+#include <sys/ucontext.h>
+#else
+#include <ucontext.h> // IWYU pragma: keep
+#endif
 #endif
 
 // IWYU pragma: no_include <errhandlingapi.h>
@@ -16,41 +26,63 @@
 
 namespace Common::HostException {
 
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+#if !defined(__APPLE__)
 
 static std::atomic<Handler> g_handler {nullptr};
 static std::atomic_uint32_t g_install_state {0};
-static thread_local bool    g_in_exception_filter = false;
 
 static_assert(decltype(g_handler)::is_always_lock_free);
 static_assert(decltype(g_install_state)::is_always_lock_free);
+#endif
 
-[[noreturn]] static void FailFast(const char* reason) noexcept {
-	std::fputs("HostException fail-fast: ", stderr);
-	std::fputs(reason != nullptr ? reason : "unspecified", stderr);
-	std::fputc('\n', stderr);
-	std::fflush(stderr);
-	TerminateProcess(GetCurrentProcess(), static_cast<UINT>(EXCEPTION_NONCONTINUABLE_EXCEPTION));
-	std::_Exit(321);
-}
+#if KYTY_PLATFORM == KYTY_PLATFORM_LINUX
 
-class FilterScope final {
+// macOS uses the same POSIX platform setting and needs a signal stack too.
+class ThreadSignalStack {
 public:
-	FilterScope() noexcept {
-		if (g_in_exception_filter) {
-			FailFast("nested exception while resolving a host fault");
+	ThreadSignalStack() {
+		const auto page_size = static_cast<size_t>(::getpagesize());
+		const auto stack_size =
+		    (std::max<size_t>(64 * 1024, MINSIGSTKSZ) + page_size - 1) & ~(page_size - 1);
+		if (::posix_memalign(&m_memory, page_size, stack_size) != 0) {
+			return;
+		}
+
+		stack_t stack {};
+		stack.ss_sp   = m_memory;
+		stack.ss_size = stack_size;
+		if (::sigaltstack(&stack, &m_previous) != 0) {
+			std::free(m_memory);
+			m_memory = nullptr;
 		}
-		g_in_exception_filter = true;
 	}
 
-	~FilterScope() { g_in_exception_filter = false; }
+	~ThreadSignalStack() {
+		if (m_memory != nullptr && ::sigaltstack(&m_previous, nullptr) == 0) {
+			std::free(m_memory);
+		}
+	}
 
-	KYTY_CLASS_NO_COPY(FilterScope);
+	[[nodiscard]] bool IsInitialized() const { return m_memory != nullptr; }
+
+	KYTY_CLASS_NO_COPY(ThreadSignalStack)
+
+private:
+	void*   m_memory = nullptr;
+	stack_t m_previous {};
 };
 
-static LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS exception) {
-	FilterScope filter_scope;
+bool InitializeThreadSignalStack() {
+	// Keep fault handling off guest stacks, which GPU tracking can make read-only.
+	thread_local ThreadSignalStack signal_stack;
+	return signal_stack.IsInitialized();
+}
 
+#endif
+
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+
+static LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS exception) noexcept {
 	auto* exception_record = exception->ExceptionRecord;
 
 	if (exception_record->ExceptionCode == DBG_PRINTEXCEPTION_C ||
@@ -80,12 +112,6 @@ static LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS exception) {
 	} else if (exception_record->ExceptionCode == EXCEPTION_ILLEGAL_INSTRUCTION) {
 		info.type = ExceptionType::IllegalInstruction;
 	} else {
-		printf("Unhandled win exception: code=0x%08" PRIx32 ", addr=0x%016" PRIx64
-		       ", rip=0x%016" PRIx64 ", rsp=0x%016" PRIx64 ", rbp=0x%016" PRIx64 "\n",
-		       static_cast<uint32_t>(exception_record->ExceptionCode),
-		       reinterpret_cast<uint64_t>(exception_record->ExceptionAddress),
-		       exception->ContextRecord->Rip, exception->ContextRecord->Rsp,
-		       exception->ContextRecord->Rbp);
 		return EXCEPTION_CONTINUE_SEARCH;
 	}
 
@@ -106,22 +132,154 @@ static LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS exception) {
 	info.r14 = exception->ContextRecord->R14;
 	info.r15 = exception->ContextRecord->R15;
 
-	if (g_install_state.load(std::memory_order_acquire) == 0) {
-		FailFast("host exception handler is not installed");
+	const auto handler = g_handler.load(std::memory_order_acquire);
+	if (handler != nullptr && handler(info)) {
+		return EXCEPTION_CONTINUE_EXECUTION;
 	}
+	return EXCEPTION_CONTINUE_SEARCH;
+}
+
+#elif defined(__APPLE__)
+
+static std::atomic<Handler> g_handler {nullptr};
+static std::atomic_uint32_t g_install_state {0};
+
+static_assert(decltype(g_handler)::is_always_lock_free);
+static_assert(decltype(g_install_state)::is_always_lock_free);
+
+// Translate the x86-64 page-fault error code (mcontext __es.__err) into an access type.
+// bit 1 (0x2) = write, bit 4 (0x10) = instruction fetch, otherwise a read.
+static AccessViolationType DecodeAccess(uint64_t err) {
+	if ((err & 0x10u) != 0) {
+		return AccessViolationType::Execute;
+	}
+	if ((err & 0x2u) != 0) {
+		return AccessViolationType::Write;
+	}
+	return AccessViolationType::Read;
+}
+
+// POSIX signal handler that mirrors the Windows vectored handler: build an ExceptionInfo
+// from the mcontext and dispatch. A resolved fault (handler returns true) simply returns,
+// re-executing the faulting instruction against the now-fixed protection. An unresolved
+// fault restores the default disposition so the retry terminates the process.
+static void SignalHandler(int sig, siginfo_t* si, void* uctx) {
+	auto*       uc = static_cast<ucontext_t*>(uctx);
+	const auto* mc = uc->uc_mcontext;
+	const auto& ss = mc->__ss;
+
+	ExceptionInfo info {};
+	info.exception_address = ss.__rip;
+	info.native_code       = static_cast<uint32_t>(si->si_code);
+	info.native_context    = uctx;
+
+	if (sig == SIGILL) {
+		info.type = ExceptionType::IllegalInstruction;
+	} else {
+		info.type                   = ExceptionType::AccessViolation;
+		info.access_violation_type  = DecodeAccess(mc->__es.__err);
+		info.access_violation_vaddr = reinterpret_cast<uint64_t>(si->si_addr);
+	}
+
+	info.rax = ss.__rax;
+	info.rbx = ss.__rbx;
+	info.rcx = ss.__rcx;
+	info.rdx = ss.__rdx;
+	info.rsi = ss.__rsi;
+	info.rdi = ss.__rdi;
+	info.rbp = ss.__rbp;
+	info.rsp = ss.__rsp;
+	info.r8  = ss.__r8;
+	info.r9  = ss.__r9;
+	info.r10 = ss.__r10;
+	info.r11 = ss.__r11;
+	info.r12 = ss.__r12;
+	info.r13 = ss.__r13;
+	info.r14 = ss.__r14;
+	info.r15 = ss.__r15;
 
 	const auto handler = g_handler.load(std::memory_order_acquire);
-	if (handler == nullptr) {
-		FailFast("host exception callback is null");
+	if (handler != nullptr && handler(info)) {
+		return; // retry the faulting instruction against the fixed mapping
 	}
 
-	return handler(info) ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_CONTINUE_SEARCH;
+	// Unresolved: restore the default action so the re-executed instruction terminates.
+	struct sigaction dfl {};
+	dfl.sa_handler = SIG_DFL;
+	sigemptyset(&dfl.sa_mask);
+	sigaction(sig, &dfl, nullptr);
+}
+
+#else
+
+// x86-64 page-fault error bits.
+constexpr uint64_t PAGE_FAULT_ERROR_WRITE       = 0x02;
+constexpr uint64_t PAGE_FAULT_ERROR_INSTRUCTION = 0x10;
+
+// Let the kernel handle an unresolved fault on retry.
+static void ChainToDefault(int signal_number) noexcept {
+	struct sigaction restore {};
+	restore.sa_handler = SIG_DFL;
+	sigemptyset(&restore.sa_mask);
+	restore.sa_flags = 0;
+	::sigaction(signal_number, &restore, nullptr);
+}
+
+static void SignalHandler(int signal_number, siginfo_t* signal_info, void* native_context) {
+	auto* context = static_cast<ucontext_t*>(native_context);
+	auto* gregs   = context->uc_mcontext.gregs;
+
+	ExceptionInfo info {};
+	info.exception_address = static_cast<uint64_t>(gregs[REG_RIP]);
+	info.native_code       = static_cast<uint32_t>(signal_number);
+	info.native_context    = context;
+
+	if (signal_number == SIGSEGV || signal_number == SIGBUS) {
+		info.type             = ExceptionType::AccessViolation;
+		const auto error_code = static_cast<uint64_t>(gregs[REG_ERR]);
+		if ((error_code & PAGE_FAULT_ERROR_INSTRUCTION) != 0) {
+			info.access_violation_type = AccessViolationType::Execute;
+		} else if ((error_code & PAGE_FAULT_ERROR_WRITE) != 0) {
+			info.access_violation_type = AccessViolationType::Write;
+		} else {
+			info.access_violation_type = AccessViolationType::Read;
+		}
+		info.access_violation_vaddr = reinterpret_cast<uint64_t>(signal_info->si_addr);
+	} else if (signal_number == SIGILL) {
+		info.type = ExceptionType::IllegalInstruction;
+	} else {
+		ChainToDefault(signal_number);
+		return;
+	}
+
+	info.rax = static_cast<uint64_t>(gregs[REG_RAX]);
+	info.rbx = static_cast<uint64_t>(gregs[REG_RBX]);
+	info.rcx = static_cast<uint64_t>(gregs[REG_RCX]);
+	info.rdx = static_cast<uint64_t>(gregs[REG_RDX]);
+	info.rsi = static_cast<uint64_t>(gregs[REG_RSI]);
+	info.rdi = static_cast<uint64_t>(gregs[REG_RDI]);
+	info.rbp = static_cast<uint64_t>(gregs[REG_RBP]);
+	info.rsp = static_cast<uint64_t>(gregs[REG_RSP]);
+	info.r8  = static_cast<uint64_t>(gregs[REG_R8]);
+	info.r9  = static_cast<uint64_t>(gregs[REG_R9]);
+	info.r10 = static_cast<uint64_t>(gregs[REG_R10]);
+	info.r11 = static_cast<uint64_t>(gregs[REG_R11]);
+	info.r12 = static_cast<uint64_t>(gregs[REG_R12]);
+	info.r13 = static_cast<uint64_t>(gregs[REG_R13]);
+	info.r14 = static_cast<uint64_t>(gregs[REG_R14]);
+	info.r15 = static_cast<uint64_t>(gregs[REG_R15]);
+
+	const auto handler = g_handler.load(std::memory_order_acquire);
+	if (handler != nullptr && handler(info)) {
+		return;
+	}
+
+	ChainToDefault(signal_number);
 }
 
 #endif
 
 bool InstallHandler(Handler handler) {
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	if (handler == nullptr) {
 		return false;
 	}
@@ -133,19 +291,51 @@ bool InstallHandler(Handler handler) {
 
 	g_handler.store(handler, std::memory_order_release);
 
-	if (AddVectoredExceptionHandler(1, ExceptionFilter) == nullptr) {
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+	if (AddVectoredExceptionHandler(0, ExceptionFilter) == nullptr) {
 		g_handler.store(nullptr, std::memory_order_release);
 		g_install_state.store(0, std::memory_order_release);
 		printf("AddVectoredExceptionHandler() failed\n");
 		return false;
 	}
+#elif defined(__APPLE__)
+	struct sigaction sa {};
+	sa.sa_sigaction = SignalHandler;
+	sa.sa_flags     = SA_SIGINFO | SA_ONSTACK;
+	sigemptyset(&sa.sa_mask);
+	// The guest signal-dispatch path (KernelRaiseException) interrupts threads with
+	// SIGUSR1; block it while a fault is being resolved so a stop-the-world request
+	// cannot preempt the handler between the protection fix and the retry.
+	sigaddset(&sa.sa_mask, SIGUSR1);
+
+	// macOS raises SIGBUS for protection faults on some paths and SIGSEGV on others;
+	// SIGILL covers instructions the host cannot execute (routed to the x64 emulator).
+	bool ok = sigaction(SIGSEGV, &sa, nullptr) == 0 && sigaction(SIGBUS, &sa, nullptr) == 0 &&
+	          sigaction(SIGILL, &sa, nullptr) == 0;
+	if (!ok) {
+		g_handler.store(nullptr, std::memory_order_release);
+		g_install_state.store(0, std::memory_order_release);
+		printf("sigaction() failed to install the host fault handler\n");
+		return false;
+	}
+#else
+	struct sigaction action {};
+	action.sa_sigaction = SignalHandler;
+	sigemptyset(&action.sa_mask);
+	action.sa_flags = SA_SIGINFO | SA_RESTART | SA_ONSTACK;
+
+	for (const int signal_number: {SIGSEGV, SIGBUS, SIGILL}) {
+		if (::sigaction(signal_number, &action, nullptr) != 0) {
+			g_handler.store(nullptr, std::memory_order_release);
+			g_install_state.store(0, std::memory_order_release);
+			printf("sigaction(%d) failed\n", signal_number);
+			return false;
+		}
+	}
+#endif
 
 	g_install_state.store(2, std::memory_order_release);
 	return true;
-#else
-	(void)handler;
-	return false;
-#endif
 }
 
 } // namespace Common::HostException

src/common/hostException.h

@@ -39,6 +39,10 @@ using Handler = bool (*)(const ExceptionInfo&);
 
 bool InstallHandler(Handler handler);
 
+#if KYTY_PLATFORM == KYTY_PLATFORM_LINUX
+bool InitializeThreadSignalStack();
+#endif
+
 } // namespace Common::HostException
 
 #endif /* KYTY_COMMON_HOST_EXCEPTION_H_ */

src/common/logging/log.cpp

@@ -129,6 +129,14 @@ static void WriteImpl(std::string_view text, fmt::text_style style = {}) {
 	}
 }
 
+void WriteToConsoleAndLog(std::string_view text) {
+	WriteImpl(text);
+	if (g_initialized && g_direction != Direction::Console) {
+		WriteStdout(text);
+	}
+	Flush();
+}
+
 void WriteFatal(std::string_view text) {
 	if (g_direction == Direction::Silent || !g_initialized) {
 		WriteStdout(text);
@@ -149,25 +157,19 @@ void WriteFatal(fmt::text_style style, std::string_view text) {
 	Flush();
 }
 
-KYTY_SUBSYSTEM_INIT(Log) {
+void Initialize() {
 	g_initialized = true;
 	switch (Config::GetPrintfDirection()) {
-		case Config::OutputDirection::Silent: g_direction = Direction::Silent; break;
-		case Config::OutputDirection::Console: g_direction = Direction::Console; break;
-		case Config::OutputDirection::File: g_direction = Direction::File; break;
+		case Config::LogDirection::Silent: g_direction = Direction::Silent; break;
+		case Config::LogDirection::Console: g_direction = Direction::Console; break;
+		case Config::LogDirection::File: g_direction = Direction::File; break;
 	}
 	g_output_file =
 	    (g_direction == Direction::File ? Config::GetPrintfOutputFile() : std::filesystem::path {});
 	SetupLogger();
 }
 
-KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(Log) {
-	Flush();
-	std::lock_guard lock(g_logger_mutex);
-	g_logger.reset();
-}
-
-KYTY_SUBSYSTEM_DESTROY(Log) {
+void Shutdown() {
 	Flush();
 	std::lock_guard lock(g_logger_mutex);
 	g_logger.reset();
@@ -178,6 +180,11 @@ Direction GetDirection() {
 	return g_direction;
 }
 
+bool IsSilent() {
+	// Before init LOGF must keep writing to stdout, so report non-silent.
+	return g_initialized && g_direction == Direction::Silent;
+}
+
 void Write(std::string_view text) {
 	WriteImpl(text);
 }

src/common/logging/log.h

@@ -2,7 +2,6 @@
 #define KYTY_COMMON_LOGGING_LOG_H_
 
 #include "common/common.h"
-#include "common/subsystems.h"
 
 #include <fmt/color.h>
 #include <fmt/printf.h>
@@ -10,13 +9,23 @@
 
 namespace Log {
 
-KYTY_SUBSYSTEM_DEFINE(Log);
+void Initialize();
+void Shutdown();
+
+struct Lifecycle {
+	static constexpr const char* name               = "Log";
+	static constexpr auto        initialize         = Log::Initialize;
+	static constexpr auto        shutdown           = Log::Shutdown;
+	static constexpr auto        emergency_shutdown = Log::Shutdown;
+};
 
 enum class Direction { Silent, Console, File };
 
 Direction GetDirection();
+bool      IsSilent();
 void      Write(std::string_view text);
 void      Write(fmt::text_style style, std::string_view text);
+void      WriteToConsoleAndLog(std::string_view text);
 void      WriteFatal(std::string_view text);
 void      WriteFatal(fmt::text_style style, std::string_view text);
 void      Flush();
@@ -41,8 +50,18 @@ inline constexpr auto BrightWhite   = fmt::fg(fmt::terminal_color::bright_white)
 } // namespace Log
 
 // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define LOGF(...) ::Log::Write(::fmt::sprintf(__VA_ARGS__))
+#define LOGF(...)                                                                                  \
+	do {                                                                                           \
+		if (!::Log::IsSilent()) {                                                                  \
+			::Log::Write(::fmt::sprintf(__VA_ARGS__));                                             \
+		}                                                                                          \
+	} while (false)
 // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define LOGF_COLOR(style, ...) ::Log::Write((style), ::fmt::sprintf(__VA_ARGS__))
+#define LOGF_COLOR(style, ...)                                                                     \
+	do {                                                                                           \
+		if (!::Log::IsSilent()) {                                                                  \
+			::Log::Write((style), ::fmt::sprintf(__VA_ARGS__));                                    \
+		}                                                                                          \
+	} while (false)
 
 #endif /* KYTY_COMMON_LOGGING_LOG_H_ */

src/common/lruCache.h

@@ -0,0 +1,118 @@
+#ifndef EMULATOR_SRC_COMMON_LRUCACHE_H_
+#define EMULATOR_SRC_COMMON_LRUCACHE_H_
+
+#include <cstddef>
+#include <deque>
+#include <type_traits>
+#include <utility>
+
+namespace Common {
+
+template <typename Object, typename Tick>
+class LeastRecentlyUsedCache {
+	struct Item {
+		Object object {};
+		Tick   tick {};
+		Item*  next = nullptr;
+		Item*  prev = nullptr;
+	};
+
+public:
+	[[nodiscard]] size_t Insert(Object object, Tick tick) {
+		const auto id   = Build();
+		auto&      item = m_items[id];
+		item.object     = std::move(object);
+		item.tick       = tick;
+		Attach(item);
+		return id;
+	}
+
+	void Touch(size_t id, Tick tick) {
+		auto& item = m_items[id];
+		if (item.tick >= tick) {
+			return;
+		}
+		item.tick = tick;
+		if (&item != m_last) {
+			Detach(item);
+			Attach(item);
+		}
+	}
+
+	void Free(size_t id) {
+		auto& item = m_items[id];
+		Detach(item);
+		item.next = nullptr;
+		item.prev = nullptr;
+		m_free.push_back(id);
+	}
+
+	template <typename Function>
+	void ForEachItemBelow(Tick tick, Function&& function) {
+		constexpr bool ReturnsBool = std::is_same_v<std::invoke_result_t<Function, Object>, bool>;
+		for (auto* item = m_first; item != nullptr;) {
+			if (item->tick > tick) {
+				return;
+			}
+			auto* next = item->next;
+			if constexpr (ReturnsBool) {
+				if (function(item->object)) {
+					return;
+				}
+			} else {
+				function(item->object);
+			}
+			item = next;
+		}
+	}
+
+private:
+	[[nodiscard]] size_t Build() {
+		if (m_free.empty()) {
+			const auto id = m_items.size();
+			m_items.emplace_back();
+			return id;
+		}
+		const auto id = m_free.front();
+		m_free.pop_front();
+		return id;
+	}
+
+	void Attach(Item& item) {
+		if (m_first == nullptr) {
+			m_first = &item;
+		}
+		if (m_last == nullptr) {
+			m_last = &item;
+			return;
+		}
+		item.prev    = m_last;
+		m_last->next = &item;
+		item.next    = nullptr;
+		m_last       = &item;
+	}
+
+	void Detach(Item& item) {
+		if (item.prev != nullptr) {
+			item.prev->next = item.next;
+		}
+		if (item.next != nullptr) {
+			item.next->prev = item.prev;
+		}
+		if (m_first == &item) {
+			m_first = item.next;
+		}
+		if (m_last == &item) {
+			m_last = item.prev;
+		}
+	}
+
+	std::deque<Item>   m_items;
+	std::deque<size_t> m_free;
+	Item*              m_first = nullptr;
+	Item*              m_last  = nullptr;
+};
+
+} // namespace Common
+
+#endif // EMULATOR_SRC_COMMON_LRUCACHE_H_

src/common/magicEnum.h

@@ -1,42 +0,0 @@
-#ifndef KYTY_COMMON_MAGICENUM_H_
-#define KYTY_COMMON_MAGICENUM_H_
-
-#include "common/common.h"
-#include "common/stringUtils.h"
-#include "magic_enum.hpp" // IWYU pragma: export
-
-namespace Common {
-
-template <typename E>
-inline std::string EnumName(E v) {
-	auto str = magic_enum::enum_name(v);
-	return std::string(str.data(), str.length());
-}
-
-template <typename E>
-inline std::string EnumName8(E v) {
-	auto str = magic_enum::enum_name(v);
-	return std::string(str.data(), str.length());
-}
-
-template <typename E>
-inline E EnumValue(const std::string& str, E default_value) {
-	auto v = magic_enum::enum_cast<E>(str.c_str());
-	if (v.has_value()) {
-		return v.value();
-	}
-	return default_value;
-}
-
-#define KYTY_ENUM_RANGE(e, mx, mn)                                                                 \
-	namespace magic_enum::customize {                                                              \
-	template <>                                                                                    \
-	struct enum_range<e> {                                                                         \
-		static constexpr int min = (mx);                                                           \
-		static constexpr int max = (mn);                                                           \
-	};                                                                                             \
-	}
-
-} // namespace Common
-
-#endif /* KYTY_COMMON_MAGICENUM_H_ */

src/common/platform/sysDbg.h

@@ -23,11 +23,13 @@ struct sys_dbg_stack_info_t {
 	size_t    commited_size;
 	size_t    total_size;
 	size_t    code_size;
+
+	// Full stack reservation reported by pthread.
+	uintptr_t reserved_addr;
+	size_t    reserved_size;
 #endif
 };
 
-void SysStackWalk(void** stack, int* depth);
-void SysStackUsage(sys_dbg_stack_info_t& s);          // NOLINT(google-runtime-references)
-void SysStackUsagePrint(sys_dbg_stack_info_t& stack); // NOLINT(google-runtime-references)
+void SysStackUsage(sys_dbg_stack_info_t& s); // NOLINT(google-runtime-references)
 
 #endif /* KYTY_COMMON_PLATFORM_SYSDBG_H_ */

src/common/platform/sysFileIO.h

@@ -52,7 +52,6 @@ uint64_t    SysFileTell(sys_file_t& f);                    // NOLINT(google-runt
 bool        SysFileTruncate(sys_file_t& f, uint64_t size); // NOLINT(google-runtime-references)
 bool        SysFileUnlink(sys_file_t&                  f,
                           const std::filesystem::path& name); // NOLINT(google-runtime-references)
-void        SysFileWrite(uint32_t n, sys_file_t& f);          // NOLINT(google-runtime-references)
 uint64_t    SysFileSize(const std::filesystem::path& file_name);
 bool        SysFileIsError(sys_file_t& f); // NOLINT(google-runtime-references)
 bool        SysFileIsDirectoryExisting(const std::filesystem::path& path);
@@ -80,7 +79,7 @@ void SysFileFindFiles(const std::filesystem::path& path, std::vector<sys_file_fi
 // NOLINTNEXTLINE(google-runtime-references)
 void SysFileGetDents(const std::filesystem::path& path, std::vector<sys_dir_entry_t>& out);
 bool SysFileCopyFile(const std::filesystem::path& src, const std::filesystem::path& dst);
-bool SysFileMoveFile(const std::filesystem::path& src, const std::filesystem::path& dst);
+bool SysFileRenameFile(const std::filesystem::path& src, const std::filesystem::path& dst);
 void SysFileRemoveReadonly(const std::filesystem::path& name);
 
 #endif /* KYTY_COMMON_PLATFORM_SYSFILEIO_H_ */

src/common/platform/sysLinuxDbg.cpp

@@ -8,20 +8,13 @@
 
 #include <cstdlib>
 #include <cstring>
+#include <pthread.h>
 #include <sys/param.h>
 #include <sys/types.h>
 #include <unistd.h>
-
-void SysStackWalk(void** /*stack*/, int* depth) {
-	*depth = 0;
-}
-
-void SysStackUsagePrint(sys_dbg_stack_info_t& stack) {
-	printf("stack: (0x%" PRIx64 ", %" PRIu64 ")\n", static_cast<uint64_t>(stack.commited_addr),
-	       static_cast<uint64_t>(stack.commited_size));
-	printf("code: (0x%" PRIx64 ", %" PRIu64 ")\n", static_cast<uint64_t>(stack.code_addr),
-	       static_cast<uint64_t>(stack.code_size));
-}
+#if defined(__APPLE__)
+#include <libgen.h> // POSIX basename() lives here on macOS, not in <cstring>
+#endif
 
 void SysStackUsage(sys_dbg_stack_info_t& s) {
 	pid_t pid = getpid();
@@ -30,6 +23,33 @@ void SysStackUsage(sys_dbg_stack_info_t& s) {
 
 	[[maybe_unused]] int result = 0;
 
+	memset(&s, 0, sizeof(sys_dbg_stack_info_t));
+
+	// Record the reservation before the Linux /proc walk.
+	{
+		pthread_attr_t self_attr {};
+#if defined(__APPLE__)
+		void*        stack_top  = pthread_get_stackaddr_np(pthread_self());
+		const size_t stack_size = pthread_get_stacksize_np(pthread_self());
+		if (stack_top != nullptr && stack_size != 0) {
+			s.reserved_addr = reinterpret_cast<uintptr_t>(stack_top) - stack_size;
+			s.reserved_size = stack_size;
+		}
+		(void)self_attr;
+#else
+		if (pthread_getattr_np(pthread_self(), &self_attr) == 0) {
+			void*  stack_base = nullptr;
+			size_t stack_size = 0;
+			if (pthread_attr_getstack(&self_attr, &stack_base, &stack_size) == 0 &&
+			    stack_base != nullptr && stack_size != 0) {
+				s.reserved_addr = reinterpret_cast<uintptr_t>(stack_base);
+				s.reserved_size = stack_size;
+			}
+			pthread_attr_destroy(&self_attr);
+		}
+#endif
+	}
+
 	char str[1024];
 	char str2[1024];
 	result = sprintf(str, "/proc/%d/exe", static_cast<int>(pid));
@@ -43,8 +63,6 @@ void SysStackUsage(sys_dbg_stack_info_t& s) {
 
 	result = sprintf(str, "/proc/%d/maps", static_cast<int>(pid));
 
-	memset(&s, 0, sizeof(sys_dbg_stack_info_t));
-
 	FILE* f = fopen(str, "r");
 
 	if (f == nullptr) {
@@ -118,6 +136,11 @@ void SysStackUsage(sys_dbg_stack_info_t& s) {
 	}
 
 	result = fclose(f);
+
+	if (s.reserved_addr == 0) {
+		s.reserved_addr = s.addr;
+		s.reserved_size = s.total_size;
+	}
 }
 
 #endif

src/common/platform/sysLinuxFileIO.cpp

@@ -11,7 +11,12 @@
 
 #include <cerrno>
 #include <cstdlib>
+#include <cstring>
+#include <dirent.h>
+#include <fcntl.h>
+#include <filesystem>
 #include <sys/stat.h>
+#include <system_error>
 #include <unistd.h>
 #include <utime.h>
 
@@ -39,10 +44,43 @@ struct sys_file_t {
 	};
 };
 
+// Darwin uses BSD timestamp member names.
+#if defined(__APPLE__)
+#define KYTY_STAT_ATIME_NS(st) ((st).st_atimespec.tv_nsec)
+#define KYTY_STAT_MTIME_NS(st) ((st).st_mtimespec.tv_nsec)
+#else
+#define KYTY_STAT_ATIME_NS(st) ((st).st_atim.tv_nsec)
+#define KYTY_STAT_MTIME_NS(st) ((st).st_mtim.tv_nsec)
+#endif
+
 static std::filesystem::path get_internal_name(const std::filesystem::path& name) {
 	return name.is_absolute() ? name : (std::filesystem::path(".") / name);
 }
 
+// Pass access-pattern hints to the host.
+static void apply_cache_hint(FILE* f, sys_file_cache_type_t cache_type) {
+	if (f == nullptr) {
+		return;
+	}
+
+#if !defined(__APPLE__)
+	int advice = POSIX_FADV_NORMAL;
+	switch (cache_type) {
+		case SYS_FILE_CACHE_RANDOM_ACCESS: advice = POSIX_FADV_RANDOM; break;
+		case SYS_FILE_CACHE_SEQUENTIAL_SCAN: advice = POSIX_FADV_SEQUENTIAL; break;
+		case SYS_FILE_CACHE_AUTO:
+		default: return;
+	}
+	::posix_fadvise(fileno(f), 0, 0, advice);
+#else
+	if (cache_type == SYS_FILE_CACHE_SEQUENTIAL_SCAN) {
+		::fcntl(fileno(f), F_RDAHEAD, 1);
+	} else if (cache_type == SYS_FILE_CACHE_RANDOM_ACCESS) {
+		::fcntl(fileno(f), F_RDAHEAD, 0);
+	}
+#endif
+}
+
 void SysFileRead(void* data, uint32_t size, sys_file_t& f, uint32_t* bytes_read) {
 	if (f.type == SYS_FILE_FILE) {
 		size_t w = fread(data, 1, size, f.f);
@@ -114,10 +152,6 @@ void SysFileWrite(const void* data, uint32_t size, sys_file_t& f, uint32_t* byte
 	}
 }
 
-void SysFileWrite(uint32_t n, sys_file_t& f) {
-	SysFileWrite(&n, 4, f);
-}
-
 sys_file_t* SysFileCreate(const std::filesystem::path& file_name) {
 	auto* ret = new sys_file_t;
 
@@ -135,8 +169,7 @@ sys_file_t* SysFileCreate(const std::filesystem::path& file_name) {
 	return ret;
 }
 
-sys_file_t* SysFileOpenR(const std::filesystem::path& file_name,
-                         sys_file_cache_type_t /*cache_type*/) {
+sys_file_t* SysFileOpenR(const std::filesystem::path& file_name, sys_file_cache_type_t cache_type) {
 	auto* ret = new sys_file_t;
 
 	ret->type = SYS_FILE_FILE;
@@ -150,6 +183,8 @@ sys_file_t* SysFileOpenR(const std::filesystem::path& file_name,
 		ret->type = SYS_FILE_ERROR;
 	}
 
+	apply_cache_hint(f, cache_type);
+
 	ret->f = f;
 
 	return ret;
@@ -179,8 +214,7 @@ sys_file_t* SysFileCreate() {
 	return ret;
 }
 
-sys_file_t* SysFileOpenW(const std::filesystem::path& file_name,
-                         sys_file_cache_type_t /*cache_type*/) {
+sys_file_t* SysFileOpenW(const std::filesystem::path& file_name, sys_file_cache_type_t cache_type) {
 	auto* ret = new sys_file_t;
 
 	auto real_name     = get_internal_name(file_name);
@@ -194,13 +228,15 @@ sys_file_t* SysFileOpenW(const std::filesystem::path& file_name,
 		ret->type = SYS_FILE_FILE;
 	}
 
+	apply_cache_hint(f, cache_type);
+
 	ret->f = f;
 
 	return ret;
 }
 
 sys_file_t* SysFileOpenRw(const std::filesystem::path& file_name,
-                          sys_file_cache_type_t /*cache_type*/) {
+                          sys_file_cache_type_t        cache_type) {
 	auto* ret = new sys_file_t;
 
 	auto real_name     = get_internal_name(file_name);
@@ -214,6 +250,8 @@ sys_file_t* SysFileOpenRw(const std::filesystem::path& file_name,
 		ret->type = SYS_FILE_FILE;
 	}
 
+	apply_cache_hint(f, cache_type);
+
 	ret->f = f;
 
 	return ret;
@@ -239,11 +277,17 @@ uint64_t SysFileSize(sys_file_t& f) {
 	[[maybe_unused]] int result = 0;
 
 	if (f.type == SYS_FILE_FILE) {
-		uint32_t pos  = ftell(f.f);
-		result        = fseek(f.f, 0, SEEK_END);
-		uint32_t size = ftell(f.f);
-		result        = fseek(f.f, pos, SEEK_SET);
-		return size;
+		// Preserve sizes above 4 GiB.
+		const off_t pos = ftello(f.f);
+		if (pos < 0) {
+			return 0;
+		}
+		if (fseeko(f.f, 0, SEEK_END) != 0) {
+			return 0;
+		}
+		const off_t size = ftello(f.f);
+		result           = fseeko(f.f, pos, SEEK_SET);
+		return (size < 0 ? 0 : static_cast<uint64_t>(size));
 	}
 
 	if (f.type == SYS_FILE_MEMORY_STAT || f.type == SYS_FILE_MEMORY_DYN) {
@@ -260,8 +304,18 @@ uint64_t SysFileSize(const std::filesystem::path& file_name) {
 	return size;
 }
 
-bool SysFileTruncate(sys_file_t& /*f*/, uint64_t /*size*/) {
-	return false;
+bool SysFileTruncate(sys_file_t& f, uint64_t size) {
+	bool ok = false;
+	if (f.type == SYS_FILE_FILE) {
+		// Flush before resizing and restore the caller's position.
+		const auto position = ftell(f.f);
+		fflush(f.f);
+		ok = (ftruncate(fileno(f.f), static_cast<off_t>(size)) == 0);
+		if (position >= 0) {
+			fseek(f.f, position, SEEK_SET);
+		}
+	}
+	return ok;
 }
 
 bool SysFileUnlink(sys_file_t& /*f*/, const std::filesystem::path& name) {
@@ -382,6 +436,7 @@ SysFileTimeStruct SysFileGetLastAccessTimeUtc(const std::filesystem::path& name)
 	} else {
 		r.is_invalid = false;
 		r.time       = s.st_atime;
+		r.nanos      = KYTY_STAT_ATIME_NS(s);
 	}
 
 	return r;
@@ -400,6 +455,7 @@ SysFileTimeStruct SysFileGetLastWriteTimeUtc(const std::filesystem::path& name)
 	} else {
 		r.is_invalid = false;
 		r.time       = s.st_mtime;
+		r.nanos      = KYTY_STAT_MTIME_NS(s);
 	}
 
 	return r;
@@ -419,13 +475,36 @@ void SysFileGetLastAccessAndWriteTimeUtc(const std::filesystem::path& name, SysF
 		a.is_invalid = false;
 		w.is_invalid = false;
 		a.time       = s.st_atime;
+		a.nanos      = KYTY_STAT_ATIME_NS(s);
 		w.time       = s.st_mtime;
+		w.nanos      = KYTY_STAT_MTIME_NS(s);
 	}
 }
 
-void SysFileGetLastAccessAndWriteTimeUtc(sys_file_t& /*f*/, SysFileTimeStruct& /*a*/,
-                                         SysFileTimeStruct& /*w*/) {
-	EXIT("not implemented\n");
+void SysFileGetLastAccessAndWriteTimeUtc(sys_file_t& f, SysFileTimeStruct& a,
+                                         SysFileTimeStruct& w) {
+	if (f.type == SYS_FILE_FILE) {
+		struct stat s {};
+
+		const bool ok = (0 == fstat(fileno(f.f), &s));
+
+		a.is_invalid = w.is_invalid = !ok;
+
+		if (ok) {
+			a.time  = s.st_atime;
+			a.nanos = KYTY_STAT_ATIME_NS(s);
+			w.time  = s.st_mtime;
+			w.nanos = KYTY_STAT_MTIME_NS(s);
+		}
+	} else if (f.type == SYS_FILE_MEMORY_STAT || f.type == SYS_FILE_MEMORY_DYN) {
+		// Memory-backed files use the current time.
+		SysTimeStruct t {};
+		SysGetSystemTimeUtc(t);
+		SysSystemToFileTimeUtc(t, a);
+		SysSystemToFileTimeUtc(t, w);
+	} else {
+		a.is_invalid = w.is_invalid = true;
+	}
 }
 
 bool SysFileSetLastAccessTimeUtc(const std::filesystem::path& name, SysFileTimeStruct& access) {
@@ -531,27 +610,110 @@ bool SysFileSetLastAccessAndWriteTimeUtc(const std::filesystem::path& name,
 	//	}
 }
 
-void SysFileFindFiles(const std::filesystem::path& /*path*/,
-                      std::vector<sys_file_find_t>& /*out*/) {
-	EXIT("not implemented\n");
+// Recursively collect regular files.
+void SysFileFindFiles(const std::filesystem::path& path, std::vector<sys_file_find_t>& out) {
+	auto real_path = get_internal_name(path);
+
+	DIR* dir = opendir(real_path.string().c_str());
+	if (dir == nullptr) {
+		return;
+	}
+
+	for (const dirent* entry = readdir(dir); entry != nullptr; entry = readdir(dir)) {
+		const std::string file_name(entry->d_name);
+
+		if (file_name == "." || file_name == "..") {
+			continue;
+		}
+
+		auto        child = real_path / file_name;
+		struct stat s {};
+
+		// lstat, so a symlink is never followed into a cycle during the recursive walk.
+		if (0 != lstat(child.string().c_str(), &s)) {
+			continue;
+		}
+
+		if (S_ISDIR(s.st_mode)) {
+			SysFileFindFiles(child, out);
+		} else if (S_ISREG(s.st_mode)) {
+			sys_file_find_t r {};
+
+			r.path_with_name              = child;
+			r.size                        = static_cast<uint64_t>(s.st_size);
+			r.last_access_time.is_invalid = false;
+			r.last_access_time.time       = s.st_atime;
+			r.last_access_time.nanos      = KYTY_STAT_ATIME_NS(s);
+			r.last_write_time.is_invalid  = false;
+			r.last_write_time.time        = s.st_mtime;
+			r.last_write_time.nanos       = KYTY_STAT_MTIME_NS(s);
+
+			out.push_back(r);
+		}
+	}
+
+	closedir(dir);
 }
 
-void SysFileGetDents(const std::filesystem::path& /*path*/, std::vector<sys_dir_entry_t>& /*out*/) {
-	EXIT("not implemented\n");
+// Keep "." and ".." to match FindFirstFileW.
+void SysFileGetDents(const std::filesystem::path& path, std::vector<sys_dir_entry_t>& out) {
+	auto real_path = get_internal_name(path);
+
+	DIR* dir = opendir(real_path.string().c_str());
+	if (dir == nullptr) {
+		return;
+	}
+
+	for (const dirent* entry = readdir(dir); entry != nullptr; entry = readdir(dir)) {
+		sys_dir_entry_t r {};
+
+		r.name = entry->d_name;
+
+		if (entry->d_type == DT_UNKNOWN) {
+			// Some filesystems do not populate d_type.
+			struct stat s {};
+			r.is_file = 0 == lstat((real_path / r.name).string().c_str(), &s) && S_ISREG(s.st_mode);
+		} else {
+			r.is_file = entry->d_type != DT_DIR;
+		}
+
+		out.push_back(r);
+	}
+
+	closedir(dir);
 }
 
-bool SysFileCopyFile(const std::filesystem::path& /*src*/, const std::filesystem::path& /*dst*/) {
-	EXIT("not implemented\n");
-	return false;
+bool SysFileCopyFile(const std::filesystem::path& src, const std::filesystem::path& dst) {
+	std::error_code error;
+	return std::filesystem::copy_file(get_internal_name(src), get_internal_name(dst),
+	                                  std::filesystem::copy_options::overwrite_existing, error) &&
+	       !error;
 }
 
-bool SysFileMoveFile(const std::filesystem::path& /*src*/, const std::filesystem::path& /*dst*/) {
-	EXIT("not implemented\n");
-	return false;
+bool SysFileRenameFile(const std::filesystem::path& src, const std::filesystem::path& dst) {
+	auto real_src = get_internal_name(src);
+	auto real_dst = get_internal_name(dst);
+
+	// Match MoveFileW: fail when the destination exists.
+	std::error_code error;
+	if (std::filesystem::exists(real_dst, error)) {
+		return false;
+	}
+
+	return 0 == rename(real_src.string().c_str(), real_dst.string().c_str());
 }
 
-void SysFileRemoveReadonly(const std::filesystem::path& /*name*/) {
-	EXIT("not implemented\n");
+void SysFileRemoveReadonly(const std::filesystem::path& name) {
+	auto real_name     = get_internal_name(name);
+	auto real_name_str = real_name.string();
+
+	struct stat s {};
+
+	if (0 != stat(real_name_str.c_str(), &s)) {
+		return;
+	}
+
+	chmod(real_name_str.c_str(), s.st_mode | S_IWUSR);
 }
 
 #endif

src/common/platform/sysLinuxVirtual.cpp

@@ -5,12 +5,18 @@
 #else
 
 #include "common/assert.h"
-#include "common/platform/sysVirtual.h"
 #include "common/virtualMemory.h"
 
+#include <atomic>
 #include <map>
 #include <pthread.h>
 #include <sys/mman.h>
+#include <unistd.h>
+
+#if defined(__APPLE__)
+#include <mach/mach.h>
+#include <mach/mach_vm.h>
+#endif
 
 // IWYU pragma: no_include <asm/mman-common.h>
 // IWYU pragma: no_include <asm/mman.h>
@@ -21,81 +27,122 @@
 #define KYTY_FIXED_NOREPLACE
 #endif
 
-namespace Common {
+namespace Common::VirtualMemory {
 
 static pthread_mutex_t              g_virtual_mutex {};
-static std::map<uintptr_t, size_t>* g_allocs   = nullptr;
-static std::map<uintptr_t, int>*    g_protects = nullptr;
+static std::map<uintptr_t, size_t>* g_allocs = nullptr;
 
-void SysVirtualInit() {
+void Init() {
 	pthread_mutexattr_t attr {};
 
 	pthread_mutexattr_init(&attr);
-#if KYTY_PLATFORM == KYTY_PLATFORM_LINUX
-	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_FAST_NP);
+#if KYTY_PLATFORM == KYTY_PLATFORM_LINUX && !defined(__APPLE__)
+	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_FAST_NP); // glibc-only fast mutex
 #else
 	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
 #endif
 	pthread_mutex_init(&g_virtual_mutex, &attr);
 	pthread_mutexattr_destroy(&attr);
 
-	g_allocs   = new std::map<uintptr_t, size_t>;
-	g_protects = new std::map<uintptr_t, int>;
+	g_allocs = new std::map<uintptr_t, size_t>;
 }
 
-static int get_protection_flag(VirtualMemory::Mode mode) {
+static int get_protection_flag(Mode mode) {
 	int protect = PROT_NONE;
 	switch (mode) {
-		case VirtualMemory::Mode::Read: protect = PROT_READ; break;
-		case VirtualMemory::Mode::Write:
-		case VirtualMemory::Mode::ReadWrite: protect = PROT_READ | PROT_WRITE; break; // NOLINT
-		case VirtualMemory::Mode::Execute: protect = PROT_EXEC; break;
-		case VirtualMemory::Mode::ExecuteRead: protect = PROT_EXEC | PROT_READ; break; // NOLINT
-		case VirtualMemory::Mode::ExecuteWrite:
-		case VirtualMemory::Mode::ExecuteReadWrite:
+		case Mode::Read: protect = PROT_READ; break;
+		case Mode::Write:
+		case Mode::ReadWrite: protect = PROT_READ | PROT_WRITE; break; // NOLINT
+		case Mode::Execute: protect = PROT_EXEC; break;
+		case Mode::ExecuteRead: protect = PROT_EXEC | PROT_READ; break; // NOLINT
+		case Mode::ExecuteWrite:
+		case Mode::ExecuteReadWrite:
 			protect = PROT_EXEC | PROT_WRITE | PROT_READ;
 			break; // NOLINT
-		case VirtualMemory::Mode::NoAccess:
+		case Mode::NoAccess:
 		default: protect = PROT_NONE; break;
 	}
 	return protect;
 }
 
-static VirtualMemory::Mode get_protection_flag(int mode) {
-	switch (mode) {
-		case PROT_NONE: return VirtualMemory::Mode::NoAccess;
-		case PROT_READ: return VirtualMemory::Mode::Read;
-		case PROT_WRITE: return VirtualMemory::Mode::Write;
-		case PROT_READ | PROT_WRITE: return VirtualMemory::Mode::ReadWrite; // NOLINT
-		case PROT_EXEC: return VirtualMemory::Mode::Execute;
-		case PROT_EXEC | PROT_WRITE: return VirtualMemory::Mode::ExecuteWrite; // NOLINT
-		case PROT_EXEC | PROT_READ: return VirtualMemory::Mode::ExecuteRead;   // NOLINT
-		case PROT_EXEC | PROT_WRITE | PROT_READ:
-			return VirtualMemory::Mode::ExecuteReadWrite; // NOLINT
-		default: return VirtualMemory::Mode::NoAccess;
+// Keep automatic mappings inside the guest and GPU-addressable low window.
+#ifdef KYTY_FIXED_NOREPLACE
+static constexpr uintptr_t LOW_ARENA_LIMIT = 0x000000FC00000000ULL; // libc mspace window ceiling
+static constexpr uintptr_t LOW_ARENA_FLOOR = 0x000000A000000000ULL; // 640 GiB
+static constexpr uintptr_t LOW_ARENA_GRAIN = 0x0000000000010000ULL; // 64 KiB
+
+static_assert(LOW_ARENA_LIMIT <= 0x0000010000000000ULL,
+              "arena must stay inside the GPU page tracker's 1<<40 window");
+static_assert(LOW_ARENA_FLOOR < LOW_ARENA_LIMIT, "arena floor must sit below its ceiling");
+
+static std::atomic<uintptr_t> g_low_arena_next {LOW_ARENA_LIMIT};
+#endif
+
+// Caller holds g_virtual_mutex.
+static void record_alloc(uintptr_t addr, size_t size) {
+	auto next = g_allocs->upper_bound(addr);
+	if (next != g_allocs->begin()) {
+		auto       it         = std::prev(next);
+		const auto alloc_addr = it->first;
+		const auto alloc_end  = alloc_addr + it->second;
+		if (alloc_addr <= addr && addr + size <= alloc_end) {
+			g_allocs->erase(it);
+			if (alloc_addr < addr) {
+				(*g_allocs)[alloc_addr] = addr - alloc_addr;
+			}
+			if (addr + size < alloc_end) {
+				(*g_allocs)[addr + size] = alloc_end - (addr + size);
+			}
+		}
 	}
+	(*g_allocs)[addr] = size;
 }
 
-uint64_t SysVirtualAlloc(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
+#ifdef KYTY_FIXED_NOREPLACE
+static uintptr_t align_up_to(uintptr_t addr, uint64_t alignment) {
+	return (addr + alignment - 1) & ~(alignment - 1);
+}
+#endif
+
+// Freed arena addresses are not reused while GPU caches remain keyed by address.
+static void* map_anonymous(uintptr_t addr, size_t size, int protect, int flags) {
+	if (addr != 0) {
+		return mmap(reinterpret_cast<void*>(addr), size, protect, flags, -1, 0); // NOLINT
+	}
+
+#ifdef KYTY_FIXED_NOREPLACE
+	const auto step = align_up_to(size, LOW_ARENA_GRAIN);
+	for (int attempt = 0; attempt < 256; attempt++) {
+		const auto top = g_low_arena_next.fetch_sub(step, std::memory_order_relaxed);
+		if (top < step || top - step < LOW_ARENA_FLOOR) {
+			break;
+		}
+		const auto hint = (top - step) & ~(LOW_ARENA_GRAIN - 1);
+		void* ptr = mmap(reinterpret_cast<void*>(hint), size, protect, flags | MAP_FIXED_NOREPLACE,
+		                 -1, 0); // NOLINT
+		if (ptr != MAP_FAILED) {
+			return ptr;
+		}
+	}
+#endif
+
+	return mmap(nullptr, size, protect, flags, -1, 0); // NOLINT
+}
+
+uint64_t Alloc(uint64_t address, uint64_t size, Mode mode) {
 	EXIT_IF(g_allocs == nullptr);
 
 	auto addr = static_cast<uintptr_t>(address);
 
 	int protect = get_protection_flag(mode);
 
-	void* ptr =
-	    mmap(reinterpret_cast<void*>(addr), size, protect, MAP_PRIVATE | MAP_ANON, -1, 0); // NOLINT
+	void* ptr = map_anonymous(addr, size, protect, MAP_PRIVATE | MAP_ANON);
 
 	auto ret_addr = reinterpret_cast<uintptr_t>(ptr);
 
 	if (ptr != MAP_FAILED) {
 		pthread_mutex_lock(&g_virtual_mutex);
-		(*g_allocs)[ret_addr] = size;
-		uintptr_t page_start  = ret_addr >> 12u;
-		uintptr_t page_end    = (ret_addr + size - 1) >> 12u;
-		for (uintptr_t page = page_start; page <= page_end; page++) {
-			(*g_protects)[page] = protect;
-		}
+		record_alloc(ret_addr, size);
 		pthread_mutex_unlock(&g_virtual_mutex);
 	}
 
@@ -106,8 +153,7 @@ static uintptr_t align_up(uintptr_t addr, uint64_t alignment) {
 	return (addr + alignment - 1) & ~(alignment - 1);
 }
 
-uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::Mode mode,
-                                uint64_t alignment) {
+uint64_t AllocAligned(uint64_t address, uint64_t size, Mode mode, uint64_t alignment) {
 	if (alignment == 0) {
 		return 0;
 	}
@@ -117,18 +163,43 @@ uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::
 	auto addr    = static_cast<uintptr_t>(address);
 	int  protect = get_protection_flag(mode);
 
-	void* ptr =
-	    mmap(reinterpret_cast<void*>(addr), size, protect, MAP_PRIVATE | MAP_ANON, -1, 0); // NOLINT
+	void* ptr = map_anonymous(addr, size, protect, MAP_PRIVATE | MAP_ANON);
 
 	auto ret_addr = reinterpret_cast<uintptr_t>(ptr);
 
 	if (ptr != MAP_FAILED && ((ret_addr & (alignment - 1)) != 0)) {
 		munmap(ptr, size);
 
-		ptr      = mmap(reinterpret_cast<void*>(addr), size + alignment, protect,
-		                MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0); // NOLINT
+		ptr =
+		    map_anonymous(addr, size + alignment, protect, MAP_PRIVATE | MAP_ANON | MAP_NORESERVE);
 		ret_addr = reinterpret_cast<uintptr_t>(ptr);
 		if (ptr != MAP_FAILED) {
+#if defined(__APPLE__)
+			// Carve the aligned subrange out of the live mapping with MAP_FIXED (in-place
+			// replacement) and trim the slack; never munmap the whole range first, or a
+			// concurrent host mapping (dyld, Rosetta, Metal) could claim the hole and be
+			// destroyed by the MAP_FIXED. Other platforms keep the original path below.
+			auto aligned_addr = align_up(ret_addr, alignment);
+			// NOLINTNEXTLINE
+			void* fixed = mmap(reinterpret_cast<void*>(aligned_addr), size, protect,
+			                   MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1, 0);
+			if (fixed == MAP_FAILED) {
+				munmap(ptr, size + alignment);
+				ret_addr = 0;
+				ptr      = MAP_FAILED;
+			} else {
+				if (aligned_addr > ret_addr) {
+					munmap(reinterpret_cast<void*>(ret_addr), aligned_addr - ret_addr);
+				}
+				const uintptr_t tail_start = aligned_addr + size;
+				const uintptr_t resv_end   = ret_addr + size + alignment;
+				if (resv_end > tail_start) {
+					munmap(reinterpret_cast<void*>(tail_start), resv_end - tail_start);
+				}
+				ptr      = fixed;
+				ret_addr = aligned_addr;
+			}
+#else
 			munmap(ptr, size + alignment);
 			auto aligned_addr = align_up(ret_addr, alignment);
 #ifdef KYTY_FIXED_NOREPLACE
@@ -146,25 +217,42 @@ uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::
 				ret_addr = 0;
 				ptr      = MAP_FAILED;
 			}
+#endif
 		}
 	}
 
 	if (ptr == MAP_FAILED) {
-		return SysVirtualAllocAligned(address, size, mode, alignment << 1u);
+		return AllocAligned(address, size, mode, alignment << 1u);
 	}
 
 	pthread_mutex_lock(&g_virtual_mutex);
-	(*g_allocs)[ret_addr] = size;
-	uintptr_t page_start  = ret_addr >> 12u;
-	uintptr_t page_end    = (ret_addr + size - 1) >> 12u;
-	for (uintptr_t page = page_start; page <= page_end; page++) {
-		(*g_protects)[page] = protect;
-	}
+	record_alloc(ret_addr, size);
 	pthread_mutex_unlock(&g_virtual_mutex);
 
 	return ret_addr;
 }
 
+#if defined(__APPLE__)
+// macOS has no /proc/self/maps; query the Mach VM map directly. mach_vm_region returns
+// the first mapped region at or above `region_addr`; if it begins before the end of the
+// requested range, the range overlaps an existing mapping.
+static bool is_mapped(void* ptr, size_t length) {
+	auto                           query_addr  = reinterpret_cast<mach_vm_address_t>(ptr);
+	mach_vm_address_t              region_addr = query_addr;
+	mach_vm_size_t                 region_size = 0;
+	vm_region_basic_info_data_64_t info {};
+	mach_msg_type_number_t         count       = VM_REGION_BASIC_INFO_COUNT_64;
+	mach_port_t                    object_name = MACH_PORT_NULL;
+
+	kern_return_t kr =
+	    mach_vm_region(mach_task_self(), &region_addr, &region_size, VM_REGION_BASIC_INFO_64,
+	                   reinterpret_cast<vm_region_info_t>(&info), &count, &object_name);
+	if (kr != KERN_SUCCESS) {
+		return false; // no region at or above the address → unmapped
+	}
+	return region_addr < (query_addr + length);
+}
+#else
 static bool is_mapped(void* ptr, size_t length) {
 	FILE* file = fopen("/proc/self/maps", "r");
 	char  line[1024];
@@ -189,8 +277,9 @@ static bool is_mapped(void* ptr, size_t length) {
 	fclose(file);
 	return ret;
 }
+#endif
 
-bool SysVirtualAllocFixed(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
+bool AllocFixed(uint64_t address, uint64_t size, Mode mode) {
 	EXIT_IF(g_allocs == nullptr);
 
 	auto addr    = static_cast<uintptr_t>(address);
@@ -218,12 +307,7 @@ bool SysVirtualAllocFixed(uint64_t address, uint64_t size, VirtualMemory::Mode m
 
 	if (ptr != MAP_FAILED) {
 		pthread_mutex_lock(&g_virtual_mutex);
-		(*g_allocs)[ret_addr] = size;
-		uintptr_t page_start  = ret_addr >> 12u;
-		uintptr_t page_end    = (ret_addr + size - 1) >> 12u;
-		for (uintptr_t page = page_start; page <= page_end; page++) {
-			(*g_protects)[page] = protect;
-		}
+		record_alloc(ret_addr, size);
 		pthread_mutex_unlock(&g_virtual_mutex);
 
 		return true;
@@ -232,15 +316,15 @@ bool SysVirtualAllocFixed(uint64_t address, uint64_t size, VirtualMemory::Mode m
 	return false;
 }
 
-bool SysVirtualCommit(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
-	return SysVirtualProtect(address, size, mode);
+bool Commit(uint64_t address, uint64_t size, Mode mode) {
+	return Protect(address, size, mode);
 }
 
-uint64_t SysVirtualReserve(uint64_t address, uint64_t size) {
-	return SysVirtualReserveAligned(address, size, 1);
+uint64_t Reserve(uint64_t address, uint64_t size) {
+	return ReserveAligned(address, size, 1);
 }
 
-uint64_t SysVirtualReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
+uint64_t ReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
 	if (alignment == 0) {
 		return 0;
 	}
@@ -249,18 +333,44 @@ uint64_t SysVirtualReserveAligned(uint64_t address, uint64_t size, uint64_t alig
 
 	auto addr = static_cast<uintptr_t>(address);
 
-	void* ptr = mmap(reinterpret_cast<void*>(addr), size, PROT_NONE,
-	                 MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0); // NOLINT
+	void* ptr = map_anonymous(addr, size, PROT_NONE, MAP_PRIVATE | MAP_ANON | MAP_NORESERVE);
 
 	auto ret_addr = reinterpret_cast<uintptr_t>(ptr);
 
 	if (ptr != MAP_FAILED && ((ret_addr & (alignment - 1)) != 0)) {
 		munmap(ptr, size);
 
-		ptr      = mmap(reinterpret_cast<void*>(addr), size + alignment, PROT_NONE,
-		                MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0); // NOLINT
+		ptr      = map_anonymous(addr, size + alignment, PROT_NONE,
+		                         MAP_PRIVATE | MAP_ANON | MAP_NORESERVE);
 		ret_addr = reinterpret_cast<uintptr_t>(ptr);
 		if (ptr != MAP_FAILED) {
+#if defined(__APPLE__)
+			// Carve the aligned subrange out of the live reservation with MAP_FIXED (an
+			// in-place replacement), then trim the slack. The range must never be
+			// returned to the OS in between: another thread (dyld, Rosetta, Metal,
+			// malloc) could claim the hole, and the subsequent MAP_FIXED would silently
+			// destroy its mapping. Other platforms keep the original path below.
+			auto aligned_addr = align_up(ret_addr, alignment);
+			// NOLINTNEXTLINE
+			void* fixed = mmap(reinterpret_cast<void*>(aligned_addr), size, PROT_NONE,
+			                   MAP_FIXED | MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0);
+			if (fixed == MAP_FAILED) {
+				munmap(ptr, size + alignment);
+				ret_addr = 0;
+				ptr      = MAP_FAILED;
+			} else {
+				if (aligned_addr > ret_addr) {
+					munmap(reinterpret_cast<void*>(ret_addr), aligned_addr - ret_addr);
+				}
+				const uintptr_t tail_start = aligned_addr + size;
+				const uintptr_t resv_end   = ret_addr + size + alignment;
+				if (resv_end > tail_start) {
+					munmap(reinterpret_cast<void*>(tail_start), resv_end - tail_start);
+				}
+				ptr      = fixed;
+				ret_addr = aligned_addr;
+			}
+#else
 			munmap(ptr, size + alignment);
 			auto aligned_addr = align_up(ret_addr, alignment);
 #ifdef KYTY_FIXED_NOREPLACE
@@ -278,26 +388,22 @@ uint64_t SysVirtualReserveAligned(uint64_t address, uint64_t size, uint64_t alig
 				ret_addr = 0;
 				ptr      = MAP_FAILED;
 			}
+#endif
 		}
 	}
 
 	if (ptr == MAP_FAILED) {
-		return SysVirtualReserveAligned(address, size, alignment << 1u);
+		return ReserveAligned(address, size, alignment << 1u);
 	}
 
 	pthread_mutex_lock(&g_virtual_mutex);
-	(*g_allocs)[ret_addr] = size;
-	uintptr_t page_start  = ret_addr >> 12u;
-	uintptr_t page_end    = (ret_addr + size - 1) >> 12u;
-	for (uintptr_t page = page_start; page <= page_end; page++) {
-		(*g_protects)[page] = PROT_NONE;
-	}
+	record_alloc(ret_addr, size);
 	pthread_mutex_unlock(&g_virtual_mutex);
 
 	return ret_addr;
 }
 
-bool SysVirtualReserveFixed(uint64_t address, uint64_t size) {
+bool ReserveFixed(uint64_t address, uint64_t size) {
 	EXIT_IF(g_allocs == nullptr);
 
 	auto addr = static_cast<uintptr_t>(address);
@@ -324,12 +430,7 @@ bool SysVirtualReserveFixed(uint64_t address, uint64_t size) {
 
 	if (ptr != MAP_FAILED) {
 		pthread_mutex_lock(&g_virtual_mutex);
-		(*g_allocs)[ret_addr] = size;
-		uintptr_t page_start  = ret_addr >> 12u;
-		uintptr_t page_end    = (ret_addr + size - 1) >> 12u;
-		for (uintptr_t page = page_start; page <= page_end; page++) {
-			(*g_protects)[page] = PROT_NONE;
-		}
+		record_alloc(ret_addr, size);
 		pthread_mutex_unlock(&g_virtual_mutex);
 
 		return true;
@@ -338,11 +439,33 @@ bool SysVirtualReserveFixed(uint64_t address, uint64_t size) {
 	return false;
 }
 
-bool SysVirtualDecommit(uint64_t address, uint64_t size) {
-	return SysVirtualProtect(address, size, VirtualMemory::Mode::NoAccess);
+bool Decommit(uint64_t address, uint64_t size) {
+	// Drop physical pages while preserving the reservation.
+	if (!Protect(address, size, Mode::NoAccess)) {
+		return false;
+	}
+
+	if (size != 0) {
+#if defined(__APPLE__)
+		constexpr int RECLAIM_ADVICE = MADV_FREE;
+#else
+		constexpr int RECLAIM_ADVICE = MADV_DONTNEED;
+#endif
+		const auto page_size = static_cast<uintptr_t>(sysconf(_SC_PAGESIZE));
+		if (page_size != 0) {
+			// Do not discard pages outside the requested range.
+			const auto begin = (static_cast<uintptr_t>(address) + page_size - 1) & ~(page_size - 1);
+			const auto end   = (static_cast<uintptr_t>(address) + size) & ~(page_size - 1);
+			if (end > begin) {
+				::madvise(reinterpret_cast<void*>(begin), end - begin, RECLAIM_ADVICE);
+			}
+		}
+	}
+
+	return true;
 }
 
-bool SysVirtualFree(uint64_t address) {
+bool Free(uint64_t address) {
 	EXIT_IF(g_allocs == nullptr);
 	size_t size = 0;
 
@@ -359,21 +482,10 @@ bool SysVirtualFree(uint64_t address) {
 		return false;
 	}
 
-	if (munmap(reinterpret_cast<void*>(addr), size) == 0) {
-		uintptr_t page_start = addr >> 12u;
-		uintptr_t page_end   = (addr + size - 1) >> 12u;
-		pthread_mutex_lock(&g_virtual_mutex);
-		for (uintptr_t page = page_start; page <= page_end; page++) {
-			g_protects->erase(page);
-		}
-		pthread_mutex_unlock(&g_virtual_mutex);
-		return true;
-	}
-
-	return false;
+	return munmap(reinterpret_cast<void*>(addr), size) == 0;
 }
 
-bool SysVirtualFreeRange(uint64_t address, uint64_t size) {
+bool FreeRange(uint64_t address, uint64_t size) {
 	EXIT_IF(g_allocs == nullptr);
 	if (size == 0 || (address & 0xfffu) != 0 || (size & 0xfffu) != 0) {
 		return false;
@@ -391,61 +503,56 @@ bool SysVirtualFreeRange(uint64_t address, uint64_t size) {
 		pthread_mutex_unlock(&g_virtual_mutex);
 		return false;
 	}
-	auto       it         = std::prev(next);
-	const auto alloc_addr = it->first;
-	const auto alloc_end  = alloc_addr + it->second;
-	if (addr < alloc_addr || end > alloc_end || munmap(reinterpret_cast<void*>(addr), size) != 0) {
+
+	// A reservation may have been split into several adjacent records.
+	auto       first      = std::prev(next);
+	const auto alloc_addr = first->first;
+	if (addr < alloc_addr || alloc_addr + first->second <= addr) {
 		pthread_mutex_unlock(&g_virtual_mutex);
 		return false;
 	}
 
-	g_allocs->erase(it);
+	auto      last   = first;
+	uintptr_t cursor = alloc_addr + first->second;
+	while (cursor < end) {
+		auto following = std::next(last);
+		if (following == g_allocs->end() || following->first != cursor) {
+			pthread_mutex_unlock(&g_virtual_mutex);
+			return false;
+		}
+		last   = following;
+		cursor = following->first + following->second;
+	}
+	const auto alloc_end = cursor;
+
+	if (munmap(reinterpret_cast<void*>(addr), size) != 0) {
+		pthread_mutex_unlock(&g_virtual_mutex);
+		return false;
+	}
+
+	g_allocs->erase(first, std::next(last));
 	if (alloc_addr < addr) {
 		(*g_allocs)[alloc_addr] = addr - alloc_addr;
 	}
 	if (end < alloc_end) {
 		(*g_allocs)[end] = alloc_end - end;
 	}
-	for (uintptr_t page = addr >> 12u; page <= (end - 1u) >> 12u; page++) {
-		g_protects->erase(page);
-	}
 	pthread_mutex_unlock(&g_virtual_mutex);
 	return true;
 }
 
-bool SysVirtualProtect(uint64_t address, uint64_t size, VirtualMemory::Mode mode,
-                       VirtualMemory::Mode* old_mode) {
-	auto addr = static_cast<uintptr_t>(address);
-
-	pthread_mutex_lock(&g_virtual_mutex);
-	if (old_mode != nullptr) {
-		if (auto s = g_protects->find(addr >> 12u); s != g_protects->end()) {
-			*old_mode = get_protection_flag(s->second);
-		} else {
-			*old_mode = VirtualMemory::Mode::NoAccess;
-		}
-	}
-	pthread_mutex_unlock(&g_virtual_mutex);
-
-	uintptr_t page_start = addr >> 12u;
-	uintptr_t page_end   = (addr + size - 1) >> 12u;
-	if (mprotect(reinterpret_cast<void*>(page_start << 12u), (page_end - page_start + 1) << 12u,
-	             get_protection_flag(mode)) == 0) {
-		pthread_mutex_lock(&g_virtual_mutex);
-		for (uintptr_t page = page_start; page <= page_end; page++) {
-			(*g_protects)[page] = get_protection_flag(mode);
-		}
-		pthread_mutex_unlock(&g_virtual_mutex);
-		return true;
-	}
-
-	return false;
+bool Protect(uint64_t address, uint64_t size, Mode mode) {
+	const auto addr       = static_cast<uintptr_t>(address);
+	const auto page_start = addr >> 12u;
+	const auto page_end   = (addr + size - 1) >> 12u;
+	return mprotect(reinterpret_cast<void*>(page_start << 12u), (page_end - page_start + 1) << 12u,
+	                get_protection_flag(mode)) == 0;
 }
 
-bool SysVirtualFlushInstructionCache(uint64_t /*address*/, uint64_t /*size*/) {
+bool FlushInstructionCache(uint64_t /*address*/, uint64_t /*size*/) {
 	return true;
 }
 
-} // namespace Common
+} // namespace Common::VirtualMemory
 
 #endif

src/common/platform/sysSwapByteOrder.h

@@ -1,53 +0,0 @@
-#ifndef KYTY_COMMON_PLATFORM_SYSSWAPBYTEORDER_H_
-#define KYTY_COMMON_PLATFORM_SYSSWAPBYTEORDER_H_
-
-#include "common/common.h"
-
-#include <type_traits>
-
-inline uint16_t SwapByteOrder16(uint16_t value) {
-	uint16_t hi = value << 8u;
-	uint16_t lo = value >> 8u;
-	return hi | lo;
-}
-
-inline uint32_t SwapByteOrder32(uint32_t value) {
-	return __builtin_bswap32(value);
-}
-
-inline uint64_t SwapByteOrder64(uint64_t value) {
-	return __builtin_bswap64(value);
-}
-
-template <typename T>
-inline void SwapByteOrder(T& x) {
-	if (sizeof(x) == 2) {
-		if (std::is_signed_v<T>) {
-			x = static_cast<std::make_signed_t<T>>(
-			    SwapByteOrder16(static_cast<std::make_unsigned_t<uint16_t>>(x)));
-		} else {
-			x = SwapByteOrder16(x);
-		}
-	}
-	if (sizeof(x) == 4) {
-		if (std::is_signed_v<T>) {
-			x = static_cast<std::make_signed_t<T>>(
-			    SwapByteOrder32(static_cast<std::make_unsigned_t<uint32_t>>(x)));
-		} else {
-			x = SwapByteOrder32(x);
-		}
-	}
-	if (sizeof(x) == 8) {
-		if (std::is_signed_v<T>) {
-			x = static_cast<std::make_signed_t<T>>(
-			    SwapByteOrder64(static_cast<std::make_unsigned_t<uint64_t>>(x)));
-		} else {
-			x = SwapByteOrder64(x);
-		}
-	}
-}
-
-template <typename T>
-inline void NoSwapByteOrder(T& x) {}
-
-#endif /* KYTY_COMMON_PLATFORM_SYSSWAPBYTEORDER_H_ */

src/common/platform/sysTimer.h

@@ -27,7 +27,9 @@ struct SysFileTimeStruct {
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	FILETIME time;
 #elif KYTY_PLATFORM == KYTY_PLATFORM_LINUX
+	// Nanoseconds preserve sub-second file timestamps.
 	time_t time;
+	long   nanos;
 #endif
 	bool is_invalid;
 };
@@ -139,7 +141,7 @@ inline void SysFileToSystemTimeUtc(const SysFileTimeStruct& f, SysTimeStruct& t)
 	t.Hour         = i.tm_hour;
 	t.Minute       = i.tm_min;
 	t.Second       = (i.tm_sec == 60 ? 59 : i.tm_sec);
-	t.Milliseconds = 0;
+	t.Milliseconds = static_cast<uint16_t>((f.nanos / 1000000) % 1000);
 }
 
 inline void SysTimeTToSystem(time_t t, SysTimeStruct& s) {
@@ -149,10 +151,6 @@ inline void SysTimeTToSystem(time_t t, SysTimeStruct& s) {
 	SysFileToSystemTimeUtc(ft, s);
 }
 
-inline time_t SysTimegm(struct tm* tm) {
-	return timegm(tm);
-}
-
 inline void SysSystemToFileTimeUtc(const SysTimeStruct& f, SysFileTimeStruct& t) {
 	struct tm i {};
 
@@ -163,15 +161,16 @@ inline void SysSystemToFileTimeUtc(const SysTimeStruct& f, SysFileTimeStruct& t)
 	i.tm_min  = f.Minute;
 	i.tm_sec  = f.Second;
 
-	t.is_invalid = (f.is_invalid || (t.time = SysTimegm(&i)) == static_cast<time_t>(-1));
+	t.is_invalid = (f.is_invalid || (t.time = ::timegm(&i)) == static_cast<time_t>(-1));
 }
 
 // Retrieves the current local date and time.
 inline void SysGetSystemTime(SysTimeStruct& t) {
-	time_t    st {};
+	// Preserve millisecond precision.
+	timespec  now {};
 	struct tm i {};
 
-	if (time(&st) == static_cast<time_t>(-1) || localtime_r(&st, &i) == nullptr) {
+	if (clock_gettime(CLOCK_REALTIME, &now) != 0 || localtime_r(&now.tv_sec, &i) == nullptr) {
 		t.is_invalid = true;
 		return;
 	}
@@ -183,15 +182,16 @@ inline void SysGetSystemTime(SysTimeStruct& t) {
 	t.Hour         = i.tm_hour;
 	t.Minute       = i.tm_min;
 	t.Second       = (i.tm_sec == 60 ? 59 : i.tm_sec);
-	t.Milliseconds = 0;
+	t.Milliseconds = static_cast<uint16_t>((now.tv_nsec / 1000000) % 1000);
 }
 
 // Retrieves the current system date and time in Coordinated Universal Time (UTC).
 inline void SysGetSystemTimeUtc(SysTimeStruct& t) {
-	time_t    st {};
+	// Preserve millisecond precision.
+	timespec  now {};
 	struct tm i {};
 
-	if (time(&st) == static_cast<time_t>(-1) || gmtime_r(&st, &i) == nullptr) {
+	if (clock_gettime(CLOCK_REALTIME, &now) != 0 || gmtime_r(&now.tv_sec, &i) == nullptr) {
 		t.is_invalid = true;
 		return;
 	}
@@ -203,7 +203,7 @@ inline void SysGetSystemTimeUtc(SysTimeStruct& t) {
 	t.Hour         = i.tm_hour;
 	t.Minute       = i.tm_min;
 	t.Second       = (i.tm_sec == 60 ? 59 : i.tm_sec);
-	t.Milliseconds = 0;
+	t.Milliseconds = static_cast<uint16_t>((now.tv_nsec / 1000000) % 1000);
 }
 
 inline void SysQueryPerformanceFrequency(uint64_t* freq) {

src/common/platform/sysVirtual.h

@@ -1,28 +0,0 @@
-#ifndef KYTY_COMMON_PLATFORM_SYSVIRTUAL_H_
-#define KYTY_COMMON_PLATFORM_SYSVIRTUAL_H_
-
-#include "common/common.h"
-#include "common/virtualMemory.h"
-
-namespace Common {
-
-void SysVirtualInit();
-
-uint64_t SysVirtualAlloc(uint64_t address, uint64_t size, VirtualMemory::Mode mode);
-uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::Mode mode,
-                                uint64_t alignment);
-bool     SysVirtualAllocFixed(uint64_t address, uint64_t size, VirtualMemory::Mode mode);
-bool     SysVirtualCommit(uint64_t address, uint64_t size, VirtualMemory::Mode mode);
-uint64_t SysVirtualReserve(uint64_t address, uint64_t size);
-uint64_t SysVirtualReserveAligned(uint64_t address, uint64_t size, uint64_t alignment);
-bool     SysVirtualReserveFixed(uint64_t address, uint64_t size);
-bool     SysVirtualDecommit(uint64_t address, uint64_t size);
-bool     SysVirtualFree(uint64_t address);
-bool     SysVirtualFreeRange(uint64_t address, uint64_t size);
-bool     SysVirtualProtect(uint64_t address, uint64_t size, VirtualMemory::Mode mode,
-                           VirtualMemory::Mode* old_mode = nullptr);
-bool     SysVirtualFlushInstructionCache(uint64_t address, uint64_t size);
-
-} // namespace Common
-
-#endif /* KYTY_COMMON_PLATFORM_SYSVIRTUAL_H_ */

src/common/platform/sysWindowsDbg.cpp

@@ -15,66 +15,6 @@
 #include "common/assert.h"
 #include "common/platform/sysDbg.h"
 
-struct FrameS {
-	struct FrameS* next;
-	void*          ret_addr;
-};
-
-int WalkStack(int z_stack_depth, void** z_stack_trace) {
-	CONTEXT context;
-	//	KNONVOLATILE_CONTEXT_POINTERS NvContext;
-	PRUNTIME_FUNCTION runtime_function  = nullptr;
-	PVOID             handler_data      = nullptr;
-	ULONG64           establisher_frame = 0;
-	ULONG64           image_base        = 0;
-
-	RtlCaptureContext(&context);
-
-	int frame = 0;
-
-	while (true) {
-		if (frame >= z_stack_depth) {
-			break;
-		}
-
-		z_stack_trace[frame] = reinterpret_cast<void*>(context.Rip);
-
-		frame++;
-
-		runtime_function = RtlLookupFunctionEntry(context.Rip, &image_base, nullptr);
-
-		if (runtime_function == nullptr) {
-			break;
-		}
-
-		// RtlZeroMemory(&NvContext, sizeof(KNONVOLATILE_CONTEXT_POINTERS));
-		RtlVirtualUnwind(0, image_base, context.Rip, runtime_function, &context, &handler_data,
-		                 &establisher_frame, nullptr /*&NvContext*/);
-
-		if (context.Rip == 0u) {
-			break;
-		}
-	}
-
-	return frame;
-}
-
-void SysStackWalk(void** stack, int* depth) {
-	int n  = WalkStack(*depth, stack);
-	*depth = n;
-	//	unwind_info_t info = {stack, 0, *depth};
-	//	 _Unwind_Backtrace(&trace_fcn, &info);
-	//	 *depth = info.depth;
-}
-
-void SysStackUsagePrint(sys_dbg_stack_info_t& stack) {
-	printf("stack: (0x%" PRIx64 ", %" PRIu64 ") + (0x%" PRIx64 ", %" PRIu64 ") + (0x%" PRIx64
-	       ", %" PRIu64 ")\n",
-	       static_cast<uint64_t>(stack.reserved_addr), static_cast<uint64_t>(stack.reserved_size),
-	       static_cast<uint64_t>(stack.guard_addr), static_cast<uint64_t>(stack.guard_size),
-	       static_cast<uint64_t>(stack.commited_addr), static_cast<uint64_t>(stack.commited_size));
-}
-
 void SysStackUsage(sys_dbg_stack_info_t& s) {
 	MEMORY_BASIC_INFORMATION mbi {};
 	[[maybe_unused]] size_t  ss = VirtualQuery(&mbi, &mbi, sizeof(mbi));

src/common/platform/sysWindowsFileIO.cpp

@@ -14,6 +14,7 @@
 #include "common/stringUtils.h"
 
 #include <cstdlib>
+#include <cstring>
 #include <vector>
 
 // NOLINTNEXTLINE(readability-identifier-naming)
@@ -135,10 +136,6 @@ void SysFileWrite(const void* data, uint32_t size, sys_file_t& f, uint32_t* byte
 	}
 }
 
-void SysFileWrite(uint32_t n, sys_file_t& f) {
-	SysFileWrite(&n, 4, f);
-}
-
 sys_file_t* SysFileCreate(const std::filesystem::path& file_name) {
 	auto* ret = new sys_file_t;
 
@@ -481,7 +478,7 @@ bool SysFileSetLastAccessAndWriteTimeUtc(const std::filesystem::path& name,
 
 void SysFileFindFiles(const std::filesystem::path& path, std::vector<sys_file_find_t>& out) {
 	std::string real_path = Common::ReplaceChar(Common::PathToGenericString(path), '\\', '/');
-	if (!Common::EndsWith(real_path, "/")) {
+	if (!real_path.ends_with("/")) {
 		real_path += "/";
 	}
 
@@ -528,7 +525,7 @@ void SysFileFindFiles(const std::filesystem::path& path, std::vector<sys_file_fi
 
 void SysFileGetDents(const std::filesystem::path& path, std::vector<sys_dir_entry_t>& out) {
 	std::string real_path = Common::ReplaceChar(Common::PathToGenericString(path), '\\', '/');
-	if (!Common::EndsWith(real_path, "/")) {
+	if (!real_path.ends_with("/")) {
 		real_path += "/";
 	}
 
@@ -565,7 +562,7 @@ bool SysFileCopyFile(const std::filesystem::path& src, const std::filesystem::pa
 	return CopyFileW(src_wide.c_str(), dst_wide.c_str(), FALSE) != 0;
 }
 
-bool SysFileMoveFile(const std::filesystem::path& src, const std::filesystem::path& dst) {
+bool SysFileRenameFile(const std::filesystem::path& src, const std::filesystem::path& dst) {
 	auto src_wide = src.wstring();
 	auto dst_wide = dst.wstring();
 	return MoveFileW(src_wide.c_str(), dst_wide.c_str()) != 0;

src/common/platform/sysWindowsVirtual.cpp

@@ -10,7 +10,6 @@
 #include <windows.h> // IWYU pragma: keep
 
 #include "common/assert.h"
-#include "common/platform/sysVirtual.h"
 #include "common/virtualMemory.h"
 
 // IWYU pragma: no_include <basetsd.h>
@@ -22,45 +21,33 @@
 // IWYU pragma: no_include <winerror.h>
 // IWYU pragma: no_include <wtypes.h>
 
-namespace Common {
+namespace Common::VirtualMemory {
 
-static DWORD GetProtectionFlag(VirtualMemory::Mode mode) {
+static DWORD GetProtectionFlag(Mode mode) {
 	DWORD protect = PAGE_NOACCESS;
 	switch (mode) {
-		case VirtualMemory::Mode::Read: protect = PAGE_READONLY; break;
+		case Mode::Read: protect = PAGE_READONLY; break;
 
-		case VirtualMemory::Mode::Write:
-		case VirtualMemory::Mode::ReadWrite: protect = PAGE_READWRITE; break;
+		case Mode::Write:
+		case Mode::ReadWrite: protect = PAGE_READWRITE; break;
 
-		case VirtualMemory::Mode::Execute: protect = PAGE_EXECUTE; break;
+		case Mode::Execute: protect = PAGE_EXECUTE; break;
 
-		case VirtualMemory::Mode::ExecuteRead: protect = PAGE_EXECUTE_READ; break;
+		case Mode::ExecuteRead: protect = PAGE_EXECUTE_READ; break;
 
-		case VirtualMemory::Mode::ExecuteWrite:
-		case VirtualMemory::Mode::ExecuteReadWrite: protect = PAGE_EXECUTE_READWRITE; break;
+		case Mode::ExecuteWrite:
+		case Mode::ExecuteReadWrite: protect = PAGE_EXECUTE_READWRITE; break;
 
-		case VirtualMemory::Mode::NoAccess:
+		case Mode::NoAccess:
 		default: protect = PAGE_NOACCESS; break;
 	}
 	return protect;
 }
 
-static VirtualMemory::Mode GetProtectionFlag(DWORD mode) {
-	switch (mode) {
-		case PAGE_NOACCESS: return VirtualMemory::Mode::NoAccess;
-		case PAGE_READONLY: return VirtualMemory::Mode::Read;
-		case PAGE_READWRITE: return VirtualMemory::Mode::ReadWrite;
-		case PAGE_EXECUTE: return VirtualMemory::Mode::Execute;
-		case PAGE_EXECUTE_READ: return VirtualMemory::Mode::ExecuteRead;
-		case PAGE_EXECUTE_READWRITE: return VirtualMemory::Mode::ExecuteReadWrite;
-		default: return VirtualMemory::Mode::NoAccess;
-	}
-}
+void Init() {}
 
-void SysVirtualInit() {}
-
-uint64_t SysVirtualAlloc(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
-	auto ptr = (address == 0 ? SysVirtualAllocAligned(address, size, mode, 1)
+uint64_t Alloc(uint64_t address, uint64_t size, Mode mode) {
+	auto ptr = (address == 0 ? AllocAligned(address, size, mode, 1)
 	                         : reinterpret_cast<uintptr_t>(VirtualAlloc(
 	                               reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	                               static_cast<DWORD>(MEM_COMMIT) | static_cast<DWORD>(MEM_RESERVE),
@@ -71,7 +58,7 @@ uint64_t SysVirtualAlloc(uint64_t address, uint64_t size, VirtualMemory::Mode mo
 		if (err != ERROR_INVALID_ADDRESS) {
 			printf("VirtualAlloc() failed: 0x%08" PRIx32 "\n", err);
 		} else {
-			return SysVirtualAllocAligned(address, size, mode, 1);
+			return AllocAligned(address, size, mode, 1);
 		}
 	}
 	return ptr;
@@ -92,8 +79,7 @@ static uint64_t AlignUp(uint64_t addr, uint64_t alignment) {
 	return (addr + alignment - 1) & ~(alignment - 1);
 }
 
-uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::Mode mode,
-                                uint64_t alignment) {
+uint64_t AllocAligned(uint64_t address, uint64_t size, Mode mode, uint64_t alignment) {
 	if (alignment == 0) {
 		printf("VirtualAlloc2 failed: 0x%08" PRIx32 "\n", static_cast<uint32_t>(GetLastError()));
 		return 0;
@@ -147,13 +133,13 @@ uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::
 			printf("VirtualAlloc2(alignment = 0x%016" PRIx64 ") failed: 0x%08" PRIx32 "\n",
 			       alignment, err);
 		} else {
-			return SysVirtualAllocAligned(address, size, mode, alignment << 1u);
+			return AllocAligned(address, size, mode, alignment << 1u);
 		}
 	}
 	return ptr;
 }
 
-bool SysVirtualAllocFixed(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
+bool AllocFixed(uint64_t address, uint64_t size, Mode mode) {
 	auto ptr = reinterpret_cast<uintptr_t>(VirtualAlloc(
 	    reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	    static_cast<DWORD>(MEM_COMMIT) | static_cast<DWORD>(MEM_RESERVE), GetProtectionFlag(mode)));
@@ -173,7 +159,7 @@ bool SysVirtualAllocFixed(uint64_t address, uint64_t size, VirtualMemory::Mode m
 	return true;
 }
 
-bool SysVirtualCommit(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
+bool Commit(uint64_t address, uint64_t size, Mode mode) {
 	auto ptr = reinterpret_cast<uintptr_t>(
 	    VirtualAlloc(reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	                 static_cast<DWORD>(MEM_COMMIT), GetProtectionFlag(mode)));
@@ -191,8 +177,8 @@ bool SysVirtualCommit(uint64_t address, uint64_t size, VirtualMemory::Mode mode)
 	return true;
 }
 
-uint64_t SysVirtualReserve(uint64_t address, uint64_t size) {
-	auto ptr = (address == 0 ? SysVirtualReserveAligned(address, size, 1)
+uint64_t Reserve(uint64_t address, uint64_t size) {
+	auto ptr = (address == 0 ? ReserveAligned(address, size, 1)
 	                         : reinterpret_cast<uintptr_t>(VirtualAlloc(
 	                               reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	                               static_cast<DWORD>(MEM_RESERVE), PAGE_NOACCESS)));
@@ -202,13 +188,13 @@ uint64_t SysVirtualReserve(uint64_t address, uint64_t size) {
 		if (err != ERROR_INVALID_ADDRESS) {
 			printf("VirtualAlloc(MEM_RESERVE) failed: 0x%08" PRIx32 "\n", err);
 		} else {
-			return SysVirtualReserveAligned(address, size, 1);
+			return ReserveAligned(address, size, 1);
 		}
 	}
 	return ptr;
 }
 
-uint64_t SysVirtualReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
+uint64_t ReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
 	if (alignment == 0) {
 		printf("VirtualAlloc2(MEM_RESERVE) failed: 0x%08" PRIx32 "\n",
 		       static_cast<uint32_t>(GetLastError()));
@@ -262,13 +248,13 @@ uint64_t SysVirtualReserveAligned(uint64_t address, uint64_t size, uint64_t alig
 			       "\n",
 			       alignment, err);
 		} else {
-			return SysVirtualReserveAligned(address, size, alignment << 1u);
+			return ReserveAligned(address, size, alignment << 1u);
 		}
 	}
 	return ptr;
 }
 
-bool SysVirtualReserveFixed(uint64_t address, uint64_t size) {
+bool ReserveFixed(uint64_t address, uint64_t size) {
 	auto ptr = reinterpret_cast<uintptr_t>(
 	    VirtualAlloc(reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	                 static_cast<DWORD>(MEM_RESERVE), PAGE_NOACCESS));
@@ -288,7 +274,7 @@ bool SysVirtualReserveFixed(uint64_t address, uint64_t size) {
 	return true;
 }
 
-bool SysVirtualDecommit(uint64_t address, uint64_t size) {
+bool Decommit(uint64_t address, uint64_t size) {
 	if (VirtualFree(reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	                MEM_DECOMMIT) == 0) {
 		printf("VirtualFree(MEM_DECOMMIT) failed: 0x%08" PRIx32 "\n",
@@ -298,7 +284,7 @@ bool SysVirtualDecommit(uint64_t address, uint64_t size) {
 	return true;
 }
 
-bool SysVirtualFree(uint64_t address) {
+bool Free(uint64_t address) {
 	if (VirtualFree(reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), 0, MEM_RELEASE) ==
 	    0) {
 		printf("VirtualFree() failed: 0x%08" PRIx32 "\n", static_cast<uint32_t>(GetLastError()));
@@ -307,7 +293,7 @@ bool SysVirtualFree(uint64_t address) {
 	return true;
 }
 
-bool SysVirtualFreeRange(uint64_t address, uint64_t size) {
+bool FreeRange(uint64_t address, uint64_t size) {
 	if (address == 0 || size == 0) {
 		return false;
 	}
@@ -325,24 +311,20 @@ bool SysVirtualFreeRange(uint64_t address, uint64_t size) {
 		}
 		current = next;
 	}
-	return current - address == size && SysVirtualFree(address);
+	return current - address == size && Free(address);
 }
 
-bool SysVirtualProtect(uint64_t address, uint64_t size, VirtualMemory::Mode mode,
-                       VirtualMemory::Mode* old_mode) {
+bool Protect(uint64_t address, uint64_t size, Mode mode) {
 	DWORD old_protect = 0;
 	if (VirtualProtect(reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)), size,
 	                   GetProtectionFlag(mode), &old_protect) == 0) {
 		printf("VirtualProtect() failed: 0x%08" PRIx32 "\n", static_cast<uint32_t>(GetLastError()));
 		return false;
 	}
-	if (old_mode != nullptr) {
-		*old_mode = GetProtectionFlag(old_protect);
-	}
 	return true;
 }
 
-bool SysVirtualFlushInstructionCache(uint64_t address, uint64_t size) {
+bool FlushInstructionCache(uint64_t address, uint64_t size) {
 	if (::FlushInstructionCache(GetCurrentProcess(),
 	                            reinterpret_cast<LPVOID>(static_cast<uintptr_t>(address)),
 	                            size) == 0) {
@@ -353,6 +335,6 @@ bool SysVirtualFlushInstructionCache(uint64_t address, uint64_t size) {
 	return true;
 }
 
-} // namespace Common
+} // namespace Common::VirtualMemory
 
 #endif

src/common/profiler.cpp

@@ -1,7 +1,6 @@
 #include "common/profiler.h"
 
 #include "common/emulatorConfig.h"
-#include "common/subsystems.h"
 
 #include <algorithm>
 #include <common/TracyProtocol.hpp>
@@ -55,35 +54,21 @@ void SetThreadName(const char* name) {
 	}
 }
 
-void Close() {
+void Initialize() {
+	if (Config::ProfilerEnabled() && !tracy::ProfilerAvailable()) {
+		tracy::StartupProfiler();
+		TracySetProgramName("KytyPS5");
+		::printf("Tracy profiler enabled: client %d.%d.%d, protocol %u, "
+		         "broadcast %u, connect to 127.0.0.1:8086\n",
+		         tracy::Version::Major, tracy::Version::Minor, tracy::Version::Patch,
+		         tracy::ProtocolVersion, tracy::BroadcastVersion);
+	}
+}
+
+void Shutdown() {
 	if (tracy::ProfilerAvailable()) {
 		tracy::ShutdownProfiler();
 	}
 }
 
-KYTY_SUBSYSTEM_INIT(Profiler) {
-	switch (Config::GetProfilerDirection()) {
-		case Config::ProfilerDirection::Network:
-			if (!tracy::ProfilerAvailable()) {
-				tracy::StartupProfiler();
-				TracySetProgramName("KytyPS5");
-				::printf("Tracy profiler enabled: client %d.%d.%d, protocol %u, "
-				         "broadcast %u, connect to 127.0.0.1:8086\n",
-				         tracy::Version::Major, tracy::Version::Minor, tracy::Version::Patch,
-				         tracy::ProtocolVersion, tracy::BroadcastVersion);
-			}
-			break;
-		case Config::ProfilerDirection::None:
-		default: break;
-	}
-}
-
-KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(Profiler) {
-	Close();
-}
-
-KYTY_SUBSYSTEM_DESTROY(Profiler) {
-	Close();
-}
-
 } // namespace Profiler

src/common/profiler.h

@@ -2,7 +2,6 @@
 #define KYTY_COMMON_PROFILER_H_
 
 #include "common/common.h"
-#include "common/subsystems.h"
 
 #include <cstdint>
 #include <optional>
@@ -42,7 +41,15 @@ private:
 void EndBlock();
 void SetThreadName(const char* name);
 
-KYTY_SUBSYSTEM_DEFINE(Profiler);
+void Initialize();
+void Shutdown();
+
+struct Lifecycle {
+	static constexpr const char* name               = "Profiler";
+	static constexpr auto        initialize         = Profiler::Initialize;
+	static constexpr auto        shutdown           = Profiler::Shutdown;
+	static constexpr auto        emergency_shutdown = Profiler::Shutdown;
+};
 
 } // namespace Profiler
 

src/common/slotVector.h

@@ -0,0 +1,132 @@
+#ifndef EMULATOR_SRC_COMMON_SLOTVECTOR_H_
+#define EMULATOR_SRC_COMMON_SLOTVECTOR_H_
+
+#include "common/assert.h"
+#include "common/abi.h"
+
+#include <compare>
+#include <cstdint>
+#include <deque>
+#include <functional>
+#include <limits>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace Common {
+
+struct SlotId {
+	static constexpr uint32_t INVALID_INDEX = std::numeric_limits<uint32_t>::max();
+
+	constexpr SlotId() noexcept = default;
+	constexpr SlotId(uint32_t value) noexcept: index(value), generation(1) {}
+	constexpr SlotId(uint32_t value, uint32_t slot_generation) noexcept
+	    : index(value), generation(slot_generation) {}
+
+	[[nodiscard]] constexpr explicit operator bool() const noexcept { return index != INVALID_INDEX; }
+	constexpr auto operator<=>(const SlotId&) const noexcept = default;
+
+	uint32_t index = INVALID_INDEX;
+	uint32_t generation = 0;
+};
+
+// Stable-address slot storage for cache resources that are intentionally non-movable.
+template <typename T>
+class SlotVector {
+public:
+	SlotVector() = default;
+	KYTY_CLASS_NO_COPY(SlotVector);
+
+	[[nodiscard]] T& operator[](SlotId id) noexcept {
+		EXIT_IF(!is_allocated(id));
+		return *m_values[id.index].value;
+	}
+
+	[[nodiscard]] const T& operator[](SlotId id) const noexcept {
+		EXIT_IF(!is_allocated(id));
+		return *m_values[id.index].value;
+	}
+
+	[[nodiscard]] T* try_get(SlotId id) noexcept {
+		return is_allocated(id) ? &*m_values[id.index].value : nullptr;
+	}
+
+	[[nodiscard]] const T* try_get(SlotId id) const noexcept {
+		return is_allocated(id) ? &*m_values[id.index].value : nullptr;
+	}
+
+	[[nodiscard]] bool is_allocated(SlotId id) const noexcept {
+		return id && id.index < m_values.size() &&
+		       m_values[id.index].generation == id.generation && m_values[id.index].value.has_value();
+	}
+
+	template <typename... Args>
+	[[nodiscard]] SlotId insert(Args&&... args) {
+		uint32_t index = 0;
+		if (m_free_list.empty()) {
+			index = static_cast<uint32_t>(m_values.size());
+			m_values.emplace_back();
+			m_values.back().value.emplace(std::forward<Args>(args)...);
+		} else {
+			index = m_free_list.back();
+			m_free_list.pop_back();
+			EXIT_IF(m_values[index].value.has_value());
+			m_values[index].value.emplace(std::forward<Args>(args)...);
+		}
+		++m_size;
+		return SlotId {index, m_values[index].generation};
+	}
+
+	void erase(SlotId id) noexcept {
+		EXIT_IF(!is_allocated(id));
+		auto& slot = m_values[id.index];
+		slot.value.reset();
+		if (++slot.generation == 0) {
+			slot.generation = 1;
+		}
+		m_free_list.push_back(id.index);
+		--m_size;
+	}
+
+	[[nodiscard]] size_t size() const noexcept { return m_size; }
+	[[nodiscard]] size_t capacity() const noexcept { return m_values.size(); }
+
+	template <typename F>
+	void ForEach(F&& fn) {
+		for (uint32_t index = 0; index < m_values.size(); ++index) {
+			if (m_values[index].value) {
+				fn(SlotId {index, m_values[index].generation}, *m_values[index].value);
+			}
+		}
+	}
+
+	template <typename F>
+	void ForEach(F&& fn) const {
+		for (uint32_t index = 0; index < m_values.size(); ++index) {
+			if (m_values[index].value) {
+				fn(SlotId {index, m_values[index].generation}, *m_values[index].value);
+			}
+		}
+	}
+
+private:
+	struct Slot {
+		std::optional<T> value;
+		uint32_t         generation = 1;
+	};
+
+	std::deque<Slot>             m_values;
+	std::vector<uint32_t>        m_free_list;
+	size_t                       m_size = 0;
+};
+
+} // namespace Common
+
+template <>
+struct std::hash<Common::SlotId> {
+	[[nodiscard]] size_t operator()(Common::SlotId id) const noexcept {
+		return std::hash<uint64_t> {}((static_cast<uint64_t>(id.generation) << 32u) | id.index);
+	}
+};
+
+#endif // EMULATOR_SRC_COMMON_SLOTVECTOR_H_

src/common/stringUtils.h

@@ -1,7 +1,6 @@
 #ifndef KYTY_COMMON_STRING_UTILS_H_
 #define KYTY_COMMON_STRING_UTILS_H_
 
-#include "common/byteBuffer.h"
 #include "common/common.h"
 
 #include <algorithm>
@@ -9,7 +8,6 @@
 #include <charconv>
 #include <codecvt>
 #include <filesystem>
-#include <fmt/format.h>
 #include <locale>
 #include <string>
 #include <string_view>
@@ -18,8 +16,6 @@
 
 namespace Common {
 
-constexpr uint32_t FIND_INVALID_INDEX = static_cast<uint32_t>(-1);
-
 inline std::string PathToString(const std::filesystem::path& path) {
 #if defined(__cpp_char8_t)
 	auto u8 = path.u8string();
@@ -38,10 +34,6 @@ inline std::string PathToGenericString(const std::filesystem::path& path) {
 #endif
 }
 
-inline bool IsSpace(char c) {
-	return std::isspace(static_cast<unsigned char>(c)) != 0;
-}
-
 inline bool EqualNoCase(std::string_view lhs, std::string_view rhs) {
 	if (lhs.size() != rhs.size()) {
 		return false;
@@ -63,65 +55,6 @@ inline std::string ToLower(std::string_view text) {
 	return ret;
 }
 
-inline bool ContainsStr(std::string_view text, std::string_view needle) {
-	return text.find(needle) != std::string_view::npos;
-}
-
-inline bool StartsWith(std::string_view text, std::string_view prefix) {
-	return text.starts_with(prefix);
-}
-
-inline bool StartsWith(std::string_view text, char prefix) {
-	return !text.empty() && text.front() == prefix;
-}
-
-inline bool EndsWith(std::string_view text, std::string_view suffix) {
-	return text.ends_with(suffix);
-}
-
-inline bool EndsWith(std::string_view text, char suffix) {
-	return !text.empty() && text.back() == suffix;
-}
-
-inline bool ContainsChar(std::string_view text, char needle) {
-	return text.find(needle) != std::string_view::npos;
-}
-
-inline bool IndexValid(std::string_view text, uint32_t index) {
-	return index < text.size();
-}
-
-inline uint32_t FindIndex(std::string_view text, std::string_view needle, size_t from = 0) {
-	const auto pos = text.find(needle, from);
-	return pos == std::string_view::npos ? FIND_INVALID_INDEX : static_cast<uint32_t>(pos);
-}
-
-inline uint32_t FindIndex(std::string_view text, char needle, size_t from = 0) {
-	const auto pos = text.find(needle, from);
-	return pos == std::string_view::npos ? FIND_INVALID_INDEX : static_cast<uint32_t>(pos);
-}
-
-inline uint32_t FindLastIndex(std::string_view text, std::string_view needle,
-                              size_t from = FIND_INVALID_INDEX) {
-	if (needle.empty()) {
-		return 0;
-	}
-	if (from == FIND_INVALID_INDEX || from > text.size()) {
-		from = text.size();
-	}
-	const auto pos = text.rfind(needle, from);
-	return pos == std::string_view::npos ? FIND_INVALID_INDEX : static_cast<uint32_t>(pos);
-}
-
-inline uint32_t FindLastIndex(std::string_view text, char needle,
-                              size_t from = FIND_INVALID_INDEX) {
-	if (from == FIND_INVALID_INDEX || from > text.size()) {
-		from = text.size();
-	}
-	const auto pos = text.rfind(needle, from);
-	return pos == std::string_view::npos ? FIND_INVALID_INDEX : static_cast<uint32_t>(pos);
-}
-
 inline std::string Mid(std::string_view text, size_t first, size_t count = std::string_view::npos) {
 	if (first >= text.size()) {
 		return {};
@@ -129,49 +62,18 @@ inline std::string Mid(std::string_view text, size_t first, size_t count = std::
 	return std::string(text.substr(first, count));
 }
 
-inline std::string Left(std::string_view text, size_t count) {
-	return Mid(text, 0, count);
-}
-
-inline std::string Right(std::string_view text, size_t count) {
-	if (count >= text.size()) {
-		return std::string(text);
-	}
-	return Mid(text, text.size() - count, count);
-}
-
 inline std::string RemoveLast(std::string_view text, size_t count) {
 	if (count >= text.size()) {
 		return {};
 	}
-	return Left(text, text.size() - count);
+	return std::string(text.substr(0, text.size() - count));
 }
 
 inline std::string RemoveFirst(std::string_view text, size_t count) {
 	if (count >= text.size()) {
 		return {};
 	}
-	return Right(text, text.size() - count);
-}
-
-inline std::string TrimRight(std::string_view text) {
-	size_t end = text.size();
-	while (end > 0 && IsSpace(text[end - 1])) {
-		end--;
-	}
-	return std::string(text.substr(0, end));
-}
-
-inline std::string TrimLeft(std::string_view text) {
-	size_t first = 0;
-	while (first < text.size() && IsSpace(text[first])) {
-		first++;
-	}
-	return std::string(text.substr(first));
-}
-
-inline std::string Trim(std::string_view text) {
-	return TrimRight(TrimLeft(text));
+	return std::string(text.substr(count));
 }
 
 inline std::string ReplaceChar(std::string_view text, char old_char, char new_char) {
@@ -204,16 +106,6 @@ inline std::string FilenameWithoutDirectory(std::string_view text) {
 	return pos == std::string_view::npos ? std::string(text) : std::string(text.substr(pos + 1));
 }
 
-inline std::string FilenameWithoutExtension(std::string_view text) {
-	const auto pos = text.find_last_of('.');
-	return pos == std::string_view::npos ? std::string(text) : std::string(text.substr(0, pos));
-}
-
-inline std::string ExtensionWithoutFilename(std::string_view text) {
-	const auto pos = text.find_last_of('.');
-	return pos == std::string_view::npos ? std::string() : std::string(text.substr(pos));
-}
-
 inline std::string FixFilenameSlash(std::string_view text) {
 	return ReplaceChar(text, '\\', '/');
 }
@@ -257,86 +149,18 @@ inline std::vector<std::string> Split(std::string_view text, char sep, bool keep
 	return Split(text, std::string_view(&sep, 1), keep_empty);
 }
 
-inline std::string Concat(const std::vector<std::string>& list, std::string_view sep) {
-	std::string ret;
-	for (size_t i = 0; i < list.size(); i++) {
-		if (i != 0) {
-			ret += sep;
-		}
-		ret += list[i];
-	}
-	return ret;
-}
-
-inline std::string Concat(const std::vector<std::string>& list, char sep) {
-	return Concat(list, std::string_view(&sep, 1));
-}
-
-inline uint32_t ToUint32(std::string_view text, int base = 10) {
-	uint32_t value = 0;
-	std::from_chars(text.data(), text.data() + text.size(), value, base);
-	return value;
-}
-
-inline uint64_t ToUint64(std::string_view text, int base = 10) {
-	uint64_t value = 0;
-	std::from_chars(text.data(), text.data() + text.size(), value, base);
-	return value;
-}
-
 inline int32_t ToInt32(std::string_view text, int base = 10) {
 	int32_t value = 0;
 	std::from_chars(text.data(), text.data() + text.size(), value, base);
 	return value;
 }
 
-inline int64_t ToInt64(std::string_view text, int base = 10) {
-	int64_t value = 0;
-	std::from_chars(text.data(), text.data() + text.size(), value, base);
-	return value;
-}
-
-inline double ToDouble(std::string_view text) {
-	return std::stod(std::string(text));
-}
-
-inline float ToFloat(std::string_view text) {
-	return std::stof(std::string(text));
-}
-
-inline std::string SafeCsv(std::string_view text) {
-	const bool add_space =
-	    !text.empty() && (text.front() == '+' || text.front() == '=' || text.front() == '-');
-	if (text.find('"') != std::string_view::npos || text.find(';') != std::string_view::npos ||
-	    text.find('+') != std::string_view::npos || text.find('=') != std::string_view::npos ||
-	    text.find('-') != std::string_view::npos) {
-		return "\"" + std::string(add_space ? " " : "") +
-		       ReplaceStr(std::string(text), "\"", "\"\"") + "\"";
+inline std::string Utf16ToUtf8(std::u16string_view utf16) {
+	if (utf16.empty()) {
+		return {};
 	}
-	return std::string(text);
-}
-
-inline std::string Utf16ToUtf8(const char16_t* utf16) {
-	std::u16string                                                    input(utf16);
 	std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
-	return convert.to_bytes(input);
-}
-
-inline ByteBuffer HexToBin(std::string_view text) {
-	ByteBuffer ret;
-	for (size_t i = 0; i + 1 < text.size(); i += 2) {
-		ret.Add(static_cast<Byte>((ToUint32(text.substr(i, 2), 16) & 0xffu)));
-	}
-	return ret;
-}
-
-inline std::string HexFromBin(const ByteBuffer& bin) {
-	std::string ret;
-	ret.reserve(bin.Size() * 2);
-	for (uint32_t i = 0; i < bin.Size(); i++) {
-		ret += fmt::format("{:02X}", std::to_integer<uint8_t>(bin.At(i)));
-	}
-	return ret;
+	return convert.to_bytes(utf16.data(), utf16.data() + utf16.size());
 }
 
 } // namespace Common

src/common/subsystems.cpp

@@ -1,232 +1,43 @@
 #include "common/subsystems.h"
 
-#include "common/assert.h"
-
-#include <cstdarg>
-#include <cstdio>
-#include <cstring>
-#include <memory>
-#include <string>
-
 namespace Common {
 
-class SubsystemPrivate {
-public:
-	SubsystemPrivate()          = default;
-	virtual ~SubsystemPrivate() = default;
+static Subsystems* g_active_subsystems = nullptr;
 
-	KYTY_CLASS_NO_COPY(SubsystemPrivate);
+Subsystems::Subsystems(bool print): m_print(print) {
+	m_active.reserve(16);
+	g_active_subsystems = this;
+}
 
-	bool        failed {false};
-	std::string fail_msg;
-};
-
-class SubsystemsListPrivate {
-public:
-	explicit SubsystemsListPrivate(SubsystemsList& p): parent(p) {}
-
-	virtual ~SubsystemsListPrivate() = default;
-
-	void SetArgs(int argc, char** argv) {
-		this->m_argc = argc;
-		this->m_argv = argv;
+Subsystems::~Subsystems() {
+	Destroy();
+	if (g_active_subsystems == this) {
+		g_active_subsystems = nullptr;
 	}
+}
 
-	void Add(Subsystem* s, std::initializer_list<Subsystem*> deps) {
-		EXIT_IF(!s);
-
-		const char* name = s->Id();
-
-		EXIT_IF(FindByName(name) != nullptr);
-
-		auto nl = std::make_unique<SubsListStruct>();
-
-		nl->s         = s;
-		nl->name      = name;
-		nl->deps      = nullptr;
-		nl->next      = std::move(list);
-		nl->prev_init = nullptr;
-
-		auto* node = nl.get();
-		list       = std::move(nl);
-
-		for (auto* dep: deps) {
-			const char* str = dep->Id();
-
-			auto l      = std::make_unique<DepsListStruct>();
-			l->dep_name = str;
-			l->next     = std::move(node->deps);
-
-			node->deps = std::move(l);
+void Subsystems::Destroy() {
+	for (auto it = m_active.rbegin(); it != m_active.rend(); ++it) {
+		if (it->shutdown != nullptr) {
+			it->shutdown();
 		}
-
-		node->initialized = false;
 	}
+	m_active.clear();
+}
 
-	bool InitAll(bool print_msg) {
-		while (SubsListStruct* n = FindNextToInitialize()) {
-			n->s->Init(&parent);
-
-			if (n->s->m_p->failed) {
-				fail_msg  = n->s->m_p->fail_msg.c_str();
-				fail_name = n->name;
-				return false;
-			}
-
-			if (print_msg) {
-				printf("Initialized: %s\n", n->name);
-			}
-
-			n->initialized = true;
-
-			SubsListStruct* last = last_init;
-			last_init            = n;
-			n->prev_init         = last;
+void Subsystems::EmergencyShutdown() {
+	for (auto it = m_active.rbegin(); it != m_active.rend(); ++it) {
+		if (it->emergency_shutdown != nullptr) {
+			it->emergency_shutdown();
 		}
-
-		return true;
 	}
+	m_active.clear();
+}
 
-	void DestroyAll(bool print_msg) {
-		for (SubsListStruct* n = last_init; n != nullptr; n = n->prev_init) {
-			n->s->Destroy(&parent);
-			n->initialized = false;
-
-			if (print_msg) {
-				printf("Destroyed: %s\n", n->name);
-			}
-		}
-
-		last_init = nullptr;
+void Subsystems::EmergencyShutdownActive() {
+	if (g_active_subsystems != nullptr) {
+		g_active_subsystems->EmergencyShutdown();
 	}
-
-	void ShutdownAll() {
-		for (SubsListStruct* n = last_init; n != nullptr; n = n->prev_init) {
-			n->s->UnexpectedShutdown(&parent);
-			n->initialized = false;
-		}
-
-		last_init = nullptr;
-	}
-
-	struct DepsListStruct {
-		const char*                     dep_name;
-		std::unique_ptr<DepsListStruct> next;
-	};
-
-	struct SubsListStruct {
-		Subsystem*                      s;
-		const char*                     name;
-		std::unique_ptr<DepsListStruct> deps;
-		std::unique_ptr<SubsListStruct> next;
-		SubsListStruct*                 prev_init;
-		bool                            initialized;
-	};
-
-	[[nodiscard]] SubsListStruct* FindByName(const char* name) const {
-		for (SubsListStruct* n = list.get(); n != nullptr; n = n->next.get()) {
-			if (std::strcmp(n->name, name) == 0) {
-				return n;
-			}
-		}
-
-		return nullptr;
-	}
-
-	[[nodiscard]] SubsListStruct* FindNextToInitialize() const {
-		for (SubsListStruct* n = list.get(); n != nullptr; n = n->next.get()) {
-			if (n->initialized) {
-				continue;
-			}
-
-			DepsListStruct* d = n->deps.get();
-			for (; d != nullptr; d = d->next.get()) {
-				SubsListStruct* s = FindByName(d->dep_name);
-				if ((s == nullptr) || !s->initialized) {
-					break;
-				}
-			}
-
-			if (d == nullptr) {
-				return n;
-			}
-		}
-
-		return nullptr;
-	}
-
-	KYTY_CLASS_NO_COPY(SubsystemsListPrivate);
-
-	std::unique_ptr<SubsListStruct> list;
-	SubsListStruct*                 last_init = nullptr;
-	int                             m_argc    = 0;
-	char**                          m_argv    = nullptr;
-	const char*                     fail_msg  = nullptr;
-	const char*                     fail_name = nullptr;
-	SubsystemsList&                 parent;
-};
-
-SubsystemsList::SubsystemsList(): m_p(std::make_unique<SubsystemsListPrivate>(*this)) {}
-
-SubsystemsList::~SubsystemsList() = default;
-
-void SubsystemsList::Add(Subsystem* s, std::initializer_list<Subsystem*> deps) {
-	m_p->Add(s, deps);
-}
-
-bool SubsystemsList::InitAll(bool print_msg) {
-	return m_p->InitAll(print_msg);
-}
-
-void SubsystemsList::DestroyAll(bool print_msg) {
-	m_p->DestroyAll(print_msg);
-}
-
-int* SubsystemsList::GetArgc() {
-	return &m_p->m_argc;
-}
-
-char** SubsystemsList::GetArgv() {
-	return m_p->m_argv;
-}
-
-Subsystem::Subsystem(): m_p(std::make_unique<SubsystemPrivate>()) {}
-
-Subsystem::~Subsystem() = default;
-
-void Subsystem::Fail(const char* format, ...) {
-	va_list args {};
-	va_start(args, format);
-
-	va_list args_copy {};
-	va_copy(args_copy, args);
-	int len = std::vsnprintf(nullptr, 0, format, args_copy);
-	va_end(args_copy);
-
-	if (len > 0) {
-		std::string msg(static_cast<size_t>(len) + 1, '\0');
-		std::vsnprintf(msg.data(), msg.size(), format, args);
-		m_p->fail_msg = msg.c_str();
-		m_p->failed   = true;
-	}
-
-	va_end(args);
-}
-
-const char* SubsystemsList::GetFailName() const {
-	return m_p->fail_name;
-}
-
-const char* SubsystemsList::GetFailMsg() const {
-	return m_p->fail_msg;
-}
-
-void SubsystemsList::SetArgs(int argc, char* argv[]) {
-	m_p->SetArgs(argc, argv);
-}
-
-void SubsystemsList::ShutdownAll() {
-	m_p->ShutdownAll();
 }
 
 } // namespace Common

src/common/subsystems.h

@@ -2,90 +2,61 @@
 #define KYTY_COMMON_SUBSYSTEMS_H_
 
 #include "common/common.h"
-#include "common/singleton.h"
 
-#include <initializer_list>
-#include <memory>
+#include <cstdio>
+#include <vector>
 
 namespace Common {
 
-class Subsystem;
-class SubsystemsListPrivate;
-class SubsystemPrivate;
-
-class SubsystemsList {
+class Subsystems {
 public:
-	SubsystemsList();
-	virtual ~SubsystemsList();
-	void SetArgs(int argc, char* argv[]);
+	using Callback = void (*)();
 
-	// void Add(Subsystem* s, const char* name, ...);
-	void Add(Subsystem* s, std::initializer_list<Subsystem*> deps);
+	explicit Subsystems(bool print = false);
+	~Subsystems();
 
-	bool InitAll(bool print_msg = false);
-	void DestroyAll(bool print_msg = false);
+	template <typename Lifecycle>
+	void Initialize() {
+		Lifecycle::initialize();
+		m_active.push_back({ShutdownCallback<Lifecycle>(), EmergencyCallback<Lifecycle>()});
+		if (m_print) {
+			std::printf("Initialized: %s\n", Lifecycle::name);
+		}
+	}
 
-	int*   GetArgc();
-	char** GetArgv();
+	void Destroy();
+	void EmergencyShutdown();
 
-	[[nodiscard]] const char* GetFailName() const;
-	[[nodiscard]] const char* GetFailMsg() const;
+	static void EmergencyShutdownActive();
 
-	void ShutdownAll();
-
-	static SubsystemsList* Instance() { return Common::Singleton<SubsystemsList>::Instance(); }
-
-	KYTY_CLASS_NO_COPY(SubsystemsList);
+	KYTY_CLASS_NO_COPY(Subsystems);
 
 private:
-	std::unique_ptr<SubsystemsListPrivate> m_p;
+	template <typename Lifecycle>
+	static consteval Callback ShutdownCallback() {
+		if constexpr (requires { Lifecycle::shutdown; }) {
+			return Lifecycle::shutdown;
+		}
+		return nullptr;
+	}
+
+	template <typename Lifecycle>
+	static consteval Callback EmergencyCallback() {
+		if constexpr (requires { Lifecycle::emergency_shutdown; }) {
+			return Lifecycle::emergency_shutdown;
+		}
+		return nullptr;
+	}
+
+	struct Entry {
+		Callback shutdown;
+		Callback emergency_shutdown;
+	};
+
+	std::vector<Entry> m_active;
+	bool               m_print;
 };
 
-using SubsystemsListSingleton = Common::Singleton<SubsystemsList>;
-
-class Subsystem {
-public:
-	Subsystem();
-	virtual ~Subsystem();
-
-	virtual const char* Id()                                       = 0;
-	virtual void        Init(SubsystemsList* parent)               = 0;
-	virtual void        Destroy(SubsystemsList* parent)            = 0;
-	virtual void        UnexpectedShutdown(SubsystemsList* parent) = 0;
-
-	friend class SubsystemsListPrivate;
-
-	KYTY_CLASS_NO_COPY(Subsystem);
-
-protected:
-	void Fail(const char* format, ...) KYTY_FORMAT_PRINTF(2, 3);
-
-private:
-	std::unique_ptr<SubsystemPrivate> m_p;
-};
-
-#define KYTY_SUBSYSTEM_DEFINE(s)                                                                   \
-	class s##Subsystem: public Common::Subsystem {                                                 \
-	public:                                                                                        \
-		static Subsystem* Instance() { return Common::Singleton<s##Subsystem>::Instance(); }       \
-		const char*       Id() { return #s; }                                                      \
-		void              Init(Common::SubsystemsList* parent);                                    \
-		void              Destroy(Common::SubsystemsList* parent);                                 \
-		void              UnexpectedShutdown(Common::SubsystemsList* parent);                      \
-	};                                                                                             \
-	typedef Common::Singleton<s##Subsystem> s##SubsystemSingleton;
-
-#define KYTY_SUBSYSTEM_INIT(s)                                                                     \
-	void s##Subsystem::Init([[maybe_unused]] Common::SubsystemsList* parent)
-#define KYTY_SUBSYSTEM_DESTROY(s)                                                                  \
-	void s##Subsystem::Destroy([[maybe_unused]] Common::SubsystemsList* parent)
-#define KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(s)                                                      \
-	void s##Subsystem::UnexpectedShutdown([[maybe_unused]] Common::SubsystemsList* parent)
-
-// #define KYTY_SUBSYSTEM_ADD(list, s, ...) list.push_back(s##SubsystemSingleton::Instance(), #s,
-// __VA_ARGS__); #define KYTY_SUBSYSTEM_ADD2(list, ...) list.Add2(s##SubsystemSingleton::Instance(),
-// __VA_ARGS__);
-
 } // namespace Common
 
 #endif /* KYTY_COMMON_SUBSYSTEMS_H_ */

src/common/threads.cpp

@@ -1,19 +1,24 @@
 #include "common/threads.h"
 
 #include "common/assert.h"
-#include "common/debug.h"
 
 #include <algorithm>
 #include <atomic>
+#include <cerrno>
 #include <chrono>             // IWYU pragma: keep
 #include <condition_variable> // IWYU pragma: keep
 #include <mutex>
-#include <vector>
 
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS && KYTY_COMPILER == KYTY_COMPILER_CLANG
 #define KYTY_WIN_CS
 #endif
 
+// macOS has no clock_nanosleep.
+#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS && !defined(__APPLE__)
+#define KYTY_POSIX_HIGH_RES_SLEEP
+#include <ctime>
+#endif
+
 #include <sstream>
 #include <string>
 #include <thread>
@@ -21,7 +26,8 @@
 #ifdef KYTY_WIN_CS
 #include <windows.h> // IWYU pragma: keep
 // IWYU pragma: no_include <winbase.h>
-constexpr DWORD KYTY_CS_SPIN_COUNT = 4000;
+constexpr DWORD    KYTY_CS_SPIN_COUNT          = 4000;
+constexpr uint64_t KYTY_SLEEP_SPIN_LIMIT_100NS = 500; // 50 us
 
 #ifndef CREATE_WAITABLE_TIMER_HIGH_RESOLUTION
 #define CREATE_WAITABLE_TIMER_HIGH_RESOLUTION 0x00000002
@@ -32,7 +38,10 @@ static void SleepHighResolution100ns(uint64_t units_100ns) {
 		return;
 	}
 
-	if (units_100ns <= 10000) {
+	// Keep spinning only where a kernel transition is
+	// likely to cost more than the requested delay; ordinary millisecond sleeps use the
+	// per-thread high-resolution waitable timer below.
+	if (units_100ns <= KYTY_SLEEP_SPIN_LIMIT_100NS) {
 		LARGE_INTEGER frequency {};
 		LARGE_INTEGER start {};
 		if (QueryPerformanceFrequency(&frequency) != 0 && QueryPerformanceCounter(&start) != 0 &&
@@ -121,6 +130,42 @@ static SleepConditionVariableCS_func_t ResolveSleepConditionVariableCS() {
 
 #endif
 
+#ifdef KYTY_POSIX_HIGH_RES_SLEEP
+// Spin for very short waits; use an absolute deadline for longer waits.
+static void SleepHighResolutionNanos(uint64_t nanos) {
+	if (nanos == 0) {
+		return;
+	}
+
+	constexpr uint64_t NANOS_PER_SEC = 1000000000;
+	constexpr uint64_t SPIN_LIMIT_NS = 50000; // below this a context switch dominates
+
+	timespec deadline {};
+	if (clock_gettime(CLOCK_MONOTONIC, &deadline) != 0) {
+		std::this_thread::sleep_for(std::chrono::nanoseconds(nanos));
+		return;
+	}
+
+	auto target_nsec = static_cast<uint64_t>(deadline.tv_nsec) + nanos;
+	deadline.tv_sec += static_cast<time_t>(target_nsec / NANOS_PER_SEC);
+	deadline.tv_nsec = static_cast<long>(target_nsec % NANOS_PER_SEC);
+
+	if (nanos <= SPIN_LIMIT_NS) {
+		timespec now {};
+		do {
+			if (clock_gettime(CLOCK_MONOTONIC, &now) != 0) {
+				return;
+			}
+		} while (now.tv_sec < deadline.tv_sec ||
+		         (now.tv_sec == deadline.tv_sec && now.tv_nsec < deadline.tv_nsec));
+		return;
+	}
+
+	while (clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &deadline, nullptr) == EINTR) {
+	}
+}
+#endif
+
 namespace Common {
 
 using thread_id_t = std::thread::id;
@@ -151,37 +196,7 @@ struct CondVarPrivate {
 #endif
 };
 
-static std::recursive_mutex                         g_cond_waiters_mutex;
-static std::vector<std::pair<int, CondVarPrivate*>> g_cond_waiters;
-static wait_poll_func_t                             g_cond_wait_poll_callback = nullptr;
-
-static void WakeCondVar(CondVarPrivate* cond_var) {
-#ifdef KYTY_WIN_CS
-	static auto func = ResolveWakeAllConditionVariable();
-	EXIT_NOT_IMPLEMENTED(func == nullptr);
-	func(&cond_var->m_cv);
-#else
-	cond_var->m_cv.notify_all();
-#endif
-}
-
-static void RegisterCondWaiter(CondVarPrivate* cond_var) {
-	std::lock_guard lock(g_cond_waiters_mutex);
-	g_cond_waiters.emplace_back(Thread::GetThreadIdUnique(), cond_var);
-}
-
-static void UnregisterCondWaiter(CondVarPrivate* cond_var) {
-	const auto      thread_id = Thread::GetThreadIdUnique();
-	std::lock_guard lock(g_cond_waiters_mutex);
-
-	const auto it = std::find_if(g_cond_waiters.begin(), g_cond_waiters.end(),
-	                             [thread_id, cond_var](const auto& waiter) {
-		                             return waiter.first == thread_id && waiter.second == cond_var;
-	                             });
-	if (it != g_cond_waiters.end()) {
-		g_cond_waiters.erase(it);
-	}
-}
+static wait_poll_func_t g_cond_wait_poll_callback = nullptr;
 
 struct ThreadPrivate {
 	ThreadPrivate(thread_func_t f, void* a): func(f), arg(a), m_thread(&Run, this) {}
@@ -205,15 +220,11 @@ static thread_id_t      g_main_thread;
 static int              g_main_thread_int;
 static std::atomic<int> g_thread_counter = 0;
 
-KYTY_SUBSYSTEM_INIT(Threads) {
+void InitializeThreads() {
 	g_main_thread     = std::this_thread::get_id();
 	g_main_thread_int = Thread::GetThreadIdUnique();
 }
 
-KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(Threads) {}
-
-KYTY_SUBSYSTEM_DESTROY(Threads) {}
-
 Thread::Thread(thread_func_t func, void* arg)
     : m_thread(std::make_unique<ThreadPrivate>(func, arg)) {
 	while (!m_thread->started) {
@@ -242,13 +253,11 @@ void Thread::Detach() {
 	m_thread->m_thread.detach();
 }
 
-void Thread::Sleep(uint32_t millis) {
-	std::this_thread::sleep_for(std::chrono::milliseconds(millis));
-}
-
 void Thread::SleepMicro(uint32_t micros) {
 #ifdef KYTY_WIN_CS
 	SleepHighResolution100ns(static_cast<uint64_t>(micros) * 10);
+#elif defined(KYTY_POSIX_HIGH_RES_SLEEP)
+	SleepHighResolutionNanos(static_cast<uint64_t>(micros) * 1000);
 #else
 	std::this_thread::sleep_for(std::chrono::microseconds(micros));
 #endif
@@ -257,6 +266,8 @@ void Thread::SleepMicro(uint32_t micros) {
 void Thread::SleepNano(uint64_t nanos) {
 #ifdef KYTY_WIN_CS
 	SleepHighResolution100ns((nanos + 99) / 100);
+#elif defined(KYTY_POSIX_HIGH_RES_SLEEP)
+	SleepHighResolutionNanos(nanos);
 #else
 	std::this_thread::sleep_for(std::chrono::nanoseconds(nanos));
 #endif
@@ -319,7 +330,6 @@ CondVar::~CondVar() {
 }
 
 void CondVar::Wait(Mutex* mutex) {
-	RegisterCondWaiter(m_cond_var.get());
 #ifndef KYTY_WIN_CS
 	std::unique_lock<std::recursive_mutex> cpp_lock(mutex->m_mutex->m_mutex, std::adopt_lock_t());
 #endif
@@ -360,7 +370,6 @@ void CondVar::Wait(Mutex* mutex) {
 	}
 	cpp_lock.release();
 #endif
-	UnregisterCondWaiter(m_cond_var.get());
 }
 
 void CondVar::SetWaitPollCallback(wait_poll_func_t callback) {
@@ -369,7 +378,6 @@ void CondVar::SetWaitPollCallback(wait_poll_func_t callback) {
 
 bool CondVar::WaitFor(Mutex* mutex, uint32_t micros) {
 	bool ok = false;
-	RegisterCondWaiter(m_cond_var.get());
 #ifndef KYTY_WIN_CS
 	std::unique_lock<std::recursive_mutex> cpp_lock(mutex->m_mutex->m_mutex, std::adopt_lock_t());
 #endif
@@ -384,7 +392,6 @@ bool CondVar::WaitFor(Mutex* mutex, uint32_t micros) {
 	      std::cv_status::no_timeout);
 	cpp_lock.release();
 #endif
-	UnregisterCondWaiter(m_cond_var.get());
 	return ok;
 }
 
@@ -399,16 +406,13 @@ void CondVar::Signal() {
 }
 
 void CondVar::SignalAll() {
-	WakeCondVar(m_cond_var.get());
-}
-
-void CondVar::SignalThread(int thread_id) {
-	std::lock_guard lock(g_cond_waiters_mutex);
-	for (const auto& waiter: g_cond_waiters) {
-		if (waiter.first == thread_id) {
-			WakeCondVar(waiter.second);
-		}
-	}
+#ifdef KYTY_WIN_CS
+	static auto func = ResolveWakeAllConditionVariable();
+	EXIT_NOT_IMPLEMENTED(func == nullptr);
+	func(&m_cond_var->m_cv);
+#else
+	m_cond_var->m_cv.notify_all();
+#endif
 }
 
 int Thread::GetThreadIdUnique() {

src/common/threads.h

@@ -2,14 +2,13 @@
 #define KYTY_COMMON_THREADS_H_
 
 #include "common/common.h"
-#include "common/subsystems.h"
 
 #include <memory>
 #include <string>
 
 namespace Common {
 
-KYTY_SUBSYSTEM_DEFINE(Threads);
+void InitializeThreads();
 
 using thread_func_t    = void (*)(void*);
 using wait_poll_func_t = void (*)();
@@ -32,7 +31,6 @@ public:
 	// The id is unique and can't be reused by another thread.
 	[[nodiscard]] int GetUniqueId() const;
 
-	static void Sleep(uint32_t millis);
 	static void SleepMicro(uint32_t micros);
 	static void SleepNano(uint64_t nanos);
 	static bool IsMainThread();
@@ -78,7 +76,6 @@ public:
 	void Signal();
 	void SignalAll();
 
-	static void SignalThread(int thread_id);
 	static void SetWaitPollCallback(wait_poll_func_t callback);
 
 	KYTY_CLASS_NO_COPY(CondVar);

src/common/timer.cpp

@@ -62,23 +62,6 @@ double Timer::GetTimeS() const {
 	return (static_cast<double>(current_time - m_StartTime)) / static_cast<double>(m_Frequency);
 }
 
-// return time in ticks
-uint64_t Timer::GetTicks() const {
-	if (m_is_paused) {
-		return (m_PauseTime - m_StartTime);
-	}
-
-	uint64_t current_time = 0;
-	SysQueryPerformanceCounter(&current_time);
-
-	return (current_time - m_StartTime);
-}
-
-// return ticks frequency
-uint64_t Timer::GetFrequency() const {
-	return m_Frequency;
-}
-
 uint64_t Timer::QueryPerformanceFrequency() {
 	uint64_t ret = 0;
 	SysQueryPerformanceFrequency(&ret);

src/common/timer.h

@@ -24,12 +24,6 @@ public:
 	// return time in seconds
 	[[nodiscard]] double GetTimeS() const;
 
-	// return time in ticks
-	[[nodiscard]] uint64_t GetTicks() const;
-
-	// return ticks frequency
-	[[nodiscard]] uint64_t GetFrequency() const;
-
 	KYTY_CLASS_NO_COPY(Timer);
 
 	[[nodiscard]] static uint64_t QueryPerformanceFrequency();

src/common/uniqueFunction.h

@@ -0,0 +1,54 @@
+#ifndef KYTY_COMMON_UNIQUEFUNCTION_H_
+#define KYTY_COMMON_UNIQUEFUNCTION_H_
+
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace Common {
+
+template <typename Result, typename... Args>
+class UniqueFunction {
+	class CallableBase {
+	public:
+		virtual ~CallableBase()               = default;
+		virtual Result Invoke(Args&&... args) = 0;
+	};
+
+	template <typename Function>
+	class Callable final: public CallableBase {
+	public:
+		explicit Callable(Function function): m_function(std::move(function)) {}
+
+		Result Invoke(Args&&... args) override { return m_function(std::forward<Args>(args)...); }
+
+	private:
+		Function m_function;
+	};
+
+public:
+	UniqueFunction() = default;
+
+	template <typename Function>
+	UniqueFunction(Function&& function)
+	    : m_callable(std::make_unique<Callable<std::decay_t<Function>>>(
+	          std::forward<Function>(function))) {}
+
+	UniqueFunction(UniqueFunction&&) noexcept            = default;
+	UniqueFunction& operator=(UniqueFunction&&) noexcept = default;
+	UniqueFunction(const UniqueFunction&)                = delete;
+	UniqueFunction& operator=(const UniqueFunction&)     = delete;
+
+	Result operator()(Args... args) const {
+		return m_callable->Invoke(std::forward<Args>(args)...);
+	}
+
+	explicit operator bool() const noexcept { return m_callable != nullptr; }
+
+private:
+	std::unique_ptr<CallableBase> m_callable;
+};
+
+} // namespace Common
+
+#endif // KYTY_COMMON_UNIQUEFUNCTION_H_

src/common/virtualMemory.cpp

@@ -1,82 +0,0 @@
-#include "common/virtualMemory.h"
-
-#include "common/platform/sysVirtual.h"
-
-namespace Common {
-
-namespace VirtualMemory {
-
-void Init() {
-	SysVirtualInit();
-}
-
-uint64_t Alloc(uint64_t address, uint64_t size, Mode mode) {
-	return SysVirtualAlloc(address, size, mode);
-}
-
-uint64_t AllocAligned(uint64_t address, uint64_t size, Mode mode, uint64_t alignment) {
-	return SysVirtualAllocAligned(address, size, mode, alignment);
-}
-
-bool AllocFixed(uint64_t address, uint64_t size, Mode mode) {
-	return SysVirtualAllocFixed(address, size, mode);
-}
-
-bool Commit(uint64_t address, uint64_t size, Mode mode) {
-	return SysVirtualCommit(address, size, mode);
-}
-
-uint64_t Reserve(uint64_t address, uint64_t size) {
-	return SysVirtualReserve(address, size);
-}
-
-uint64_t ReserveAligned(uint64_t address, uint64_t size, uint64_t alignment) {
-	return SysVirtualReserveAligned(address, size, alignment);
-}
-
-bool ReserveFixed(uint64_t address, uint64_t size) {
-	return SysVirtualReserveFixed(address, size);
-}
-
-bool Decommit(uint64_t address, uint64_t size) {
-	return SysVirtualDecommit(address, size);
-}
-
-bool Free(uint64_t address) {
-	return SysVirtualFree(address);
-}
-
-bool FreeRange(uint64_t address, uint64_t size) {
-	return SysVirtualFreeRange(address, size);
-}
-
-bool Protect(uint64_t address, uint64_t size, Mode mode, Mode* old_mode) {
-	return SysVirtualProtect(address, size, mode, old_mode);
-}
-
-bool FlushInstructionCache(uint64_t address, uint64_t size) {
-	return SysVirtualFlushInstructionCache(address, size);
-}
-
-bool PatchReplace(uint64_t vaddr, uint64_t value) {
-	Mode old_mode {};
-	Protect(vaddr, 8, Mode::ReadWrite, &old_mode);
-
-	auto* ptr = reinterpret_cast<uint64_t*>(vaddr);
-
-	bool ret = (*ptr != value);
-
-	*ptr = value;
-
-	Protect(vaddr, 8, old_mode);
-
-	if (IsExecute(old_mode)) {
-		FlushInstructionCache(vaddr, 8);
-	}
-
-	return ret;
-}
-
-} // namespace VirtualMemory
-
-} // namespace Common

src/common/virtualMemory.h

@@ -35,9 +35,8 @@ bool     ReserveFixed(uint64_t address, uint64_t size);
 bool     Decommit(uint64_t address, uint64_t size);
 bool     Free(uint64_t address);
 bool     FreeRange(uint64_t address, uint64_t size);
-bool     Protect(uint64_t address, uint64_t size, Mode mode, Mode* old_mode = nullptr);
+bool     Protect(uint64_t address, uint64_t size, Mode mode);
 bool     FlushInstructionCache(uint64_t address, uint64_t size);
-bool     PatchReplace(uint64_t vaddr, uint64_t value);
 
 } // namespace VirtualMemory
 

src/emulator.cpp

@@ -2,7 +2,6 @@
 
 #include "common/abi.h"
 #include "common/assert.h"
-#include "common/commonSubsystem.h"
 #include "common/emulatorConfig.h"
 #include "common/file.h"
 #include "common/logging/log.h"
@@ -16,6 +15,7 @@
 #include "kernel/fileSystem.h"
 #include "kernel/memory.h"
 #include "kernel/pthread.h"
+#include "kytyGitVersion.h"
 #include "libs/agc.h"
 #include "libs/audio.h"
 #include "libs/controller.h"
@@ -27,13 +27,31 @@
 
 #include <cstdlib>
 #include <filesystem>
+#include <thread>
 
 namespace Emulator {
 
 static void PrintSystemInfo() {
-	Common::SystemInfo info = Common::GetSystemInfo();
+	const Common::SystemInfo info = Common::GetSystemInfo();
 
-	LOGF("ProcessorName = %s\n", info.ProcessorName.c_str());
+#if defined(__APPLE__)
+	static constexpr auto platform_name = "macOS";
+#elif KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+	static constexpr auto platform_name = "Windows";
+#elif KYTY_PLATFORM == KYTY_PLATFORM_LINUX
+	static constexpr auto platform_name = "Linux";
+#else
+	static constexpr auto platform_name = "Unknown";
+#endif
+
+	LOGF("Build\n"
+	     "  version: %s\n\n"
+	     "Host\n"
+	     "  os:      %s\n"
+	     "  cpu:     %s\n"
+	     "  threads: %u\n\n",
+	     KYTY_BUILD_LABEL, platform_name, info.ProcessorName.c_str(),
+	     std::thread::hardware_concurrency());
 }
 
 static void KytyClose() {
@@ -43,7 +61,7 @@ static void KytyClose() {
 
 	LOGF("done!\n");
 
-	Common::SubsystemsListSingleton::Instance()->ShutdownAll();
+	Common::Subsystems::EmergencyShutdownActive();
 }
 
 static void MountOrCreateDir(const std::filesystem::path& dir, const std::string& point) {
@@ -105,41 +123,32 @@ static void ClearDebugTextureFolder() {
 	}
 }
 
-static void Init(const Config::ConfigOptions& cfg) {
+static void Init(const Config::ConfigOptions& cfg, const std::filesystem::path& param_json,
+                 Common::Subsystems& subsystems) {
 	EXIT_IF(!Common::Thread::IsMainThread());
 
-	auto* slist = Common::SubsystemsList::Instance();
-
-	auto* audio       = Libs::Audio::AudioSubsystem::Instance();
-	auto* config      = Config::ConfigSubsystem::Instance();
-	auto* controller  = Libs::Controller::ControllerSubsystem::Instance();
-	auto* core        = Common::CommonSubsystem::Instance();
-	auto* file_system = Libs::LibKernel::FileSystem::FileSystemSubsystem::Instance();
-	auto* graphics    = Libs::Graphics::GraphicsSubsystem::Instance();
-	auto* log         = Log::LogSubsystem::Instance();
-	auto* memory      = Libs::LibKernel::Memory::MemorySubsystem::Instance();
-	auto* network     = Libs::Network::NetworkSubsystem::Instance();
-	auto* profiler    = Profiler::ProfilerSubsystem::Instance();
-	auto* pthread     = Libs::LibKernel::PthreadSubsystem::Instance();
-	auto* timer       = Loader::Timer::TimerSubsystem::Instance();
-
-	slist->Add(config, {core});
-	slist->InitAll(true);
-
+	subsystems.Initialize<Config::Lifecycle>();
 	Config::Load(cfg);
+	subsystems.Initialize<Log::Lifecycle>();
 
-	slist->Add(audio, {core, log, pthread, memory});
-	slist->Add(controller, {core, log, config});
-	slist->Add(file_system, {core, log, pthread});
-	slist->Add(graphics, {core, log, pthread, memory, config, profiler, controller});
-	slist->Add(log, {core, config});
-	slist->Add(memory, {core, log});
-	slist->Add(network, {core, log, pthread});
-	slist->Add(profiler, {core, config});
-	slist->Add(pthread, {core, log, timer});
-	slist->Add(timer, {core, log});
+	if (Common::File::IsFileExisting(param_json)) {
+		Loader::SystemContentLoadParamSfo(param_json);
+		if (const auto flexible_memory_size = Loader::SystemContentGetFlexibleMemorySize();
+		    flexible_memory_size != 0) {
+			Libs::LibKernel::Memory::SetFlexibleMemorySize(flexible_memory_size);
+		}
+	}
 
-	slist->InitAll(true);
+	// Initialization order is explicit; destruction is automatic and reversed.
+	subsystems.Initialize<Loader::Timer::Lifecycle>();
+	subsystems.Initialize<Libs::LibKernel::PthreadLifecycle>();
+	subsystems.Initialize<Profiler::Lifecycle>();
+	subsystems.Initialize<Libs::Network::Lifecycle>();
+	subsystems.Initialize<Libs::LibKernel::Memory::Lifecycle>();
+	subsystems.Initialize<Libs::LibKernel::FileSystem::Lifecycle>();
+	subsystems.Initialize<Libs::Controller::Lifecycle>();
+	subsystems.Initialize<Libs::Audio::Lifecycle>();
+	subsystems.Initialize<Libs::Graphics::Lifecycle>();
 }
 
 static void LoadElf(const std::filesystem::path& elf, bool dbg_print_reloc = false,
@@ -159,25 +168,16 @@ static void LoadElf(const std::filesystem::path& elf, bool dbg_print_reloc = fal
 	}
 }
 
-static void Execute() {
-	int thread_model = 1;
-
-	if (thread_model == 0) {
-		Common::Thread t([](void* /*unused*/) { Libs::Graphics::WindowRun(); }, nullptr);
-		t.Detach();
-		auto* rt = Common::Singleton<Loader::RuntimeLinker>::Instance();
-		rt->Execute();
-	} else {
-		Common::Thread t(
-		    [](void* /*unused*/) {
-			    auto* rt = Common::Singleton<Loader::RuntimeLinker>::Instance();
-			    rt->Execute();
-		    },
-		    nullptr);
-		t.Detach();
-		Libs::Graphics::WindowRun();
-		t.Join();
-	}
+static void Execute(const std::filesystem::path& game_patch) {
+	auto           patch_path = game_patch;
+	Common::Thread guest_thread(
+	    [](void* param) {
+		    auto* rt = Common::Singleton<Loader::RuntimeLinker>::Instance();
+		    rt->Execute(*static_cast<const std::filesystem::path*>(param));
+	    },
+	    &patch_path);
+	Libs::Graphics::WindowRun();
+	std::quick_exit(0);
 }
 
 void Run(const RunOptions& options) {
@@ -189,27 +189,28 @@ void Run(const RunOptions& options) {
 		EXIT("ELF is required\n");
 	}
 
-	Init(options.config);
+	const auto         param_json = options.app0_dir / "sce_sys" / "param.json";
+	Common::Subsystems subsystems(true);
+	Init(options.config, param_json, subsystems);
 
 	ClearDebugTextureFolder();
 
 	PrintSystemInfo();
+	std::string title_id;
+	if (Loader::SystemContentParamSfoGetString("TITLE_ID", &title_id) && !title_id.empty()) {
+		Log::WriteToConsoleAndLog(fmt::format("Title ID: {}\n", title_id));
+	}
 
 	int ok = atexit(KytyClose);
 	EXIT_NOT_IMPLEMENTED(ok != 0);
 
+	// Guest threads are still running, so skip KytyClose() and only flush emergency state.
+	ok = at_quick_exit(Common::Subsystems::EmergencyShutdownActive);
+	EXIT_NOT_IMPLEMENTED(ok != 0);
+
 	Libs::LibKernel::FileSystem::Mount(options.app0_dir, "/app0");
 	Libs::LibKernel::FileSystem::Mount(options.app0_dir, "/hostapp");
 
-	auto param_json = options.app0_dir / "sce_sys" / "param.json";
-	if (Common::File::IsFileExisting(param_json)) {
-		Loader::SystemContentLoadParamSfo(param_json);
-		if (auto flexible_memory_size = Loader::SystemContentGetFlexibleMemorySize();
-		    flexible_memory_size != 0) {
-			Libs::LibKernel::Memory::SetFlexibleMemorySize(flexible_memory_size);
-		}
-	}
-
 	MountSandboxDirs();
 
 	auto* rt = Common::Singleton<Loader::RuntimeLinker>::Instance();
@@ -217,7 +218,7 @@ void Run(const RunOptions& options) {
 
 	LoadElf(options.elf);
 
-	Execute();
+	Execute(options.game_patch);
 }
 
 } // namespace Emulator

src/emulator.h

@@ -12,6 +12,7 @@ struct RunOptions {
 	Config::ConfigOptions config;
 	std::filesystem::path app0_dir;
 	std::filesystem::path elf;
+	std::filesystem::path game_patch;
 };
 
 void Run(const RunOptions& options);

src/generate_version.cmake

@@ -1,8 +1,41 @@
-#message("${GIT_EXECUTABLE}")
+set(KYTY_GIT_VERSION "unknown")
+set(KYTY_GIT_HASH "unknown")
+set(KYTY_GIT_REVISION "unknown")
 if(GIT_EXECUTABLE)
-	execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags --always OUTPUT_VARIABLE KYTY_GIT_VERSION)
-else()
-	set(KYTY_GIT_VERSION "unknown")
+	execute_process(
+		COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty
+		WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
+		OUTPUT_VARIABLE KYTY_GIT_VERSION
+		OUTPUT_STRIP_TRAILING_WHITESPACE
+		RESULT_VARIABLE GIT_RESULT
+		ERROR_QUIET
+	)
+	if(NOT GIT_RESULT EQUAL 0)
+		set(KYTY_GIT_VERSION "unknown")
+	endif()
+
+	execute_process(
+		COMMAND "${GIT_EXECUTABLE}" rev-parse HEAD
+		WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
+		OUTPUT_VARIABLE KYTY_GIT_REVISION
+		OUTPUT_STRIP_TRAILING_WHITESPACE
+		RESULT_VARIABLE GIT_HASH_RESULT
+		ERROR_QUIET
+	)
+	if(NOT GIT_HASH_RESULT EQUAL 0)
+		set(KYTY_GIT_HASH "unknown")
+		set(KYTY_GIT_REVISION "unknown")
+	else()
+		string(SUBSTRING "${KYTY_GIT_REVISION}" 0 7 KYTY_GIT_HASH)
+		execute_process(
+			COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
+			WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
+			RESULT_VARIABLE GIT_DIRTY_RESULT
+			ERROR_QUIET
+		)
+		if(NOT GIT_DIRTY_RESULT EQUAL 0)
+			string(APPEND KYTY_GIT_HASH "-dirty")
+		endif()
+	endif()
 endif()
-string(STRIP ${KYTY_GIT_VERSION} KYTY_GIT_VERSION)
-configure_file(${INPUT_FILE} ${OUTPUT_FILE})
+configure_file("${INPUT_FILE}" "${OUTPUT_FILE}")

src/graphics/asyncJob.h

@@ -1,96 +0,0 @@
-#ifndef EMULATOR_INCLUDE_EMULATOR_GRAPHICS_ASYNCJOB_H_
-#define EMULATOR_INCLUDE_EMULATOR_GRAPHICS_ASYNCJOB_H_
-
-#include "common/common.h"
-#include "common/profiler.h"
-#include "common/threads.h"
-
-#include <functional>
-#include <string>
-#include <utility>
-
-namespace Libs::Graphics {
-
-class AsyncJob final {
-public:
-	using Task = std::function<void()>;
-
-	explicit AsyncJob(std::string thread_name = {})
-	    : m_thread_name(std::move(thread_name)), m_worker_thread(WorkerEntry, this) {}
-
-	~AsyncJob() {
-		{
-			Common::LockGuard lock(m_mutex);
-			m_stop_requested = true;
-			m_task_available_condition.Signal();
-		}
-
-		m_worker_thread.Join();
-	}
-
-	KYTY_CLASS_NO_COPY(AsyncJob);
-
-	void Execute(Task task) {
-		Common::LockGuard lock(m_mutex);
-		while (m_is_busy) {
-			m_idle_condition.Wait(&m_mutex);
-		}
-
-		m_task    = std::move(task);
-		m_is_busy = true;
-		m_task_available_condition.Signal();
-	}
-
-	void Wait() {
-		Common::LockGuard lock(m_mutex);
-		while (m_is_busy) {
-			m_idle_condition.Wait(&m_mutex);
-		}
-	}
-
-private:
-	static void WorkerEntry(void* data) { static_cast<AsyncJob*>(data)->WorkerLoop(); }
-
-	void WorkerLoop() {
-		if (!m_thread_name.empty()) {
-			KYTY_PROFILER_THREAD(m_thread_name.c_str());
-		}
-
-		for (;;) {
-			Task task;
-			{
-				Common::LockGuard lock(m_mutex);
-				while (!m_is_busy && !m_stop_requested) {
-					m_task_available_condition.Wait(&m_mutex);
-				}
-
-				if (!m_is_busy) {
-					return;
-				}
-
-				task = std::move(m_task);
-			}
-
-			task();
-
-			{
-				Common::LockGuard lock(m_mutex);
-				m_is_busy = false;
-				m_idle_condition.SignalAll();
-			}
-		}
-	}
-
-	std::string     m_thread_name;
-	Common::Mutex   m_mutex;
-	Common::CondVar m_task_available_condition;
-	Common::CondVar m_idle_condition;
-	Task            m_task;
-	bool            m_is_busy        = false;
-	bool            m_stop_requested = false;
-	Common::Thread  m_worker_thread;
-};
-
-} // namespace Libs::Graphics
-
-#endif /* EMULATOR_INCLUDE_EMULATOR_GRAPHICS_ASYNCJOB_H_ */

src/graphics/guest_gpu/command_processor/commandProcessor.h

@@ -2,109 +2,44 @@
 #define GRAPHICS_GUEST_GPU_COMMAND_PROCESSOR_COMMAND_PROCESSOR_H
 
 #include "common/assert.h"
-#include "common/threads.h"
 #include "graphics/guest_gpu/hardwareContext.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
 
-#include <array>
 #include <cstdint>
+#include <span>
 #include <vector>
 
 namespace Libs::Graphics {
 
-inline constexpr uint32_t AcquireGcrGl2Writeback = 1u << 15u;
-
 bool TestWaitRegMemValue(uint64_t value, uint64_t ref, uint64_t mask, uint32_t func);
 
-class CommandScheduler {
+enum class Pm4ProcessResult { Complete, Blocked };
+
+enum class ContextStateOperation : uint32_t {
+	Clear     = 0,
+	Push      = 1,
+	Pop       = 2,
+	PushClear = 3,
+};
+
+class Pm4Execution {
 public:
-	static constexpr int BuffersNum = 8;
-
-	CommandScheduler(HW::Context& registers, HW::UserConfig& user_config, HW::Shader& shaders)
-	    : m_registers(registers), m_user_config(user_config), m_shaders(shaders) {}
-
-	bool Active() const { return m_current >= 0 && m_current < BuffersNum; }
-	void CheckActive() const { EXIT_IF(!Active()); }
-
-	RenderCommandBuffer& Current() const {
-		CheckActive();
-		EXIT_IF(m_buffers[m_current] == nullptr);
-		return *m_buffers[m_current];
-	}
-
-	void Init() {
-		if (m_current >= 0) {
-			return;
-		}
-		for (auto& buf: m_buffers) {
-			EXIT_IF(buf != nullptr);
-			buf = new RenderCommandBuffer(m_registers, m_user_config, m_shaders);
-		}
-		m_current = 0;
-		Current().Begin();
-	}
-
-	void Flush() {
-		SubmitCurrent();
-		BeginNext();
-	}
-
-	CommandBuffer& FlushAndGetSubmitted() {
-		auto& submitted = SubmitCurrent();
-		BeginNext();
-		return submitted;
-	}
-
-	void CopyBuffers(std::array<CommandBuffer*, BuffersNum>& out) const {
-		for (int i = 0; i < BuffersNum; i++) {
-			auto* buf = m_buffers[i];
-			EXIT_IF(buf == nullptr);
-			out[i] = buf;
-		}
-	}
-
-	void WaitAll() {
-		for (auto* buf: m_buffers) {
-			EXIT_IF(buf == nullptr);
-			buf->WaitForFenceAndReset();
-		}
-	}
-
-	void SubmitForReadback() {
-		if (!Active()) {
-			return;
-		}
-		SubmitCurrent();
-	}
-
-	void ResumeAfterReadback() {
-		if (!Active()) {
-			return;
-		}
-		Current().WaitForFenceAndReset();
-		Current().Begin();
-	}
+	[[nodiscard]] bool MadeProgress() const noexcept { return m_made_progress; }
 
 private:
-	CommandBuffer& SubmitCurrent() {
-		auto& submitted = Current();
-		submitted.End();
-		submitted.Execute();
-		return submitted;
-	}
+	friend class CommandProcessor;
 
-	void BeginNext() {
-		m_current = (m_current + 1) % BuffersNum;
-		Current().WaitForFenceAndReset();
-		Current().Begin();
-	}
+	struct BufferCursor {
+		std::span<const uint32_t> commands;
+		uint32_t                  offset_dw = 0;
+	};
 
-	RenderCommandBuffer* m_buffers[BuffersNum] = {};
-	int                  m_current             = -1;
-	HW::Context&         m_registers;
-	HW::UserConfig&      m_user_config;
-	HW::Shader&          m_shaders;
+	std::vector<BufferCursor> m_buffer_stack;
+	std::span<const uint32_t> m_next_buffer;
+	bool                      m_chain         = false;
+	bool                      m_suspended     = false;
+	bool                      m_made_progress = false;
 };
 
 class CommandProcessor {
@@ -116,38 +51,19 @@ public:
 		int64_t flip_arg  = 0;
 	};
 
-	CommandProcessor();
-	~CommandProcessor() { KYTY_NOT_IMPLEMENTED; }
+	CommandProcessor(RenderContext& renderer, int interrupt_event_id)
+	    : m_renderer(renderer), m_interrupt_event_id(interrupt_event_id) {}
+	~CommandProcessor() = default;
 
 	KYTY_CLASS_NO_COPY(CommandProcessor);
 
 	void Reset();
+	void ApplyContextStateOperation(ContextStateOperation operation);
 
-	void BufferInit();
-	void BufferFlush();
-	void BufferFlushAndWait();
-	void BufferWait();
-	void BeginReadbackTransaction() {
-		m_mutex.Lock();
-		if (m_readback_active) {
-			EXIT("nested command-processor readback transaction\n");
-		}
-		m_readback_active   = true;
-		m_readback_finished = false;
-	}
-	void FinishReadbackTransaction();
-	void EndReadbackTransaction() {
-		if (!m_readback_active) {
-			EXIT("command-processor readback transaction is not active\n");
-		}
-		m_readback_active   = false;
-		m_readback_finished = false;
-		m_mutex.Unlock();
-	}
-
-	void RunLock() { m_run_mutex.Lock(); }
-	void RunUnlock() { m_run_mutex.Unlock(); }
-
+	void            BufferInit();
+	void            BufferFlush();
+	void            BufferFlushAndWait();
+	void            BufferWait();
 	HW::Context&    GetCtx() { return m_ctx; }
 	HW::UserConfig& GetUcfg() { return m_ucfg; }
 	HW::Shader&     GetShCtx() { return m_sh_ctx; }
@@ -158,14 +74,9 @@ public:
 	void SetDrawIndirectArgsBaseAddress(uint64_t draw_indirect_args_base_addr);
 	void SetDispatchIndirectArgsBaseAddress(uint64_t dispatch_indirect_args_base_addr);
 	void SetNumInstances(uint32_t num_instances);
-	void DrawIndex(uint32_t index_count, const void* index_addr, uint32_t flags, uint32_t type,
-	               uint32_t instance_count = 0, const void* object_ids = nullptr,
-	               uint32_t render_target_slice_offset = 0, int32_t vertex_offset_add = 0,
-	               uint32_t first_instance = 0);
-	void DrawIndexOffset(uint32_t index_offset, uint32_t index_count, uint32_t flags);
-	void DrawIndexAuto(uint32_t index_count, uint32_t flags,
-	                   uint32_t render_target_slice_offset = 0, uint32_t instance_count = 1,
-	                   uint32_t first_vertex = 0, uint32_t first_instance = 0);
+	void DrawIndex(DrawIndexArgs args);
+	void DrawIndexOffset(uint32_t index_offset, uint32_t index_count);
+	void DrawIndexAuto(DrawAutoArgs args);
 	void DrawIndirect(uint32_t data_offset, uint32_t draw_initiator, bool indexed);
 	void DrawIndirectMulti(uint32_t data_offset, uint32_t max_count_or_count,
 	                       const volatile uint32_t* count_addr, uint32_t stride_in_bytes,
@@ -182,30 +93,26 @@ public:
 	void Flip(void* dst_gpu_addr, uint32_t value);
 	void FlipWithInterrupt(uint32_t eop_event_type, uint32_t cache_action, void* dst_gpu_addr,
 	                       uint32_t value);
-	void PrepareCpuFlip();
+	void PrepareCpuFlip(uint64_t request_id);
 	void SynchronizeGpu();
-	void MemoryBarrier();
+	void EmitGlobalBarrier();
 	void TriggerEopEventAtEndOfPipe(uint32_t interrupt_context_id);
-	void RenderTextureBarrier(uint64_t vaddr, uint64_t size);
-	void DepthStencilBarrier(uint64_t vaddr, uint64_t size);
 	void DispatchDirect(uint32_t thread_group_x, uint32_t thread_group_y, uint32_t thread_group_z,
 	                    uint32_t mode);
 	void DispatchIndirect(uint32_t data_offset, uint32_t mode);
 	void WaitFlipDone(uint32_t video_out_handle, uint32_t display_buffer_index);
-	void TriggerEvent(uint32_t event_type, uint32_t event_index);
+	void TriggerEvent(uint32_t event_type, uint32_t event_index, uint64_t event_address = 0);
 
 	void SetUserDataMarker(HW::UserSgprType type) { m_user_data_marker = type; }
 	[[nodiscard]] HW::UserSgprType GetUserDataMarker() const { return m_user_data_marker; }
-	void SetEmbeddedDataMarker(const uint32_t* buffer, uint32_t num_dw, uint32_t align) {}
-	void PushMarker(const char* str) {}
-	void PopMarker() {}
 
-	void PrefetchL2(void* addr, uint32_t size) {}
 	void ResetDeCe();
+	void SetCeComplete(bool complete) { m_ce_complete = complete; }
 	void WaitCe();
 	void WaitDeDiff(uint32_t diff);
-	void IncremenetDe();
-	void IncremenetCe();
+	void WaitForRewind(bool valid);
+	void IncrementDe();
+	void IncrementCe();
 
 	void WriteConstRam(uint32_t offset, const uint32_t* src, uint32_t dw_num);
 	void DumpConstRam(uint32_t* dst, uint32_t offset, uint32_t dw_num);
@@ -222,33 +129,31 @@ public:
 	                    const volatile void* address, uint32_t count_in_dwords);
 	[[nodiscard]] bool ShouldSkipPredicatedPackets() const { return m_predicate_skip; }
 
-	void Run(uint32_t* data, uint32_t num_dw);
+	Pm4ProcessResult Process(Pm4Execution& execution, std::span<const uint32_t> commands);
+	void             ProcessIndirectBuffer(std::span<const uint32_t> commands, bool chain);
 
-	[[nodiscard]] const FlipInfo& GetFlip() const { return m_flip; }
-	void                          SetFlip(const FlipInfo& flip) { m_flip = flip; }
+	void SetFlip(const FlipInfo& flip) { m_flip = flip; }
 
 	[[nodiscard]] uint64_t GetSubmitId() const { return m_submit_id; }
 	void                   SetSubmitId(uint64_t submit_id) { m_submit_id = submit_id; }
+	[[nodiscard]] bool     IsAsyncComputeQueue() const { return m_interrupt_event_id >= 0x20; }
 
 private:
-	struct Counter {
-		Common::Mutex   mutex;
-		Common::CondVar cond_var;
-		uint32_t        value = 0;
-	};
-
 	template <typename T>
 	void WriteAtEndOfPipe(uint32_t cache_policy, uint32_t event_write_dest, uint32_t eop_event_type,
 	                      uint32_t cache_action, uint32_t event_index, uint32_t event_write_source,
 	                      void* dst_gpu_addr, T value, uint32_t interrupt_selector,
 	                      uint32_t interrupt_context_id);
-	void FinishCommandProcessors();
-
-	RenderCommandBuffer& CurrentBuffer() { return m_scheduler.Current(); }
-	void                 CheckBuffer() const { m_scheduler.CheckActive(); }
-	GpuResourceManager&  GetGpuResources() const { return GetRenderContext().GetGpuResources(); }
+	void ProcessPm4(Pm4Execution& execution);
+	void SuspendPm4();
+	CommandScheduler&   GetScheduler() const { return m_renderer.GetCommandScheduler(); }
+	CommandBuffer&      CurrentBuffer() { return GetScheduler().Current(); }
+	void                CheckBuffer() const { GetScheduler().CheckActive(); }
 
+	RenderContext&   m_renderer;
 	HW::Context      m_ctx;
+	HW::Context      m_saved_ctx;
+	bool             m_context_state_pushed = false;
 	HW::UserConfig   m_ucfg;
 	HW::Shader       m_sh_ctx;
 	HW::UserSgprType m_user_data_marker                 = HW::UserSgprType::Unknown;
@@ -257,24 +162,20 @@ private:
 	uint64_t         m_index_base_addr                  = 0;
 	uint64_t         m_draw_indirect_args_base_addr     = 0;
 	uint64_t         m_dispatch_indirect_args_base_addr = 0;
-	uint32_t         m_num_instances                    = 1;
+	// Persistent draw state: indirect draws update it for subsequent draws.
+	uint32_t m_num_instances = 1;
 
-	inline static Common::Mutex                  m_mutex;
-	inline static std::vector<CommandProcessor*> m_processors;
-	inline static bool                           m_readback_active   = false;
-	inline static bool                           m_readback_finished = false;
-	Common::Mutex                                m_run_mutex;
-
-	CommandScheduler m_scheduler;
-
-	Counter m_de_counter;
-	Counter m_ce_counter;
+	uint32_t m_de_count    = 0;
+	uint32_t m_ce_count    = 0;
+	bool     m_ce_complete = false;
 
 	uint32_t m_const_ram[0x3000] = {0};
 
-	FlipInfo m_flip;
-	uint64_t m_submit_id      = 0;
-	bool     m_predicate_skip = false;
+	FlipInfo  m_flip;
+	const int m_interrupt_event_id;
+	uint64_t  m_submit_id                   = 0;
+	uint64_t  m_synthetic_occlusion_counter = 0;
+	bool      m_predicate_skip              = false;
 };
 
 } // namespace Libs::Graphics

src/graphics/guest_gpu/command_processor/pm4Dispatch.cpp

@@ -23,9 +23,7 @@ constexpr auto MakeContextDispatchTable() {
 	g_hw_ctx_func[Pm4::DB_STENCIL_CLEAR]             = HwCtxSetStencilClear;
 	g_hw_ctx_func[Pm4::DB_DEPTH_CLEAR]               = HwCtxSetDepthClear;
 	g_hw_ctx_func[Pm4::PA_SC_SCREEN_SCISSOR_TL]      = HwCtxSetScreenScissor;
-	g_hw_ctx_func[Pm4::DB_Z_INFO]                    = HwCtxSetDepthRenderTarget;
 	g_hw_ctx_func[Pm4::DB_STENCIL_INFO]              = HwCtxSetStencilInfo;
-	g_hw_ctx_func[Pm4::DB_HTILE_SURFACE]             = HwCtxSetDepthHtileSurface;
 	g_hw_ctx_func[Pm4::PA_SU_HARDWARE_SCREEN_OFFSET] = HwCtxSetHardwareScreenOffset;
 	g_hw_ctx_func[Pm4::PA_SC_WINDOW_OFFSET]          = HwCtxSetWindowOffset;
 	g_hw_ctx_func[Pm4::PA_SC_WINDOW_SCISSOR_TL]      = HwCtxSetWindowScissor;
@@ -35,7 +33,6 @@ constexpr auto MakeContextDispatchTable() {
 	}
 	g_hw_ctx_func[Pm4::CB_TARGET_MASK]                 = HwCtxSetRenderTargetMask;
 	g_hw_ctx_func[Pm4::PA_SC_GENERIC_SCISSOR_TL]       = HwCtxSetGenericScissor;
-	g_hw_ctx_func[Pm4::CB_BLEND_RED]                   = HwCtxSetBlendColor;
 	g_hw_ctx_func[Pm4::CB_DCC_CONTROL]                 = HwCtxSetCbDccControl;
 	g_hw_ctx_func[Pm4::DB_STENCIL_CONTROL]             = HwCtxSetStencilControl;
 	g_hw_ctx_func[Pm4::DB_STENCILREFMASK]              = HwCtxSetStencilMask;
@@ -76,16 +73,13 @@ constexpr auto MakeContextDispatchTable() {
 	g_hw_ctx_func[Pm4::PA_SC_BINNER_CNTL_0]                   = HwCtxSetPaScExtendedControl;
 	g_hw_ctx_func[Pm4::PA_SC_BINNER_CNTL_1]                   = HwCtxSetPaScExtendedControl;
 	g_hw_ctx_func[Pm4::PA_SC_CONSERVATIVE_RASTERIZATION_CNTL] = HwCtxSetPaScExtendedControl;
-	g_hw_ctx_func[Pm4::PA_SC_NGG_MODE_CNTL]                   = HwCtxSetPaScExtendedControl;
 	g_hw_ctx_func[Pm4::DB_ALPHA_TO_MASK]                      = HwCtxSetAlphaToMask;
 	g_hw_ctx_func[Pm4::VGT_DRAW_PAYLOAD_CNTL]                 = HwCtxSetDrawPayloadControl;
 	g_hw_ctx_func[Pm4::VGT_PRIMITIVEID_RESET]                 = HwCtxSetPrimitiveIdReset;
 	g_hw_ctx_func[Pm4::PA_CL_OBJPRIM_ID_CNTL]                 = HwCtxSetObjprimIdControl;
 	g_hw_ctx_func[Pm4::VGT_SHADER_STAGES_EN]                  = HwCtxSetShaderStages;
-	g_hw_ctx_func[Pm4::PA_CL_GB_VERT_CLIP_ADJ]                = HwCtxSetGuardBands;
 
 	for (uint32_t slot = 0; slot < 8; slot++) {
-		g_hw_ctx_func[Pm4::CB_COLOR0_BASE + slot * 15] = HwCtxSetRenderTarget;
 		g_hw_ctx_func[Pm4::CB_COLOR0_INFO + slot * 15] = HwCtxSetColorInfo;
 
 		g_hw_ctx_func[Pm4::CB_BLEND0_CONTROL + slot * 1] = HwCtxSetBlendControl;
@@ -118,25 +112,21 @@ constexpr auto MakeShaderDispatchTable() {
 	}
 
 	for (uint32_t slot = 0; slot < 4; slot++) {
-		g_hw_sh_func[Pm4::SPI_SHADER_USER_ACCUM_PS_0 + slot] = HwShSetPsUserAccumSgpr;
+		g_hw_sh_func[Pm4::SPI_SHADER_USER_ACCUM_PS_0 + slot] = HwShIgnoreUserAccumulator;
 	}
 
 	for (uint32_t slot = 0; slot < 4; slot++) {
-		g_hw_sh_func[Pm4::SPI_SHADER_USER_ACCUM_ESGS_0 + slot] = HwShSetGsUserAccumSgpr;
+		g_hw_sh_func[Pm4::SPI_SHADER_USER_ACCUM_ESGS_0 + slot] = HwShIgnoreUserAccumulator;
 	}
 	for (uint32_t slot = 0; slot < 4; slot++) {
-		g_hw_sh_func[Pm4::SPI_SHADER_USER_ACCUM_LSHS_0 + slot] = HwShSetHsUserAccumSgpr;
+		g_hw_sh_func[Pm4::SPI_SHADER_USER_ACCUM_LSHS_0 + slot] = HwShIgnoreUserAccumulator;
 	}
 
-	for (uint32_t slot = 0; Pm4::COMPUTE_USER_ACCUM_0 + slot < Pm4::COMPUTE_USER_DATA_0; slot++) {
-		g_hw_sh_func[Pm4::COMPUTE_USER_ACCUM_0 + slot] = HwShSetCsUserAccumSgpr;
+	for (uint32_t slot = 0; slot < 4; slot++) {
+		g_hw_sh_func[Pm4::COMPUTE_USER_ACCUM_0 + slot] = HwShIgnoreUserAccumulator;
 	}
 	g_hw_sh_func[Pm4::COMPUTE_PGM_LO]                  = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_PGM_HI]                  = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::COMPUTE_TBA_LO]                  = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::COMPUTE_TBA_HI]                  = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::COMPUTE_TMA_LO]                  = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::COMPUTE_TMA_HI]                  = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_PGM_RSRC1]               = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_PGM_RSRC2]               = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_START_X]                 = HwShSetCsRegisters;
@@ -146,30 +136,16 @@ constexpr auto MakeShaderDispatchTable() {
 	g_hw_sh_func[Pm4::COMPUTE_NUM_THREAD_Y]            = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_NUM_THREAD_Z]            = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_RESOURCE_LIMITS]         = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::COMPUTE_DESTINATION_EN_SE0]      = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::COMPUTE_DESTINATION_EN_SE1]      = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_TMPRING_SIZE]            = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::COMPUTE_DESTINATION_EN_SE2]      = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::COMPUTE_DESTINATION_EN_SE3]      = HwShSetCsRegisters;
 	g_hw_sh_func[Pm4::COMPUTE_PGM_RSRC3]               = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::COMPUTE_SHADER_CHKSUM]           = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::COMPUTE_DISPATCH_TUNNEL]         = HwShSetCsRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_TBA_LO_PS]            = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_PGM_RSRC3_PS]         = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_PGM_RSRC4_PS]         = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_TMA_LO_PS]            = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_TMA_HI_PS]            = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_REQ_CTRL_PS]          = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_PGM_RSRC3_GS]         = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_PGM_RSRC4_GS]         = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_USER_DATA_ADDR_LO_GS] = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_USER_DATA_ADDR_HI_GS] = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_REQ_CTRL_ESGS]        = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_PGM_RSRC3_HS]         = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_PGM_RSRC4_HS]         = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_USER_DATA_ADDR_LO_HS] = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_USER_DATA_ADDR_HI_HS] = HwShIgnoreRegisters;
-	g_hw_sh_func[Pm4::SPI_SHADER_REQ_CTRL_LSHS]        = HwShIgnoreRegisters;
+	g_hw_sh_func[Pm4::COMPUTE_PACE_ID]                 = HwShSetCsRegisters;
+	g_hw_sh_func[Pm4::SPI_GRAPHICS_SHADER_CONTROL_PS]  = HwShSetRegisters;
+	g_hw_sh_func[Pm4::SPI_GRAPHICS_SHADER_CONTROL_GS]  = HwShSetRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_USER_DATA_ADDR_LO_GS] = HwShSetRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_USER_DATA_ADDR_HI_GS] = HwShSetRegisters;
+	g_hw_sh_func[Pm4::SPI_GRAPHICS_SHADER_CONTROL_HS]  = HwShSetRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_USER_DATA_ADDR_LO_HS] = HwShSetRegisters;
+	g_hw_sh_func[Pm4::SPI_SHADER_USER_DATA_ADDR_HI_HS] = HwShSetRegisters;
 
 	return g_hw_sh_func;
 }
@@ -181,6 +157,7 @@ constexpr auto MakeUconfigDispatchTable() {
 	g_hw_uc_func[Pm4::VGT_INDEX_TYPE]            = HwUcSetIndexType;
 	g_hw_uc_func[Pm4::VGT_OBJECT_ID]             = HwUcSetObjectId;
 	g_hw_uc_func[Pm4::TEXTURE_GRADIENT_FACTORS]  = HwUcSetTextureGradientFactors;
+	g_hw_uc_func[Pm4::TEXTURE_GRADIENT_CONTROL]  = HwUcSetTextureGradientFactors;
 	g_hw_uc_func[Pm4::IA_MULTI_VGT_PARAM]        = HwUcSetIaMultiVgtParam;
 	g_hw_uc_func[Pm4::GE_MULTI_PRIM_IB_RESET_EN] = HwUcSetMultiPrimIbReset;
 	g_hw_uc_func[Pm4::TA_CS_BC_BASE_ADDR]        = HwUcSetBorderColorTableAddr;
@@ -217,6 +194,7 @@ constexpr auto MakeOpcodeDispatchTable() {
 	g_cp_op_func[Pm4::IT_COND_EXEC]                 = CpOpCondExec;
 	g_cp_op_func[Pm4::IT_SET_PREDICATION]           = CpOpSetPredication;
 	g_cp_op_func[Pm4::IT_WRITE_DATA]                = CpOpWriteData;
+	g_cp_op_func[Pm4::IT_WAIT_REG_MEM]              = CpOpWaitRegMem32;
 	g_cp_op_func[Pm4::IT_INDIRECT_BUFFER]           = CpOpIndirectBuffer;
 	g_cp_op_func[Pm4::IT_COPY_DATA]                 = CpOpCopyData;
 	g_cp_op_func[Pm4::IT_EVENT_WRITE]               = CpOpEventWrite;
@@ -224,6 +202,7 @@ constexpr auto MakeOpcodeDispatchTable() {
 	g_cp_op_func[Pm4::IT_EVENT_WRITE_EOS]           = CpOpEventWriteEos;
 	g_cp_op_func[Pm4::IT_DMA_DATA]                  = CpOpDmaData;
 	g_cp_op_func[Pm4::IT_ACQUIRE_MEM]               = CpOpAcquireMem;
+	g_cp_op_func[Pm4::IT_REWIND]                    = CpOpRewind;
 	g_cp_op_func[Pm4::IT_SET_CONTEXT_REG]           = CpOpSetContextReg;
 	g_cp_op_func[Pm4::IT_SET_SH_REG]                = CpOpSetShaderReg;
 	g_cp_op_func[Pm4::IT_SET_UCONFIG_REG]           = CpOpSetUconfigReg;
@@ -238,6 +217,7 @@ constexpr auto MakeOpcodeDispatchTable() {
 	g_cp_op_func[Pm4::IT_WAIT_ON_CE_COUNTER]        = CpOpWaitOnCeCounter;
 	g_cp_op_func[Pm4::IT_WAIT_ON_DE_COUNTER_DIFF]   = CpOpWaitOnDeCounterDiff;
 	g_cp_op_func[Pm4::IT_GET_LOD_STATS]             = CpOpGetLodStats;
+	g_cp_op_func[Pm4::IT_WAIT_REG_MEM_64]           = CpOpWaitRegMem64;
 
 	return g_cp_op_func;
 }
@@ -246,14 +226,13 @@ constexpr auto MakeCustomOpcodeDispatchTable() {
 	std::array<cp_op_parser_func_t, Pm4::R_NUM> g_cp_op_custom_func {};
 
 	g_cp_op_custom_func[Pm4::R_DISPATCH_RESET] = CpOpDispatchReset;
-	g_cp_op_custom_func[Pm4::R_WAIT_MEM_32]    = CpOpWaitRegMem32;
 	g_cp_op_custom_func[Pm4::R_WAIT_FLIP_DONE] = CpOpWaitFlipDone;
 	g_cp_op_custom_func[Pm4::R_PUSH_MARKER]    = CpOpPushMarker;
 	g_cp_op_custom_func[Pm4::R_POP_MARKER]     = CpOpPopMarker;
 	g_cp_op_custom_func[Pm4::R_ACQUIRE_MEM]    = CpOpAcquireMem;
-	g_cp_op_custom_func[Pm4::R_WAIT_MEM_64]    = CpOpWaitRegMem64;
 	g_cp_op_custom_func[Pm4::R_FLIP]           = CpOpFlip;
 	g_cp_op_custom_func[Pm4::R_RELEASE_MEM]    = CpOpReleaseMem;
+	g_cp_op_custom_func[Pm4::R_CONTEXT_STATE]  = CpOpContextState;
 
 	return g_cp_op_custom_func;
 }

src/graphics/guest_gpu/command_processor/pm4Dispatch.h

@@ -44,11 +44,7 @@ uint32_t HwCtxSetBorderColorTableAddr(CommandProcessor&, uint32_t, uint32_t, con
 uint32_t HwCtxSetStencilClear(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetDepthClear(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetScreenScissor(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
-uint32_t HwCtxSetDepthRenderTarget(CommandProcessor&, uint32_t, uint32_t, const uint32_t*,
-                                   uint32_t);
 uint32_t HwCtxSetStencilInfo(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
-uint32_t HwCtxSetDepthHtileSurface(CommandProcessor&, uint32_t, uint32_t, const uint32_t*,
-                                   uint32_t);
 uint32_t HwCtxSetHardwareScreenOffset(CommandProcessor&, uint32_t, uint32_t, const uint32_t*,
                                       uint32_t);
 uint32_t HwCtxSetWindowOffset(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
@@ -56,7 +52,6 @@ uint32_t HwCtxSetWindowScissor(CommandProcessor&, uint32_t, uint32_t, const uint
 uint32_t HwCtxSetClipRect(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetRenderTargetMask(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetGenericScissor(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
-uint32_t HwCtxSetBlendColor(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetCbDccControl(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetStencilControl(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetStencilMask(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
@@ -90,8 +85,6 @@ uint32_t HwCtxSetDrawPayloadControl(CommandProcessor&, uint32_t, uint32_t, const
 uint32_t HwCtxSetPrimitiveIdReset(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetObjprimIdControl(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetShaderStages(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
-uint32_t HwCtxSetGuardBands(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
-uint32_t HwCtxSetRenderTarget(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetColorInfo(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetBlendControl(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwCtxSetViewportScissor(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
@@ -102,12 +95,10 @@ uint32_t HwShSetPsUserSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t
 uint32_t HwShSetGsUserSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwShSetHsUserSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwShSetCsUserSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
-uint32_t HwShSetPsUserAccumSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
-uint32_t HwShSetGsUserAccumSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
-uint32_t HwShSetHsUserAccumSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
-uint32_t HwShSetCsUserAccumSgpr(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
+uint32_t HwShIgnoreUserAccumulator(CommandProcessor&, uint32_t, uint32_t, const uint32_t*,
+                                   uint32_t);
 uint32_t HwShSetCsRegisters(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
-uint32_t HwShIgnoreRegisters(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
+uint32_t HwShSetRegisters(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwUcSetPrimitiveType(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwUcSetIndexType(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 uint32_t HwUcSetObjectId(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
@@ -121,6 +112,7 @@ uint32_t HwUcSetGeIndexOffset(CommandProcessor&, uint32_t, uint32_t, const uint3
 uint32_t HwUcSetGdsOaRegisters(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 
 uint32_t CpOpNop(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
+uint32_t CpOpContextState(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpSetBase(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpClearState(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpIndexBase(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
@@ -132,6 +124,7 @@ uint32_t CpOpDrawIndirectMulti(CommandProcessor&, uint32_t, const uint32_t*, uin
 uint32_t CpOpDrawIndex(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpDrawIndexOffset(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpPfpSyncMe(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
+uint32_t CpOpRewind(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpIndexType(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpNumInstances(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpDrawIndexAuto(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);

src/graphics/guest_gpu/gpu_defs.h

@@ -3,15 +3,8 @@
 
 #include "common/common.h"
 
-#include <type_traits>
-
 namespace Libs::Graphics::Prospero {
 
-template <typename T>
-constexpr auto GpuEnumValue(T value) {
-	return static_cast<std::underlying_type_t<T>>(value);
-}
-
 enum class PrimitiveType : uint32_t {
 	kNone               = 0,
 	kPointList          = 1,
@@ -60,23 +53,34 @@ enum class GsOutputPrimitiveType : uint32_t {
 };
 
 enum class ChannelLayout : uint32_t {
-	kInvalid     = 0,
-	k8           = 1,
-	k16          = 2,
-	k8_8         = 3,
-	k32          = 4,
-	k16_16       = 5,
-	k11_11_10    = 6,
-	k10_10_10_2  = 9,
-	k8_8_8_8     = 10,
-	k32_32       = 11,
-	k16_16_16_16 = 12,
-	k32_32_32_32 = 14,
-	k5_5_5_1     = 17,
-	k4_4_4_4     = 19,
-	kBc1         = 35,
-	kBc2         = 36,
-	kBc3         = 37,
+	kInvalid         = 0,
+	k8               = 1,
+	k16              = 2,
+	k8_8             = 3,
+	k32              = 4,
+	k16_16           = 5,
+	k11_11_10        = 6,
+	k10_11_11        = 7,
+	k2_10_10_10      = 8,
+	k10_10_10_2      = 9,
+	k8_8_8_8         = 10,
+	k32_32           = 11,
+	k16_16_16_16     = 12,
+	k32_32_32        = 13,
+	k32_32_32_32     = 14,
+	k5_6_5           = 16,
+	k5_5_5_1         = 17,
+	k1_5_5_5         = 18,
+	k4_4_4_4         = 19,
+	k10_10_10_2Float = 31,
+	k9_9_9_5         = 34,
+	kBc1             = 35,
+	kBc2             = 36,
+	kBc3             = 37,
+	kBc4             = 38,
+	kBc5             = 39,
+	kBc6             = 40,
+	kBc7             = 41,
 };
 
 enum class ChannelType : uint32_t {
@@ -104,32 +108,52 @@ enum class ChannelOrder : uint32_t {
 	kAltReversed = 3,
 };
 
-// Maps a shader's logical RGBA export to the host color-attachment components. Two bits per
-// component keep this cheap to carry in shader and pipeline keys.
+// Selects the logical shader component written to each physical color-attachment component.
+// Two bits per component keep this cheap to carry in shader and pipeline keys.
 struct ColorComponentMapping {
-	uint8_t packed = 0xe4u; // RGBA: 0, 1, 2, 3
+	static constexpr uint8_t kIdentity = 0xe4u;
+
+	uint8_t packed = kIdentity;
 
 	[[nodiscard]] constexpr uint32_t Map(uint32_t component) const {
 		return component < 4u ? (packed >> (component * 2u)) & 0x3u : component;
 	}
 
-	[[nodiscard]] constexpr uint32_t ApplyMask(uint32_t mask) const {
+	[[nodiscard]] constexpr uint32_t ApplyMask(uint32_t logical_mask) const {
 		uint32_t mapped = 0;
-		for (uint32_t component = 0; component < 4u; component++) {
-			mapped |= ((mask >> component) & 1u) << Map(component);
+		for (uint32_t physical_component = 0; physical_component < 4u; physical_component++) {
+			mapped |= ((logical_mask >> Map(physical_component)) & 1u) << physical_component;
 		}
 		return mapped;
 	}
 
-	[[nodiscard]] constexpr bool IsIdentity() const { return packed == 0xe4u; }
+	// This mapping selects an intermediate component; next selects the final logical component.
+	[[nodiscard]] constexpr ColorComponentMapping Then(ColorComponentMapping next) const {
+		ColorComponentMapping result {0u};
+		for (uint32_t physical_component = 0; physical_component < 4u; physical_component++) {
+			result.packed |= static_cast<uint8_t>(next.Map(Map(physical_component))
+			                                      << (physical_component * 2u));
+		}
+		return result;
+	}
+
+	[[nodiscard]] constexpr bool IsIdentity() const { return packed == kIdentity; }
 
 	bool operator==(const ColorComponentMapping&) const = default;
 };
 
 static_assert(sizeof(ColorComponentMapping) == sizeof(uint8_t));
 
-inline constexpr ColorComponentMapping ColorMappingAbgr {0x1bu}; // 3, 2, 1, 0
+inline constexpr ColorComponentMapping ColorMappingRgba {ColorComponentMapping::kIdentity};
+inline constexpr ColorComponentMapping ColorMappingGr {0xe1u};   // 1, 0, 2, 3
+inline constexpr ColorComponentMapping ColorMappingRabg {0x6cu}; // 0, 3, 2, 1
+inline constexpr ColorComponentMapping ColorMappingRgab {0xb4u}; // 0, 1, 3, 2
 inline constexpr ColorComponentMapping ColorMappingBgra {0xc6u}; // 2, 1, 0, 3
+inline constexpr ColorComponentMapping ColorMappingAbgr {0x1bu}; // 3, 2, 1, 0
+inline constexpr ColorComponentMapping ColorMappingAgba {0x27u}; // 3, 1, 2, 0
+inline constexpr ColorComponentMapping ColorMappingArbg {0x63u}; // 3, 0, 2, 1
+inline constexpr ColorComponentMapping ColorMappingAgbr {0x87u}; // 3, 1, 0, 2
+inline constexpr ColorComponentMapping ColorMappingArgb {0x93u}; // 3, 0, 1, 2
 
 enum class DepthFormat : uint32_t {
 	kInvalid = 0,
@@ -142,6 +166,24 @@ enum class StencilFormat : uint32_t {
 	k8UInt   = 1,
 };
 
+enum class TextureCompatiblePlaneCompression : uint32_t {
+	kDisable = 0x00000000,
+	kEnable  = 0x02900800,
+	kBitMask = 0x02900800,
+};
+
+enum class TextureCompatibleStencil : uint32_t {
+	kDisable = 0x00000000,
+	kEnable  = 0x00100800,
+	kBitMask = 0x00100800,
+};
+
+enum class ZCompareBase : uint32_t {
+	kZMin    = 0x00000000,
+	kZMax    = 0x80000000,
+	kBitMask = 0x80000000,
+};
+
 enum class TileMode : uint32_t {
 	kLinear       = 0x00,
 	kStandard256B = 0x01,
@@ -356,12 +398,28 @@ enum class BufferFormat : uint32_t {
 	k32_32_32_32UInt    = 75,
 	k32_32_32_32SInt    = 76,
 	k32_32_32_32Float   = 77,
+	k8Srgb              = 128,
+	k8_8Srgb            = 129,
 	k8_8_8_8Srgb        = 130,
+	k10_10_10_2Float    = 131,
 	k9_9_9_5Float       = 132,
 	k5_6_5UNorm         = 133,
 	k5_5_5_1UNorm       = 134,
+	k1_5_5_5UNorm       = 135,
 	k4_4_4_4UNorm       = 136,
+	kFmask8_S2_F1       = 156,
+	kFmask8_S4_F1       = 157,
+	kFmask8_S8_F1       = 158,
+	kFmask8_S2_F2       = 159,
+	kFmask8_S4_F2       = 160,
 	kFmask8_S4_F4       = 161,
+	kFmask16_S16_F1     = 162,
+	kFmask16_S8_F2      = 163,
+	kFmask32_S16_F2     = 164,
+	kFmask32_S8_F4      = 165,
+	kFmask32_S8_F8      = 166,
+	kFmask64_S16_F4     = 167,
+	kFmask64_S16_F8     = 168,
 	kBc1UNorm           = 169,
 	kBc1Srgb            = 170,
 	kBc2UNorm           = 171,

src/graphics/guest_gpu/gpu_format.cpp

@@ -3,126 +3,235 @@
 #include "graphics/guest_gpu/gpu_defs.h"
 
 #include <array>
+#include <bit>
 
 namespace Libs::Graphics::Prospero {
 namespace {
 
 struct FormatInfo {
-	uint32_t format;
-	uint32_t bytes_per_element;
-	uint32_t block_compressed_bytes_per_block;
-	uint32_t render_target_bytes_per_element;
-	bool     supported_sampled_texture_format;
-	bool     unsigned_integer_texture_format;
+	BufferFormat       format;
+	uint32_t           bytes_per_element;
+	uint32_t           block_compressed_bytes_per_block;
+	uint32_t           render_target_bytes_per_element;
+	bool               sampled_texture;
+	bool               uint_texture;
+	bool               sint_texture = false;
 };
 
 constexpr FormatInfo kFormatInfo[] = {
-    {GpuEnumValue(BufferFormat::k8UNorm), 1, 0, 1, true, false},
-    {GpuEnumValue(BufferFormat::k8SNorm), 0, 0, 1, false, false},
-    {GpuEnumValue(BufferFormat::k8UInt), 1, 0, 1, true, true},
-    {GpuEnumValue(BufferFormat::k16UNorm), 2, 0, 2, true, false},
-    {GpuEnumValue(BufferFormat::k16SNorm), 2, 0, 2, true, false},
-    {GpuEnumValue(BufferFormat::k16UInt), 2, 0, 2, true, true},
-    {GpuEnumValue(BufferFormat::k16SInt), 2, 0, 2, false, false},
-    {GpuEnumValue(BufferFormat::k16Float), 2, 0, 2, true, false},
-    {GpuEnumValue(BufferFormat::k8_8UNorm), 2, 0, 2, true, false},
-    {GpuEnumValue(BufferFormat::k8_8SNorm), 2, 0, 2, true, false},
-    {GpuEnumValue(BufferFormat::k8_8UInt), 2, 0, 2, true, true},
-    {GpuEnumValue(BufferFormat::k8_8SInt), 2, 0, 2, false, false},
-    {GpuEnumValue(BufferFormat::k32UInt), 4, 0, 4, true, true},
-    {GpuEnumValue(BufferFormat::k32SInt), 4, 0, 4, false, false},
-    {GpuEnumValue(BufferFormat::k32Float), 4, 0, 4, true, false},
-    {GpuEnumValue(BufferFormat::k16_16UNorm), 4, 0, 4, true, false},
-    {GpuEnumValue(BufferFormat::k16_16SNorm), 4, 0, 4, true, false},
-    {GpuEnumValue(BufferFormat::k16_16UInt), 4, 0, 4, true, true},
-    {GpuEnumValue(BufferFormat::k16_16SInt), 4, 0, 4, false, false},
-    {GpuEnumValue(BufferFormat::k16_16Float), 4, 0, 4, true, false},
-    {GpuEnumValue(BufferFormat::k11_11_10Float), 4, 0, 4, true, false},
-    {GpuEnumValue(BufferFormat::k10_10_10_2UNorm), 4, 0, 4, true, false},
-    {GpuEnumValue(BufferFormat::k8_8_8_8UNorm), 4, 0, 4, true, false},
-    {GpuEnumValue(BufferFormat::k8_8_8_8SNorm), 4, 0, 4, true, false},
-    {GpuEnumValue(BufferFormat::k8_8_8_8UInt), 4, 0, 4, true, true},
-    {GpuEnumValue(BufferFormat::k8_8_8_8SInt), 4, 0, 4, false, false},
-    {GpuEnumValue(BufferFormat::k32_32UInt), 8, 0, 8, true, true},
-    {GpuEnumValue(BufferFormat::k32_32SInt), 8, 0, 8, false, false},
-    {GpuEnumValue(BufferFormat::k32_32Float), 8, 0, 8, true, false},
-    {GpuEnumValue(BufferFormat::k16_16_16_16UNorm), 8, 0, 8, true, false},
-    {GpuEnumValue(BufferFormat::k16_16_16_16SNorm), 8, 0, 8, true, false},
-    {GpuEnumValue(BufferFormat::k16_16_16_16UInt), 8, 0, 8, true, true},
-    {GpuEnumValue(BufferFormat::k16_16_16_16SInt), 8, 0, 8, false, false},
-    {GpuEnumValue(BufferFormat::k16_16_16_16Float), 8, 0, 8, true, false},
-    {GpuEnumValue(BufferFormat::k32_32_32UInt), 12, 0, 12, true, true},
-    {GpuEnumValue(BufferFormat::k32_32_32SInt), 12, 0, 12, false, false},
-    {GpuEnumValue(BufferFormat::k32_32_32Float), 12, 0, 12, true, false},
-    {GpuEnumValue(BufferFormat::k32_32_32_32UInt), 16, 0, 16, true, true},
-    {GpuEnumValue(BufferFormat::k32_32_32_32SInt), 16, 0, 16, false, false},
-    {GpuEnumValue(BufferFormat::k32_32_32_32Float), 16, 0, 16, true, false},
-    {GpuEnumValue(BufferFormat::k8_8_8_8Srgb), 4, 0, 4, true, false},
-    {GpuEnumValue(BufferFormat::k9_9_9_5Float), 4, 0, 0, true, false},
-    {GpuEnumValue(BufferFormat::k5_6_5UNorm), 2, 0, 2, true, false},
-    {GpuEnumValue(BufferFormat::k5_5_5_1UNorm), 2, 0, 2, true, false},
-    {GpuEnumValue(BufferFormat::k4_4_4_4UNorm), 2, 0, 2, true, false},
-    {GpuEnumValue(BufferFormat::kFmask8_S4_F4), 1, 0, 1, true, false},
-    {GpuEnumValue(BufferFormat::kBc1UNorm), 0, 8, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc1Srgb), 0, 8, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc2UNorm), 0, 16, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc2Srgb), 0, 16, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc3UNorm), 0, 16, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc3Srgb), 0, 16, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc4UNorm), 0, 8, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc4SNorm), 0, 8, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc5UNorm), 0, 16, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc5SNorm), 0, 16, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc6UFloat), 0, 16, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc6SFloat), 0, 16, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc7UNorm), 0, 16, 0, true, false},
-    {GpuEnumValue(BufferFormat::kBc7Srgb), 0, 16, 0, true, false},
+	{BufferFormat::k8UNorm, 1, 0, 1, true, false},
+	{BufferFormat::k8SNorm, 0, 0, 1, false, false},
+	{BufferFormat::k8UInt, 1, 0, 1, true, true},
+	{BufferFormat::k16UNorm, 2, 0, 2, true, false},
+	{BufferFormat::k16SNorm, 2, 0, 2, true, false},
+	{BufferFormat::k16UInt, 2, 0, 2, true, true},
+	{BufferFormat::k16SInt, 2, 0, 2, true, false, true},
+	{BufferFormat::k16Float, 2, 0, 2, true, false},
+	{BufferFormat::k8_8UNorm, 2, 0, 2, true, false},
+	{BufferFormat::k8_8SNorm, 2, 0, 2, true, false},
+	{BufferFormat::k8_8UInt, 2, 0, 2, true, true},
+	{BufferFormat::k8_8SInt, 2, 0, 2, true, false, true},
+	{BufferFormat::k32UInt, 4, 0, 4, true, true},
+	{BufferFormat::k32SInt, 4, 0, 4, true, false, true},
+	{BufferFormat::k32Float, 4, 0, 4, true, false},
+	{BufferFormat::k16_16UNorm, 4, 0, 4, true, false},
+	{BufferFormat::k16_16SNorm, 4, 0, 4, true, false},
+	{BufferFormat::k16_16UInt, 4, 0, 4, true, true},
+	{BufferFormat::k16_16SInt, 4, 0, 4, true, false, true},
+	{BufferFormat::k16_16Float, 4, 0, 4, true, false},
+	{BufferFormat::k11_11_10UInt, 4, 0, 4, true, true},
+	{BufferFormat::k11_11_10Float, 4, 0, 4, true, false},
+	{BufferFormat::k10_10_10_2UNorm, 4, 0, 4, true, false},
+	{BufferFormat::k10_10_10_2UInt, 4, 0, 4, true, true},
+	{BufferFormat::k8_8_8_8UNorm, 4, 0, 4, true, false},
+	{BufferFormat::k8_8_8_8SNorm, 4, 0, 4, true, false},
+	{BufferFormat::k8_8_8_8UInt, 4, 0, 4, true, true},
+	{BufferFormat::k8_8_8_8SInt, 4, 0, 4, true, false, true},
+	{BufferFormat::k32_32UInt, 8, 0, 8, true, true},
+	{BufferFormat::k32_32SInt, 8, 0, 8, true, false, true},
+	{BufferFormat::k32_32Float, 8, 0, 8, true, false},
+	{BufferFormat::k16_16_16_16UNorm, 8, 0, 8, true, false},
+	{BufferFormat::k16_16_16_16SNorm, 8, 0, 8, true, false},
+	{BufferFormat::k16_16_16_16UInt, 8, 0, 8, true, true},
+	{BufferFormat::k16_16_16_16SInt, 8, 0, 8, true, false, true},
+	{BufferFormat::k16_16_16_16Float, 8, 0, 8, true, false},
+	{BufferFormat::k32_32_32UInt, 12, 0, 12, true, true},
+	{BufferFormat::k32_32_32SInt, 12, 0, 12, true, false, true},
+	{BufferFormat::k32_32_32Float, 12, 0, 12, true, false},
+	{BufferFormat::k32_32_32_32UInt, 16, 0, 16, true, true},
+	{BufferFormat::k32_32_32_32SInt, 16, 0, 16, true, false, true},
+	{BufferFormat::k32_32_32_32Float, 16, 0, 16, true, false},
+	{BufferFormat::k8Srgb, 1, 0, 0, true, false},
+	{BufferFormat::k8_8Srgb, 2, 0, 0, true, false},
+	{BufferFormat::k8_8_8_8Srgb, 4, 0, 4, true, false},
+	{BufferFormat::k9_9_9_5Float, 4, 0, 0, true, false},
+	{BufferFormat::k5_6_5UNorm, 2, 0, 2, true, false},
+	{BufferFormat::k5_5_5_1UNorm, 2, 0, 2, true, false},
+	{BufferFormat::k1_5_5_5UNorm, 0, 0, 2, false, false},
+	{BufferFormat::k4_4_4_4UNorm, 2, 0, 2, true, false},
+	{BufferFormat::kFmask8_S2_F1, 1, 0, 1, true, false},
+	{BufferFormat::kFmask8_S4_F1, 1, 0, 1, true, false},
+	{BufferFormat::kFmask8_S8_F1, 1, 0, 1, true, false},
+	{BufferFormat::kFmask8_S2_F2, 1, 0, 1, true, false},
+	{BufferFormat::kFmask8_S4_F2, 1, 0, 1, true, false},
+	{BufferFormat::kFmask8_S4_F4, 1, 0, 1, true, false},
+	{BufferFormat::kFmask16_S16_F1, 2, 0, 2, true, false},
+	{BufferFormat::kFmask16_S8_F2, 2, 0, 2, true, false},
+	{BufferFormat::kFmask32_S16_F2, 4, 0, 4, true, false},
+	{BufferFormat::kFmask32_S8_F4, 4, 0, 4, true, false},
+	{BufferFormat::kFmask32_S8_F8, 4, 0, 4, true, false},
+	{BufferFormat::kFmask64_S16_F4, 8, 0, 8, true, false},
+	{BufferFormat::kFmask64_S16_F8, 8, 0, 8, true, false},
+	{BufferFormat::kBc1UNorm, 0, 8, 0, true, false},
+	{BufferFormat::kBc1Srgb, 0, 8, 0, true, false},
+	{BufferFormat::kBc2UNorm, 0, 16, 0, true, false},
+	{BufferFormat::kBc2Srgb, 0, 16, 0, true, false},
+	{BufferFormat::kBc3UNorm, 0, 16, 0, true, false},
+	{BufferFormat::kBc3Srgb, 0, 16, 0, true, false},
+	{BufferFormat::kBc4UNorm, 0, 8, 0, true, false},
+	{BufferFormat::kBc4SNorm, 0, 8, 0, true, false},
+	{BufferFormat::kBc5UNorm, 0, 16, 0, true, false},
+	{BufferFormat::kBc5SNorm, 0, 16, 0, true, false},
+	{BufferFormat::kBc6UFloat, 0, 16, 0, true, false},
+	{BufferFormat::kBc6SFloat, 0, 16, 0, true, false},
+	{BufferFormat::kBc7UNorm, 0, 16, 0, true, false},
+	{BufferFormat::kBc7Srgb, 0, 16, 0, true, false},
 };
 
+constexpr uint8_t RenderTargetTypeBit(ChannelType type) {
+	return static_cast<uint8_t>(1u << static_cast<uint32_t>(type));
+}
+
+constexpr auto kUNormType = RenderTargetTypeBit(ChannelType::kUNorm);
+constexpr auto kIntegerTypes =
+    RenderTargetTypeBit(ChannelType::kUInt) | RenderTargetTypeBit(ChannelType::kSInt);
+constexpr auto kNormalizedIntegerTypes =
+    kUNormType | RenderTargetTypeBit(ChannelType::kSNorm) | kIntegerTypes;
+
+struct RenderTargetLayoutInfo {
+	ChannelLayout       layout;
+	BufferFormat        first_linear_format;
+	uint8_t             linear_type_mask;
+	uint8_t             components;
+	BufferFormat        extra_format  = BufferFormat::kInvalid;
+	ChannelType         extra_type    = ChannelType::kUNorm;
+	ChannelOrderSupport order_support = ChannelOrderSupport::kAll;
+};
+
+constexpr RenderTargetLayoutInfo kRenderTargetLayouts[] = {
+    {ChannelLayout::k8, BufferFormat::k8UNorm, kNormalizedIntegerTypes, 1, BufferFormat::k8Srgb,
+     ChannelType::kSrgb},
+    {ChannelLayout::k16, BufferFormat::k16UNorm, kNormalizedIntegerTypes, 1, BufferFormat::k16Float,
+     ChannelType::kFloat},
+    {ChannelLayout::k8_8, BufferFormat::k8_8UNorm, kNormalizedIntegerTypes, 2,
+     BufferFormat::k8_8Srgb, ChannelType::kSrgb},
+    {ChannelLayout::k32, BufferFormat::k32UInt, kIntegerTypes, 1, BufferFormat::k32Float,
+     ChannelType::kFloat},
+    {ChannelLayout::k16_16, BufferFormat::k16_16UNorm, kNormalizedIntegerTypes, 2,
+     BufferFormat::k16_16Float, ChannelType::kFloat},
+    {ChannelLayout::k11_11_10, BufferFormat::k11_11_10UNorm, kNormalizedIntegerTypes, 3,
+     BufferFormat::k11_11_10Float, ChannelType::kFloat},
+    {ChannelLayout::k10_11_11, BufferFormat::k10_11_11UNorm, kNormalizedIntegerTypes, 3,
+     BufferFormat::k10_11_11Float, ChannelType::kFloat},
+    {ChannelLayout::k2_10_10_10, BufferFormat::k2_10_10_10UNorm, kNormalizedIntegerTypes, 4},
+    {ChannelLayout::k10_10_10_2, BufferFormat::k10_10_10_2UNorm, kNormalizedIntegerTypes, 4},
+    {ChannelLayout::k8_8_8_8, BufferFormat::k8_8_8_8UNorm, kNormalizedIntegerTypes, 4,
+     BufferFormat::k8_8_8_8Srgb, ChannelType::kSrgb},
+    {ChannelLayout::k32_32, BufferFormat::k32_32UInt, kIntegerTypes, 2, BufferFormat::k32_32Float,
+     ChannelType::kFloat},
+    {ChannelLayout::k16_16_16_16, BufferFormat::k16_16_16_16UNorm, kNormalizedIntegerTypes, 4,
+     BufferFormat::k16_16_16_16Float, ChannelType::kFloat},
+    {ChannelLayout::k32_32_32_32, BufferFormat::k32_32_32_32UInt, kIntegerTypes, 4,
+     BufferFormat::k32_32_32_32Float, ChannelType::kFloat},
+    {ChannelLayout::k5_6_5, BufferFormat::k5_6_5UNorm, kUNormType, 3},
+    {ChannelLayout::k5_5_5_1, BufferFormat::k5_5_5_1UNorm, kUNormType, 4},
+    {ChannelLayout::k1_5_5_5, BufferFormat::k1_5_5_5UNorm, kUNormType, 4},
+    {ChannelLayout::k4_4_4_4, BufferFormat::k4_4_4_4UNorm, kUNormType, 4},
+    {ChannelLayout::k10_10_10_2Float, BufferFormat::kInvalid, 0, 4, BufferFormat::k10_10_10_2Float,
+     ChannelType::kFloat, ChannelOrderSupport::kStandardOnly},
+};
+
+const RenderTargetLayoutInfo* FindRenderTargetLayout(ChannelLayout layout) {
+	for (const auto& info: kRenderTargetLayouts) {
+		if (info.layout == layout) {
+			return &info;
+		}
+	}
+	return nullptr;
+}
+
 constexpr auto MakeFormatInfoLookup() {
-	constexpr uint32_t                            kMaxFormat = GpuEnumValue(BufferFormat::kBc7Srgb);
+	constexpr size_t kMaxFormat = static_cast<size_t>(BufferFormat::kBc7Srgb);
 	std::array<const FormatInfo*, kMaxFormat + 1> lookup {};
 	for (const auto& info: kFormatInfo) {
-		lookup[info.format] = &info;
+		lookup[static_cast<size_t>(info.format)] = &info;
 	}
 	return lookup;
 }
 
 constexpr auto kFormatInfoLookup = MakeFormatInfoLookup();
 
-const FormatInfo* FindFormatInfo(uint32_t format) {
-	return format < kFormatInfoLookup.size() ? kFormatInfoLookup[format] : nullptr;
+const FormatInfo* FindFormatInfo(BufferFormat format) {
+	const auto index = static_cast<size_t>(format);
+	return index < kFormatInfoLookup.size() ? kFormatInfoLookup[index] : nullptr;
 }
 
 } // namespace
 
-uint32_t NumBytesPerElement(uint32_t format) {
+RenderTargetFormatEncoding ResolveRenderTargetFormat(ChannelLayout layout, ChannelType type) {
+	const auto* layout_info = FindRenderTargetLayout(layout);
+	const auto  raw_type    = static_cast<uint32_t>(type);
+	if (layout_info == nullptr || raw_type >= 8u) {
+		return {};
+	}
+
+	auto format = BufferFormat::kInvalid;
+	if (layout_info->extra_format != BufferFormat::kInvalid && type == layout_info->extra_type) {
+		format = layout_info->extra_format;
+	} else if ((layout_info->linear_type_mask & (1u << raw_type)) != 0) {
+		const auto first_type =
+		    std::countr_zero(static_cast<uint32_t>(layout_info->linear_type_mask));
+		format = static_cast<BufferFormat>(static_cast<uint32_t>(layout_info->first_linear_format) +
+		                                   raw_type - first_type);
+	}
+	if (format == BufferFormat::kInvalid) {
+		return {};
+	}
+	return {format, layout_info->components, layout_info->order_support};
+}
+
+uint32_t NumBytesPerElement(BufferFormat format) {
 	const auto* info = FindFormatInfo(format);
 	return info != nullptr ? info->bytes_per_element : 0;
 }
 
-uint32_t BlockCompressedBytesPerBlock(uint32_t format) {
+uint32_t BlockCompressedBytesPerBlock(BufferFormat format) {
 	const auto* info = FindFormatInfo(format);
 	return info != nullptr ? info->block_compressed_bytes_per_block : 0;
 }
 
-uint32_t RenderTargetBytesPerElement(uint32_t format) {
+uint32_t RenderTargetBytesPerElement(BufferFormat format) {
 	const auto* info = FindFormatInfo(format);
 	return info != nullptr ? info->render_target_bytes_per_element : 0;
 }
 
-bool IsSupportedTextureFormat(uint32_t format) {
-	const auto* info = FindFormatInfo(format);
-	return info != nullptr && info->supported_sampled_texture_format;
+bool IsFmaskTextureFormat(BufferFormat format) {
+	return format >= BufferFormat::kFmask8_S2_F1 && format <= BufferFormat::kFmask64_S16_F8;
 }
 
-bool IsUintTextureFormat(uint32_t format) {
+TextureNumericClass SampledTextureNumericClass(BufferFormat format) {
 	const auto* info = FindFormatInfo(format);
-	return info != nullptr && info->unsigned_integer_texture_format;
+	if (info == nullptr || !info->sampled_texture) {
+		return TextureNumericClass::Unsupported;
+	}
+	if (info->sint_texture) {
+		return TextureNumericClass::Sint;
+	}
+	return info->uint_texture ? TextureNumericClass::Uint : TextureNumericClass::Float;
 }
 
-bool IsFmaskTextureFormat(uint32_t format) {
-	return format == GpuEnumValue(BufferFormat::kFmask8_S4_F4);
+BufferFormat RemapTextureFormat(BufferFormat format) {
+	return format == BufferFormat::k11_11_10UInt ? BufferFormat::k32UInt : format;
 }
 
 } // namespace Libs::Graphics::Prospero

src/graphics/guest_gpu/gpu_format.h

@@ -1,16 +1,51 @@
 #ifndef EMULATOR_INCLUDE_EMULATOR_GRAPHICS_GUEST_GPU_GPU_FORMAT_H_
 #define EMULATOR_INCLUDE_EMULATOR_GRAPHICS_GUEST_GPU_GPU_FORMAT_H_
 
-#include "common/common.h"
+#include "graphics/guest_gpu/gpu_defs.h"
 
 namespace Libs::Graphics::Prospero {
 
-uint32_t NumBytesPerElement(uint32_t format);
-uint32_t BlockCompressedBytesPerBlock(uint32_t format);
-uint32_t RenderTargetBytesPerElement(uint32_t format);
-bool     IsSupportedTextureFormat(uint32_t format);
-bool     IsUintTextureFormat(uint32_t format);
-bool     IsFmaskTextureFormat(uint32_t format);
+enum class ChannelOrderSupport : uint8_t {
+	kNone,
+	kStandardOnly,
+	kAll,
+};
+
+struct RenderTargetFormatEncoding {
+	BufferFormat        buffer_format = BufferFormat::kInvalid;
+	uint8_t             components    = 0;
+	ChannelOrderSupport order_support = ChannelOrderSupport::kNone;
+
+	[[nodiscard]] constexpr bool IsValid() const {
+		return buffer_format != BufferFormat::kInvalid && components >= 1u && components <= 4u &&
+		       order_support != ChannelOrderSupport::kNone;
+	}
+
+	[[nodiscard]] constexpr bool SupportsOrder(ChannelOrder order) const {
+		switch (order_support) {
+			case ChannelOrderSupport::kStandardOnly: return order == ChannelOrder::kStandard;
+			case ChannelOrderSupport::kAll:
+				switch (order) {
+					case ChannelOrder::kStandard:
+					case ChannelOrder::kAlt:
+					case ChannelOrder::kReversed:
+					case ChannelOrder::kAltReversed: return true;
+				}
+				return false;
+			default: return false;
+		}
+	}
+};
+
+enum class TextureNumericClass { Unsupported, Float, Uint, Sint };
+
+RenderTargetFormatEncoding ResolveRenderTargetFormat(ChannelLayout layout, ChannelType type);
+uint32_t                   NumBytesPerElement(BufferFormat format);
+uint32_t                   BlockCompressedBytesPerBlock(BufferFormat format);
+uint32_t                   RenderTargetBytesPerElement(BufferFormat format);
+bool                       IsFmaskTextureFormat(BufferFormat format);
+TextureNumericClass        SampledTextureNumericClass(BufferFormat format);
+BufferFormat               RemapTextureFormat(BufferFormat format);
 
 } // namespace Libs::Graphics::Prospero
 

src/graphics/guest_gpu/graphicsRun.h

@@ -3,33 +3,101 @@
 
 #include "common/abi.h"
 #include "common/common.h"
+#include "common/threads.h"
+#include "common/uniqueFunction.h"
+#include "graphics/guest_gpu/command_processor/commandProcessor.h"
+
+#include <array>
+#include <atomic>
+#include <cstdint>
+#include <deque>
+#include <memory>
+#include <mutex>
+#include <span>
+#include <thread>
 
 namespace Libs::Graphics {
 
-class CommandProcessor;
+class RenderContext;
 
-class GraphicsRunSubmissionLock final {
+class GuestGpu final {
 public:
-	GraphicsRunSubmissionLock();
-	~GraphicsRunSubmissionLock();
-	KYTY_CLASS_NO_COPY(GraphicsRunSubmissionLock);
+	explicit GuestGpu(RenderContext& renderer);
+	~GuestGpu();
+	KYTY_CLASS_NO_COPY(GuestGpu);
+
+	void               Shutdown();
+	[[nodiscard]] bool IsStopping();
+	void               SendCommand(Common::UniqueFunction<void>&& command);
+	void               SendCommandSync(Common::UniqueFunction<void>&& command);
+
+	// Submitted command memory is borrowed and must remain valid until GPU execution completes.
+	void              Submit(std::span<const uint32_t> draw_commands,
+	                         std::span<const uint32_t> constant_commands);
+	void              SubmitCompute(uint32_t queue, std::span<const uint32_t> commands);
+	void              SubmitFlipPreparation(uint64_t request_id);
+	void              Done();
+	[[nodiscard]] int GetFrameNum() const;
+
+	[[nodiscard]] static bool IsGpuThread() noexcept;
+
+private:
+	static constexpr uint32_t ComputePipeCount     = 7;
+	static constexpr uint32_t QueuesPerComputePipe = 8;
+	static constexpr uint32_t ComputeQueueCount    = ComputePipeCount * QueuesPerComputePipe;
+	static constexpr uint32_t ComputeQueueBase     = 0x20;
+	static constexpr uint32_t QueueCount           = 1 + ComputeQueueCount;
+
+	enum class SubmissionType { Graphics, Compute, FlipPreparation };
+
+	struct Submission {
+		SubmissionType            type     = SubmissionType::Graphics;
+		uint32_t                  queue_id = 0;
+		std::span<const uint32_t> commands;
+		std::span<const uint32_t> constant_commands;
+		Pm4Execution              command_execution;
+		Pm4Execution              constant_execution;
+		bool                      reset_processor   = false;
+		bool                      started           = false;
+		bool                      command_complete  = false;
+		bool                      constant_complete = false;
+		bool                      blocked           = false;
+		uint64_t                  flip_request_id   = 0;
+	};
+
+	void              Enqueue(Submission submission);
+	void              WaitForIdle();
+	void              ProcessCommands();
+	bool              Process(Submission& submission);
+	static void       ThreadRun(void* data);
+	CommandProcessor& GetProcessor(uint32_t queue_id);
+
+	RenderContext&                                 m_renderer;
+	Common::Mutex                                  m_submission_mutex;
+	Common::Mutex                                  m_queue_mutex;
+	std::mutex                                     m_shutdown_mutex;
+	Common::CondVar                                m_work_available;
+	Common::CondVar                                m_idle;
+	std::array<std::deque<Submission>, QueueCount> m_queues;
+	std::deque<Common::UniqueFunction<void>>       m_commands;
+	std::atomic_uint32_t                           m_pending_commands {0};
+	uint32_t                                       m_next_queue        = 0;
+	uint32_t                                       m_submission_count  = 0;
+	bool                                           m_processing        = false;
+	bool                                           m_graphics_done     = true;
+	bool                                           m_accepting         = true;
+	bool                                           m_stopping          = false;
+	bool                                           m_shutdown_complete = false;
+
+	std::unique_ptr<CommandProcessor>                                m_gfx_cp;
+	std::array<std::unique_ptr<CommandProcessor>, ComputeQueueCount> m_compute_cp;
+
+	uint64_t        m_submit_id = 0;
+	std::atomic_int m_done_num  = 0;
+	std::jthread    m_thread;
+
+	friend class CommandProcessor;
 };
-
-void GraphicsRunInit();
-
-void GraphicsRunSubmit(uint32_t* cmd_draw_buffer, uint32_t num_draw_dw, uint32_t* cmd_const_buffer,
-                       uint32_t num_const_dw, bool trigger_agc_interrupt_on_done = false);
-void GraphicsRunSubmitCompute(uint32_t queue, uint32_t* cmd_buffer, uint32_t num_dw,
-                              bool trigger_agc_interrupt_on_done = false);
-void GraphicsRunSubmitFlipPreparation();
-void GraphicsRunWait();
-void GraphicsRunDone();
-int  GraphicsRunGetFrameNum();
-[[nodiscard]] bool              GraphicsRunIsCommandProcessorThread() noexcept;
-[[nodiscard]] CommandProcessor* GraphicsRunCurrentCommandProcessor() noexcept;
-void                            GraphicsRunFinishCommandProcessors();
-[[nodiscard]] bool              GraphicsRunSubmissionLockHeld() noexcept;
-[[nodiscard]] bool              GraphicsRunGpuLockHeld() noexcept;
 } // namespace Libs::Graphics
 
 #endif /* EMULATOR_INCLUDE_EMULATOR_GRAPHICS_GRAPHICSRUN_H_ */

src/graphics/guest_gpu/hardwareContext.h

@@ -3,6 +3,7 @@
 
 #include "common/abi.h"
 #include "common/common.h"
+#include "graphics/guest_gpu/gpu_defs.h"
 
 namespace Libs::Graphics::HW {
 
@@ -10,15 +11,6 @@ struct ColorBase {
 	uint64_t addr = 0;
 };
 
-struct ColorPitch {
-	uint32_t pitch_div8_minus1       = 0;
-	uint32_t fmask_pitch_div8_minus1 = 0;
-};
-
-struct ColorSlice {
-	uint32_t slice_div64_minus1 = 0;
-};
-
 struct ColorView {
 	uint32_t base_array_slice_index = 0;
 	uint32_t last_array_slice_index = 0;
@@ -28,25 +20,20 @@ struct ColorView {
 struct ColorInfo {
 	bool fmask_compression_enable = false;
 	// uint32_t fmask_compression_mode   = 0;
-	bool     fmask_data_compression_disable = false;
-	bool     fmask_one_frag_mode            = false;
-	bool     cmask_fast_clear_enable        = false;
-	bool     dcc_compression_enable         = false;
-	bool     blend_clamp                    = false;
-	bool     blend_bypass                   = false;
-	bool     round_mode                     = false;
-	uint32_t cmask_is_linear                = 0;
-	uint32_t cmask_addr_type                = 0;
-	bool     alt_tile_mode                  = false;
-	uint32_t format                         = 0;
-	uint32_t channel_type                   = 0;
-	uint32_t channel_order                  = 0;
+	bool                    fmask_data_compression_disable = false;
+	bool                    fmask_one_frag_mode            = false;
+	bool                    cmask_fast_clear_enable        = false;
+	bool                    dcc_compression_enable         = false;
+	bool                    blend_clamp                    = false;
+	bool                    blend_bypass                   = false;
+	bool                    round_mode                     = false;
+	Prospero::ChannelLayout format                         = Prospero::ChannelLayout::kInvalid;
+	Prospero::ChannelType   channel_type                   = Prospero::ChannelType::kUNorm;
+	Prospero::ChannelOrder  channel_order                  = Prospero::ChannelOrder::kStandard;
 };
 
 struct ColorAttrib {
 	bool     force_dest_alpha_to_one = false;
-	uint32_t tile_mode               = 0;
-	uint32_t fmask_tile_mode         = 0;
 	uint32_t num_samples             = 0;
 	uint32_t num_fragments           = 0;
 };
@@ -58,41 +45,33 @@ struct ColorAttrib2 {
 };
 
 struct ColorAttrib3 {
-	uint32_t depth              = 0;
-	uint32_t tile_mode          = 0;
-	uint32_t dimension          = 0;
-	bool     cmask_pipe_aligned = false;
-	bool     dcc_pipe_aligned   = false;
+	uint32_t           depth                        = 0;
+	Prospero::TileMode tile_mode                    = Prospero::TileMode::kRenderTarget;
+	uint32_t           dimension                    = 0;
+	bool               metadata_pipe_aligned        = false;
+	bool               write_vrs_rate_hint_to_cmask = false;
 };
 
 struct ColorDccControl {
-	uint32_t max_uncompressed_block_size    = 0;
-	uint32_t max_compressed_block_size      = 0;
-	uint32_t min_compressed_block_size      = 0;
-	uint32_t color_transform                = 0;
-	bool     dcc_clear_key_enable           = false;
-	bool     overwrite_combiner_disable     = false;
-	bool     independent_64b_blocks         = false;
-	bool     independent_128b_blocks        = false;
-	bool     data_write_on_dcc_clear_to_reg = false;
+	enum class IndependentBlockSize : uint8_t { Disabled, Bytes64, Bytes128 };
+
+	uint32_t             max_uncompressed_block_size    = 2;
+	uint32_t             max_compressed_block_size      = 2;
+	uint32_t             color_transform                = 0;
+	bool                 dcc_clear_key_enable           = false;
+	bool                 overwrite_combiner_disable     = false;
+	IndependentBlockSize independent_block_size         = IndependentBlockSize::Disabled;
+	bool                 data_write_on_dcc_clear_to_reg = false;
 };
 
 struct ColorCmask {
 	uint64_t addr = 0;
 };
 
-struct ColorCmaskSlice {
-	uint32_t slice_minus1 = 0;
-};
-
 struct ColorFmask {
 	uint64_t addr = 0;
 };
 
-struct ColorFmaskSlice {
-	uint32_t slice_minus1 = 0;
-};
-
 struct ColorClearWord0 {
 	uint32_t word0 = 0;
 };
@@ -105,15 +84,8 @@ struct ColorDccAddr {
 	uint64_t addr = 0;
 };
 
-struct ColorSize {
-	uint32_t width  = 0;
-	uint32_t height = 0;
-};
-
 struct RenderTarget {
 	ColorBase       base;
-	ColorPitch      pitch;
-	ColorSlice      slice;
 	ColorView       view;
 	ColorInfo       info;
 	ColorAttrib     attrib;
@@ -121,46 +93,73 @@ struct RenderTarget {
 	ColorAttrib3    attrib3;
 	ColorDccControl dcc;
 	ColorCmask      cmask;
-	ColorCmaskSlice cmask_slice;
 	ColorFmask      fmask;
-	ColorFmaskSlice fmask_slice;
 	ColorClearWord0 clear_word0;
 	ColorClearWord1 clear_word1;
 	ColorDccAddr    dcc_addr;
-	ColorSize       size;
 };
 
 struct DepthZInfo {
-	uint32_t format                    = 0;
-	uint32_t tile_mode_index           = 0;
-	uint32_t num_samples               = 0;
-	uint32_t zrange_precision          = 0;
-	bool     tile_surface_enable       = false;
-	bool     expclear_enabled          = false;
-	bool     embedded_sample_locations = false;
-	bool     partially_resident        = false;
-	uint8_t  num_mip_levels            = 0;
-	uint8_t  plane_compression         = 0;
+	Prospero::DepthFormat                       format      = Prospero::DepthFormat::kInvalid;
+	uint32_t                                    num_samples = 0;
+	Prospero::TextureCompatiblePlaneCompression texture_compatibility =
+	    Prospero::TextureCompatiblePlaneCompression::kDisable;
+	Prospero::ZCompareBase z_compare_base     = Prospero::ZCompareBase::kZMax;
+	bool                   htile_acceleration = false;
+	bool                   expclear_enabled   = false;
+	bool                   partially_resident = false;
+	uint8_t                max_mip_level      = 0;
+
+	[[nodiscard]] static DepthZInfo Decode(uint32_t value) {
+		DepthZInfo info;
+		info.format                = static_cast<Prospero::DepthFormat>(value & 0x3u);
+		info.num_samples           = (value >> 2u) & 0x3u;
+		info.texture_compatibility = static_cast<Prospero::TextureCompatiblePlaneCompression>(
+		    value & static_cast<uint32_t>(Prospero::TextureCompatiblePlaneCompression::kBitMask));
+		info.partially_resident = (value & 0x00001000u) != 0;
+		info.max_mip_level      = static_cast<uint8_t>((value >> 16u) & 0x0fu);
+		info.expclear_enabled   = (value & 0x08000000u) != 0;
+		info.htile_acceleration = (value & 0x20000000u) != 0;
+		info.z_compare_base     = static_cast<Prospero::ZCompareBase>(
+		    value & static_cast<uint32_t>(Prospero::ZCompareBase::kBitMask));
+		return info;
+	}
+
+	[[nodiscard]] bool HasValidTextureCompatibility() const {
+		switch (texture_compatibility) {
+			case Prospero::TextureCompatiblePlaneCompression::kDisable:
+			case Prospero::TextureCompatiblePlaneCompression::kEnable: return true;
+			default: return false;
+		}
+	}
 };
 
 struct DepthStencilInfo {
-	uint32_t format                     = 0;
-	uint32_t tile_mode_index            = 0;
-	uint32_t tile_split                 = 0;
-	bool     expclear_enabled           = false;
-	bool     tile_stencil_disable       = false;
-	bool     texture_compatible_stencil = false;
-	bool     partially_resident         = false;
-};
+	Prospero::StencilFormat            format = Prospero::StencilFormat::kInvalid;
+	Prospero::TextureCompatibleStencil texture_compatibility =
+	    Prospero::TextureCompatibleStencil::kDisable;
+	bool expclear_enabled       = false;
+	bool htile_stencil_disabled = true;
+	bool partially_resident     = false;
 
-struct DepthRenderTargetDepthInfo {
-	uint32_t addr5_swizzle_mask = 0;
-	uint32_t array_mode         = 0;
-	uint32_t pipe_config        = 0;
-	uint32_t bank_width         = 0;
-	uint32_t bank_height        = 0;
-	uint32_t macro_tile_aspect  = 0;
-	uint32_t num_banks          = 0;
+	[[nodiscard]] static DepthStencilInfo Decode(uint32_t value) {
+		DepthStencilInfo info;
+		info.format                = static_cast<Prospero::StencilFormat>(value & 0x1u);
+		info.texture_compatibility = static_cast<Prospero::TextureCompatibleStencil>(
+		    value & static_cast<uint32_t>(Prospero::TextureCompatibleStencil::kBitMask));
+		info.partially_resident     = (value & 0x00001000u) != 0;
+		info.expclear_enabled       = (value & 0x08000000u) != 0;
+		info.htile_stencil_disabled = (value & 0x20000000u) != 0;
+		return info;
+	}
+
+	[[nodiscard]] bool HasValidTextureCompatibility() const {
+		switch (texture_compatibility) {
+			case Prospero::TextureCompatibleStencil::kDisable:
+			case Prospero::TextureCompatibleStencil::kEnable: return true;
+			default: return false;
+		}
+	}
 };
 
 struct DepthDepthView {
@@ -177,36 +176,18 @@ struct DepthDepthSizeXY {
 	bool     valid = false;
 };
 
-struct DepthRenderTargetHTileSurface {
-	uint32_t linear                  = 0;
-	uint32_t full_cache              = 0;
-	uint32_t htile_uses_preload_win  = 0;
-	uint32_t preload                 = 0;
-	uint32_t prefetch_width          = 0;
-	uint32_t prefetch_height         = 0;
-	uint32_t dst_outside_zero_to_one = 0;
-};
-
 struct DepthRenderTarget {
-	DepthZInfo                    z_info;
-	DepthStencilInfo              stencil_info;
-	DepthDepthView                depth_view;
-	DepthDepthSizeXY              size;
-	DepthRenderTargetDepthInfo    depth_info;
-	DepthRenderTargetHTileSurface htile_surface;
+	DepthZInfo       z_info;
+	DepthStencilInfo stencil_info;
+	DepthDepthView   depth_view;
+	DepthDepthSizeXY size;
 
 	uint64_t z_read_base_addr        = 0;
 	uint64_t stencil_read_base_addr  = 0;
 	uint64_t z_write_base_addr       = 0;
 	uint64_t stencil_write_base_addr = 0;
-	uint32_t pitch_div8_minus1       = 0;
-	uint32_t height_div8_minus1      = 0;
-	bool     pitch_height_valid      = false;
-	uint32_t slice_div64_minus1      = 0;
 	uint64_t htile_data_base_addr    = 0;
-	uint32_t width                   = 0;
-	uint32_t height                  = 0;
-	bool     width_height_valid      = false;
+	uint8_t  shading_rate_encoding   = 0;
 };
 
 struct RenderControl {
@@ -215,10 +196,19 @@ struct RenderControl {
 	bool    resummarize_enable       = false;
 	bool    stencil_compress_disable = false;
 	bool    depth_compress_disable   = false;
+	bool    copy_depth_to_color      = false;
+	bool    copy_stencil_to_color    = false;
 	bool    copy_centroid            = false;
 	uint8_t copy_sample              = 0;
 };
 
+struct DepthRenderOverride {
+	bool force_z_valid       = false;
+	bool force_z_dirty       = false;
+	bool force_stencil_valid = false;
+	bool force_stencil_dirty = false;
+};
+
 struct GdsOaCounter {
 	uint32_t counter = 0;
 	uint32_t address = 0;
@@ -254,23 +244,18 @@ struct ClipControl {
 	bool    linear_attribute_clip_enable        = false;
 	bool    force_viewport_index_from_vs_enable = false;
 
-	[[nodiscard]] bool IsZClipModeRepresentable() const {
-		return min_z_clip_disable == max_z_clip_disable;
-	}
-	[[nodiscard]] bool IsZClipEnabled() const { return !min_z_clip_disable; }
+	[[nodiscard]] bool IsZClipEnabled() const { return !min_z_clip_disable && !max_z_clip_disable; }
 };
 
 struct DepthControl {
-	bool    stencil_enable                     = false;
-	bool    z_enable                           = false;
-	bool    z_write_enable                     = false;
-	bool    depth_bounds_enable                = false;
-	uint8_t zfunc                              = 0;
-	bool    backface_enable                    = false;
-	uint8_t stencilfunc                        = 0;
-	uint8_t stencilfunc_bf                     = 0;
-	bool    color_writes_on_depth_fail_enable  = false;
-	bool    color_writes_on_depth_pass_disable = false;
+	bool    stencil_enable      = false;
+	bool    z_enable            = false;
+	bool    z_write_enable      = false;
+	bool    depth_bounds_enable = false;
+	uint8_t zfunc               = 0;
+	bool    backface_enable     = false;
+	uint8_t stencilfunc         = 0;
+	uint8_t stencilfunc_bf      = 0;
 };
 
 struct StencilControl {
@@ -307,6 +292,16 @@ struct ModeControl {
 	bool    persp_corr_dis           = false;
 };
 
+struct PolyOffset {
+	int8_t neg_num_db_bits = -23;
+	bool   db_is_float_fmt = true;
+	float  clamp           = 0.0f;
+	float  front_scale     = 0.0f;
+	float  front_offset    = 0.0f;
+	float  back_scale      = 0.0f;
+	float  back_offset     = 0.0f;
+};
+
 struct BlendControl {
 	uint8_t color_srcblend       = 1;
 	uint8_t color_comb_fcn       = 0;
@@ -374,16 +369,16 @@ struct AaConfig {
 struct Viewport {
 	float zmin                                  = 0.0f;
 	float zmax                                  = 0.0f;
-	float xscale                                = 0.0f;
+	float xscale                                = 1.0f;
 	float xoffset                               = 0.0f;
-	float yscale                                = 0.0f;
+	float yscale                                = 1.0f;
 	float yoffset                               = 0.0f;
-	float zscale                                = 0.0f;
+	float zscale                                = 1.0f;
 	float zoffset                               = 0.0f;
 	int   viewport_scissor_left                 = 0;
 	int   viewport_scissor_top                  = 0;
-	int   viewport_scissor_right                = 0;
-	int   viewport_scissor_bottom               = 0;
+	int   viewport_scissor_right                = 16384;
+	int   viewport_scissor_bottom               = 16384;
 	bool  viewport_scissor_window_offset_enable = false;
 };
 
@@ -392,26 +387,26 @@ struct ScreenViewport {
 	uint32_t transform_control                    = 1087;
 	int      screen_scissor_left                  = 0;
 	int      screen_scissor_top                   = 0;
-	int      screen_scissor_right                 = 0;
-	int      screen_scissor_bottom                = 0;
+	int      screen_scissor_right                 = 16384;
+	int      screen_scissor_bottom                = 16384;
 	int      window_scissor_left                  = 0;
 	int      window_scissor_top                   = 0;
-	int      window_scissor_right                 = 0;
-	int      window_scissor_bottom                = 0;
+	int      window_scissor_right                 = 16384;
+	int      window_scissor_bottom                = 16384;
 	bool     window_scissor_window_offset_enable  = false;
 	int      generic_scissor_left                 = 0;
 	int      generic_scissor_top                  = 0;
-	int      generic_scissor_right                = 0;
-	int      generic_scissor_bottom               = 0;
+	int      generic_scissor_right                = 16384;
+	int      generic_scissor_bottom               = 16384;
 	bool     generic_scissor_window_offset_enable = false;
 	int      window_offset_x                      = 0;
 	int      window_offset_y                      = 0;
 	uint32_t hw_offset_x                          = 0;
 	uint32_t hw_offset_y                          = 0;
-	float    guard_band_horz_clip                 = 0.0f;
-	float    guard_band_vert_clip                 = 0.0f;
-	float    guard_band_horz_discard              = 0.0f;
-	float    guard_band_vert_discard              = 0.0f;
+	float    guard_band_horz_clip                 = 1.0f;
+	float    guard_band_vert_clip                 = 1.0f;
+	float    guard_band_horz_discard              = 1.0f;
+	float    guard_band_vert_discard              = 1.0f;
 	uint16_t clip_rect_rule                       = 0xffffu;
 	int      clip_rect_left[4]                    = {};
 	int      clip_rect_top[4]                     = {};
@@ -420,30 +415,28 @@ struct ScreenViewport {
 	bool     clip_rect_window_offset_enable[4]    = {};
 };
 
-struct VsShaderResource1 {
-	uint8_t vgprs                    = 0;
-	uint8_t sgprs                    = 0;
-	uint8_t priority                 = 0;
-	uint8_t float_mode               = 0;
-	bool    dx10_clamp               = false;
-	bool    ieee_mode                = false;
-	uint8_t vgpr_component_count     = 0;
-	bool    cu_group_enable          = false;
-	bool    require_forward_progress = false;
-	bool    fp16_overflow            = false;
+struct HsShaderResource1 {
+	uint8_t vgprs                     = 0;
+	uint8_t priority                  = 0;
+	uint8_t float_mode                = 0;
+	bool    dx10_clamp                = false;
+	bool    debug_mode                = false;
+	bool    ieee_mode                 = false;
+	bool    require_forward_progress  = false;
+	bool    threadgroup_configuration = false;
+	uint8_t ls_vgpr_component_count   = 0;
+	bool    fp16_overflow             = false;
 };
 
-struct VsShaderResource2 {
-	bool    scratch_en        = false;
-	uint8_t user_sgpr         = 0;
-	bool    offchip_lds       = false;
-	bool    streamout_enabled = false;
-	uint8_t shared_vgprs      = 0;
+struct HsShaderResource2 {
+	bool     scratch_en   = false;
+	uint8_t  user_sgpr    = 0;
+	uint16_t lds_size     = 0;
+	uint8_t  shared_vgprs = 0;
 };
 
 struct PsShaderResource1 {
 	uint8_t vgprs                    = 0;
-	uint8_t sgprs                    = 0;
 	uint8_t priority                 = 0;
 	uint8_t float_mode               = 0;
 	bool    dx10_clamp               = false;
@@ -459,7 +452,7 @@ struct PsShaderResource2 {
 	uint8_t user_sgpr              = 0;
 	bool    wave_cnt_en            = false;
 	uint8_t extra_lds_size         = 0;
-	bool    raster_ordered_shading = false;
+	uint8_t raster_ordered_shading = 0;
 	uint8_t shared_vgprs           = 0;
 };
 
@@ -467,27 +460,33 @@ struct PsStageRegisters {
 	uint64_t          data_addr = 0;
 	PsShaderResource1 rsrc1;
 	PsShaderResource2 rsrc2;
-	uint64_t          chksum = 0;
 };
 
 struct CsStageRegisters {
 
-	uint64_t data_addr      = 0;
-	uint32_t num_thread_x   = 0;
-	uint32_t num_thread_y   = 0;
-	uint32_t num_thread_z   = 0;
-	uint8_t  vgprs          = 0;
-	uint8_t  sgprs          = 0;
-	uint8_t  bulky          = 0;
-	uint8_t  wave_size      = 64;
-	uint8_t  scratch_en     = 0;
-	uint8_t  user_sgpr      = 0;
-	uint8_t  tgid_x_en      = 0;
-	uint8_t  tgid_y_en      = 0;
-	uint8_t  tgid_z_en      = 0;
-	uint8_t  tg_size_en     = 0;
-	uint8_t  tidig_comp_cnt = 0;
-	uint8_t  lds_size       = 0;
+	uint64_t data_addr                 = 0;
+	uint32_t num_thread_x              = 0;
+	uint32_t num_thread_y              = 0;
+	uint32_t num_thread_z              = 0;
+	uint8_t  vgprs                     = 0;
+	uint8_t  priority                  = 0;
+	uint8_t  float_mode                = 0;
+	bool     dx10_clamp                = false;
+	bool     debug_mode                = false;
+	bool     ieee_mode                 = false;
+	bool     require_forward_progress  = false;
+	bool     fp16_overflow             = false;
+	bool     threadgroup_configuration = false;
+	uint8_t  wave_size                 = 64;
+	bool     scratch_en                = false;
+	uint8_t  user_sgpr                 = 0;
+	bool     tgid_x_en                 = false;
+	bool     tgid_y_en                 = false;
+	bool     tgid_z_en                 = false;
+	bool     tg_size_en                = false;
+	uint8_t  tidig_comp_cnt            = 0;
+	uint16_t lds_size                  = 0;
+	uint8_t  shared_vgprs              = 0;
 };
 
 struct EsStageRegisters {
@@ -495,31 +494,28 @@ struct EsStageRegisters {
 };
 
 struct LsStageRegisters {
-	uint64_t          data_addr = 0;
-	VsShaderResource1 rsrc1;
-	VsShaderResource2 rsrc2;
+	uint64_t data_addr = 0;
 };
 
 struct HsStageRegisters {
-	uint64_t          data_addr = 0;
-	VsShaderResource1 rsrc1;
-	VsShaderResource2 rsrc2;
-	uint64_t          chksum = 0;
+	uint64_t          data_addr      = 0;
+	uint64_t          user_data_addr = 0;
+	HsShaderResource1 rsrc1;
+	HsShaderResource2 rsrc2;
 };
 
 struct GsShaderResource1 {
-	uint8_t vgprs                    = 0;
-	uint8_t sgprs                    = 0;
-	uint8_t priority                 = 0;
-	uint8_t float_mode               = 0;
-	bool    dx10_clamp               = false;
-	bool    debug_mode               = false;
-	bool    ieee_mode                = false;
-	bool    cu_group_enable          = false;
-	bool    require_forward_progress = false;
-	bool    lds_configuration        = false;
-	uint8_t gs_vgpr_component_count  = 0;
-	bool    fp16_overflow            = false;
+	uint8_t vgprs                     = 0;
+	uint8_t priority                  = 0;
+	uint8_t float_mode                = 0;
+	bool    dx10_clamp                = false;
+	bool    debug_mode                = false;
+	bool    ieee_mode                 = false;
+	bool    cu_group_enable           = false;
+	bool    require_forward_progress  = false;
+	bool    threadgroup_configuration = false;
+	uint8_t gs_vgpr_component_count   = 0;
+	bool    fp16_overflow             = false;
 };
 
 struct GsShaderResource2 {
@@ -532,10 +528,10 @@ struct GsShaderResource2 {
 };
 
 struct GsStageRegisters {
-	uint64_t          data_addr = 0;
+	uint64_t          data_addr      = 0;
+	uint64_t          user_data_addr = 0;
 	GsShaderResource1 rsrc1;
 	GsShaderResource2 rsrc2;
-	uint64_t          chksum = 0;
 };
 
 struct ShaderRegisters {
@@ -591,8 +587,7 @@ struct ShaderRegisters {
 enum class UserSgprType { Unknown, Region, Vsharp };
 
 struct UserSgprInfo {
-	// Changed from 16 to 64
-	static constexpr int SGPRS_MAX = 64;
+	static constexpr int SGPRS_MAX = 32;
 
 	uint32_t     value[SGPRS_MAX] = {0};
 	UserSgprType type[SGPRS_MAX]  = {};
@@ -639,12 +634,6 @@ public:
 	void Reset() { *this = Context(); }
 
 	void SetColorBase(uint32_t slot, const ColorBase& base) { m_render_targets[slot].base = base; }
-	void SetColorPitch(uint32_t slot, const ColorPitch& pitch) {
-		m_render_targets[slot].pitch = pitch;
-	}
-	void SetColorSlice(uint32_t slot, const ColorSlice& slice) {
-		m_render_targets[slot].slice = slice;
-	}
 	void SetColorView(uint32_t slot, const ColorView& view) { m_render_targets[slot].view = view; }
 	void SetColorInfo(uint32_t slot, const ColorInfo& info) { m_render_targets[slot].info = info; }
 	void SetColorAttrib(uint32_t slot, const ColorAttrib& attrib) {
@@ -662,15 +651,9 @@ public:
 	void SetColorCmask(uint32_t slot, const ColorCmask& cmask) {
 		m_render_targets[slot].cmask = cmask;
 	}
-	void SetColorCmaskSlice(uint32_t slot, const ColorCmaskSlice& cmask_slice) {
-		m_render_targets[slot].cmask_slice = cmask_slice;
-	}
 	void SetColorFmask(uint32_t slot, const ColorFmask& fmask) {
 		m_render_targets[slot].fmask = fmask;
 	}
-	void SetColorFmaskSlice(uint32_t slot, const ColorFmaskSlice& fmask_slice) {
-		m_render_targets[slot].fmask_slice = fmask_slice;
-	}
 	void SetColorClearWord0(uint32_t slot, const ColorClearWord0& clear_word0) {
 		m_render_targets[slot].clear_word0 = clear_word0;
 	}
@@ -680,7 +663,6 @@ public:
 	void SetColorDccAddr(uint32_t slot, const ColorDccAddr& dcc_addr) {
 		m_render_targets[slot].dcc_addr = dcc_addr;
 	}
-	void SetColorSize(uint32_t slot, const ColorSize& size) { m_render_targets[slot].size = size; }
 	[[nodiscard]] const RenderTarget& GetRenderTarget(uint32_t slot) const {
 		return m_render_targets[slot];
 	}
@@ -835,10 +817,18 @@ public:
 	void SetClipControl(const ClipControl& control) { m_clip_control = control; }
 	[[nodiscard]] const RenderControl& GetRenderControl() const { return m_render_control; }
 	void SetRenderControl(const RenderControl& control) { m_render_control = control; }
+	[[nodiscard]] const DepthRenderOverride& GetDepthRenderOverride() const {
+		return m_depth_render_override;
+	}
+	void SetDepthRenderOverride(const DepthRenderOverride& control) {
+		m_depth_render_override = control;
+	}
 	[[nodiscard]] const DepthControl& GetDepthControl() const { return m_depth_control; }
 	void SetDepthControl(const DepthControl& control) { m_depth_control = control; }
 	[[nodiscard]] const ModeControl& GetModeControl() const { return m_mode_control; }
 	void SetModeControl(const ModeControl& control) { m_mode_control = control; }
+	[[nodiscard]] const PolyOffset& GetPolyOffset() const { return m_poly_offset; }
+	void SetPolyOffset(const PolyOffset& offset) { m_poly_offset = offset; }
 	[[nodiscard]] const EqaaControl& GetEqaaControl() const { return m_eqaa_control; }
 	void SetEqaaControl(const EqaaControl& control) { m_eqaa_control = control; }
 	[[nodiscard]] const StencilControl& GetStencilControl() const { return m_stencil_control; }
@@ -863,8 +853,10 @@ public:
 	[[nodiscard]] uint8_t GetStencilClearValue() const { return m_stencil_clear_value; }
 	void SetStencilClearValue(uint8_t clear_value) { m_stencil_clear_value = clear_value; }
 
-	[[nodiscard]] float GetLineWidth() const { return m_line_width; }
-	void                SetLineWidth(float width) { m_line_width = width; }
+	[[nodiscard]] float    GetLineWidth() const { return m_line_width; }
+	void                   SetLineWidth(float width) { m_line_width = width; }
+	[[nodiscard]] uint32_t GetPrimitiveResetIndex() const { return m_primitive_reset_index; }
+	void SetPrimitiveResetIndex(uint32_t index) { m_primitive_reset_index = index; }
 
 	[[nodiscard]] const ShaderRegisters& GetShaderRegisters() const { return m_sh_regs; }
 
@@ -909,7 +901,8 @@ public:
 	void SetScShaderControl(uint32_t value) { m_sh_regs.m_paScShaderControl = value; }
 
 private:
-	float m_line_width = 1.0f;
+	float    m_line_width            = 1.0f;
+	uint32_t m_primitive_reset_index = 0xffffffffu;
 
 	BlendControl    m_blend_control[8];
 	BlendColor      m_blend_color;
@@ -925,22 +918,30 @@ private:
 
 	uint32_t m_shader_stages = 0;
 
-	DepthRenderTarget m_depth_render_target;
-	RenderControl     m_render_control;
-	DepthControl      m_depth_control;
-	StencilControl    m_stencil_control;
-	StencilMask       m_stencil_mask;
-	float             m_depth_clear_value   = 0.0f;
-	float             m_depth_bounds_min    = 0.0f;
-	float             m_depth_bounds_max    = 1.0f;
-	uint8_t           m_stencil_clear_value = 0;
+	DepthRenderTarget   m_depth_render_target;
+	RenderControl       m_render_control;
+	DepthRenderOverride m_depth_render_override;
+	DepthControl        m_depth_control;
+	StencilControl      m_stencil_control;
+	StencilMask         m_stencil_mask;
+	float               m_depth_clear_value   = 0.0f;
+	float               m_depth_bounds_min    = 0.0f;
+	float               m_depth_bounds_max    = 1.0f;
+	uint8_t             m_stencil_clear_value = 0;
 
 	ModeControl m_mode_control;
+	PolyOffset  m_poly_offset;
 	EqaaControl m_eqaa_control;
 
 	ShaderRegisters m_sh_regs;
 };
 
+struct FsrView {
+	uint32_t control_points[2][4] {};
+	uint32_t alphas[2][2] {};
+	uint32_t window[2] {};
+};
+
 class UserConfig {
 public:
 	UserConfig()  = default;
@@ -950,12 +951,14 @@ public:
 
 	void Reset() { *this = UserConfig(); }
 
-	void                   SetPrimitiveType(uint32_t prim_type) { m_prim_type = prim_type; }
-	[[nodiscard]] uint32_t GetPrimType() const { return m_prim_type; }
+	void SetPrimitiveType(Prospero::PrimitiveType prim_type) { m_prim_type = prim_type; }
+	[[nodiscard]] Prospero::PrimitiveType GetPrimType() const { return m_prim_type; }
 	void                   SetIndexOffset(uint32_t index_offset) { m_index_offset = index_offset; }
 	[[nodiscard]] uint32_t GetIndexOffset() const { return m_index_offset; }
 	void                   SetObjectId(uint32_t object_id) { m_object_id = object_id; }
 	[[nodiscard]] uint32_t GetObjectId() const { return m_object_id; }
+	void SetPrimitiveResetControl(uint32_t control) { m_primitive_reset_control = control; }
+	[[nodiscard]] uint32_t GetPrimitiveResetControl() const { return m_primitive_reset_control; }
 
 	[[nodiscard]] const GeControl& GetGeControl() const { return m_ge_cntl; }
 	void                           SetGeControl(const GeControl& control) { m_ge_cntl = control; }
@@ -968,11 +971,21 @@ public:
 	void SetGdsOaCntl(uint32_t value) { m_gds_oa.cntl = value; }
 	void SetGdsOaCounter(uint32_t value) { m_gds_oa.counters[m_gds_oa.GetIndex()].counter = value; }
 	void SetGdsOaAddress(uint32_t value) { m_gds_oa.counters[m_gds_oa.GetIndex()].address = value; }
+	void SetFsrControlPoint(uint32_t axis, uint32_t index, uint32_t value) {
+		m_fsr_view.control_points[axis][index] = value;
+	}
+	void SetFsrAlpha(uint32_t axis, uint32_t index, uint32_t value) {
+		m_fsr_view.alphas[axis][index] = value;
+	}
+	void SetFsrWindow(uint32_t index, uint32_t value) { m_fsr_view.window[index] = value; }
+	[[nodiscard]] const FsrView& GetFsrView() const { return m_fsr_view; }
 
 private:
-	uint32_t m_prim_type    = 0;
-	uint32_t m_index_offset = 0;
-	uint32_t m_object_id    = 0;
+	FsrView m_fsr_view;
+	Prospero::PrimitiveType m_prim_type               = Prospero::PrimitiveType::kNone;
+	uint32_t                m_index_offset            = 0;
+	uint32_t                m_object_id               = 0;
+	uint32_t                m_primitive_reset_control = 0;
 
 	GeControl    m_ge_cntl;
 	GeUserVgprEn m_ge_user_vgpr_en;
@@ -990,23 +1003,25 @@ public:
 
 	void SetEsShaderBase(uint64_t addr) { m_vs.es_regs.data_addr = addr; }
 	void SetLsShaderBase(uint64_t addr) { m_vs.ls_regs.data_addr = addr; }
-	void SetLsShaderResource1(const VsShaderResource1& rsrc1) { m_vs.ls_regs.rsrc1 = rsrc1; }
-	void SetLsShaderResource2(const VsShaderResource2& rsrc2) { m_vs.ls_regs.rsrc2 = rsrc2; }
 	void SetHsShaderBase(uint64_t addr) { m_vs.hs_regs.data_addr = addr; }
-	void SetHsShaderResource1(const VsShaderResource1& rsrc1) { m_vs.hs_regs.rsrc1 = rsrc1; }
-	void SetHsShaderResource2(const VsShaderResource2& rsrc2) { m_vs.hs_regs.rsrc2 = rsrc2; }
-	void SetHsShaderChksum(uint32_t value) { m_vs.hs_regs.chksum = value; }
+	void SetHsUserDataAddress(uint32_t word, uint32_t value) {
+		SetUserDataAddressWord(m_vs.hs_regs.user_data_addr, word, value);
+	}
+	void SetHsShaderResource1(const HsShaderResource1& rsrc1) { m_vs.hs_regs.rsrc1 = rsrc1; }
+	void SetHsShaderResource2(const HsShaderResource2& rsrc2) { m_vs.hs_regs.rsrc2 = rsrc2; }
 	void SetGsShaderBase(uint64_t addr) { m_vs.gs_regs.data_addr = addr; }
+	void SetGsUserDataAddress(uint32_t word, uint32_t value) {
+		SetUserDataAddressWord(m_vs.gs_regs.user_data_addr, word, value);
+	}
 	void SetGsShaderResource1(const GsShaderResource1& rsrc1) { m_vs.gs_regs.rsrc1 = rsrc1; }
 	void SetGsShaderResource2(const GsShaderResource2& rsrc2) { m_vs.gs_regs.rsrc2 = rsrc2; }
-	void SetGsShaderChksum(uint32_t value) { m_vs.gs_regs.chksum = value; }
 
 	void SetPsShaderBase(uint64_t addr) { m_ps.ps_regs.data_addr = addr; }
 	void SetPsShaderResource1(const PsShaderResource1& rsrc1) { m_ps.ps_regs.rsrc1 = rsrc1; }
 	void SetPsShaderResource2(const PsShaderResource2& rsrc2) { m_ps.ps_regs.rsrc2 = rsrc2; }
-	void SetPsShaderChksum(uint32_t value) { m_ps.ps_regs.chksum = value; }
 
 	void SetCsShader(const CsStageRegisters& cs_regs) { m_cs.cs_regs = cs_regs; }
+	void SetCsWaveSize(uint8_t wave_size) { m_cs.cs_regs.wave_size = wave_size; }
 
 	void SetPsUserSgpr(uint32_t id, uint32_t value, UserSgprType type) {
 		m_ps.ps_user_sgpr.value[id] = value;
@@ -1038,6 +1053,12 @@ public:
 	[[nodiscard]] const ComputeShaderInfo& GetCs() const { return m_cs; }
 
 private:
+	static void SetUserDataAddressWord(uint64_t& address, uint32_t word, uint32_t value) {
+		const auto shift = word * 32u;
+		address = (address & ~(uint64_t {0xffffffffu} << shift)) |
+		          (static_cast<uint64_t>(value) << shift);
+	}
+
 	VertexShaderInfo  m_vs;
 	PixelShaderInfo   m_ps;
 	ComputeShaderInfo m_cs;

src/graphics/guest_gpu/pm4.cpp

@@ -21,15 +21,14 @@ constexpr auto MakeRegisterNames() {
 	names[R_DRAW_RESET]     = "R_DRAW_RESET";
 	names[R_WAIT_FLIP_DONE] = "R_WAIT_FLIP_DONE";
 	names[R_DISPATCH_RESET] = "R_DISPATCH_RESET";
-	names[R_WAIT_MEM_32]    = "R_WAIT_MEM_32";
 	names[R_PUSH_MARKER]    = "R_PUSH_MARKER";
 	names[R_POP_MARKER]     = "R_POP_MARKER";
 	names[R_ACQUIRE_MEM]    = "R_ACQUIRE_MEM";
 	names[R_WRITE_DATA]     = "R_WRITE_DATA";
-	names[R_WAIT_MEM_64]    = "R_WAIT_MEM_64";
 	names[R_FLIP]           = "R_FLIP";
 	names[R_RELEASE_MEM]    = "R_RELEASE_MEM";
 	names[R_DMA_DATA]       = "R_DMA_DATA";
+	names[R_CONTEXT_STATE]  = "R_CONTEXT_STATE";
 	return names;
 }
 
@@ -61,6 +60,7 @@ constexpr auto MakeOpcodeNames() {
 	names[IT_WRITE_DATA]                = "IT_WRITE_DATA";
 	names[IT_MEM_SEMAPHORE]             = "IT_MEM_SEMAPHORE";
 	names[IT_DRAW_INDEX_INDIRECT_MULTI] = "IT_DRAW_INDEX_INDIRECT_MULTI";
+	names[IT_WAIT_REG_MEM]               = "IT_WAIT_REG_MEM";
 	names[IT_INDIRECT_BUFFER]           = "IT_INDIRECT_BUFFER";
 	names[IT_COPY_DATA]                 = "IT_COPY_DATA";
 	names[IT_CP_DMA]                    = "IT_CP_DMA";
@@ -90,6 +90,7 @@ constexpr auto MakeOpcodeNames() {
 	names[IT_DISPATCH_DRAW_PREAMBLE]    = "IT_DISPATCH_DRAW_PREAMBLE";
 	names[IT_DISPATCH_DRAW]             = "IT_DISPATCH_DRAW";
 	names[IT_GET_LOD_STATS]             = "IT_GET_LOD_STATS";
+	names[IT_WAIT_REG_MEM_64]           = "IT_WAIT_REG_MEM_64";
 	names[IT_SET_CONTEXT_REG_INDIRECT]  = "IT_SET_CONTEXT_REG_INDIRECT";
 	return names;
 }
@@ -99,7 +100,7 @@ constexpr auto g_opcode_names   = MakeOpcodeNames();
 
 } // namespace
 
-void DumpPm4PacketStream(Common::File* file, uint32_t* cmd_buffer, uint32_t start_dw,
+void DumpPm4PacketStream(Common::File* file, const uint32_t* cmd_buffer, uint32_t start_dw,
                          uint32_t num_dw) {
 	// db_dump();
 
@@ -110,7 +111,6 @@ void DumpPm4PacketStream(Common::File* file, uint32_t* cmd_buffer, uint32_t star
 	auto* cmd = cmd_buffer + start_dw;
 	auto  dw  = num_dw;
 	while (dw != 0) {
-		EXIT_NOT_IMPLEMENTED(dw < 2);
 		EXIT_NOT_IMPLEMENTED(dw > num_dw);
 
 		auto cmd_id = *cmd++;
@@ -120,6 +120,9 @@ void DumpPm4PacketStream(Common::File* file, uint32_t* cmd_buffer, uint32_t star
 		uint32_t len = 0;
 
 		const auto packet_type = static_cast<PacketType>(cmd_id >> 30u);
+		// Type-2 packets are header-only padding; every other packet type requires a body.
+		EXIT_NOT_IMPLEMENTED(dw < 2 && packet_type != PacketType::Type2);
+
 		switch (packet_type) {
 			case PacketType::Type3: {
 				const bool    sh_gx = (cmd_id & 0x2u) == 0;
@@ -140,9 +143,9 @@ void DumpPm4PacketStream(Common::File* file, uint32_t* cmd_buffer, uint32_t star
 				if ((op == IT_SET_CONTEXT_REG_INDIRECT || op == IT_SET_SH_REG_INDIRECT ||
 				     op == IT_SET_UCONFIG_REG_INDIRECT) &&
 				    len == 4) {
-					auto* indirect_buffer =
-					    reinterpret_cast<uint32_t*>((static_cast<uint64_t>(cmd[0]) & 0xfffffffcu) |
-					                                (static_cast<uint64_t>(cmd[1]) << 32u));
+					auto* indirect_buffer = reinterpret_cast<const uint32_t*>(
+					    (static_cast<uint64_t>(cmd[0]) & 0xfffffffcu) |
+					    (static_cast<uint64_t>(cmd[1]) << 32u));
 					const uint32_t indirect_num_regs = cmd[3] & 0x3fffu;
 
 					for (uint32_t i = 0; indirect_buffer != nullptr && i < indirect_num_regs;

src/graphics/guest_gpu/pm4.h

@@ -42,6 +42,7 @@ constexpr uint32_t IT_WRITE_DATA                = 0x37;
 constexpr uint32_t IT_MEM_SEMAPHORE             = 0x39;
 constexpr uint32_t IT_DRAW_INDEX_INDIRECT_MULTI = 0x38;
 constexpr uint32_t IT_DISPATCH_DRAW_PREAMBLE    = 0x3A;
+constexpr uint32_t IT_WAIT_REG_MEM              = 0x3C;
 constexpr uint32_t IT_INDIRECT_BUFFER           = 0x3F;
 constexpr uint32_t IT_COPY_DATA                 = 0x40;
 constexpr uint32_t IT_CP_DMA                    = 0x41;
@@ -70,6 +71,7 @@ constexpr uint32_t IT_WAIT_ON_CE_COUNTER        = 0x86;
 constexpr uint32_t IT_WAIT_ON_DE_COUNTER_DIFF   = 0x88;
 constexpr uint32_t IT_DISPATCH_DRAW             = 0x8D;
 constexpr uint32_t IT_GET_LOD_STATS             = 0x8E;
+constexpr uint32_t IT_WAIT_REG_MEM_64           = 0x93;
 constexpr uint32_t IT_SET_CONTEXT_REG_INDIRECT  = 0x9F;
 
 /* Custom codes. Implemented via IT_NOP */
@@ -78,15 +80,14 @@ constexpr uint32_t R_ZERO           = 0x00;
 constexpr uint32_t R_DRAW_RESET     = 0x05;
 constexpr uint32_t R_WAIT_FLIP_DONE = 0x06;
 constexpr uint32_t R_DISPATCH_RESET = 0x09;
-constexpr uint32_t R_WAIT_MEM_32    = 0x0A;
 constexpr uint32_t R_PUSH_MARKER    = 0x0B;
 constexpr uint32_t R_POP_MARKER     = 0x0C;
 constexpr uint32_t R_ACQUIRE_MEM    = 0x14;
 constexpr uint32_t R_WRITE_DATA     = 0x15;
-constexpr uint32_t R_WAIT_MEM_64    = 0x16;
 constexpr uint32_t R_FLIP           = 0x17;
 constexpr uint32_t R_RELEASE_MEM    = 0x18;
 constexpr uint32_t R_DMA_DATA       = 0x19;
+constexpr uint32_t R_CONTEXT_STATE  = 0x1A;
 
 constexpr uint32_t R_NUM = 0x3F + 1;
 
@@ -97,6 +98,10 @@ constexpr uint32_t DB_RENDER_CONTROL_DEPTH_CLEAR_ENABLE_SHIFT       = 0;
 constexpr uint32_t DB_RENDER_CONTROL_DEPTH_CLEAR_ENABLE_MASK        = 0x1;
 constexpr uint32_t DB_RENDER_CONTROL_STENCIL_CLEAR_ENABLE_SHIFT     = 1;
 constexpr uint32_t DB_RENDER_CONTROL_STENCIL_CLEAR_ENABLE_MASK      = 0x1;
+constexpr uint32_t DB_RENDER_CONTROL_COPY_DEPTH_TO_COLOR_SHIFT      = 2;
+constexpr uint32_t DB_RENDER_CONTROL_COPY_DEPTH_TO_COLOR_MASK       = 0x1;
+constexpr uint32_t DB_RENDER_CONTROL_COPY_STENCIL_TO_COLOR_SHIFT    = 3;
+constexpr uint32_t DB_RENDER_CONTROL_COPY_STENCIL_TO_COLOR_MASK     = 0x1;
 constexpr uint32_t DB_RENDER_CONTROL_RESUMMARIZE_ENABLE_SHIFT       = 4;
 constexpr uint32_t DB_RENDER_CONTROL_RESUMMARIZE_ENABLE_MASK        = 0x1;
 constexpr uint32_t DB_RENDER_CONTROL_STENCIL_COMPRESS_DISABLE_SHIFT = 5;
@@ -162,22 +167,6 @@ constexpr uint32_t PA_SC_SCREEN_SCISSOR_BR_BR_Y_MASK  = 0xFFFF;
 
 constexpr uint32_t DB_DFSM_CONTROL = 0xE;
 
-constexpr uint32_t DB_DEPTH_INFO                          = 0xF;
-constexpr uint32_t DB_DEPTH_INFO_ADDR5_SWIZZLE_MASK_SHIFT = 0;
-constexpr uint32_t DB_DEPTH_INFO_ADDR5_SWIZZLE_MASK_MASK  = 0xF;
-constexpr uint32_t DB_DEPTH_INFO_ARRAY_MODE_SHIFT         = 4;
-constexpr uint32_t DB_DEPTH_INFO_ARRAY_MODE_MASK          = 0xF;
-constexpr uint32_t DB_DEPTH_INFO_PIPE_CONFIG_SHIFT        = 8;
-constexpr uint32_t DB_DEPTH_INFO_PIPE_CONFIG_MASK         = 0x1F;
-constexpr uint32_t DB_DEPTH_INFO_BANK_WIDTH_SHIFT         = 13;
-constexpr uint32_t DB_DEPTH_INFO_BANK_WIDTH_MASK          = 0x3;
-constexpr uint32_t DB_DEPTH_INFO_BANK_HEIGHT_SHIFT        = 15;
-constexpr uint32_t DB_DEPTH_INFO_BANK_HEIGHT_MASK         = 0x3;
-constexpr uint32_t DB_DEPTH_INFO_MACRO_TILE_ASPECT_SHIFT  = 17;
-constexpr uint32_t DB_DEPTH_INFO_MACRO_TILE_ASPECT_MASK   = 0x3;
-constexpr uint32_t DB_DEPTH_INFO_NUM_BANKS_SHIFT          = 19;
-constexpr uint32_t DB_DEPTH_INFO_NUM_BANKS_MASK           = 0x3;
-
 constexpr uint32_t DB_Z_INFO                               = 0x10;
 constexpr uint32_t DB_Z_INFO_FORMAT_SHIFT                  = 0;
 constexpr uint32_t DB_Z_INFO_FORMAT_MASK                   = 0x3;
@@ -221,16 +210,6 @@ constexpr uint32_t DB_STENCIL_READ_BASE  = 0x13;
 constexpr uint32_t DB_Z_WRITE_BASE       = 0x14;
 constexpr uint32_t DB_STENCIL_WRITE_BASE = 0x15;
 
-constexpr uint32_t DB_DEPTH_SIZE                       = 0x16;
-constexpr uint32_t DB_DEPTH_SIZE_PITCH_TILE_MAX_SHIFT  = 0;
-constexpr uint32_t DB_DEPTH_SIZE_PITCH_TILE_MAX_MASK   = 0x7FF;
-constexpr uint32_t DB_DEPTH_SIZE_HEIGHT_TILE_MAX_SHIFT = 11;
-constexpr uint32_t DB_DEPTH_SIZE_HEIGHT_TILE_MAX_MASK  = 0x7FF;
-
-constexpr uint32_t DB_DEPTH_SLICE                      = 0x17;
-constexpr uint32_t DB_DEPTH_SLICE_SLICE_TILE_MAX_SHIFT = 0;
-constexpr uint32_t DB_DEPTH_SLICE_SLICE_TILE_MAX_MASK  = 0x3FFFFF;
-
 constexpr uint32_t DB_Z_READ_BASE_HI                  = 0x1A;
 constexpr uint32_t DB_STENCIL_READ_BASE_HI            = 0x1B;
 constexpr uint32_t DB_Z_WRITE_BASE_HI                 = 0x1C;
@@ -316,8 +295,8 @@ constexpr uint32_t FSR_RECURSIONS1              = 0xF2;
 constexpr uint32_t VGT_MULTI_PRIM_IB_RESET_INDX = 0x103;
 constexpr uint32_t CB_RMI_GL2_CACHE_CONTROL     = 0x104;
 constexpr uint32_t CB_BLEND_RED                 = 0x105;
-constexpr uint32_t CB_BLEND_GREEN               = 0x106;
-constexpr uint32_t CB_BLEND_BLUE                = 0x107;
+constexpr uint32_t CB_BLEND_BLUE                = 0x106;
+constexpr uint32_t CB_BLEND_GREEN               = 0x107;
 constexpr uint32_t CB_BLEND_ALPHA               = 0x108;
 constexpr uint32_t CB_DCC_CONTROL               = 0x109;
 
@@ -371,6 +350,7 @@ constexpr uint32_t PA_CL_UCP_0_X          = 0x16F;
 constexpr uint32_t PA_CL_UCP_0_Y          = 0x170;
 constexpr uint32_t PA_CL_UCP_0_Z          = 0x171;
 constexpr uint32_t PA_CL_UCP_0_W          = 0x172;
+constexpr uint32_t PA_CL_UCP_5_W          = 0x186;
 constexpr uint32_t SPI_PS_INPUT_CNTL_0    = 0x191;
 constexpr uint32_t SPI_PS_INPUT_CNTL_31   = 0x1B0;
 constexpr uint32_t SPI_VS_OUT_CONFIG      = 0x1B1;
@@ -422,11 +402,6 @@ constexpr uint32_t DB_DEPTH_CONTROL_STENCILFUNC_SHIFT                        = 8
 constexpr uint32_t DB_DEPTH_CONTROL_STENCILFUNC_MASK                         = 0x7;
 constexpr uint32_t DB_DEPTH_CONTROL_STENCILFUNC_BF_SHIFT                     = 20;
 constexpr uint32_t DB_DEPTH_CONTROL_STENCILFUNC_BF_MASK                      = 0x7;
-constexpr uint32_t DB_DEPTH_CONTROL_ENABLE_COLOR_WRITES_ON_DEPTH_FAIL_SHIFT  = 30;
-constexpr uint32_t DB_DEPTH_CONTROL_ENABLE_COLOR_WRITES_ON_DEPTH_FAIL_MASK   = 0x1;
-constexpr uint32_t DB_DEPTH_CONTROL_DISABLE_COLOR_WRITES_ON_DEPTH_PASS_SHIFT = 31;
-constexpr uint32_t DB_DEPTH_CONTROL_DISABLE_COLOR_WRITES_ON_DEPTH_PASS_MASK  = 0x1;
-
 constexpr uint32_t DB_EQAA                                  = 0x201;
 constexpr uint32_t DB_EQAA_MAX_ANCHOR_SAMPLES_SHIFT         = 0;
 constexpr uint32_t DB_EQAA_MAX_ANCHOR_SAMPLES_MASK          = 0x7;
@@ -558,40 +533,32 @@ constexpr uint32_t VGT_DRAW_PAYLOAD_CNTL  = 0x2A6;
 constexpr uint32_t VGT_ESGS_RING_ITEMSIZE = 0x2AB;
 constexpr uint32_t VGT_REUSE_OFF          = 0x2AD;
 
-constexpr uint32_t DB_HTILE_SURFACE                               = 0x2AF;
-constexpr uint32_t DB_HTILE_SURFACE_LINEAR_SHIFT                  = 0;
-constexpr uint32_t DB_HTILE_SURFACE_LINEAR_MASK                   = 0x1;
-constexpr uint32_t DB_HTILE_SURFACE_FULL_CACHE_SHIFT              = 1;
-constexpr uint32_t DB_HTILE_SURFACE_FULL_CACHE_MASK               = 0x1;
-constexpr uint32_t DB_HTILE_SURFACE_HTILE_USES_PRELOAD_WIN_SHIFT  = 2;
-constexpr uint32_t DB_HTILE_SURFACE_HTILE_USES_PRELOAD_WIN_MASK   = 0x1;
-constexpr uint32_t DB_HTILE_SURFACE_PRELOAD_SHIFT                 = 3;
-constexpr uint32_t DB_HTILE_SURFACE_PRELOAD_MASK                  = 0x1;
-constexpr uint32_t DB_HTILE_SURFACE_PREFETCH_WIDTH_SHIFT          = 4;
-constexpr uint32_t DB_HTILE_SURFACE_PREFETCH_WIDTH_MASK           = 0x3F;
-constexpr uint32_t DB_HTILE_SURFACE_PREFETCH_HEIGHT_SHIFT         = 10;
-constexpr uint32_t DB_HTILE_SURFACE_PREFETCH_HEIGHT_MASK          = 0x3F;
-constexpr uint32_t DB_HTILE_SURFACE_DST_OUTSIDE_ZERO_TO_ONE_SHIFT = 16;
-constexpr uint32_t DB_HTILE_SURFACE_DST_OUTSIDE_ZERO_TO_ONE_MASK  = 0x1;
+constexpr uint32_t DB_SHADING_RATE_ENCODING                             = 0x2AF;
+constexpr uint32_t DB_SHADING_RATE_ENCODING_SHADING_RATE_ENCODING_SHIFT = 19;
+constexpr uint32_t DB_SHADING_RATE_ENCODING_SHADING_RATE_ENCODING_MASK  = 0x3;
 
-constexpr uint32_t DB_SRESULTS_COMPARE_STATE0     = 0x2B0;
-constexpr uint32_t DB_SRESULTS_COMPARE_STATE1     = 0x2B1;
-constexpr uint32_t VGT_GS_MAX_VERT_OUT            = 0x2CE;
-constexpr uint32_t GE_NGG_SUBGRP_CNTL             = 0x2D3;
-constexpr uint32_t VGT_TESS_DISTRIBUTION          = 0x2D4;
-constexpr uint32_t VGT_SHADER_STAGES_EN           = 0x2D5;
-constexpr uint32_t VGT_LS_HS_CONFIG               = 0x2D6;
-constexpr uint32_t VGT_TF_PARAM                   = 0x2DB;
-constexpr uint32_t DB_ALPHA_TO_MASK               = 0x2DC;
-constexpr uint32_t PA_SU_POLY_OFFSET_DB_FMT_CNTL  = 0x2DE;
-constexpr uint32_t PA_SU_POLY_OFFSET_CLAMP        = 0x2DF;
-constexpr uint32_t PA_SU_POLY_OFFSET_FRONT_SCALE  = 0x2E0;
-constexpr uint32_t PA_SU_POLY_OFFSET_FRONT_OFFSET = 0x2E1;
-constexpr uint32_t PA_SU_POLY_OFFSET_BACK_SCALE   = 0x2E2;
-constexpr uint32_t PA_SU_POLY_OFFSET_BACK_OFFSET  = 0x2E3;
-constexpr uint32_t VGT_GS_INSTANCE_CNT            = 0x2E4;
-constexpr uint32_t PA_SC_CENTROID_PRIORITY_0      = 0x2F5;
-constexpr uint32_t PA_SC_CENTROID_PRIORITY_1      = 0x2F6;
+constexpr uint32_t DB_SRESULTS_COMPARE_STATE0                          = 0x2B0;
+constexpr uint32_t DB_SRESULTS_COMPARE_STATE1                          = 0x2B1;
+constexpr uint32_t VGT_GS_MAX_VERT_OUT                                 = 0x2CE;
+constexpr uint32_t GE_NGG_SUBGRP_CNTL                                  = 0x2D3;
+constexpr uint32_t VGT_TESS_DISTRIBUTION                               = 0x2D4;
+constexpr uint32_t VGT_SHADER_STAGES_EN                                = 0x2D5;
+constexpr uint32_t VGT_LS_HS_CONFIG                                    = 0x2D6;
+constexpr uint32_t VGT_TF_PARAM                                        = 0x2DB;
+constexpr uint32_t DB_ALPHA_TO_MASK                                    = 0x2DC;
+constexpr uint32_t PA_SU_POLY_OFFSET_DB_FMT_CNTL                       = 0x2DE;
+constexpr uint32_t PA_SU_POLY_OFFSET_DB_FMT_CNTL_NEG_NUM_DB_BITS_SHIFT = 0;
+constexpr uint32_t PA_SU_POLY_OFFSET_DB_FMT_CNTL_NEG_NUM_DB_BITS_MASK  = 0xFF;
+constexpr uint32_t PA_SU_POLY_OFFSET_DB_FMT_CNTL_DB_IS_FLOAT_FMT_SHIFT = 8;
+constexpr uint32_t PA_SU_POLY_OFFSET_DB_FMT_CNTL_DB_IS_FLOAT_FMT_MASK  = 0x1;
+constexpr uint32_t PA_SU_POLY_OFFSET_CLAMP                             = 0x2DF;
+constexpr uint32_t PA_SU_POLY_OFFSET_FRONT_SCALE                       = 0x2E0;
+constexpr uint32_t PA_SU_POLY_OFFSET_FRONT_OFFSET                      = 0x2E1;
+constexpr uint32_t PA_SU_POLY_OFFSET_BACK_SCALE                        = 0x2E2;
+constexpr uint32_t PA_SU_POLY_OFFSET_BACK_OFFSET                       = 0x2E3;
+constexpr uint32_t VGT_GS_INSTANCE_CNT                                 = 0x2E4;
+constexpr uint32_t PA_SC_CENTROID_PRIORITY_0                           = 0x2F5;
+constexpr uint32_t PA_SC_CENTROID_PRIORITY_1                           = 0x2F6;
 
 constexpr uint32_t PA_SC_AA_CONFIG                             = 0x2F8;
 constexpr uint32_t PA_SC_AA_CONFIG_MSAA_NUM_SAMPLES_SHIFT      = 0;
@@ -615,7 +582,6 @@ constexpr uint32_t PA_SC_SHADER_CONTROL                  = 0x310;
 constexpr uint32_t PA_SC_BINNER_CNTL_0                   = 0x311;
 constexpr uint32_t PA_SC_BINNER_CNTL_1                   = 0x312;
 constexpr uint32_t PA_SC_CONSERVATIVE_RASTERIZATION_CNTL = 0x313;
-constexpr uint32_t PA_SC_NGG_MODE_CNTL                   = 0x314;
 constexpr uint32_t CB_COLOR0_BASE                        = 0x318;
 
 constexpr uint32_t CB_COLOR0_VIEW                   = 0x31B;
@@ -643,24 +609,13 @@ constexpr uint32_t CB_COLOR0_INFO_BLEND_BYPASS_SHIFT              = 16;
 constexpr uint32_t CB_COLOR0_INFO_BLEND_BYPASS_MASK               = 0x1;
 constexpr uint32_t CB_COLOR0_INFO_ROUND_MODE_SHIFT                = 18;
 constexpr uint32_t CB_COLOR0_INFO_ROUND_MODE_MASK                 = 0x1;
-constexpr uint32_t CB_COLOR0_INFO_CMASK_IS_LINEAR_SHIFT           = 19;
-constexpr uint32_t CB_COLOR0_INFO_CMASK_IS_LINEAR_MASK            = 0x1;
 constexpr uint32_t CB_COLOR0_INFO_FMASK_COMPRESSION_DISABLE_SHIFT = 26;
 constexpr uint32_t CB_COLOR0_INFO_FMASK_COMPRESSION_DISABLE_MASK  = 0x1;
 constexpr uint32_t CB_COLOR0_INFO_FMASK_COMPRESS_1FRAG_ONLY_SHIFT = 27;
 constexpr uint32_t CB_COLOR0_INFO_FMASK_COMPRESS_1FRAG_ONLY_MASK  = 0x1;
 constexpr uint32_t CB_COLOR0_INFO_DCC_ENABLE_SHIFT                = 28;
 constexpr uint32_t CB_COLOR0_INFO_DCC_ENABLE_MASK                 = 0x1;
-constexpr uint32_t CB_COLOR0_INFO_CMASK_ADDR_TYPE_SHIFT           = 29;
-constexpr uint32_t CB_COLOR0_INFO_CMASK_ADDR_TYPE_MASK            = 0x3;
-constexpr uint32_t CB_COLOR0_INFO_ALT_TILE_MODE_SHIFT             = 31;
-constexpr uint32_t CB_COLOR0_INFO_ALT_TILE_MODE_MASK              = 0x1;
-
 constexpr uint32_t CB_COLOR0_ATTRIB                             = 0x31D;
-constexpr uint32_t CB_COLOR0_ATTRIB_TILE_MODE_INDEX_SHIFT       = 0;
-constexpr uint32_t CB_COLOR0_ATTRIB_TILE_MODE_INDEX_MASK        = 0x1F;
-constexpr uint32_t CB_COLOR0_ATTRIB_FMASK_TILE_MODE_INDEX_SHIFT = 5;
-constexpr uint32_t CB_COLOR0_ATTRIB_FMASK_TILE_MODE_INDEX_MASK  = 0x1F;
 constexpr uint32_t CB_COLOR0_ATTRIB_NUM_SAMPLES_SHIFT           = 12;
 constexpr uint32_t CB_COLOR0_ATTRIB_NUM_SAMPLES_MASK            = 0x7;
 constexpr uint32_t CB_COLOR0_ATTRIB_NUM_FRAGMENTS_SHIFT         = 15;
@@ -675,8 +630,6 @@ constexpr uint32_t CB_COLOR0_DCC_CONTROL_KEY_CLEAR_ENABLE_SHIFT
 constexpr uint32_t CB_COLOR0_DCC_CONTROL_KEY_CLEAR_ENABLE_MASK                  = 0x1;
 constexpr uint32_t CB_COLOR0_DCC_CONTROL_MAX_UNCOMPRESSED_BLOCK_SIZE_SHIFT      = 2;
 constexpr uint32_t CB_COLOR0_DCC_CONTROL_MAX_UNCOMPRESSED_BLOCK_SIZE_MASK       = 0x3;
-constexpr uint32_t CB_COLOR0_DCC_CONTROL_MIN_COMPRESSED_BLOCK_SIZE_SHIFT        = 4;
-constexpr uint32_t CB_COLOR0_DCC_CONTROL_MIN_COMPRESSED_BLOCK_SIZE_MASK         = 0x1;
 constexpr uint32_t CB_COLOR0_DCC_CONTROL_MAX_COMPRESSED_BLOCK_SIZE_SHIFT        = 5;
 constexpr uint32_t CB_COLOR0_DCC_CONTROL_MAX_COMPRESSED_BLOCK_SIZE_MASK         = 0x3;
 constexpr uint32_t CB_COLOR0_DCC_CONTROL_COLOR_TRANSFORM_SHIFT                  = 7;
@@ -733,31 +686,25 @@ constexpr uint32_t CB_COLOR0_ATTRIB3_CMASK_PIPE_ALIGNED_SHIFT = 26;
 constexpr uint32_t CB_COLOR0_ATTRIB3_CMASK_PIPE_ALIGNED_MASK  = 0x1;
 constexpr uint32_t CB_COLOR0_ATTRIB3_DCC_PIPE_ALIGNED_SHIFT   = 30;
 constexpr uint32_t CB_COLOR0_ATTRIB3_DCC_PIPE_ALIGNED_MASK    = 0x1;
+constexpr uint32_t CB_COLOR0_ATTRIB3_WRITE_VRS_RATE_HINT_TO_CMASK_SHIFT = 31;
+constexpr uint32_t CB_COLOR0_ATTRIB3_WRITE_VRS_RATE_HINT_TO_CMASK_MASK  = 0x1;
 
 constexpr uint32_t CB_COLOR7_ATTRIB3 = 0x3BF;
 
-/* Fake codes. Don't exist on real HW */
-
-constexpr uint32_t CX_NOP = 0x800003FF;
+constexpr uint32_t CX_NOP = 0xDB;
 
 constexpr uint32_t CX_NUM = 0x3FF + 1;
 
 /* Shader registers */
 
-constexpr uint32_t SPI_SHADER_TBA_LO_PS     = 0x0;
-constexpr uint32_t SPI_SHADER_PGM_RSRC4_PS  = 0x1;
-constexpr uint32_t SPI_SHADER_TMA_LO_PS     = 0x2;
-constexpr uint32_t SPI_SHADER_TMA_HI_PS     = 0x3;
-constexpr uint32_t SPI_SHADER_PGM_CHKSUM_PS = 0x6;
-constexpr uint32_t SPI_SHADER_PGM_RSRC3_PS  = 0x7;
-constexpr uint32_t SPI_SHADER_PGM_LO_PS     = 0x8;
-constexpr uint32_t SPI_SHADER_PGM_HI_PS     = 0x9;
+constexpr uint32_t SPI_SHADER_PACE_ID_PS            = 0x6;
+constexpr uint32_t SPI_GRAPHICS_SHADER_CONTROL_PS    = 0x7;
+constexpr uint32_t SPI_SHADER_PGM_LO_PS              = 0x8;
+constexpr uint32_t SPI_SHADER_PGM_HI_PS              = 0x9;
 
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS                        = 0xA;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_VGPRS_SHIFT            = 0;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_VGPRS_MASK             = 0x3F;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_SGPRS_SHIFT            = 6;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_SGPRS_MASK             = 0xF;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_PRIORITY_SHIFT         = 10;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_PRIORITY_MASK          = 0x3;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_FLOAT_MODE_SHIFT       = 12;
@@ -775,33 +722,30 @@ constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_FWD_PROGRESS_MASK      = 0x1;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_FP16_OVFL_SHIFT        = 29;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_PS_FP16_OVFL_MASK         = 0x1;
 
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS                                = 0xB;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SCRATCH_EN_SHIFT               = 0;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SCRATCH_EN_MASK                = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_SHIFT                = 1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_MASK                 = 0x1F;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_WAVE_CNT_EN_SHIFT              = 7;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_WAVE_CNT_EN_MASK               = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_EXTRA_LDS_SIZE_SHIFT           = 8;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_EXTRA_LDS_SIZE_MASK            = 0xFF;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_LOAD_INTRAWAVE_COLLISION_SHIFT = 26;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_LOAD_INTRAWAVE_COLLISION_MASK  = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_MSB_SHIFT            = 27;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_MSB_MASK             = 0x1;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SHARED_VGPR_CNT_SHIFT          = 28;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SHARED_VGPR_CNT_MASK           = 0xF;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS                              = 0xB;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SCRATCH_EN_SHIFT             = 0;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SCRATCH_EN_MASK              = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_SHIFT              = 1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_MASK               = 0x1F;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_WAVE_CNT_EN_SHIFT            = 7;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_WAVE_CNT_EN_MASK             = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_EXTRA_LDS_SIZE_SHIFT         = 8;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_EXTRA_LDS_SIZE_MASK          = 0xFF;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_RASTER_ORDERED_SHADING_SHIFT = 25;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_RASTER_ORDERED_SHADING_MASK  = 0x3;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_MSB_SHIFT          = 27;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_USER_SGPR_MSB_MASK           = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SHARED_VGPR_CNT_SHIFT        = 28;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_PS_SHARED_VGPR_CNT_MASK         = 0xF;
 
 constexpr uint32_t SPI_SHADER_USER_DATA_PS_0  = 0xC;
 constexpr uint32_t SPI_SHADER_USER_DATA_PS_15 = 0x1B;
 constexpr uint32_t SPI_SHADER_USER_DATA_PS_31 = 0x2B;
-constexpr uint32_t SPI_SHADER_REQ_CTRL_PS     = 0x30;
 constexpr uint32_t SPI_SHADER_USER_ACCUM_PS_0 = 0x32;
 constexpr uint32_t SPI_SHADER_USER_ACCUM_PS_3 = 0x35;
 
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_VGPRS_SHIFT           = 0;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_VGPRS_MASK            = 0x3F;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_SGPRS_SHIFT           = 6;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_SGPRS_MASK            = 0xF;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_PRIORITY_SHIFT        = 10;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_PRIORITY_MASK         = 0x3;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_VS_FLOAT_MODE_SHIFT      = 12;
@@ -832,19 +776,20 @@ constexpr uint32_t SPI_SHADER_PGM_RSRC2_VS_USER_SGPR_MSB_MASK    = 0x1;
 constexpr uint32_t SPI_SHADER_PGM_RSRC2_VS_SHARED_VGPR_CNT_SHIFT = 28;
 constexpr uint32_t SPI_SHADER_PGM_RSRC2_VS_SHARED_VGPR_CNT_MASK  = 0xF;
 
-constexpr uint32_t SPI_SHADER_PGM_CHKSUM_GS        = 0x80;
+constexpr uint32_t SPI_SHADER_PACE_ID_GS           = 0x80;
+// AGC compiler records use this numeric tag as opaque metadata. It is not a shader checksum
+// register and intentionally has no checksum-state consumer in HardwareContext.
+constexpr uint32_t SPI_SHADER_PGM_CHKSUM_GS        = SPI_SHADER_PACE_ID_GS;
 constexpr uint32_t SPI_SHADER_PGM_RSRC4_GS         = 0x81;
 constexpr uint32_t SPI_SHADER_USER_DATA_ADDR_LO_GS = 0x82;
 constexpr uint32_t SPI_SHADER_USER_DATA_ADDR_HI_GS = 0x83;
-constexpr uint32_t SPI_SHADER_PGM_RSRC3_GS         = 0x87;
+constexpr uint32_t SPI_GRAPHICS_SHADER_CONTROL_GS  = 0x87;
 constexpr uint32_t SPI_SHADER_PGM_LO_GS            = 0x88;
 constexpr uint32_t SPI_SHADER_PGM_HI_GS            = 0x89;
 
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS                        = 0x8A;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_VGPRS_SHIFT            = 0;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_VGPRS_MASK             = 0x3F;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_SGPRS_SHIFT            = 6;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_SGPRS_MASK             = 0xF;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_PRIORITY_SHIFT         = 10;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_PRIORITY_MASK          = 0x3;
 constexpr uint32_t SPI_SHADER_PGM_RSRC1_GS_FLOAT_MODE_SHIFT       = 12;
@@ -882,61 +827,98 @@ constexpr uint32_t SPI_SHADER_PGM_RSRC2_GS_USER_SGPR_MSB_MASK     = 0x1;
 constexpr uint32_t SPI_SHADER_PGM_RSRC2_GS_SHARED_VGPR_CNT_SHIFT  = 28;
 constexpr uint32_t SPI_SHADER_PGM_RSRC2_GS_SHARED_VGPR_CNT_MASK   = 0xF;
 
-constexpr uint32_t SPI_SHADER_USER_DATA_GS_0       = 0x8C;
-constexpr uint32_t SPI_SHADER_USER_DATA_GS_15      = 0x9B;
-constexpr uint32_t SPI_SHADER_USER_DATA_GS_31      = 0xAB;
-constexpr uint32_t SPI_SHADER_REQ_CTRL_ESGS        = 0xB0;
-constexpr uint32_t SPI_SHADER_USER_ACCUM_ESGS_0    = 0xB2;
-constexpr uint32_t SPI_SHADER_USER_ACCUM_ESGS_3    = 0xB5;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_ES_GS      = 0xBC;
-constexpr uint32_t SPI_SHADER_PGM_LO_ES            = 0xC8;
-constexpr uint32_t SPI_SHADER_PGM_HI_ES            = 0xC9;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_ES         = 0xCA;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_ES         = 0xCB;
-constexpr uint32_t SPI_SHADER_USER_DATA_ES_0       = 0xCC;
-constexpr uint32_t SPI_SHADER_USER_DATA_ES_15      = 0xDB;
-constexpr uint32_t SPI_SHADER_USER_DATA_ES_31      = 0xEB;
-constexpr uint32_t SPI_SHADER_PGM_CHKSUM_HS        = 0x100;
-constexpr uint32_t SPI_SHADER_PGM_RSRC4_HS         = 0x101;
-constexpr uint32_t SPI_SHADER_USER_DATA_ADDR_LO_HS = 0x102;
-constexpr uint32_t SPI_SHADER_USER_DATA_ADDR_HI_HS = 0x103;
-constexpr uint32_t SPI_SHADER_PGM_RSRC3_HS         = 0x107;
-constexpr uint32_t SPI_SHADER_PGM_LO_HS            = 0x108;
-constexpr uint32_t SPI_SHADER_PGM_HI_HS            = 0x109;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS         = 0x10A;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS         = 0x10B;
-constexpr uint32_t SPI_SHADER_USER_DATA_HS_0       = 0x10C;
-constexpr uint32_t SPI_SHADER_USER_DATA_HS_15      = 0x11B;
-constexpr uint32_t SPI_SHADER_USER_DATA_HS_31      = 0x12B;
-constexpr uint32_t SPI_SHADER_REQ_CTRL_LSHS        = 0x130;
-constexpr uint32_t SPI_SHADER_USER_ACCUM_LSHS_0    = 0x132;
-constexpr uint32_t SPI_SHADER_USER_ACCUM_LSHS_3    = 0x135;
-constexpr uint32_t SPI_SHADER_PGM_LO_LS            = 0x148;
-constexpr uint32_t SPI_SHADER_PGM_HI_LS            = 0x149;
-constexpr uint32_t SPI_SHADER_PGM_RSRC1_LS         = 0x14A;
-constexpr uint32_t SPI_SHADER_PGM_RSRC2_LS         = 0x14B;
-constexpr uint32_t COMPUTE_START_X                 = 0x204;
-constexpr uint32_t COMPUTE_START_Y                 = 0x205;
-constexpr uint32_t COMPUTE_START_Z                 = 0x206;
-constexpr uint32_t COMPUTE_NUM_THREAD_X            = 0x207;
-constexpr uint32_t COMPUTE_NUM_THREAD_Y            = 0x208;
-constexpr uint32_t COMPUTE_NUM_THREAD_Z            = 0x209;
-constexpr uint32_t COMPUTE_PGM_LO                  = 0x20C;
-constexpr uint32_t COMPUTE_PGM_HI                  = 0x20D;
-constexpr uint32_t COMPUTE_TBA_LO                  = 0x20E;
-constexpr uint32_t COMPUTE_TBA_HI                  = 0x20F;
-constexpr uint32_t COMPUTE_TMA_LO                  = 0x210;
-constexpr uint32_t COMPUTE_TMA_HI                  = 0x211;
+constexpr uint32_t SPI_SHADER_USER_DATA_GS_0                      = 0x8C;
+constexpr uint32_t SPI_SHADER_USER_DATA_GS_15                     = 0x9B;
+constexpr uint32_t SPI_SHADER_USER_DATA_GS_31                     = 0xAB;
+constexpr uint32_t SPI_SHADER_USER_ACCUM_ESGS_0                   = 0xB2;
+constexpr uint32_t SPI_SHADER_USER_ACCUM_ESGS_3                   = 0xB5;
+constexpr uint32_t SPI_SHADER_PGM_LO_ES                           = 0xC8;
+constexpr uint32_t SPI_SHADER_PGM_HI_ES                           = 0xC9;
+// Private AGC registers used by shader binaries submitted through SET_SH_REG_INDIRECT.
+constexpr uint32_t SPI_SHADER_PGM_CHKSUM_HS                       = 0x100;
+constexpr uint32_t SPI_SHADER_PGM_RSRC4_HS                        = 0x101;
+constexpr uint32_t SPI_SHADER_USER_DATA_ADDR_LO_HS                = 0x102;
+constexpr uint32_t SPI_SHADER_USER_DATA_ADDR_HI_HS                = 0x103;
+constexpr uint32_t SPI_GRAPHICS_SHADER_CONTROL_HS                 = 0x107;
+constexpr uint32_t SPI_SHADER_PGM_LO_HS                           = 0x108;
+constexpr uint32_t SPI_SHADER_PGM_HI_HS                           = 0x109;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS                        = 0x10A;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS                        = 0x10B;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_VGPRS_SHIFT            = 0;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_VGPRS_MASK             = 0x3F;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_PRIORITY_SHIFT         = 10;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_PRIORITY_MASK          = 0x3;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_FLOAT_MODE_SHIFT       = 12;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_FLOAT_MODE_MASK        = 0xFF;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_DX10_CLAMP_SHIFT       = 21;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_DX10_CLAMP_MASK        = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_DEBUG_MODE_SHIFT       = 22;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_DEBUG_MODE_MASK        = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_IEEE_MODE_SHIFT        = 23;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_IEEE_MODE_MASK         = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_FWD_PROGRESS_SHIFT     = 25;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_FWD_PROGRESS_MASK      = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_WGP_MODE_SHIFT         = 26;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_WGP_MODE_MASK          = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_LS_VGPR_COMP_CNT_SHIFT = 28;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_LS_VGPR_COMP_CNT_MASK  = 0x3;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_FP16_OVFL_SHIFT        = 30;
+constexpr uint32_t SPI_SHADER_PGM_RSRC1_HS_FP16_OVFL_MASK         = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_SCRATCH_EN_SHIFT       = 0;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_SCRATCH_EN_MASK        = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_USER_SGPR_SHIFT        = 1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_USER_SGPR_MASK         = 0x1F;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_LDS_SIZE_SHIFT         = 18;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_LDS_SIZE_MASK          = 0x1FF;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_USER_SGPR_MSB_SHIFT    = 27;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_USER_SGPR_MSB_MASK     = 0x1;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_SHARED_VGPR_CNT_SHIFT  = 28;
+constexpr uint32_t SPI_SHADER_PGM_RSRC2_HS_SHARED_VGPR_CNT_MASK   = 0xF;
+constexpr uint32_t SPI_SHADER_USER_DATA_HS_0                      = 0x10C;
+constexpr uint32_t SPI_SHADER_USER_DATA_HS_15                     = 0x11B;
+constexpr uint32_t SPI_SHADER_USER_DATA_HS_31                     = 0x12B;
+constexpr uint32_t SPI_SHADER_USER_ACCUM_LSHS_0                   = 0x132;
+constexpr uint32_t SPI_SHADER_USER_ACCUM_LSHS_3                   = 0x135;
+constexpr uint32_t SPI_SHADER_PGM_LO_LS                           = 0x148;
+constexpr uint32_t SPI_SHADER_PGM_HI_LS                           = 0x149;
+constexpr uint32_t COMPUTE_START_X                                = 0x204;
+constexpr uint32_t COMPUTE_START_Y                                = 0x205;
+constexpr uint32_t COMPUTE_START_Z                                = 0x206;
+constexpr uint32_t COMPUTE_NUM_THREAD_X                           = 0x207;
+constexpr uint32_t COMPUTE_NUM_THREAD_Y                           = 0x208;
+constexpr uint32_t COMPUTE_NUM_THREAD_Z                           = 0x209;
+constexpr uint32_t COMPUTE_PGM_LO                                 = 0x20C;
+constexpr uint32_t COMPUTE_PGM_HI                                 = 0x20D;
 
-constexpr uint32_t COMPUTE_PGM_RSRC1              = 0x212;
-constexpr uint32_t COMPUTE_PGM_RSRC1_VGPRS_SHIFT  = 0;
-constexpr uint32_t COMPUTE_PGM_RSRC1_VGPRS_MASK   = 0x3F;
-constexpr uint32_t COMPUTE_PGM_RSRC1_SGPRS_SHIFT  = 6;
-constexpr uint32_t COMPUTE_PGM_RSRC1_SGPRS_MASK   = 0xF;
-constexpr uint32_t COMPUTE_PGM_RSRC1_BULKY_SHIFT  = 24;
-constexpr uint32_t COMPUTE_PGM_RSRC1_BULKY_MASK   = 0x1;
-constexpr uint32_t COMPUTE_PGM_RSRC1_W32_EN_SHIFT = 30;
-constexpr uint32_t COMPUTE_PGM_RSRC1_W32_EN_MASK  = 0x1;
+constexpr uint32_t COMPUTE_PGM_RSRC1                  = 0x212;
+constexpr uint32_t COMPUTE_PGM_RSRC1_VGPRS_SHIFT      = 0;
+constexpr uint32_t COMPUTE_PGM_RSRC1_VGPRS_MASK       = 0x3F;
+constexpr uint32_t COMPUTE_PGM_RSRC1_PRIORITY_SHIFT   = 10;
+constexpr uint32_t COMPUTE_PGM_RSRC1_PRIORITY_MASK    = 0x3;
+constexpr uint32_t COMPUTE_PGM_RSRC1_FLOAT_MODE_SHIFT = 12;
+constexpr uint32_t COMPUTE_PGM_RSRC1_FLOAT_MODE_MASK  = 0xFF;
+constexpr uint32_t COMPUTE_PGM_RSRC1_DX10_CLAMP_SHIFT = 21;
+constexpr uint32_t COMPUTE_PGM_RSRC1_DX10_CLAMP_MASK  = 0x1;
+constexpr uint32_t COMPUTE_PGM_RSRC1_DEBUG_MODE_SHIFT = 22;
+constexpr uint32_t COMPUTE_PGM_RSRC1_DEBUG_MODE_MASK  = 0x1;
+constexpr uint32_t COMPUTE_PGM_RSRC1_IEEE_MODE_SHIFT  = 23;
+constexpr uint32_t COMPUTE_PGM_RSRC1_IEEE_MODE_MASK   = 0x1;
+constexpr uint32_t COMPUTE_PGM_RSRC1_FP16_OVFL_SHIFT  = 26;
+constexpr uint32_t COMPUTE_PGM_RSRC1_FP16_OVFL_MASK   = 0x1;
+constexpr uint32_t COMPUTE_PGM_RSRC1_WGP_MODE_SHIFT   = 29;
+constexpr uint32_t COMPUTE_PGM_RSRC1_WGP_MODE_MASK    = 0x1;
+constexpr uint32_t COMPUTE_PGM_RSRC1_FWD_PROGRESS_SHIFT = 31;
+constexpr uint32_t COMPUTE_PGM_RSRC1_FWD_PROGRESS_MASK  = 0x1;
+
+constexpr uint32_t COMPUTE_DISPATCH_INITIATOR_CS_W32_EN_SHIFT = 15;
+constexpr uint32_t COMPUTE_DISPATCH_INITIATOR_CS_W32_EN_MASK  = 0x1;
+
+[[nodiscard]] constexpr uint8_t ComputeWaveSize(uint32_t dispatch_initiator) {
+	return ((dispatch_initiator >> COMPUTE_DISPATCH_INITIATOR_CS_W32_EN_SHIFT) &
+	        COMPUTE_DISPATCH_INITIATOR_CS_W32_EN_MASK) != 0u
+	           ? 32u
+	           : 64u;
+}
 
 constexpr uint32_t COMPUTE_PGM_RSRC2                      = 0x213;
 constexpr uint32_t COMPUTE_PGM_RSRC2_SCRATCH_EN_SHIFT     = 0;
@@ -957,21 +939,16 @@ constexpr uint32_t COMPUTE_PGM_RSRC2_LDS_SIZE_SHIFT       = 15;
 constexpr uint32_t COMPUTE_PGM_RSRC2_LDS_SIZE_MASK        = 0x1FF;
 
 constexpr uint32_t COMPUTE_RESOURCE_LIMITS    = 0x215;
-constexpr uint32_t COMPUTE_DESTINATION_EN_SE0 = 0x216;
-constexpr uint32_t COMPUTE_DESTINATION_EN_SE1 = 0x217;
 constexpr uint32_t COMPUTE_TMPRING_SIZE       = 0x218;
-constexpr uint32_t COMPUTE_DESTINATION_EN_SE2 = 0x219;
-constexpr uint32_t COMPUTE_DESTINATION_EN_SE3 = 0x21A;
 constexpr uint32_t COMPUTE_USER_ACCUM_0       = 0x224;
 constexpr uint32_t COMPUTE_PGM_RSRC3          = 0x228;
-constexpr uint32_t COMPUTE_SHADER_CHKSUM      = 0x22A;
+constexpr uint32_t COMPUTE_PGM_RSRC3_SHARED_VGPRS_SHIFT = 0;
+constexpr uint32_t COMPUTE_PGM_RSRC3_SHARED_VGPRS_MASK  = 0xF;
+constexpr uint32_t COMPUTE_PACE_ID             = 0x22A;
 constexpr uint32_t COMPUTE_USER_DATA_0        = 0x240;
 constexpr uint32_t COMPUTE_USER_DATA_15       = 0x24F;
-constexpr uint32_t COMPUTE_DISPATCH_TUNNEL    = 0x27D;
 
-/* Fake codes. Don't exist on real HW */
-
-constexpr uint32_t SH_NOP = 0x800002FF;
+constexpr uint32_t SH_NOP = 0x280;
 
 constexpr uint32_t SH_NUM = 0x2FF + 1;
 
@@ -988,6 +965,7 @@ constexpr uint32_t GE_INDX_OFFSET            = 0x24A;
 constexpr uint32_t GE_MULTI_PRIM_IB_RESET_EN = 0x24B;
 constexpr uint32_t VGT_HS_OFFCHIP_PARAM      = 0x24F;
 constexpr uint32_t VGT_TF_MEMORY_BASE        = 0x250;
+constexpr uint32_t IA_MULTI_VGT_PARAM        = 0x258;
 
 constexpr uint32_t GE_CNTL                     = 0x25B;
 constexpr uint32_t GE_CNTL_PRIM_GRP_SIZE_SHIFT = 0;
@@ -999,6 +977,7 @@ constexpr uint32_t GE_USER_VGPR1  = 0x25C;
 constexpr uint32_t GE_USER_VGPR2  = 0x25D;
 constexpr uint32_t GE_USER_VGPR3  = 0x25E;
 constexpr uint32_t GE_STEREO_CNTL = 0x25F;
+constexpr uint32_t UC_PARAMETER_OVERSUBSCRIPTION = 0x260;
 
 constexpr uint32_t GE_USER_VGPR_EN                     = 0x262;
 constexpr uint32_t GE_USER_VGPR_EN_EN_USER_VGPR1_SHIFT = 0;
@@ -1008,32 +987,25 @@ constexpr uint32_t GE_USER_VGPR_EN_EN_USER_VGPR2_MASK  = 0x1;
 constexpr uint32_t GE_USER_VGPR_EN_EN_USER_VGPR3_SHIFT = 2;
 constexpr uint32_t GE_USER_VGPR_EN_EN_USER_VGPR3_MASK  = 0x1;
 
-constexpr uint32_t IA_MULTI_VGT_PARAM       = 0x258;
+constexpr uint32_t FSR_WINDOW_LEFT           = 0x2BC;
+constexpr uint32_t FSR_CONTROL_POINTS_LEFT_X = 0x2C4;
+constexpr uint32_t FSR_CONTROL_POINTS_LEFT_Y = 0x2CC;
+constexpr uint32_t FSR_ALPHA_LEFT_X          = 0x2E4;
+constexpr uint32_t FSR_ALPHA_LEFT_Y          = 0x2E8;
+
 constexpr uint32_t TA_CS_BC_BASE_ADDR       = 0x380;
 constexpr uint32_t TA_CS_BC_BASE_ADDR_HI    = 0x381;
-constexpr uint32_t TEXTURE_GRADIENT_FACTORS = 0x382;
+constexpr uint32_t TEXTURE_GRADIENT_FACTORS = 0x383;
+constexpr uint32_t TEXTURE_GRADIENT_CONTROL = 0x384;
 constexpr uint32_t GDS_OA_CNTL              = 0x41D;
 constexpr uint32_t GDS_OA_COUNTER           = 0x41E;
 constexpr uint32_t GDS_OA_ADDRESS           = 0x41F;
 
-/* Fake codes. Don't exist on real HW */
-
-constexpr uint32_t FSR_EXTEND_SUBPIXEL_ROUNDING = 0x80003FF4;
-constexpr uint32_t FSR_ALPHA_VALUE0             = 0x80003FF5;
-constexpr uint32_t FSR_ALPHA_VALUE1             = 0x80003FF6;
-constexpr uint32_t FSR_CONTROL_POINT0           = 0x80003FF7;
-constexpr uint32_t FSR_CONTROL_POINT1           = 0x80003FF8;
-constexpr uint32_t FSR_CONTROL_POINT2           = 0x80003FF9;
-constexpr uint32_t FSR_CONTROL_POINT3           = 0x80003FFA;
-constexpr uint32_t FSR_WINDOW0                  = 0x80003FFB;
-constexpr uint32_t FSR_WINDOW1                  = 0x80003FFC;
-constexpr uint32_t TEXTURE_GRADIENT_CONTROL     = 0x80003FFD;
-constexpr uint32_t MEMORY_MAPPING_MASK          = 0x80003FFE;
-constexpr uint32_t UC_NOP                       = 0x80003FFF;
+constexpr uint32_t UC_NOP = 0xA2;
 
 constexpr uint32_t UC_NUM = 0x3FFF + 1;
 
-void DumpPm4PacketStream(Common::File* file, uint32_t* cmd_buffer, uint32_t start_dw,
+void DumpPm4PacketStream(Common::File* file, const uint32_t* cmd_buffer, uint32_t start_dw,
                          uint32_t num_dw);
 
 } // namespace Libs::Graphics::Pm4

src/graphics/guest_gpu/tile.h

@@ -3,6 +3,7 @@
 
 #include "common/abi.h"
 #include "common/common.h"
+#include "graphics/guest_gpu/gpu_defs.h"
 
 namespace Libs::Graphics {
 
@@ -39,7 +40,7 @@ enum class TileBlockFamily : uint32_t {
 };
 
 struct TileBlockLayout {
-	TileBlockFamily family            = TileBlockFamily::Standard256B;
+	TileBlockFamily family            = TileBlockFamily::Count;
 	uint32_t        bytes_per_element = 0;
 	uint32_t        block_size        = 0;
 	uint32_t        block_width       = 0;
@@ -47,60 +48,96 @@ struct TileBlockLayout {
 	uint32_t        block_depth       = 0;
 };
 
-struct TileVolumeLayout {
-	TileBlockFamily family            = TileBlockFamily::Count;
-	uint32_t        bytes_per_element = 0;
-	uint32_t        texel_width       = 1;
-	uint32_t        texel_height      = 1;
-	uint32_t        first_tail_level  = 0;
-	uint32_t        block_depth       = 1;
-	uint64_t        block_slice_size  = 0;
-	uint64_t        total_size        = 0;
-	uint64_t        level_offsets[16] = {};
-	uint64_t        level_sizes[16]   = {};
-	uint32_t        tail_x[16]        = {};
-	uint32_t        tail_y[16]        = {};
-	uint32_t        level_widths[16]  = {};
-	uint32_t        level_heights[16] = {};
+struct TileTextureElementLayout {
+	uint32_t bytes        = 0;
+	uint32_t texel_width  = 1;
+	uint32_t texel_height = 1;
+};
+
+struct TileTextureBlockLayout {
+	TileBlockLayout block;
+	uint32_t        texel_width  = 1;
+	uint32_t        texel_height = 1;
+};
+
+enum class TileSurfaceDimension : uint32_t {
+	Dim2D,
+	Dim3D,
+};
+
+struct TileSurfaceDescription {
+	Prospero::BufferFormat format    = Prospero::BufferFormat::kInvalid;
+	Prospero::TileMode     tile_mode = Prospero::TileMode::kLinear;
+	TileSurfaceDimension   dimension = TileSurfaceDimension::Dim2D;
+	uint32_t               width     = 0;
+	uint32_t               height    = 0;
+	uint32_t               depth     = 1;
+	uint32_t               levels    = 1;
+	uint32_t               layers    = 1;
+};
+
+// Width/height fields are measured in addressable elements, not texture texels.
+struct TileMipLayout {
+	uint64_t offset        = 0;
+	uint64_t size          = 0;
+	uint32_t width         = 0;
+	uint32_t height        = 0;
+	uint32_t padded_width  = 0;
+	uint32_t padded_height = 0;
+	uint32_t tail_x        = 0;
+	uint32_t tail_y        = 0;
+	bool     operator==(const TileMipLayout&) const = default;
+};
+
+struct TileSurfaceLayout {
+	TileSurfaceDescription description;
+	TileTextureBlockLayout texture;
+	uint32_t               first_tail_level = 0;
+	uint64_t               block_slice_size = 0;
+	uint64_t               total_size       = 0;
+	TileMipLayout          mips[16]         = {};
 };
 
 bool TileGetBlockLayout(TileBlockFamily family, uint32_t bytes_per_element,
-	                    TileBlockLayout& layout);
+                        TileBlockLayout& layout);
+bool TileGetTextureElementLayout(Prospero::BufferFormat format, TileTextureElementLayout& layout);
+bool TileGetTextureBlockLayout(Prospero::BufferFormat format, Prospero::TileMode tile, bool volume,
+                               TileTextureBlockLayout& layout);
+bool TileGetTiledTextureLayout(const TileSurfaceDescription& description,
+                               TileSurfaceLayout&            layout);
 bool TileGetBlockOffset(const TileBlockLayout& layout, uint32_t x, uint32_t y, uint32_t z,
-	                    uint32_t& byte_offset);
+                        uint32_t& byte_offset);
 bool TileGetBlockXor(const TileBlockLayout& layout, uint32_t block_x, uint32_t block_y,
-	                 uint32_t& byte_offset);
+                     uint32_t& byte_offset);
 bool TileGetBlockXor(const TileBlockLayout& layout, uint32_t block_x, uint32_t block_y,
-	                 uint32_t block_z, uint32_t& byte_offset);
-bool TileIsStandard256BTextureSupported(uint32_t format);
-bool TileIsStandard4KBTextureSupported(uint32_t format);
-bool TileIsStandard64KBTextureSupported(uint32_t format);
-bool TileGetTextureVolumeLayout(uint32_t format, uint32_t width, uint32_t height, uint32_t depth,
-	                            uint32_t levels, uint32_t tile, TileVolumeLayout& layout);
+                     uint32_t block_z, uint32_t& byte_offset);
 
-bool     TileGetHtileSize(uint32_t width, uint32_t height, TileSizeAlign& htile_size);
-bool     TileGetDepthSize(uint32_t width, uint32_t height, uint32_t pitch, uint32_t z_format,
-	                      uint32_t stencil_format, bool htile, TileSizeAlign& stencil_size,
-	                      TileSizeAlign& htile_size, TileSizeAlign& depth_size,
-                          uint32_t num_fragments_log2 = 0);
+bool     TileGetDepthSize(uint32_t width, uint32_t height, uint32_t pitch,
+                          Prospero::DepthFormat z_format, Prospero::StencilFormat stencil_format,
+                          bool htile, TileSizeAlign& stencil_size, TileSizeAlign& htile_size,
+                          TileSizeAlign& depth_size, uint32_t num_fragments_log2 = 0);
 uint32_t TileGetRenderTargetPitch(uint32_t width, uint32_t bytes_per_element,
                                   uint32_t num_fragments_log2 = 0);
 uint32_t TileGetDepthPitch(uint32_t width, uint32_t bytes_per_element,
                            uint32_t num_fragments_log2 = 0);
 bool     TileGetRenderTargetSize(uint32_t width, uint32_t height, uint32_t pitch,
-	                             uint32_t bytes_per_element, TileSizeAlign& total_size,
+                                 uint32_t bytes_per_element, TileSizeAlign& total_size,
                                  uint32_t num_fragments_log2 = 0);
+bool     TileGetDccSize(uint32_t width, uint32_t height, uint32_t slices,
+                        uint32_t bytes_per_element, uint32_t levels, Prospero::TileMode tile,
+                        TileSizeAlign& total_size, uint32_t num_fragments_log2 = 0);
 bool     TileGetRenderTargetMipLayout(uint32_t width, uint32_t height, uint32_t pitch,
-	                                  uint32_t bytes_per_element, uint32_t levels,
-	                                  TileSizeAlign& total_size, TileSizeOffset* level_sizes,
+                                      uint32_t bytes_per_element, uint32_t levels,
+                                      TileSizeAlign& total_size, TileSizeOffset* level_sizes,
                                       TilePaddedSize* padded_size);
-void     TileGetTextureSize(uint32_t format, uint32_t width, uint32_t height, uint32_t pitch,
-                            uint32_t levels, uint32_t tile, TileSizeAlign* total_size,
+void     TileGetTextureSize(Prospero::BufferFormat format, uint32_t width, uint32_t height,
+                            uint32_t levels, Prospero::TileMode tile, TileSizeAlign* total_size,
                             TileSizeOffset* level_sizes, TilePaddedSize* padded_size);
-void TileGetTextureTotalSize(uint32_t format, uint32_t width, uint32_t height, uint32_t depth,
-                             uint32_t pitch, uint32_t levels, uint32_t tile, bool volume_texture,
-	                         TileSizeAlign& total_size);
-uint32_t TileGetTexturePitch(uint32_t format, uint32_t width, uint32_t levels, uint32_t tile);
+void     TileGetTextureTotalSize(Prospero::BufferFormat format, uint32_t width, uint32_t height,
+                                 uint32_t depth, uint32_t levels, Prospero::TileMode tile,
+                                 bool volume_texture, TileSizeAlign& total_size);
+uint32_t TileGetTexturePitch(Prospero::BufferFormat format, uint32_t width,
+                             Prospero::TileMode tile);
 
 } // namespace Libs::Graphics
 

src/graphics/host_gpu/gpuTiler.cpp

@@ -1,549 +0,0 @@
-#include "graphics/host_gpu/gpuTiler.h"
-
-#include "common/assert.h"
-#include "common/threads.h"
-#include "gpu_tiler_shaders/gpu_tiler_depth_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_prt_3d_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_prt_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_render_target_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_standard256_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_standard4_3d_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_standard4_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_standard64_3d_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_standard64_spv.h"
-#include "graphics/host_gpu/graphicContext.h"
-#include "graphics/host_gpu/renderer/render.h"
-#include "graphics/host_gpu/renderer/renderContext.h"
-#include "graphics/host_gpu/vma.h"
-#include "graphics/host_gpu/vulkanCommon.h"
-
-#include <algorithm>
-#include <array>
-#include <bit>
-#include <cstring>
-#include <memory>
-#include <vector>
-
-namespace Libs::Graphics {
-namespace {
-
-constexpr uint32_t GROUP_SIZE              = 64;
-constexpr uint32_t FAMILY_COUNT            = static_cast<uint32_t>(TileBlockFamily::Count);
-constexpr uint32_t BYTES_PER_ELEMENT_COUNT = 5;
-constexpr uint32_t DIRECTION_COUNT         = 2;
-constexpr uint32_t PIPELINE_COUNT = FAMILY_COUNT * BYTES_PER_ELEMENT_COUNT * DIRECTION_COUNT;
-static_assert(FAMILY_COUNT == 9);
-
-struct Push {
-	uint32_t src_base;
-	uint32_t dst_base;
-	uint32_t width;
-	uint32_t height;
-	uint32_t depth;
-	uint32_t surface_z;
-	uint32_t pitch_bytes;
-	uint32_t slice_bytes;
-	uint32_t blocks_per_row;
-	uint32_t blocks_per_slice;
-	uint32_t tail_x;
-	uint32_t tail_y;
-	uint32_t tail;
-	uint32_t first;
-	uint32_t count;
-};
-static_assert(sizeof(Push) == 60);
-
-struct Shader {
-	const uint32_t* code;
-	size_t          words;
-};
-
-constexpr std::array<Shader, FAMILY_COUNT> SHADERS {{
-    {GPU_TILER_STANDARD256_SPV, std::size(GPU_TILER_STANDARD256_SPV)},
-    {GPU_TILER_STANDARD4_SPV, std::size(GPU_TILER_STANDARD4_SPV)},
-    {GPU_TILER_STANDARD4_3D_SPV, std::size(GPU_TILER_STANDARD4_3D_SPV)},
-    {GPU_TILER_STANDARD64_SPV, std::size(GPU_TILER_STANDARD64_SPV)},
-    {GPU_TILER_STANDARD64_3D_SPV, std::size(GPU_TILER_STANDARD64_3D_SPV)},
-    {GPU_TILER_PRT_SPV, std::size(GPU_TILER_PRT_SPV)},
-    {GPU_TILER_PRT_3D_SPV, std::size(GPU_TILER_PRT_3D_SPV)},
-    {GPU_TILER_RENDER_TARGET_SPV, std::size(GPU_TILER_RENDER_TARGET_SPV)},
-    {GPU_TILER_DEPTH_SPV, std::size(GPU_TILER_DEPTH_SPV)},
-}};
-
-struct Dispatch {
-	Push     push {};
-	uint32_t pipeline_slot = 0;
-	uint32_t elements      = 0;
-};
-
-struct Resources {
-	vk::DescriptorSetLayout                  descriptor_layout = nullptr;
-	vk::PipelineLayout                       pipeline_layout   = nullptr;
-	vk::DescriptorPool                       descriptor_pool   = nullptr;
-	vk::DescriptorSet                        descriptor_set    = nullptr;
-	std::array<vk::Pipeline, PIPELINE_COUNT> pipelines {};
-	VulkanBuffer                             staging;
-	VulkanBuffer                             linear;
-	void*                                    mapped = nullptr;
-};
-
-bool CheckedAdd(uint64_t a, uint64_t b, uint64_t& result) {
-	return b <= UINT64_MAX - a && (result = a + b, true);
-}
-
-bool CheckedMultiply(uint64_t a, uint64_t b, uint64_t& result) {
-	return (a == 0 || b <= UINT64_MAX / a) && (result = a * b, true);
-}
-
-bool CheckedAddProduct(uint64_t& value, uint64_t count, uint64_t stride) {
-	uint64_t bytes = 0;
-	return CheckedMultiply(count, stride, bytes) && CheckedAdd(value, bytes, value);
-}
-
-bool IsRangeValid(uint64_t offset, uint64_t size, uint64_t capacity) {
-	return size != 0 && offset <= capacity && size <= capacity - offset;
-}
-
-uint64_t AlignToDword(uint64_t value) {
-	return (value + 3u) & ~uint64_t {3};
-}
-
-uint32_t GetPipelineSlot(bool to_tiled, TileBlockFamily family, uint32_t bytes_per_element) {
-	const uint32_t direction_index    = to_tiled ? 1u : 0u;
-	const uint32_t family_index       = static_cast<uint32_t>(family);
-	const uint32_t element_size_index = std::countr_zero(bytes_per_element);
-	return (direction_index * FAMILY_COUNT + family_index) * BYTES_PER_ELEMENT_COUNT +
-	       element_size_index;
-}
-
-void Barrier(vk::CommandBuffer command, vk::Buffer buffer, vk::AccessFlags src_access,
-             vk::AccessFlags dst_access, vk::PipelineStageFlags src_stage,
-             vk::PipelineStageFlags dst_stage) {
-	vk::BufferMemoryBarrier barrier {};
-	barrier.sType               = vk::StructureType::eBufferMemoryBarrier;
-	barrier.srcAccessMask       = src_access;
-	barrier.dstAccessMask       = dst_access;
-	barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-	barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-	barrier.buffer              = buffer;
-	barrier.size                = VK_WHOLE_SIZE;
-	command.pipelineBarrier(src_stage, dst_stage, {}, 0, nullptr, 1, &barrier, 0, nullptr);
-}
-
-class TileCompute final {
-public:
-	explicit TileCompute(GraphicContext& graphics): graphics(graphics) {}
-	void Run(bool to_tiled, const void* input, void* output, uint64_t tiled_capacity,
-	         uint64_t linear_capacity, std::span<const GpuTileInfo> infos,
-	         const GpuTileRecord& record);
-	void Release();
-
-private:
-	void Prepare(bool to_tiled, uint64_t tiled_capacity, uint64_t linear_capacity,
-	             std::span<const GpuTileInfo> infos, std::vector<Dispatch>& dispatches) const;
-	void Init();
-	void CreatePipelines(std::span<const Dispatch> dispatches);
-	void CreatePipeline(uint32_t pipeline_slot);
-	void Resize(uint64_t staging_size, uint64_t linear_size);
-	void CreateBuffer(uint64_t size, bool mapped, VulkanBuffer& buffer, void** data) const;
-	void Execute(bool to_tiled, const void* input, void* output, uint64_t tiled_capacity,
-	             uint64_t linear_capacity, std::span<const Dispatch> dispatches,
-	             const GpuTileRecord& record);
-	void Destroy(Resources& target) const;
-
-	GraphicContext& graphics;
-	Resources       resources;
-};
-
-Common::Mutex                g_tiler_mutex;
-std::unique_ptr<TileCompute> g_tiler;
-
-void TileCompute::Prepare(bool to_tiled, uint64_t tiled_capacity, uint64_t linear_capacity,
-                          std::span<const GpuTileInfo> infos,
-                          std::vector<Dispatch>&       dispatches) const {
-	EXIT_IF(infos.empty() || tiled_capacity == 0 || linear_capacity == 0);
-	const auto& limits = graphics.GetPhysicalDeviceProperties().limits;
-	EXIT_NOT_IMPLEMENTED(tiled_capacity > UINT32_MAX || linear_capacity > UINT32_MAX ||
-	                     AlignToDword(tiled_capacity) > limits.maxStorageBufferRange ||
-	                     AlignToDword(linear_capacity) > limits.maxStorageBufferRange);
-
-	dispatches.clear();
-	dispatches.reserve(infos.size());
-	for (const auto& info: infos) {
-		TileBlockLayout block {};
-		const uint32_t  tiled_width  = info.tiled_width != 0 ? info.tiled_width : info.pitch;
-		const uint32_t  tiled_height = info.tiled_height != 0 ? info.tiled_height : info.height;
-		EXIT_NOT_IMPLEMENTED(
-		    !TileGetBlockLayout(info.family, info.bytes_per_element, block) || info.width == 0 ||
-		    info.height == 0 || info.depth == 0 || info.pitch < info.width ||
-		    (!info.tail && (tiled_width < info.width || tiled_height < info.height)) ||
-		    !IsRangeValid(info.linear_offset, info.linear_size, linear_capacity) ||
-		    !IsRangeValid(info.tiled_offset, info.tiled_size, tiled_capacity) ||
-		    (block.block_depth == 1 && info.depth != 1));
-
-		uint64_t elements = 0, pitch_bytes = 0;
-		EXIT_NOT_IMPLEMENTED(!CheckedMultiply(info.width, info.height, elements) ||
-		                     !CheckedMultiply(elements, info.depth, elements) ||
-		                     !CheckedMultiply(info.pitch, info.bytes_per_element, pitch_bytes) ||
-		                     elements > UINT32_MAX || pitch_bytes > UINT32_MAX);
-		uint64_t slice_bytes = info.linear_slice_stride;
-		EXIT_NOT_IMPLEMENTED(slice_bytes == 0 &&
-		                     !CheckedMultiply(pitch_bytes, info.height, slice_bytes));
-		uint64_t linear_used = 0, minimum_slice = 0;
-		EXIT_NOT_IMPLEMENTED(!CheckedMultiply(pitch_bytes, info.height, minimum_slice) ||
-		                     (info.depth > 1 && slice_bytes < minimum_slice) ||
-		                     !CheckedAddProduct(linear_used, info.depth - 1u, slice_bytes) ||
-		                     !CheckedAddProduct(linear_used, info.height - 1u, pitch_bytes) ||
-		                     !CheckedAddProduct(linear_used, info.width, info.bytes_per_element) ||
-		                     linear_used > info.linear_size || slice_bytes > UINT32_MAX);
-
-		const uint64_t columns =
-		    (static_cast<uint64_t>(tiled_width) + block.block_width - 1u) / block.block_width;
-		const uint64_t rows =
-		    (static_cast<uint64_t>(tiled_height) + block.block_height - 1u) / block.block_height;
-		uint64_t blocks_per_slice = 0;
-		EXIT_NOT_IMPLEMENTED(!CheckedMultiply(columns, rows, blocks_per_slice) ||
-		                     columns > UINT32_MAX || blocks_per_slice > UINT32_MAX ||
-		                     rows * block.block_height > UINT32_MAX);
-		if (info.tail) {
-			const bool supported = info.family != TileBlockFamily::Standard256B;
-			EXIT_NOT_IMPLEMENTED(
-			    !supported || info.depth > block.block_depth || info.tail_x >= block.block_width ||
-			    info.width > block.block_width - info.tail_x || info.tail_y >= block.block_height ||
-			    info.height > block.block_height - info.tail_y ||
-			    info.tiled_size < block.block_size);
-		} else {
-			const uint64_t slices =
-			    (static_cast<uint64_t>(info.depth) + block.block_depth - 1u) / block.block_depth;
-			uint64_t tiled_used = 0;
-			EXIT_NOT_IMPLEMENTED(!CheckedMultiply(blocks_per_slice, slices, tiled_used) ||
-			                     !CheckedMultiply(tiled_used, block.block_size, tiled_used) ||
-			                     tiled_used > info.tiled_size);
-		}
-		const uint32_t alignment = std::min(info.bytes_per_element, 4u);
-		EXIT_NOT_IMPLEMENTED(((info.linear_offset | info.tiled_offset | pitch_bytes | slice_bytes) &
-		                      (alignment - 1u)) != 0);
-
-		Dispatch dispatch {};
-		dispatch.elements      = static_cast<uint32_t>(elements);
-		dispatch.pipeline_slot = GetPipelineSlot(to_tiled, info.family, info.bytes_per_element);
-		dispatch.push.src_base =
-		    static_cast<uint32_t>(to_tiled ? info.linear_offset : info.tiled_offset);
-		dispatch.push.dst_base =
-		    static_cast<uint32_t>(to_tiled ? info.tiled_offset : info.linear_offset);
-		dispatch.push.width            = info.width;
-		dispatch.push.height           = info.height;
-		dispatch.push.depth            = info.depth;
-		dispatch.push.surface_z        = info.surface_z;
-		dispatch.push.pitch_bytes      = static_cast<uint32_t>(pitch_bytes);
-		dispatch.push.slice_bytes      = static_cast<uint32_t>(slice_bytes);
-		dispatch.push.blocks_per_row   = static_cast<uint32_t>(columns);
-		dispatch.push.blocks_per_slice = static_cast<uint32_t>(blocks_per_slice);
-		dispatch.push.tail_x           = info.tail_x;
-		dispatch.push.tail_y           = info.tail_y;
-		dispatch.push.tail             = info.tail;
-		dispatches.push_back(dispatch);
-	}
-}
-
-void TileCompute::Destroy(Resources& target) const {
-	if (target.mapped != nullptr) {
-		graphics.UnmapMemory(target.staging.memory);
-	}
-	if (target.staging.buffer != nullptr) {
-		graphics.DeleteBuffer(target.staging);
-	}
-	if (target.linear.buffer != nullptr) {
-		graphics.DeleteBuffer(target.linear);
-	}
-	for (auto pipeline: target.pipelines) {
-		if (pipeline != nullptr) {
-			graphics.device.destroyPipeline(pipeline, nullptr);
-		}
-	}
-	if (target.descriptor_pool != nullptr) {
-		graphics.device.destroyDescriptorPool(target.descriptor_pool, nullptr);
-	}
-	if (target.pipeline_layout != nullptr) {
-		graphics.device.destroyPipelineLayout(target.pipeline_layout, nullptr);
-	}
-	if (target.descriptor_layout != nullptr) {
-		graphics.device.destroyDescriptorSetLayout(target.descriptor_layout, nullptr);
-	}
-	target = {};
-}
-
-void TileCompute::Init() {
-	if (resources.pipeline_layout != nullptr) {
-		return;
-	}
-	std::array<vk::DescriptorSetLayoutBinding, 2> bindings {};
-	for (uint32_t i = 0; i < bindings.size(); i++) {
-		bindings[i] = {i, vk::DescriptorType::eStorageBuffer, 1, vk::ShaderStageFlagBits::eCompute,
-		               nullptr};
-	}
-	vk::DescriptorSetLayoutCreateInfo descriptor_info {};
-	descriptor_info.sType        = vk::StructureType::eDescriptorSetLayoutCreateInfo;
-	descriptor_info.bindingCount = static_cast<uint32_t>(bindings.size());
-	descriptor_info.pBindings    = bindings.data();
-	RequireVulkanSuccess(graphics.device.createDescriptorSetLayout(&descriptor_info, nullptr,
-	                                                               &resources.descriptor_layout),
-	                     "create GPU tiler descriptor layout");
-
-	vk::PushConstantRange        push_range {vk::ShaderStageFlagBits::eCompute, 0, sizeof(Push)};
-	vk::PipelineLayoutCreateInfo layout_info {};
-	layout_info.sType                  = vk::StructureType::ePipelineLayoutCreateInfo;
-	layout_info.setLayoutCount         = 1;
-	layout_info.pSetLayouts            = &resources.descriptor_layout;
-	layout_info.pushConstantRangeCount = 1;
-	layout_info.pPushConstantRanges    = &push_range;
-	RequireVulkanSuccess(
-	    graphics.device.createPipelineLayout(&layout_info, nullptr, &resources.pipeline_layout),
-	    "create GPU tiler pipeline layout");
-	vk::DescriptorPoolSize       pool_size {vk::DescriptorType::eStorageBuffer, 2};
-	vk::DescriptorPoolCreateInfo pool_info {};
-	pool_info.sType         = vk::StructureType::eDescriptorPoolCreateInfo;
-	pool_info.maxSets       = 1;
-	pool_info.poolSizeCount = 1;
-	pool_info.pPoolSizes    = &pool_size;
-	RequireVulkanSuccess(
-	    graphics.device.createDescriptorPool(&pool_info, nullptr, &resources.descriptor_pool),
-	    "create GPU tiler descriptor pool");
-	vk::DescriptorSetAllocateInfo set_info {};
-	set_info.sType              = vk::StructureType::eDescriptorSetAllocateInfo;
-	set_info.descriptorPool     = resources.descriptor_pool;
-	set_info.descriptorSetCount = 1;
-	set_info.pSetLayouts        = &resources.descriptor_layout;
-	RequireVulkanSuccess(
-	    graphics.device.allocateDescriptorSets(&set_info, &resources.descriptor_set),
-	    "allocate GPU tiler descriptor set");
-}
-
-void TileCompute::CreatePipeline(uint32_t pipeline_slot) {
-	const uint32_t element_size_index     = pipeline_slot % BYTES_PER_ELEMENT_COUNT;
-	const uint32_t family_direction_index = pipeline_slot / BYTES_PER_ELEMENT_COUNT;
-	const uint32_t family_index           = family_direction_index % FAMILY_COUNT;
-	const uint32_t direction_index        = family_direction_index / FAMILY_COUNT;
-	const uint32_t specialization_values[] {1u << element_size_index, direction_index};
-	const vk::SpecializationMapEntry entries[] {{0, 0, 4}, {1, 4, 4}};
-	vk::SpecializationInfo           specialization {2, entries, sizeof(specialization_values),
-	                                                 specialization_values};
-	vk::ShaderModuleCreateInfo       module_info {};
-	module_info.sType       = vk::StructureType::eShaderModuleCreateInfo;
-	module_info.codeSize    = SHADERS[family_index].words * sizeof(uint32_t);
-	module_info.pCode       = SHADERS[family_index].code;
-	vk::ShaderModule module = nullptr;
-	RequireVulkanSuccess(graphics.device.createShaderModule(&module_info, nullptr, &module),
-	                     "create GPU tiler shader module");
-	vk::PipelineShaderStageCreateInfo stage {};
-	stage.sType               = vk::StructureType::ePipelineShaderStageCreateInfo;
-	stage.stage               = vk::ShaderStageFlagBits::eCompute;
-	stage.module              = module;
-	stage.pName               = "main";
-	stage.pSpecializationInfo = &specialization;
-	vk::ComputePipelineCreateInfo info {};
-	info.sType            = vk::StructureType::eComputePipelineCreateInfo;
-	info.stage            = stage;
-	info.layout           = resources.pipeline_layout;
-	vk::Pipeline pipeline = nullptr;
-	const auto   result =
-	    graphics.device.createComputePipelines(nullptr, 1, &info, nullptr, &pipeline);
-	graphics.device.destroyShaderModule(module, nullptr);
-	RequireVulkanSuccess(result, "create GPU tiler pipeline");
-	resources.pipelines[pipeline_slot] = pipeline;
-}
-
-void TileCompute::CreatePipelines(std::span<const Dispatch> dispatches) {
-	for (const auto& dispatch: dispatches) {
-		if (resources.pipelines[dispatch.pipeline_slot] == nullptr) {
-			CreatePipeline(dispatch.pipeline_slot);
-		}
-	}
-}
-
-void TileCompute::CreateBuffer(uint64_t size, bool mapped, VulkanBuffer& buffer,
-                               void** data) const {
-	buffer.usage = vk::BufferUsageFlagBits::eStorageBuffer | vk::BufferUsageFlagBits::eTransferSrc |
-	               vk::BufferUsageFlagBits::eTransferDst;
-	buffer.memory.property =
-	    mapped
-	        ? vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent
-	        : vk::MemoryPropertyFlags(vk::MemoryPropertyFlagBits::eDeviceLocal);
-	graphics.CreateBuffer(size, buffer);
-	if (mapped) graphics.MapMemory(buffer.memory, *data);
-}
-
-void TileCompute::Resize(uint64_t staging_size, uint64_t linear_size) {
-	if (resources.staging.buffer_size >= staging_size &&
-	    resources.linear.buffer_size >= linear_size) {
-		return;
-	}
-	staging_size = std::max(staging_size, resources.staging.buffer_size);
-	linear_size  = std::max(linear_size, resources.linear.buffer_size);
-	VulkanBuffer staging {}, linear {};
-	void*        mapped = nullptr;
-	CreateBuffer(staging_size, true, staging, &mapped);
-	CreateBuffer(linear_size, false, linear, nullptr);
-	if (resources.mapped != nullptr) graphics.UnmapMemory(resources.staging.memory);
-	if (resources.staging.buffer != nullptr) graphics.DeleteBuffer(resources.staging);
-	if (resources.linear.buffer != nullptr) graphics.DeleteBuffer(resources.linear);
-	resources.staging = staging;
-	resources.linear  = linear;
-	resources.mapped  = mapped;
-}
-
-void TileCompute::Execute(bool to_tiled, const void* input, void* output, uint64_t tiled_capacity,
-                          uint64_t linear_capacity, std::span<const Dispatch> dispatches,
-                          const GpuTileRecord& record) {
-	const uint64_t tiled_size  = AlignToDword(tiled_capacity);
-	const uint64_t linear_size = AlignToDword(linear_capacity);
-	const uint64_t input_size  = to_tiled ? linear_capacity : tiled_capacity;
-	if (input != nullptr) {
-		std::memcpy(resources.mapped, input, static_cast<size_t>(input_size));
-		std::memset(static_cast<uint8_t*>(resources.mapped) + input_size, 0,
-		            static_cast<size_t>(AlignToDword(input_size) - input_size));
-	}
-
-	std::array<vk::DescriptorBufferInfo, 2> buffer_info {{
-	    {to_tiled ? resources.linear.buffer : resources.staging.buffer, 0,
-	     to_tiled ? linear_size : tiled_size},
-	    {to_tiled ? resources.staging.buffer : resources.linear.buffer, 0,
-	     to_tiled ? tiled_size : linear_size},
-	}};
-	std::array<vk::WriteDescriptorSet, 2>   writes {};
-	for (uint32_t i = 0; i < writes.size(); i++) {
-		writes[i].sType           = vk::StructureType::eWriteDescriptorSet;
-		writes[i].dstSet          = resources.descriptor_set;
-		writes[i].dstBinding      = i;
-		writes[i].descriptorCount = 1;
-		writes[i].descriptorType  = vk::DescriptorType::eStorageBuffer;
-		writes[i].pBufferInfo     = &buffer_info[i];
-	}
-	graphics.device.updateDescriptorSets(static_cast<uint32_t>(writes.size()), writes.data(), 0,
-	                                     nullptr);
-
-	CommandBuffer command;
-	command.Begin();
-	auto vk_command = command.Handle();
-	if (input != nullptr) {
-		Barrier(vk_command, resources.staging.buffer, vk::AccessFlagBits::eHostWrite,
-		        vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eTransferRead,
-		        vk::PipelineStageFlagBits::eHost,
-		        vk::PipelineStageFlagBits::eComputeShader | vk::PipelineStageFlagBits::eTransfer);
-	}
-	if (to_tiled && input != nullptr) {
-		const vk::BufferCopy copy {0, 0, linear_size};
-		vk_command.copyBuffer(resources.staging.buffer, resources.linear.buffer, 1, &copy);
-		Barrier(vk_command, resources.linear.buffer, vk::AccessFlagBits::eTransferWrite,
-		        vk::AccessFlagBits::eShaderRead, vk::PipelineStageFlagBits::eTransfer,
-		        vk::PipelineStageFlagBits::eComputeShader);
-		Barrier(vk_command, resources.staging.buffer, vk::AccessFlagBits::eTransferRead,
-		        vk::AccessFlagBits::eTransferWrite, vk::PipelineStageFlagBits::eTransfer,
-		        vk::PipelineStageFlagBits::eTransfer);
-	}
-	if (to_tiled && record) {
-		record(command, resources.linear);
-		Barrier(vk_command, resources.linear.buffer,
-		        vk::AccessFlagBits::eTransferWrite | vk::AccessFlagBits::eMemoryWrite,
-		        vk::AccessFlagBits::eShaderRead, vk::PipelineStageFlagBits::eAllCommands,
-		        vk::PipelineStageFlagBits::eComputeShader);
-	}
-
-	const auto output_buffer = to_tiled ? resources.staging.buffer : resources.linear.buffer;
-	const auto output_size   = to_tiled ? tiled_size : linear_size;
-	vk_command.fillBuffer(output_buffer, 0, output_size, 0);
-	Barrier(vk_command, output_buffer, vk::AccessFlagBits::eTransferWrite,
-	        vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eShaderWrite,
-	        vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eComputeShader);
-	vk_command.bindDescriptorSets(vk::PipelineBindPoint::eCompute, resources.pipeline_layout, 0, 1,
-	                              &resources.descriptor_set, 0, nullptr);
-	const uint64_t limit =
-	    static_cast<uint64_t>(
-	        graphics.GetPhysicalDeviceProperties().limits.maxComputeWorkGroupCount[0]) *
-	    GROUP_SIZE;
-	for (const auto& dispatch: dispatches) {
-		vk_command.bindPipeline(vk::PipelineBindPoint::eCompute,
-		                        resources.pipelines[dispatch.pipeline_slot]);
-		for (uint32_t first = 0; first < dispatch.elements;) {
-			auto push  = dispatch.push;
-			push.first = first;
-			push.count =
-			    static_cast<uint32_t>(std::min<uint64_t>(dispatch.elements - first, limit));
-			vk_command.pushConstants(resources.pipeline_layout, vk::ShaderStageFlagBits::eCompute,
-			                         0, sizeof(push), &push);
-			vk_command.dispatch((push.count - 1u) / GROUP_SIZE + 1u, 1, 1);
-			first += push.count;
-		}
-	}
-	Barrier(vk_command, output_buffer, vk::AccessFlagBits::eShaderWrite,
-	        vk::AccessFlagBits::eTransferRead | vk::AccessFlagBits::eHostRead,
-	        vk::PipelineStageFlagBits::eComputeShader,
-	        vk::PipelineStageFlagBits::eTransfer | vk::PipelineStageFlagBits::eHost);
-	if (!to_tiled && record) {
-		record(command, resources.linear);
-	}
-	if (!to_tiled && output != nullptr) {
-		const vk::BufferCopy copy {0, 0, linear_size};
-		vk_command.copyBuffer(resources.linear.buffer, resources.staging.buffer, 1, &copy);
-		Barrier(vk_command, resources.staging.buffer, vk::AccessFlagBits::eTransferWrite,
-		        vk::AccessFlagBits::eHostRead, vk::PipelineStageFlagBits::eTransfer,
-		        vk::PipelineStageFlagBits::eHost);
-	}
-	command.End();
-	command.Execute();
-	command.WaitForFence();
-	if (output != nullptr) {
-		std::memcpy(output, resources.mapped,
-		            static_cast<size_t>(to_tiled ? tiled_capacity : linear_capacity));
-	}
-}
-
-void TileCompute::Run(bool to_tiled, const void* input, void* output, uint64_t tiled_capacity,
-                      uint64_t linear_capacity, std::span<const GpuTileInfo> infos,
-                      const GpuTileRecord& record) {
-	EXIT_IF((to_tiled && (output == nullptr || (input == nullptr && !record))) ||
-	        (!to_tiled && (input == nullptr || (output == nullptr && !record))));
-	std::vector<Dispatch> dispatches;
-	Prepare(to_tiled, tiled_capacity, linear_capacity, infos, dispatches);
-	Init();
-	CreatePipelines(dispatches);
-	const uint64_t staging_size =
-	    std::max(AlignToDword(tiled_capacity), AlignToDword(linear_capacity));
-	const uint64_t linear_size = AlignToDword(linear_capacity);
-	Resize(staging_size, linear_size);
-	Execute(to_tiled, input, output, tiled_capacity, linear_capacity, dispatches, record);
-}
-
-void TileCompute::Release() {
-	Destroy(resources);
-}
-
-} // namespace
-
-void GpuDetile(const void* tiled, void* linear, uint64_t tiled_capacity, uint64_t linear_capacity,
-               std::span<const GpuTileInfo> infos, const GpuTileRecord& after) {
-	Common::LockGuard lock(g_tiler_mutex);
-	if (!g_tiler) {
-		g_tiler = std::make_unique<TileCompute>(GetRenderContext().GetGraphics());
-	}
-	g_tiler->Run(false, tiled, linear, tiled_capacity, linear_capacity, infos, after);
-}
-
-void GpuTile(const void* linear, void* tiled, uint64_t tiled_capacity, uint64_t linear_capacity,
-             std::span<const GpuTileInfo> infos, const GpuTileRecord& before) {
-	Common::LockGuard lock(g_tiler_mutex);
-	if (!g_tiler) {
-		g_tiler = std::make_unique<TileCompute>(GetRenderContext().GetGraphics());
-	}
-	g_tiler->Run(true, linear, tiled, tiled_capacity, linear_capacity, infos, before);
-}
-
-void GpuTileRelease() {
-	Common::LockGuard lock(g_tiler_mutex);
-	if (g_tiler) {
-		g_tiler->Release();
-		g_tiler.reset();
-	}
-}
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/gpuTiler.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include "graphics/guest_gpu/tile.h"
-
-#include <cstdint>
-#include <functional>
-#include <span>
-
-namespace Libs::Graphics {
-
-struct GraphicContext;
-struct VulkanBuffer;
-class CommandBuffer;
-
-struct GpuTileInfo {
-	TileBlockFamily family              = TileBlockFamily::Count;
-	uint32_t        bytes_per_element   = 0;
-	uint64_t        linear_offset       = 0;
-	uint64_t        linear_size         = 0;
-	uint64_t        tiled_offset        = 0;
-	uint64_t        tiled_size          = 0;
-	uint64_t        linear_slice_stride = 0;
-	uint32_t        width               = 0;
-	uint32_t        height              = 0;
-	uint32_t        depth               = 1;
-	uint32_t        pitch               = 0;
-	uint32_t        tail_x              = 0;
-	uint32_t        tail_y              = 0;
-	bool            tail                = false;
-	uint32_t        tiled_width         = 0;
-	uint32_t        tiled_height        = 0;
-	uint32_t        surface_z           = 0;
-};
-
-using GpuTileRecord = std::function<void(CommandBuffer&, VulkanBuffer&)>;
-
-void GpuDetile(const void* tiled, void* linear, uint64_t tiled_capacity,
-               uint64_t linear_capacity, std::span<const GpuTileInfo> infos,
-               const GpuTileRecord& after = {});
-void GpuTile(const void* linear, void* tiled, uint64_t tiled_capacity,
-             uint64_t linear_capacity, std::span<const GpuTileInfo> infos,
-             const GpuTileRecord& before = {});
-void GpuTileRelease();
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/graphicContext.h

@@ -3,163 +3,140 @@
 
 #include "common/abi.h"
 #include "common/common.h"
+#include "common/threads.h"
 #include "graphics/host_gpu/vulkanCommon.h" // IWYU pragma: export
-#include "graphics/host_gpu/vulkanInstance.h"
 
-#include <memory>
+#include <map>
 #include <mutex>
+#include <tuple>
 #include <vector>
 #include <vk_mem_alloc.h>
 
 namespace Libs::Graphics {
 
-class CommandBuffer;
-struct VulkanBuffer;
 struct VulkanImage;
-struct VulkanMemory;
 
-struct VulkanSwapchain {
-	~VulkanSwapchain();
+inline constexpr uint32_t VULKAN_TARGET_API_VERSION = VK_API_VERSION_1_3;
 
-	vk::SwapchainKHR                 swapchain        = nullptr;
-	vk::Format                       swapchain_format = vk::Format::eUndefined;
-	vk::Extent2D                     swapchain_extent = {};
-	std::unique_ptr<vk::Image[]>     swapchain_images;
-	std::unique_ptr<vk::ImageView[]> swapchain_image_views;
-	uint32_t                         swapchain_images_count = 0;
-	std::unique_ptr<vk::Semaphore[]> image_acquired_semaphores;
-	std::unique_ptr<vk::Semaphore[]> render_complete_semaphores;
-	uint32_t                         current_index = 0;
-	uint32_t                         present_frame = 0;
-};
+struct GraphicContext {
+	vk::Instance                       instance                              = nullptr;
+	vk::DebugUtilsMessengerEXT         debug_messenger                       = nullptr;
+	vk::PhysicalDevice                 physical_device                       = nullptr;
+	vk::PhysicalDeviceProperties       physical_device_properties            = {};
+	vk::PhysicalDeviceMemoryProperties physical_device_memory_properties     = {};
+	vk::Device                         device                                = nullptr;
+	VmaAllocator                       allocator                             = nullptr;
+	bool                               memory_budget_ext_enabled             = false;
+	bool                               compute_subgroup_size_control_enabled = false;
+	bool                               sample_rate_shading_enabled           = false;
+	bool                               attachment_feedback_loop_enabled      = false;
+	bool                               provoking_vertex_last_enabled         = false;
+	bool                               supports_block_texel_view              = false;
+	bool                                      mesh_shader_enabled                   = false;
+	vk::PhysicalDeviceMeshShaderPropertiesEXT mesh_shader_properties                = {};
+	uint32_t                           subgroup_size                         = 0;
+	uint32_t                           min_subgroup_size                     = 0;
+	uint32_t                           max_subgroup_size                     = 0;
+	uint32_t                           max_push_descriptors                  = 0;
+	vk::ShaderStageFlags               required_subgroup_size_stages         = {};
+	Common::Mutex                      queue_mutex;
+	uint32_t                           queue_family = static_cast<uint32_t>(-1);
+	vk::Queue                          queue        = nullptr;
+
+	[[nodiscard]] const vk::PhysicalDeviceProperties& GetPhysicalDeviceProperties() const {
+		return physical_device_properties;
+	}
+
+	[[nodiscard]] const vk::PhysicalDeviceMemoryProperties&
+	GetPhysicalDeviceMemoryProperties() const {
+		return physical_device_memory_properties;
+	}
+
+	[[nodiscard]] vk::FormatProperties GetFormatProperties(vk::Format format) const {
+		std::scoped_lock lock(m_format_properties_mutex);
+		auto [it, inserted] = m_format_properties.try_emplace(format);
+		if (inserted) {
+			physical_device.getFormatProperties(format, &it->second);
+		}
+		return it->second;
+	}
+
+	[[nodiscard]] vk::Result GetImageFormatProperties(vk::Format format, vk::ImageType type,
+	                                                  vk::ImageTiling            tiling,
+	                                                  vk::ImageUsageFlags        usage,
+	                                                  vk::ImageCreateFlags       flags,
+	                                                  vk::ImageFormatProperties* properties) const {
+		using Key = std::tuple<vk::Format, vk::ImageType, vk::ImageTiling, vk::ImageUsageFlags,
+		                       vk::ImageCreateFlags>;
+		std::scoped_lock lock(m_image_format_properties_mutex);
+		auto [it, inserted] =
+		    m_image_format_properties.try_emplace(Key {format, type, tiling, usage, flags});
+		if (inserted) {
+			it->second.first = physical_device.getImageFormatProperties(format, type, tiling, usage,
+			                                                            flags, &it->second.second);
+		}
+		if (properties != nullptr) {
+			*properties = it->second.second;
+		}
+		return it->second.first;
+	}
+
+	[[nodiscard]] bool SupportsComputeWave64() const noexcept {
+		return subgroup_size == 64u || compute_subgroup_size_control_enabled;
+	}
+
+	[[nodiscard]] vk::DeviceSize StorageMinAlignment() const {
+		const auto alignment = physical_device_properties.limits.minStorageBufferOffsetAlignment;
+		return alignment != 0 ? alignment : 1;
+	}
 
-struct GraphicContext: public VulkanInstance {
 	[[nodiscard]] bool CreateAllocator();
 	void               DestroyAllocator();
 	void               LogMemoryBudget() const;
-	void               CreateBuffer(uint64_t size, VulkanBuffer& buffer);
-	void               DeleteBuffer(VulkanBuffer& buffer);
-	[[nodiscard]] bool CreateImage(const vk::ImageCreateInfo& info, VulkanImage& image);
-	void               DeleteImage(VulkanImage& image);
-	void               MapMemory(VulkanMemory& memory, void*& data);
-	void               UnmapMemory(VulkanMemory& memory);
-	void               AppendHardwareRayTracingDeviceExtensions(
-	    const std::vector<vk::ExtensionProperties>& available_extensions,
-	    std::vector<const char*>&                   device_extensions);
-	void LoadHardwareRayTracingFunctions() const;
+	[[nodiscard]] bool CanReportMemoryUsage() const noexcept { return memory_budget_ext_enabled; }
+	[[nodiscard]] uint64_t GetDeviceMemoryUsage() const;
+	[[nodiscard]] uint64_t GetTotalMemoryBudget() const;
+	[[nodiscard]] bool     CreateImage(const vk::ImageCreateInfo& info, VulkanImage& image);
+	void                   DeleteImage(VulkanImage& image);
 
 	uint32_t screen_width  = 0;
 	uint32_t screen_height = 0;
+
+private:
+	mutable std::mutex                                 m_format_properties_mutex;
+	mutable std::map<vk::Format, vk::FormatProperties> m_format_properties;
+	mutable std::mutex                                 m_image_format_properties_mutex;
+	mutable std::map<std::tuple<vk::Format, vk::ImageType, vk::ImageTiling, vk::ImageUsageFlags,
+	                            vk::ImageCreateFlags>,
+	                 std::pair<vk::Result, vk::ImageFormatProperties>>
+	    m_image_format_properties;
 };
 
-struct VulkanMemory {
-	vk::MemoryRequirements  requirements       = {};
-	vk::MemoryPropertyFlags property           = {};
-	vk::MemoryPropertyFlags preferred_property = {};
-	vk::DeviceMemory        memory             = nullptr;
-	VmaAllocation           allocation         = nullptr;
-	VmaAllocationInfo       allocation_info    = {};
-	vk::DeviceSize          offset             = 0;
-	uint32_t                type               = 0;
-	uint64_t                unique_id          = 0;
-};
-
-enum class VulkanImageType {
-	Unknown,
-	VideoOut,
-	DepthStencil,
-	Texture,
-	StorageTexture,
-	RenderTexture
-};
-
-struct ImageViewInfo {
-	vk::Format           format      = vk::Format::eUndefined;
-	vk::ImageViewType    type        = vk::ImageViewType::e2D;
-	vk::ImageAspectFlags aspect      = {};
-	uint32_t             base_level  = 0;
-	uint32_t             level_count = 0;
-	uint32_t             base_layer  = 0;
-	uint32_t             layer_count = 1;
-	uint32_t             swizzle     = 0;
-	vk::ImageUsageFlags  usage       = vk::ImageUsageFlagBits::eSampled;
-
-	bool operator==(const ImageViewInfo&) const = default;
-};
-
-struct CachedImageView {
-	ImageViewInfo info;
-	vk::ImageView view = nullptr;
-};
-
-struct ImageViewCache {
-	std::mutex                   mutex;
-	std::vector<CachedImageView> views;
-
-	ImageViewCache() = default;
-	KYTY_CLASS_NO_COPY(ImageViewCache);
+struct VulkanImageState {
+	vk::PipelineStageFlags2 pl_stage    = vk::PipelineStageFlagBits2::eAllCommands;
+	vk::AccessFlags2        access_mask = vk::AccessFlagBits2::eNone;
+	vk::ImageLayout         layout      = vk::ImageLayout::eUndefined;
 };
 
 struct VulkanImage {
-	static constexpr int VIEW_MAX           = 4;
-	static constexpr int VIEW_DEFAULT       = 0;
-	static constexpr int VIEW_DEFAULT_ARRAY = 1;
-	static constexpr int VIEW_STORAGE       = 2;
-	static constexpr int VIEW_STORAGE_ARRAY = 3;
-
-	explicit VulkanImage(VulkanImageType type): type(type) {}
+	VulkanImage() = default;
 	KYTY_CLASS_NO_COPY(VulkanImage);
 
-	VulkanImageType        type                 = VulkanImageType::Unknown;
-	vk::Format             format               = vk::Format::eUndefined;
-	vk::Extent2D           extent               = {};
-	uint32_t               guest_pitch          = 0;
-	uint32_t               layers               = 1;
-	uint32_t               mip_levels           = 1;
-	uint32_t               samples              = 1;
-	vk::Image              image                = nullptr;
-	vk::ImageView          image_view[VIEW_MAX] = {};
-	vk::ImageLayout        layout               = vk::ImageLayout::eUndefined;
-	Graphics::VulkanMemory memory;
-	ImageViewCache         view_cache;
+	vk::Format                    format      = vk::Format::eUndefined;
+	vk::ImageType                 image_type  = vk::ImageType::e2D;
+	vk::Extent3D                  extent      = {1, 1, 1};
+	uint32_t                      layers      = 1;
+	uint32_t                      mip_levels  = 1;
+	uint32_t                      samples     = 1;
+	vk::ImageUsageFlags           usage       = {};
+	vk::ImageCreateFlags          flags       = {};
+	vk::Image                     image       = nullptr;
+	VulkanImageState              state;
+	std::vector<VulkanImageState> subresource_states;
+	VmaAllocation                allocation = nullptr;
 };
 
-struct VideoOutVulkanImage: public VulkanImage {
-	VideoOutVulkanImage(): VulkanImage(VulkanImageType::VideoOut) {}
-};
 
-struct DepthStencilVulkanImage: public VulkanImage {
-	DepthStencilVulkanImage(): VulkanImage(VulkanImageType::DepthStencil) {}
-	bool compressed                    = false;
-	bool initial_depth_clear_pending   = false;
-	bool initial_stencil_clear_pending = false;
-};
-
-struct GpuTextureVulkanImage: public VulkanImage {
-	explicit GpuTextureVulkanImage(VulkanImageType type): VulkanImage(type) {}
-};
-
-struct TextureVulkanImage: public GpuTextureVulkanImage {
-	TextureVulkanImage(): GpuTextureVulkanImage(VulkanImageType::Texture) {}
-};
-
-struct StorageTextureVulkanImage: public GpuTextureVulkanImage {
-	StorageTextureVulkanImage(): GpuTextureVulkanImage(VulkanImageType::StorageTexture) {}
-};
-
-struct RenderTextureVulkanImage: public VulkanImage {
-	RenderTextureVulkanImage(): VulkanImage(VulkanImageType::RenderTexture) {}
-	bool initial_clear_pending = false;
-};
-
-struct VulkanBuffer {
-	vk::Buffer           buffer = nullptr;
-	VulkanMemory         memory;
-	vk::BufferUsageFlags usage       = {};
-	uint64_t             buffer_size = 0;
-};
-
-struct StorageVulkanBuffer: public VulkanBuffer {};
 
 } // namespace Libs::Graphics
 

src/graphics/host_gpu/hostMemory.cpp

@@ -30,7 +30,7 @@ bool IsAccessible(DWORD protect, HostMemoryAccess access) {
 } // namespace
 
 bool HostMemoryQueryRange(uint64_t addr, uint64_t requested_size, HostMemoryAccess access,
-	                      uint64_t& accessible_size) {
+                          uint64_t& accessible_size) {
 	accessible_size = 0;
 	if (addr == 0 || requested_size == 0) {
 		return false;

src/graphics/host_gpu/hostMemory.h

@@ -8,7 +8,7 @@ namespace Libs::Graphics {
 enum class HostMemoryAccess { Read, Mapped };
 
 bool HostMemoryQueryRange(uint64_t addr, uint64_t requested_size, HostMemoryAccess access,
-	                      uint64_t& accessible_size);
+                          uint64_t& accessible_size);
 bool HostMemoryQueryReadable(uint64_t addr, uint64_t requested_size, uint64_t& readable_size);
 bool HostMemoryIsReadable(uint64_t addr);
 bool HostMemoryRangeIsReadable(uint64_t addr, uint64_t size);

src/graphics/host_gpu/memoryTracker.cpp

@@ -1,39 +1,52 @@
 #include "graphics/host_gpu/memoryTracker.h"
 
+#include "common/alignment.h"
 #include "common/assert.h"
 
 namespace Libs::Graphics {
 
-#if defined(KYTY_MEMORY_TRACKER_TESTS)
-namespace {
-std::atomic<MemoryTracker::UnmapContentionHook> g_unmap_contention_hook {nullptr};
-}
-
-void MemoryTracker::SetUnmapContentionHook(UnmapContentionHook hook) noexcept {
-	g_unmap_contention_hook.store(hook, std::memory_order_release);
-}
-#endif
-
 static_assert(std::atomic<void*>::is_always_lock_free);
 
-MemoryTracker::MemoryTracker(PageManager& page_manager, PageWatchMode gpu_watch_mode)
-    : m_page_manager(page_manager), m_gpu_watch_mode(gpu_watch_mode) {
-	switch (m_gpu_watch_mode) {
-		case PageWatchMode::Write:
-		case PageWatchMode::ReadWrite: break;
-		default: EXIT("unsupported memory tracker GPU page-watch mode\n");
-	}
+MemoryTracker::MemoryTracker(PageManager& page_manager): m_page_manager(page_manager) {
 	m_regions = std::make_unique<std::atomic<RegionManager*>[]>(REGION_COUNT);
-	for (size_t i = 0; i < REGION_COUNT; i++) {
-		m_regions[i].store(nullptr, std::memory_order_relaxed);
-	}
 }
 
 MemoryTracker::~MemoryTracker() = default;
 
+#if KYTY_BUILD == KYTY_BUILD_DEBUG
+void MemoryTracker::ValidateGpuDirtyPages(const RangeSet& dirty, uint64_t vaddr, uint64_t size,
+                                          const char* operation) const noexcept {
+	if (!GuestRange {vaddr, size}.Valid() || (vaddr & (TRACKER_PAGE_SIZE - 1)) != 0 ||
+	    (size & (TRACKER_PAGE_SIZE - 1)) != 0) {
+		EXIT("MemoryTracker: invalid dirty-page validation range\n");
+	}
+	for (auto page = vaddr; page < vaddr + size; page += TRACKER_PAGE_SIZE) {
+		if (!dirty.Intersects(page, TRACKER_PAGE_SIZE)) {
+			EXIT("MemoryTracker: GPU-dirty tracker page has no dirty bytes, operation=%s "
+			     "addr=0x%016" PRIx64 "\n",
+			     operation, page);
+		}
+	}
+}
+
+void MemoryTracker::ValidateGpuDirtyOwnership(const RangeSet& dirty, uint64_t vaddr, uint64_t size,
+                                              const char* operation) {
+	ValidateRange(vaddr, size);
+	const auto begin = Common::AlignDown(vaddr, TRACKER_PAGE_SIZE);
+	const auto end   = Common::AlignUp(vaddr + size, TRACKER_PAGE_SIZE);
+	for (auto page = begin; page < end; page += TRACKER_PAGE_SIZE) {
+		const bool has_dirty_bytes = dirty.Intersects(page, TRACKER_PAGE_SIZE);
+		if (IsRegionGpuModified(page, TRACKER_PAGE_SIZE) != has_dirty_bytes) {
+			EXIT("MemoryTracker: tracker and byte ownership disagree, operation=%s "
+			     "addr=0x%016" PRIx64 "\n",
+			     operation, page);
+		}
+	}
+}
+#endif
+
 void MemoryTracker::ValidateRange(uint64_t vaddr, uint64_t size) {
-	if (vaddr == 0 || size == 0 || vaddr >= TRACKER_ADDRESS_SIZE ||
-	    size > TRACKER_ADDRESS_SIZE - vaddr) {
+	if (!GuestRange {vaddr, size}.Valid()) {
 		EXIT("invalid memory tracker range\n");
 	}
 }
@@ -55,8 +68,6 @@ RegionManager* MemoryTracker::GetOrCreateRegion(uint64_t index) {
 
 bool MemoryTracker::IsRegionCpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
-	std::lock_guard access(m_access_mutex);
-	RequireMapped(vaddr, size);
 	return Iterate<true>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
 		return manager->IsModified<DirtySource::Cpu>(offset, bytes);
@@ -65,8 +76,6 @@ bool MemoryTracker::IsRegionCpuModified(uint64_t vaddr, uint64_t size) {
 
 bool MemoryTracker::IsRegionGpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
-	std::lock_guard access(m_access_mutex);
-	RequireMapped(vaddr, size);
 	return Iterate<false>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
 		return manager->IsModified<DirtySource::Gpu>(offset, bytes);
@@ -75,46 +84,30 @@ bool MemoryTracker::IsRegionGpuModified(uint64_t vaddr, uint64_t size) {
 
 void MemoryTracker::MarkRegionAsCpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
-	std::lock_guard access(m_access_mutex);
-	RequireMapped(vaddr, size);
 	Iterate<true>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
-		const auto       changed =
-		    manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
-		manager->ApplyProtection(changed, false);
+		manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
 	});
 }
 
 void MemoryTracker::MarkRegionAsGpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
-	std::lock_guard access(m_access_mutex);
-	RequireMapped(vaddr, size);
-	Iterate<true>(vaddr, size, [this](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+	Iterate<true>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
-		const auto       changed =
-		    manager->ChangeState<DirtySource::Gpu, true>(manager->GetCpuAddr() + offset, bytes);
-		manager->ApplyGpuProtection(changed, true, m_gpu_watch_mode);
+		manager->ChangeState<DirtySource::Gpu, true>(manager->GetCpuAddr() + offset, bytes);
 	});
 }
 
 void MemoryTracker::UnmarkRegionAsGpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
-	std::lock_guard access(m_access_mutex);
-	RequireMapped(vaddr, size);
-	Iterate<true>(vaddr, size, [this](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+	Iterate<false>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
-		if (!manager->IsFullyModified<DirtySource::Gpu>(offset, bytes)) {
-			EXIT("cannot clear partially GPU-dirty tracking range\n");
-		}
-		const auto changed =
-		    manager->ChangeState<DirtySource::Gpu, false>(manager->GetCpuAddr() + offset, bytes);
-		manager->ApplyGpuProtection(changed, false, m_gpu_watch_mode);
+		manager->ChangeState<DirtySource::Gpu, false>(manager->GetCpuAddr() + offset, bytes);
 	});
 }
 
-void MemoryTracker::UntrackMemoryLocked(uint64_t vaddr, uint64_t size) {
-	RequireMapped(vaddr, size);
-
+void MemoryTracker::UntrackMemory(uint64_t vaddr, uint64_t size) {
+	CheckNotInUploadCallback();
 	std::vector<RegionManager*> managers;
 	managers.reserve((vaddr % TRACKER_REGION_SIZE + size + TRACKER_REGION_SIZE - 1) /
 	                 TRACKER_REGION_SIZE);
@@ -133,123 +126,8 @@ void MemoryTracker::UntrackMemoryLocked(uint64_t vaddr, uint64_t size) {
 		EXIT("cannot untrack GPU-dirty memory\n");
 	}
 	Iterate<false>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-		const auto changed =
-		    manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
-		manager->ApplyProtection(changed, false);
-		manager->Untrack(manager->GetCpuAddr() + offset, bytes);
+		manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
 	});
-	locks.clear();
-}
-
-void MemoryTracker::UntrackMemory(uint64_t vaddr, uint64_t size) {
-	CheckNotInUploadCallback();
-	std::lock_guard access(m_access_mutex);
-	UntrackMemoryLocked(vaddr, size);
-}
-
-void MemoryTracker::UnmapMemory(uint64_t vaddr, uint64_t size) {
-	CheckNotInUploadCallback();
-	std::unique_lock access(m_access_mutex, std::try_to_lock);
-	if (!access.owns_lock()) {
-#if defined(KYTY_MEMORY_TRACKER_TESTS)
-		if (const auto hook = g_unmap_contention_hook.load(std::memory_order_acquire);
-		    hook != nullptr) {
-			hook();
-		}
-#endif
-		access.lock();
-	}
-	UntrackMemoryLocked(vaddr, size);
-	m_page_manager.OnGpuUnmap(vaddr, size);
-}
-
-bool MemoryTracker::InvalidateRegion(uint64_t vaddr, uint64_t size, PageFaultPhase phase) noexcept {
-	switch (phase) {
-		case PageFaultPhase::Release: return true;
-		case PageFaultPhase::Invalidate: {
-			const auto action = BeginCpuFault(vaddr, size);
-			switch (action) {
-				case CpuFaultAction::Untracked: return false;
-				case CpuFaultAction::Continue: return true;
-				case CpuFaultAction::Download:
-					EXIT("generic region invalidation cannot download GPU-dirty memory\n");
-			}
-		}
-		case PageFaultPhase::Complete:
-			return CompleteCpuFault(vaddr, size, PageFaultAccess::Write, false);
-	}
-	EXIT("unsupported region invalidation phase\n");
-}
-
-bool MemoryTracker::InvalidateVirtualGpuWrite(PageFaultAccess access, uint64_t vaddr, uint64_t size,
-                                              PageFaultPhase phase) noexcept {
-	switch (phase) {
-		case PageFaultPhase::Release: return true;
-		case PageFaultPhase::Invalidate: {
-			const bool gpu_modified = Iterate<false>(
-			    vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-				    std::scoped_lock lock(manager->lock);
-				    return manager->IsModified<DirtySource::Gpu>(offset, bytes);
-			    });
-			if (!gpu_modified) {
-				return false;
-			}
-			const auto action = BeginCpuFault(vaddr, size);
-			if (access != PageFaultAccess::Write || action != CpuFaultAction::Download) {
-				EXIT("virtual GPU write fault requires write access to GPU-dirty memory\n");
-			}
-			return true;
-		}
-		case PageFaultPhase::Complete: {
-			if (access != PageFaultAccess::Write) {
-				EXIT("virtual GPU write completion requires write access\n");
-			}
-			bool completed = false;
-			Iterate<false>(
-			    vaddr, size, [&completed](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-				    std::scoped_lock lock(manager->lock);
-				    if (completed) {
-					    EXIT("virtual GPU write fault spans multiple tracked regions\n");
-				    }
-				    completed =
-				        manager->CompleteVirtualGpuWrite(manager->GetCpuAddr() + offset, bytes);
-			    });
-			return completed;
-		}
-	}
-	EXIT("unsupported virtual GPU write invalidation phase\n");
-}
-
-CpuFaultAction MemoryTracker::BeginCpuFault(uint64_t vaddr, uint64_t size,
-                                            PageFaultAccess access) noexcept {
-	CheckNotInUploadCallback();
-	CpuFaultAction action = CpuFaultAction::Untracked;
-	Iterate<false>(
-	    vaddr, size, [&action, access](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-		    std::scoped_lock lock(manager->lock);
-		    if (action != CpuFaultAction::Untracked) {
-			    EXIT("CPU fault spans multiple tracked regions\n");
-		    }
-		    action = manager->BeginCpuFault(manager->GetCpuAddr() + offset, bytes, access);
-	    });
-	return action;
-}
-
-bool MemoryTracker::CompleteCpuFault(uint64_t vaddr, uint64_t size, PageFaultAccess access,
-                                     bool downloaded) noexcept {
-	CheckNotInUploadCallback();
-	bool found = false;
-	Iterate<false>(
-	    vaddr, size,
-	    [&found, access, downloaded](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-		    std::scoped_lock lock(manager->lock);
-		    if (found) {
-			    EXIT("CPU fault completion spans multiple tracked regions\n");
-		    }
-		    found = manager->CompleteCpuFault(manager->GetCpuAddr() + offset, bytes, access,
-		                                      downloaded);
-	    });
-	return found;
 }
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/memoryTracker.h

@@ -3,6 +3,7 @@
 
 #include "common/assert.h"
 #include "graphics/host_gpu/pageManager.h"
+#include "graphics/host_gpu/rangeSet.h"
 #include "graphics/host_gpu/regionManager.h"
 
 #include <algorithm>
@@ -10,14 +11,14 @@
 #include <memory>
 #include <mutex>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 namespace Libs::Graphics {
 
 class MemoryTracker final {
 public:
-	explicit MemoryTracker(PageManager&  page_manager,
-	                       PageWatchMode gpu_watch_mode = PageWatchMode::ReadWrite);
+	explicit MemoryTracker(PageManager& page_manager);
 	~MemoryTracker();
 
 	KYTY_CLASS_NO_COPY(MemoryTracker);
@@ -28,81 +29,63 @@ public:
 	void               MarkRegionAsGpuModified(uint64_t vaddr, uint64_t size);
 	void               UnmarkRegionAsGpuModified(uint64_t vaddr, uint64_t size);
 	void               UntrackMemory(uint64_t vaddr, uint64_t size);
-	void               UnmapMemory(uint64_t vaddr, uint64_t size);
-	[[nodiscard]] CpuFaultAction
-	                   BeginCpuFault(uint64_t vaddr, uint64_t size,
-	                                 PageFaultAccess access = PageFaultAccess::Write) noexcept;
-	[[nodiscard]] bool CompleteCpuFault(uint64_t vaddr, uint64_t size, PageFaultAccess access,
-	                                    bool downloaded) noexcept;
-	[[nodiscard]] bool InvalidateRegion(uint64_t vaddr, uint64_t size,
-	                                    PageFaultPhase phase) noexcept;
-	[[nodiscard]] bool InvalidateVirtualGpuWrite(PageFaultAccess access, uint64_t vaddr,
-	                                             uint64_t size, PageFaultPhase phase) noexcept;
-
-	template <bool clear, typename Preflight, typename Func>
-	void ForEachDownloadRange(uint64_t vaddr, uint64_t size, Preflight&& preflight, Func&& func) {
-		static_assert(std::is_nothrow_invocable_v<Preflight&, uint64_t, uint64_t>);
-		static_assert(std::is_nothrow_invocable_v<Func&, uint64_t, uint64_t>);
+	// Removes protection from a range and flushes GPU-owned data when required.
+	template <typename Flush>
+	void InvalidateRegion(uint64_t vaddr, uint64_t size, Flush&& on_flush) noexcept {
+		static_assert(std::is_invocable_v<Flush&>);
 		CheckNotInUploadCallback();
-		std::lock_guard access(m_access_mutex);
-		RequireMapped(vaddr, size);
-		std::vector<RegionManager*> managers;
-		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t, uint64_t) {
-			managers.push_back(manager);
-		});
-		std::vector<std::unique_lock<TrackingSpinLock>> locks;
-		locks.reserve(managers.size());
-		for (auto* manager: managers) {
-			locks.emplace_back(manager->lock);
-		}
+
 		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-			const auto address = manager->GetCpuAddr() + offset;
-			if (manager->HasPendingFault(address, bytes)) {
-				EXIT("GPU download synchronization raced a pending CPU fault\n");
+			const bool should_flush = [&] {
+				// Perform both the GPU modification check and CPU state change with the lock in
+				// case the GPU thread is racing to mark the page modified. If a flush is needed,
+				// on_flush performs the CPU state change.
+				std::scoped_lock lock(manager->lock);
+				if (manager->IsModified<DirtySource::Gpu>(offset, bytes)) {
+					return true;
+				}
+				manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
+				return false;
+			}();
+			if (should_flush) {
+				on_flush();
 			}
-			manager->template ForEachModifiedRange<DirtySource::Gpu, false>(address, bytes,
-			                                                                preflight);
 		});
-		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-			manager->template ForEachModifiedRange<DirtySource::Gpu, false>(
-			    manager->GetCpuAddr() + offset, bytes, func);
-		});
-		if constexpr (clear) {
-			Iterate<false>(vaddr, size,
-			               [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-				               const auto address = manager->GetCpuAddr() + offset;
-				               const auto changed =
-				                   manager->template ForEachModifiedRange<DirtySource::Gpu, true>(
-				                       address, bytes, [](uint64_t, uint64_t) noexcept {});
-				               manager->ApplyGpuProtection(changed, false, m_gpu_watch_mode);
-			               });
-		}
 	}
+#if KYTY_BUILD == KYTY_BUILD_DEBUG
+	void ValidateGpuDirtyPages(const RangeSet& dirty, uint64_t vaddr, uint64_t size,
+	                           const char* operation) const noexcept;
+	void ValidateGpuDirtyOwnership(const RangeSet& dirty, uint64_t vaddr, uint64_t size,
+	                               const char* operation);
+#else
+	void ValidateGpuDirtyPages(const RangeSet&, uint64_t, uint64_t, const char*) const noexcept {}
+	void ValidateGpuDirtyOwnership(const RangeSet&, uint64_t, uint64_t, const char*) {}
+#endif
 
 	template <bool clear, typename Func>
 	void ForEachDownloadRange(uint64_t vaddr, uint64_t size, Func&& func) {
-		ForEachDownloadRange<clear>(
-		    vaddr, size, [](uint64_t, uint64_t) noexcept {}, std::forward<Func>(func));
+		static_assert(std::is_nothrow_invocable_v<Func&, uint64_t, uint64_t>);
+		CheckNotInUploadCallback();
+		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+			std::scoped_lock lock(manager->lock);
+			const auto       address = manager->GetCpuAddr() + offset;
+			manager->template ForEachModifiedRange<DirtySource::Gpu, false>(address, bytes, func);
+			if constexpr (clear) {
+				manager->template ChangeState<DirtySource::Gpu, false>(address, bytes);
+			}
+		});
 	}
 
-#if defined(KYTY_MEMORY_TRACKER_TESTS)
-	using UnmapContentionHook = void (*)() noexcept;
-	static void SetUnmapContentionHook(UnmapContentionHook hook) noexcept;
-#endif
-
 	template <typename RangeFunc, typename UploadFunc>
 	void ForEachUploadRange(uint64_t vaddr, uint64_t size, bool is_written, RangeFunc&& range_func,
 	                        UploadFunc&& upload_func) {
 		static_assert(std::is_nothrow_invocable_v<RangeFunc&, uint64_t, uint64_t>);
 		static_assert(std::is_nothrow_invocable_v<UploadFunc&>);
 		CheckNotInUploadCallback();
-		std::unique_lock access(m_access_mutex);
-		RequireMapped(vaddr, size);
 		Iterate<true>(vaddr, size, [](RegionManager*, uint64_t, uint64_t) {});
-		s_upload_owner = this;
+		const auto* previous_upload_owner = std::exchange(s_upload_owner, this);
 		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 			manager->lock.lock();
-			manager->Track(manager->GetCpuAddr() + offset, bytes);
 			manager->ForEachModifiedRange<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset,
 			                                                      bytes, range_func);
 			if (!is_written) {
@@ -111,23 +94,22 @@ public:
 		});
 		upload_func();
 		if (is_written) {
-			Iterate<false>(
-			    vaddr, size, [this](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-				    const auto changed = manager->template ChangeState<DirtySource::Gpu, true>(
-				        manager->GetCpuAddr() + offset, bytes);
-				    manager->ApplyGpuProtection(changed, true, m_gpu_watch_mode);
-				    manager->lock.unlock();
-			    });
+			Iterate<false>(vaddr, size,
+			               [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+				               manager->template ChangeState<DirtySource::Gpu, true>(
+				                   manager->GetCpuAddr() + offset, bytes);
+				               manager->lock.unlock();
+			               });
 		}
-		s_upload_owner = nullptr;
+		s_upload_owner = previous_upload_owner;
 	}
 
 private:
 	static constexpr size_t REGION_COUNT = TRACKER_ADDRESS_SIZE / TRACKER_REGION_SIZE;
 	inline static thread_local const MemoryTracker* s_upload_owner = nullptr;
 
-	static void CheckNotInUploadCallback() noexcept {
-		if (s_upload_owner != nullptr) {
+	void CheckNotInUploadCallback() const noexcept {
+		if (s_upload_owner == this) {
 			EXIT("memory tracker re-entered from upload callback\n");
 		}
 	}
@@ -162,22 +144,13 @@ private:
 		return false;
 	}
 
-	static void ValidateRange(uint64_t vaddr, uint64_t size);
-	void        UntrackMemoryLocked(uint64_t vaddr, uint64_t size);
-	void        RequireMapped(uint64_t vaddr, uint64_t size) const {
-		ValidateRange(vaddr, size);
-		if (!m_page_manager.IsMapped(vaddr, size)) {
-			EXIT("memory tracker range is not mapped\n");
-		}
-	}
+	static void    ValidateRange(uint64_t vaddr, uint64_t size);
 	RegionManager* GetOrCreateRegion(uint64_t index);
 
 	std::unique_ptr<std::atomic<RegionManager*>[]> m_regions;
 	std::vector<std::unique_ptr<RegionManager>>    m_region_storage;
 	std::mutex                                     m_region_mutex;
-	std::mutex                                     m_access_mutex;
 	PageManager&                                   m_page_manager;
-	PageWatchMode                                  m_gpu_watch_mode = PageWatchMode::ReadWrite;
 };
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/objects/label.cpp

@@ -1,348 +0,0 @@
-#include "graphics/host_gpu/objects/label.h"
-
-#include "common/assert.h"
-#include "common/threads.h"
-#include "graphics/host_gpu/graphicContext.h"
-#include "graphics/host_gpu/renderer/render.h"
-#include "graphics/host_gpu/renderer/renderContext.h"
-#include "graphics/host_gpu/vulkanCommon.h"
-
-#include <algorithm>
-#include <memory>
-#include <vector>
-
-namespace Libs::Graphics {
-
-enum LabelStatus {
-	New,
-	Active,
-	ActiveDeleted,
-	NotActive,
-};
-
-struct LabelCallbacks {
-	LabelCallback callback_1           = nullptr;
-	LabelCallback callback_2           = nullptr;
-	uint64_t      args[LABEL_ARGS_MAX] = {};
-};
-
-struct LabelEvent final {
-	vk::Device device = nullptr;
-	vk::Event  event  = nullptr;
-
-	~LabelEvent() {
-		if (event != nullptr) {
-			device.destroyEvent(event, nullptr);
-		}
-	}
-};
-
-struct LabelSubmission {
-	std::shared_ptr<LabelEvent> completion;
-	LabelCallbacks              callbacks;
-};
-
-struct Label {
-	vk::Device                   device = nullptr;
-	LabelStatus                  status = LabelStatus::New;
-	LabelCallbacks               callbacks;
-	std::vector<LabelSubmission> submissions;
-};
-
-class LabelManager {
-public:
-	LabelManager() {
-		EXIT_NOT_IMPLEMENTED(!Common::Thread::IsMainThread());
-		Common::Thread t(ThreadRun, this);
-		t.Detach();
-	}
-	~LabelManager() { KYTY_NOT_IMPLEMENTED; }
-	KYTY_CLASS_NO_COPY(LabelManager);
-
-	Label* Create(LabelCallback callback_1, LabelCallback callback_2, const uint64_t* args);
-	void   Delete(Label& label);
-	void   Set(CommandBuffer& buffer, Label& label);
-	void   Drain();
-
-private:
-	static void ThreadRun(void* data);
-
-	bool        Remove(Label& label);
-	static void Destroy(Label& label);
-
-	Common::Mutex       m_mutex;
-	Common::CondVar     m_cond_var;
-	std::vector<Label*> m_labels;
-	uint64_t            m_callbacks_in_flight = 0;
-};
-
-static LabelManager*     g_label_manager     = nullptr;
-static thread_local bool g_in_label_callback = false;
-
-class LabelCallbackScope final {
-public:
-	LabelCallbackScope() {
-		if (g_in_label_callback) {
-			EXIT("recursive GPU label callback\n");
-		}
-		g_in_label_callback = true;
-	}
-	~LabelCallbackScope() {
-		if (!g_in_label_callback) {
-			EXIT("GPU label callback scope is not active\n");
-		}
-		g_in_label_callback = false;
-	}
-};
-
-void LabelManager::ThreadRun(void* data) {
-	auto* manager = static_cast<LabelManager*>(data);
-
-	for (;;) {
-		manager->m_mutex.Lock();
-
-		uint64_t active_count = 0;
-
-		std::vector<Label*>          deleted_labels;
-		std::vector<LabelCallbacks>  fired_labels;
-		std::vector<LabelSubmission> finished_submissions;
-		deleted_labels.reserve(manager->m_labels.size());
-
-		for (auto& label: manager->m_labels) {
-			for (auto it = label->submissions.begin(); it != label->submissions.end();) {
-				active_count++;
-
-				if (it->completion == nullptr || it->completion->device == nullptr ||
-				    it->completion->event == nullptr) {
-					EXIT("GPU label submission has no completion event\n");
-				}
-				const auto status = it->completion->device.getEventStatus(it->completion->event);
-				switch (status) {
-					case vk::Result::eEventSet:
-						fired_labels.push_back(it->callbacks);
-						finished_submissions.push_back(*it);
-						it = label->submissions.erase(it);
-						break;
-					case vk::Result::eEventReset: ++it; break;
-					default: EXIT("vkGetEventStatus returned an unexpected result\n");
-				}
-			}
-
-			if (label->submissions.empty()) {
-				switch (label->status) {
-					case LabelStatus::ActiveDeleted: deleted_labels.push_back(label); break;
-					case LabelStatus::Active: label->status = LabelStatus::NotActive; break;
-					default: break;
-				}
-			}
-		}
-
-		if (active_count == 0) {
-			manager->m_cond_var.Wait(&manager->m_mutex);
-		}
-		if (fired_labels.size() > UINT64_MAX - manager->m_callbacks_in_flight) {
-			EXIT("GPU label callback count overflow\n");
-		}
-		manager->m_callbacks_in_flight += fired_labels.size();
-
-		for (auto& label: deleted_labels) {
-			bool removed = manager->Remove(*label);
-			EXIT_NOT_IMPLEMENTED(!removed);
-		}
-
-		manager->m_mutex.Unlock();
-
-		// Each completion event is shared with the recording command buffer's fence retainer.
-		// The event is destroyed only after both the label thread observed it and that command
-		// buffer completed, even when either side wins the race.
-		(void)finished_submissions;
-
-		for (auto& label: deleted_labels) {
-			Destroy(*label);
-		}
-
-		for (auto& label: fired_labels) {
-			LabelCallbackScope callback_scope;
-
-			if (label.callback_1 != nullptr) {
-				(void)label.callback_1(label.args);
-			}
-
-			if (label.callback_2 != nullptr) {
-				label.callback_2(label.args);
-			}
-		}
-
-		if (!fired_labels.empty()) {
-			Common::LockGuard lock(manager->m_mutex);
-			if (manager->m_callbacks_in_flight < fired_labels.size()) {
-				EXIT("GPU label callback count underflow\n");
-			}
-			manager->m_callbacks_in_flight -= fired_labels.size();
-			manager->m_cond_var.SignalAll();
-		}
-
-		Common::Thread::SleepMicro(100);
-	}
-}
-
-Label* LabelManager::Create(LabelCallback callback_1, LabelCallback callback_2,
-                            const uint64_t* args) {
-	Common::LockGuard lock(m_mutex);
-
-	auto* label = new Label;
-
-	label->status               = LabelStatus::New;
-	label->device               = GetRenderContext().GetGraphics().device;
-	label->callbacks.callback_1 = callback_1;
-	label->callbacks.callback_2 = callback_2;
-
-	if (args != nullptr) {
-		for (int i = 0; i < LABEL_ARGS_MAX; i++) {
-			label->callbacks.args[i] = args[i];
-		}
-	}
-
-	m_labels.push_back(label);
-
-	return label;
-}
-
-bool LabelManager::Remove(Label& label) {
-	EXIT_IF(label.device == nullptr);
-
-	Common::LockGuard lock(m_mutex);
-
-	const auto it = std::find(m_labels.begin(), m_labels.end(), &label);
-	EXIT_NOT_IMPLEMENTED(it == m_labels.end());
-
-	EXIT_NOT_IMPLEMENTED(label.status != LabelStatus::NotActive &&
-	                     label.status != LabelStatus::Active &&
-	                     label.status != LabelStatus::ActiveDeleted);
-
-	if (!label.submissions.empty()) {
-		label.status = LabelStatus::ActiveDeleted;
-
-		return false;
-	}
-
-	m_labels.erase(it);
-
-	return true;
-}
-
-void LabelManager::Destroy(Label& label) {
-	EXIT_IF(label.device == nullptr);
-
-	EXIT_NOT_IMPLEMENTED(!label.submissions.empty());
-
-	delete &label;
-}
-
-void LabelManager::Delete(Label& label) {
-	if (Remove(label)) {
-		Destroy(label);
-	}
-}
-
-void LabelManager::Set(CommandBuffer& buffer, Label& label) {
-	EXIT_IF(buffer.IsInvalid());
-	EXIT_IF(label.device == nullptr);
-
-	Common::LockGuard lock(m_mutex);
-
-	const auto it = std::find(m_labels.begin(), m_labels.end(), &label);
-	EXIT_NOT_IMPLEMENTED(it == m_labels.end());
-
-	EXIT_NOT_IMPLEMENTED(label.status != LabelStatus::New &&
-	                     label.status != LabelStatus::NotActive &&
-	                     label.status != LabelStatus::Active);
-
-	label.status = LabelStatus::Active;
-
-	LabelSubmission submission {};
-	submission.callbacks          = label.callbacks;
-	submission.completion         = std::make_shared<LabelEvent>();
-	submission.completion->device = label.device;
-
-	auto vk_buffer = buffer.Handle();
-
-	EXIT_NOT_IMPLEMENTED(vk_buffer == nullptr);
-
-	vk::EventCreateInfo create_info {};
-	create_info.sType = vk::StructureType::eEventCreateInfo;
-	create_info.pNext = nullptr;
-	create_info.flags = {};
-
-	const auto create_result =
-	    label.device.createEvent(&create_info, nullptr, &submission.completion->event);
-	if (create_result != vk::Result::eSuccess || submission.completion->event == nullptr) {
-		EXIT("failed to create label event: %s (%d)\n", VulkanToString(create_result).c_str(),
-		     static_cast<int>(create_result));
-	}
-	buffer.RetainResourceUntilFence(submission.completion);
-
-	// Labels can be reused before an earlier end-of-pipe event has been
-	// observed by the polling thread. Capture a separate Vulkan event and
-	// callback snapshot for each set so older writes are not lost.
-	const auto reset_result = label.device.resetEvent(submission.completion->event);
-	if (reset_result != vk::Result::eSuccess) {
-		EXIT("failed to reset label event: %s (%d)\n", VulkanToString(reset_result).c_str(),
-		     static_cast<int>(reset_result));
-	}
-	vk_buffer.setEvent(submission.completion->event, vk::PipelineStageFlagBits::eBottomOfPipe);
-
-	label.submissions.push_back(submission);
-
-	m_cond_var.SignalAll();
-}
-
-void LabelManager::Drain() {
-	m_mutex.Lock();
-	for (;;) {
-		const bool pending = std::any_of(m_labels.begin(), m_labels.end(), [](const Label* label) {
-			return !label->submissions.empty();
-		});
-		if (!pending && m_callbacks_in_flight == 0) {
-			m_mutex.Unlock();
-			return;
-		}
-		m_cond_var.SignalAll();
-		m_cond_var.Wait(&m_mutex);
-	}
-}
-
-void LabelInit() {
-	EXIT_IF(g_label_manager != nullptr);
-
-	g_label_manager = new LabelManager;
-}
-
-Label* LabelCreate(LabelCallback callback_1, LabelCallback callback_2, const uint64_t* args) {
-	EXIT_IF(g_label_manager == nullptr);
-
-	return g_label_manager->Create(callback_1, callback_2, args);
-}
-
-void LabelDelete(Label& label) {
-	EXIT_IF(g_label_manager == nullptr);
-
-	g_label_manager->Delete(label);
-}
-
-void LabelSet(CommandBuffer& buffer, Label& label) {
-	EXIT_IF(g_label_manager == nullptr);
-
-	g_label_manager->Set(buffer, label);
-}
-
-void LabelDrain() {
-	EXIT_IF(g_label_manager == nullptr);
-	g_label_manager->Drain();
-}
-
-bool LabelInCallback() noexcept {
-	return g_in_label_callback;
-}
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/objects/label.h

@@ -1,26 +0,0 @@
-#ifndef EMULATOR_INCLUDE_EMULATOR_GRAPHICS_OBJECTS_LABEL_H_
-#define EMULATOR_INCLUDE_EMULATOR_GRAPHICS_OBJECTS_LABEL_H_
-
-#include "common/abi.h"
-#include "common/common.h"
-
-namespace Libs::Graphics {
-
-struct Label;
-class CommandBuffer;
-struct GraphicContext;
-
-void LabelInit();
-
-constexpr int LABEL_ARGS_MAX = 5;
-using LabelCallback          = bool (*)(const uint64_t* args);
-
-Label* LabelCreate(LabelCallback callback_1, LabelCallback callback_2, const uint64_t* args);
-void   LabelDelete(Label& label);
-void   LabelSet(CommandBuffer& buffer, Label& label);
-void   LabelDrain();
-[[nodiscard]] bool LabelInCallback() noexcept;
-
-} // namespace Libs::Graphics
-
-#endif /* EMULATOR_INCLUDE_EMULATOR_GRAPHICS_OBJECTS_LABEL_H_ */

src/graphics/host_gpu/objects/textureCommon.h

@@ -1,137 +0,0 @@
-#ifndef EMULATOR_INCLUDE_EMULATOR_GRAPHICS_OBJECTS_TEXTURECOMMON_H_
-#define EMULATOR_INCLUDE_EMULATOR_GRAPHICS_OBJECTS_TEXTURECOMMON_H_
-
-#include "common/abi.h"
-#include "common/common.h"
-#include "graphics/guest_gpu/gpu_defs.h"
-#include "graphics/guest_gpu/tile.h"
-#include "graphics/host_gpu/transfer.h"
-#include "graphics/host_gpu/vulkanCommon.h"
-
-#include <vector>
-
-namespace Libs::Graphics {
-
-struct GraphicContext;
-struct VulkanImage;
-
-enum class TextureFormatUsage : uint32_t {
-	None    = 0,
-	Sampled = 1u << 0u,
-	Storage = 1u << 1u,
-};
-
-constexpr TextureFormatUsage operator|(TextureFormatUsage lhs, TextureFormatUsage rhs) {
-	return static_cast<TextureFormatUsage>(static_cast<uint32_t>(lhs) | static_cast<uint32_t>(rhs));
-}
-
-constexpr TextureFormatUsage operator&(TextureFormatUsage lhs, TextureFormatUsage rhs) {
-	return static_cast<TextureFormatUsage>(static_cast<uint32_t>(lhs) & static_cast<uint32_t>(rhs));
-}
-
-constexpr TextureFormatUsage operator~(TextureFormatUsage usage) {
-	return static_cast<TextureFormatUsage>(~static_cast<uint32_t>(usage));
-}
-
-constexpr TextureFormatUsage& operator|=(TextureFormatUsage& lhs, TextureFormatUsage rhs) {
-	lhs = lhs | rhs;
-	return lhs;
-}
-
-constexpr bool TextureHasFormatUsage(TextureFormatUsage usage, TextureFormatUsage flag) {
-	return (static_cast<uint32_t>(usage & flag) == static_cast<uint32_t>(flag));
-}
-
-enum class TextureUploadDestination { MipLevels, MipAtlas };
-
-struct RenderTargetFormatInfo {
-	vk::Format                      format            = vk::Format::eUndefined;
-	uint32_t                        bytes_per_element = 0;
-	Prospero::ColorComponentMapping export_mapping;
-};
-
-struct TextureUploadLayout {
-	uint32_t        tile                = 0;
-	uint32_t        pitch               = 0;
-	uint64_t        slice_stride        = 0;
-	uint64_t        source_slice_stride = 0;
-	uint32_t        first_tail_level    = 16;
-	TileBlockFamily tile_family         = TileBlockFamily::Count;
-	bool            volume_texture      = false;
-	TileSizeOffset  level_sizes[16]     = {};
-	TilePaddedSize  padded_sizes[16]    = {};
-};
-
-struct TextureImageCreateParams {
-	uint32_t                 fmt                      = 0;
-	uint64_t                 width                    = 0;
-	uint64_t                 height                   = 0;
-	uint32_t                 base_level               = 0;
-	uint64_t                 levels                   = 1;
-	uint32_t                 depth                    = 1;
-	uint64_t                 type                     = 0;
-	uint64_t                 swizzle                  = 0;
-	TextureFormatUsage       format_usage             = TextureFormatUsage::Sampled;
-	TextureFormatUsage       required_format_usage    = TextureFormatUsage::Sampled;
-	TextureFormatUsage       view_usage               = TextureFormatUsage::Sampled;
-	TextureUploadDestination image_layout             = TextureUploadDestination::MipLevels;
-	bool                     allow_cube_view          = false;
-	bool                     compatible_format_views  = false;
-	bool                     storage_swizzle_fallback = false;
-	const char*              owner                    = nullptr;
-};
-
-vk::ComponentSwizzle TextureGetComponentSwizzle(uint8_t s);
-vk::ComponentMapping TextureGetComponentMapping(uint32_t swizzle);
-bool                 TextureCheckFormat(vk::ImageCreateInfo& image_info);
-bool TextureCheckStorageSwizzle(vk::ImageCreateInfo& image_info, vk::ComponentMapping& components);
-vk::ImageUsageFlags    TextureGetUsage(TextureFormatUsage usage);
-vk::ImageUsageFlags    TextureGetViewUsage(TextureFormatUsage usage);
-vk::Format             TextureGetFormat(uint32_t fmt);
-RenderTargetFormatInfo TextureGetRenderTargetFormat(uint32_t layout, uint32_t type, uint32_t order);
-uint32_t TextureGetAtlasSliceYStride(vk::Format format, uint32_t mip_height, uint32_t depth,
-                                     uint64_t levels);
-uint32_t TextureCalcStackedImageHeight(vk::Format format, uint32_t height, uint32_t depth,
-                                       uint64_t levels);
-uint32_t TextureCalcMipmapAtlasImageHeight(vk::Format format, uint32_t width, uint32_t height,
-                                           uint32_t depth, uint64_t levels);
-bool     TextureIs3DTexture(uint64_t type);
-bool     TextureIsCubeTexture(uint64_t type);
-bool     TextureIsLayeredTexture(uint64_t type);
-bool     TextureCanCreateCubeView(uint64_t type, uint32_t base_array, uint32_t layer_count);
-vk::ComponentMapping TextureCreateImage(VulkanImage& image,
-                                        const TextureImageCreateParams& params);
-void TextureCreateImageViews(VulkanImage& vk_obj,
-                             vk::ComponentMapping components, uint64_t type, uint32_t base_array,
-                             uint32_t base_level, uint32_t level_count, uint32_t depth,
-                             bool allow_cube_view, TextureFormatUsage view_usage);
-TextureUploadLayout TextureCalcUploadLayout(uint32_t fmt, uint64_t width, uint64_t height,
-                                            uint64_t levels, uint32_t depth, uint64_t pitch,
-                                            uint64_t tile, uint64_t upload_size,
-                                            bool allow_depth_tile, bool volume_texture,
-                                            const char* owner);
-uint64_t TextureUploadSliceSourceOffset(const TextureUploadLayout& layout, uint32_t level,
-                                        uint32_t slice);
-uint64_t TextureCalcUploadSize(const TextureUploadLayout&          layout,
-                               const std::vector<BufferImageCopy>& regions, uint64_t levels,
-                               uint32_t depth);
-std::vector<BufferImageCopy> TextureBuildUploadRegions(const TextureUploadLayout& layout,
-                                                       vk::Format image_format, uint32_t width,
-                                                       uint32_t height, uint32_t depth,
-                                                       uint64_t levels, bool array_texture,
-                                                       bool                     volume_texture,
-                                                       TextureUploadDestination destination);
-std::vector<ImageBufferCopy>
-TextureBuildDownloadRegions(const std::vector<BufferImageCopy>& upload_regions);
-bool TextureBuildGpuTileInfos(uint64_t size, const std::vector<BufferImageCopy>& regions,
-                              const TextureUploadLayout& layout, uint32_t fmt, uint32_t depth,
-                              uint64_t levels, std::vector<GpuTileInfo>& infos);
-void TextureUploadGuestImage(VulkanImage& vk_obj, const void* src_data,
-                             uint64_t size, const std::vector<BufferImageCopy>& regions,
-                             const TextureUploadLayout& layout, uint32_t fmt, uint64_t width,
-                             uint64_t height, uint32_t depth, uint64_t levels, const char* owner,
-                             vk::ImageLayout dst_layout);
-
-} // namespace Libs::Graphics
-
-#endif /* EMULATOR_INCLUDE_EMULATOR_GRAPHICS_OBJECTS_TEXTURECOMMON_H_ */

src/graphics/host_gpu/pageManager.cpp

@@ -1,13 +1,16 @@
 #include "graphics/host_gpu/pageManager.h"
 
+#include "common/alignment.h"
+#include "common/virtualMemory.h"
 #include "graphics/host_gpu/regionDefinitions.h"
+#include "kernel/memory.h"
 
+#include <algorithm>
 #include <array>
 #include <atomic>
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
-#include <limits>
 #include <memory>
 #include <mutex>
 #include <vector>
@@ -19,6 +22,8 @@
 #include <windows.h>
 #undef min
 #undef max
+#else
+#include <unistd.h>
 #endif
 
 namespace Libs::Graphics {
@@ -28,25 +33,13 @@ constexpr uint64_t PAGE_SIZE    = TRACKER_PAGE_SIZE;
 constexpr uint64_t REGION_SIZE  = TRACKER_REGION_SIZE;
 constexpr uint64_t ADDRESS_SIZE = TRACKER_ADDRESS_SIZE;
 constexpr uint64_t REGION_COUNT = ADDRESS_SIZE / REGION_SIZE;
-constexpr uint64_t REGION_PAGES = REGION_SIZE / PAGE_SIZE;
 
-thread_local bool g_in_fault_resolution = false;
+constexpr uint64_t REGION_PAGES = REGION_SIZE / PAGE_SIZE;
 
 [[noreturn]] void FailFast(const char* reason = nullptr) noexcept {
 	std::fputs("PageManager fail-fast: ", stderr);
 	std::fputs(reason != nullptr ? reason : "invalid page state", stderr);
 	std::fputc('\n', stderr);
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-	void*      frames[16] {};
-	const auto frame_count =
-	    CaptureStackBackTrace(0, static_cast<DWORD>(std::size(frames)), frames, nullptr);
-	const auto image_base = reinterpret_cast<uintptr_t>(GetModuleHandleW(nullptr));
-	for (uint16_t i = 0; i < frame_count; i++) {
-		const auto address = reinterpret_cast<uintptr_t>(frames[i]);
-		std::fprintf(stderr, "  frame[%u]=0x%016" PRIxPTR " image_rva=0x%016" PRIxPTR "\n", i,
-		             address, address >= image_base ? address - image_base : 0);
-	}
-#endif
 	std::fflush(stderr);
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	TerminateProcess(GetCurrentProcess(), static_cast<UINT>(EXCEPTION_NONCONTINUABLE_EXCEPTION));
@@ -65,14 +58,6 @@ thread_local bool g_in_fault_resolution = false;
 	std::_Exit(322);
 }
 
-uint32_t CurrentThread() noexcept {
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-	return GetCurrentThreadId();
-#else
-	FailFast();
-#endif
-}
-
 class SpinGuard final {
 public:
 	explicit SpinGuard(std::atomic_flag& lock): m_lock(lock) {
@@ -88,46 +73,70 @@ private:
 };
 
 void ValidateRange(uint64_t vaddr, uint64_t size) {
-	if (vaddr == 0 || size == 0 || vaddr >= ADDRESS_SIZE || size > ADDRESS_SIZE - vaddr) {
+	if (!GuestRange {vaddr, size}.Valid()) {
 		Fatal("invalid range vaddr=0x%016" PRIx64 ", size=0x%016" PRIx64, vaddr, size);
 	}
 }
 
-uint64_t PageStart(uint64_t vaddr) {
-	return vaddr & ~(PAGE_SIZE - 1);
-}
-
-uint64_t PageEnd(uint64_t vaddr, uint64_t size) {
-	ValidateRange(vaddr, size);
-	return PageStart(vaddr + size - 1) + PAGE_SIZE;
-}
-
 } // namespace
 
 struct PageManager::Impl {
 	struct PageState {
-		std::atomic_flag lock                 = ATOMIC_FLAG_INIT;
-		uint32_t         mappings             = 0;
-		uint32_t         gpu_read_mappings    = 0;
-		uint32_t         gpu_write_mappings   = 0;
-		uint32_t         write_watchers       = 0;
-		uint32_t         access_watchers      = 0;
-		uint32_t         original_protection  = 0;
-		uint32_t         backing_writer       = 0;
-		bool             resolving            = false;
-		bool             resolving_read_write = false;
-		bool             late_read_pending    = false;
-		bool             late_write_pending   = false;
+		uint8_t write_watchers  : 7 = 0;
+		uint8_t access_watchers : 1 = 0;
+
+		[[nodiscard]] Common::VirtualMemory::Mode Perms() const noexcept {
+			if (access_watchers != 0) {
+				return Common::VirtualMemory::Mode::NoAccess;
+			}
+			if (write_watchers != 0) {
+				return Common::VirtualMemory::Mode::Read;
+			}
+			return Common::VirtualMemory::Mode::ReadWrite;
+		}
+
+		template <int delta, bool is_read>
+		uint32_t AddDelta(uint64_t address) {
+			static_assert(delta >= -1 && delta <= 1);
+			if constexpr (is_read) {
+				if constexpr (delta == 1) {
+					if (access_watchers != 0) {
+						Fatal("read-watcher overflow at 0x%016" PRIx64, address);
+					}
+					return ++access_watchers;
+				} else if constexpr (delta == -1) {
+					if (access_watchers == 0) {
+						Fatal("read-watcher underflow at 0x%016" PRIx64, address);
+					}
+					return --access_watchers;
+				} else {
+					return access_watchers;
+				}
+			} else {
+				if constexpr (delta == 1) {
+					if (write_watchers == 0x7f) {
+						Fatal("write-watcher overflow at 0x%016" PRIx64, address);
+					}
+					return ++write_watchers;
+				} else if constexpr (delta == -1) {
+					if (write_watchers == 0) {
+						Fatal("write-watcher underflow at 0x%016" PRIx64, address);
+					}
+					return --write_watchers;
+				} else {
+					return write_watchers;
+				}
+			}
+		}
 	};
+	static_assert(sizeof(PageState) == 1);
 
 	struct Region {
+		std::atomic_flag                    lock = ATOMIC_FLAG_INIT;
 		std::array<PageState, REGION_PAGES> pages;
 	};
 
-	Impl(PageFaultHandler handler, void* context): fault_handler(handler), fault_context(context) {
-		if (fault_handler == nullptr) {
-			Fatal("null fault handler");
-		}
+	Impl() {
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 		SYSTEM_INFO info {};
 		GetSystemInfo(&info);
@@ -135,22 +144,25 @@ struct PageManager::Impl {
 			Fatal("unsupported host page size 0x%08" PRIx32,
 			      static_cast<uint32_t>(info.dwPageSize));
 		}
+#elif defined(__APPLE__)
+		// Under Rosetta the host page size is 4 KB, matching TRACKER_PAGE_SIZE.
+		if (static_cast<uint64_t>(getpagesize()) != PAGE_SIZE) {
+			Fatal("unsupported host page size 0x%08" PRIx32, static_cast<uint32_t>(getpagesize()));
+		}
 #else
-		Fatal("page-fault invalidation is not implemented on this platform");
+		const auto host_page_size = ::sysconf(_SC_PAGESIZE);
+		if (host_page_size < 0 || static_cast<uint64_t>(host_page_size) != PAGE_SIZE) {
+			Fatal("unsupported host page size %ld", static_cast<long>(host_page_size));
+		}
 #endif
 		regions = std::make_unique<std::atomic<Region*>[]>(REGION_COUNT);
-		for (uint64_t i = 0; i < REGION_COUNT; i++) {
-			regions[i].store(nullptr, std::memory_order_relaxed);
-		}
 	}
 
 	~Impl() {
 		for (const auto& region: region_storage) {
+			SpinGuard lock(region->lock);
 			for (auto& page: region->pages) {
-				SpinGuard lock(page.lock);
-				if (page.mappings != 0 || page.gpu_read_mappings != 0 ||
-				    page.gpu_write_mappings != 0 || page.write_watchers != 0 ||
-				    page.access_watchers != 0 || page.backing_writer != 0 || page.resolving) {
+				if (page.write_watchers != 0 || page.access_watchers != 0) {
 					FailFast("PageManager destroyed with live page state");
 				}
 			}
@@ -178,508 +190,136 @@ struct PageManager::Impl {
 		return ptr;
 	}
 
-	PageState& GetPage(Region& region, uint64_t vaddr) const {
-		return region.pages[(vaddr % REGION_SIZE) / PAGE_SIZE];
-	}
-
-	static uint32_t WatcherProtection(const PageState& page) {
-		if (page.access_watchers != 0) {
-			return PAGE_NOACCESS;
-		}
-		if (page.write_watchers != 0) {
-			return PAGE_READONLY;
-		}
-		return page.original_protection;
-	}
-
-	static void PublishDelayedFaults(PageState& page, uint32_t old_protection,
-	                                 uint32_t new_protection) {
-		if (old_protection == PAGE_NOACCESS && new_protection != PAGE_NOACCESS) {
-			page.late_read_pending = true;
-		}
-		if ((old_protection == PAGE_NOACCESS || old_protection == PAGE_READONLY) &&
-		    new_protection == PAGE_READWRITE) {
-			page.late_write_pending = true;
+	void Protect(uint64_t vaddr, uint64_t size, Common::VirtualMemory::Mode mode) noexcept {
+		if (!Libs::LibKernel::Memory::ProtectGuestHostMemory(vaddr, size, mode)) {
+			Fatal("address-space protection failed at 0x%016" PRIx64 ", mode=0x%08" PRIx32, vaddr,
+			      static_cast<uint32_t>(mode));
 		}
 	}
 
-	static uint32_t QueryProtection(uint64_t vaddr) {
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-		MEMORY_BASIC_INFORMATION info {};
-		if (VirtualQuery(reinterpret_cast<const void*>(static_cast<uintptr_t>(vaddr)), &info,
-		                 sizeof(info)) == 0 ||
-		    info.State != MEM_COMMIT || info.Protect != PAGE_READWRITE) {
-			Fatal("basic path requires PAGE_READWRITE at 0x%016" PRIx64 " (state=0x%08" PRIx32
-			      ", protection=0x%08" PRIx32 ")",
-			      vaddr, static_cast<uint32_t>(info.State), static_cast<uint32_t>(info.Protect));
-		}
-		return info.Protect;
-#else
-		(void)vaddr;
-		Fatal("page query is unsupported on this platform");
-#endif
-	}
+	template <bool track, bool is_read, bool masked>
+	void UpdateRegionWatchers(Region& region, uint64_t base_addr, size_t first, size_t last,
+	                          const RegionBits* mask = nullptr) {
+		SpinGuard lock(region.lock);
+		auto      perms                 = region.pages[first].Perms();
+		uint64_t  range_begin           = 0;
+		uint64_t  range_bytes           = 0;
+		uint64_t  potential_range_bytes = 0;
 
-	static bool AllowsAccess(uint64_t vaddr, PageFaultAccess access) noexcept {
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-		MEMORY_BASIC_INFORMATION info {};
-		if (VirtualQuery(reinterpret_cast<const void*>(static_cast<uintptr_t>(vaddr)), &info,
-		                 sizeof(info)) == 0 ||
-		    info.State != MEM_COMMIT) {
-			return false;
-		}
-		switch (access) {
-			case PageFaultAccess::Read:
-				return info.Protect == PAGE_READONLY || info.Protect == PAGE_READWRITE;
-			case PageFaultAccess::Write: return info.Protect == PAGE_READWRITE;
-			default: return false;
-		}
-#else
-		(void)vaddr;
-		return false;
-#endif
-	}
+		const auto release_pending = [&] {
+			if (range_bytes != 0) {
+				Protect(base_addr + range_begin * PAGE_SIZE, range_bytes, perms);
+				range_bytes           = 0;
+				potential_range_bytes = 0;
+			}
+		};
 
-	static void Protect(uint64_t vaddr, uint32_t protection, uint32_t expected_old,
-	                    bool fault_path) noexcept {
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-		DWORD old_protection = 0;
-		if (VirtualProtect(reinterpret_cast<void*>(static_cast<uintptr_t>(vaddr)), PAGE_SIZE,
-		                   protection, &old_protection) == 0 ||
-		    old_protection != expected_old) {
-			if (fault_path) {
-				FailFast("VirtualProtect fault transition did not match expected protection");
+		for (size_t page_index = first; page_index < last; page_index++) {
+			auto&      page    = region.pages[page_index];
+			const auto address = base_addr + page_index * PAGE_SIZE;
+			const bool update  = !masked || mask->Get(page_index);
+
+			const auto old_perms = page.Perms();
+			const auto new_count = update ? page.AddDelta<track ? 1 : -1, is_read>(address)
+			                              : page.AddDelta<0, is_read>(address);
+			const auto new_perms = page.Perms();
+
+			if (new_perms != perms) [[unlikely]] {
+				release_pending();
+				perms = new_perms;
+			} else if (range_bytes != 0) {
+				potential_range_bytes += PAGE_SIZE;
+			}
+
+			if (!update) {
+				continue;
+			}
+
+			const bool watcher_edge = (track && new_count == 1) || (!track && new_count == 0);
+			if (watcher_edge && old_perms != new_perms) {
+				if (range_bytes == 0) {
+					range_begin           = page_index;
+					potential_range_bytes = PAGE_SIZE;
+				}
+				range_bytes = potential_range_bytes;
 			}
-			Fatal("invalid protection transition at 0x%016" PRIx64 ", old=0x%08" PRIx32
-			      ", expected=0x%08" PRIx32 ", new=0x%08" PRIx32,
-			      vaddr, static_cast<uint32_t>(old_protection), expected_old, protection);
 		}
-#else
-		(void)vaddr;
-		(void)protection;
-		(void)fault_path;
-		FailFast("page protection is unsupported on this platform");
-#endif
+
+		release_pending();
+	}
+
+	template <bool track, bool is_read>
+	void UpdatePageWatchers(uint64_t vaddr, uint64_t size) {
+		ValidateRange(vaddr, size);
+		const auto begin = Common::AlignDown(vaddr, PAGE_SIZE);
+		const auto end   = Common::AlignUp(vaddr + size, PAGE_SIZE);
+		for (auto chunk_begin = begin; chunk_begin < end;) {
+			const auto chunk_end = std::min(end, Common::AlignUp(chunk_begin + 1, REGION_SIZE));
+			const auto region_base = Common::AlignDown(chunk_begin, REGION_SIZE);
+			auto*      region = track ? GetOrCreateRegion(chunk_begin) : FindRegion(chunk_begin);
+			if (region == nullptr) {
+				Fatal("untracking unknown page 0x%016" PRIx64, chunk_begin);
+			}
+			const auto first = static_cast<size_t>((chunk_begin - region_base) / PAGE_SIZE);
+			const auto last  = static_cast<size_t>((chunk_end - region_base) / PAGE_SIZE);
+			UpdateRegionWatchers<track, is_read, false>(*region, region_base, first, last);
+			chunk_begin = chunk_end;
+		}
 	}
 
 	std::unique_ptr<std::atomic<Region*>[]> regions;
 	std::vector<std::unique_ptr<Region>>    region_storage;
 	std::mutex                              region_mutex;
-	PageFaultHandler                        fault_handler = nullptr;
-	void*                                   fault_context = nullptr;
 };
 
 static_assert(std::atomic<void*>::is_always_lock_free);
 
-PageManager::PageManager(PageFaultHandler fault_handler, void* fault_context)
-    : m_impl(std::make_unique<Impl>(fault_handler, fault_context)) {}
+PageManager::PageManager(): m_impl(std::make_unique<Impl>()) {}
 
 PageManager::~PageManager() = default;
 
 uint64_t PageManager::GetPageSize() const {
-	if (g_in_fault_resolution) {
-		FailFast("nested page fault while resolving a watched page");
-	}
 	return PAGE_SIZE;
 }
 
-bool PageManager::IsTracked(uint64_t vaddr) const noexcept {
-	if (g_in_fault_resolution) {
-		FailFast("IsTracked called during fault resolution");
+template <bool track>
+void PageManager::UpdatePageWatchers(uint64_t vaddr, uint64_t size) {
+	m_impl->UpdatePageWatchers<track, false>(vaddr, size);
+}
+
+template void PageManager::UpdatePageWatchers<true>(uint64_t, uint64_t);
+template void PageManager::UpdatePageWatchers<false>(uint64_t, uint64_t);
+
+template <bool track, bool is_read>
+void PageManager::UpdatePageWatchersForRegion(uint64_t base_addr, RegionBits& mask) {
+	if (base_addr % REGION_SIZE != 0 || base_addr >= ADDRESS_SIZE ||
+	    REGION_SIZE > ADDRESS_SIZE - base_addr) {
+		Fatal("invalid tracking region base 0x%016" PRIx64, base_addr);
 	}
-	auto* region = m_impl->FindRegion(vaddr);
+
+	const auto start_range = mask.FirstRange();
+	const auto end_range   = mask.LastRange();
+	if (start_range.first == REGION_PAGES) {
+		FailFast("empty region watcher mask");
+	}
+	const auto first = start_range.first;
+	const auto last  = end_range.second;
+	if (start_range.second == end_range.second) {
+		m_impl->UpdatePageWatchers<track, is_read>(base_addr + first * PAGE_SIZE,
+		                                           (last - first) * PAGE_SIZE);
+		return;
+	}
+
+	auto* region = track ? m_impl->GetOrCreateRegion(base_addr) : m_impl->FindRegion(base_addr);
 	if (region == nullptr) {
-		return false;
+		Fatal("untracking unknown region 0x%016" PRIx64, base_addr);
 	}
-	auto&     page = m_impl->GetPage(*region, vaddr);
-	SpinGuard lock(page.lock);
-	return page.write_watchers != 0 || page.access_watchers != 0;
+	m_impl->UpdateRegionWatchers<track, is_read, true>(*region, base_addr, first, last, &mask);
 }
 
-bool PageManager::IsMapped(uint64_t vaddr, uint64_t size) const noexcept {
-	if (g_in_fault_resolution || vaddr == 0 || size == 0 || vaddr >= ADDRESS_SIZE ||
-	    size > ADDRESS_SIZE - vaddr) {
-		return false;
-	}
-	const auto end = PageStart(vaddr + size - 1) + PAGE_SIZE;
-	for (auto page_vaddr = PageStart(vaddr); page_vaddr < end; page_vaddr += PAGE_SIZE) {
-		auto* region = m_impl->FindRegion(page_vaddr);
-		if (region == nullptr) {
-			return false;
-		}
-		auto&     page = m_impl->GetPage(*region, page_vaddr);
-		SpinGuard lock(page.lock);
-		if (page.mappings == 0) {
-			return false;
-		}
-	}
-	return true;
-}
-
-bool PageManager::HasAnyMapping(uint64_t vaddr, uint64_t size) const noexcept {
-	if (g_in_fault_resolution || vaddr == 0 || size == 0 || vaddr >= ADDRESS_SIZE ||
-	    size > ADDRESS_SIZE - vaddr) {
-		return false;
-	}
-	const auto end = PageEnd(vaddr, size);
-	for (auto page_vaddr = PageStart(vaddr); page_vaddr < end; page_vaddr += PAGE_SIZE) {
-		auto* region = m_impl->FindRegion(page_vaddr);
-		if (region == nullptr) {
-			continue;
-		}
-		auto&     page = m_impl->GetPage(*region, page_vaddr);
-		SpinGuard lock(page.lock);
-		if (page.mappings != 0) {
-			return true;
-		}
-	}
-	return false;
-}
-
-bool PageManager::HasGpuAccess(uint64_t vaddr, uint64_t size, GpuAccess access) const noexcept {
-	if (access != GpuAccess::Read && access != GpuAccess::Write && access != GpuAccess::ReadWrite) {
-		FailFast("HasGpuAccess received an invalid GPU access mode");
-	}
-	const bool need_read  = access == GpuAccess::Read || access == GpuAccess::ReadWrite;
-	const bool need_write = access == GpuAccess::Write || access == GpuAccess::ReadWrite;
-	if (vaddr == 0 || size == 0 || vaddr >= ADDRESS_SIZE || size > ADDRESS_SIZE - vaddr) {
-		return false;
-	}
-	const auto end = PageEnd(vaddr, size);
-	for (auto addr = PageStart(vaddr); addr < end; addr += PAGE_SIZE) {
-		auto* region = m_impl->FindRegion(addr);
-		if (region == nullptr) {
-			return false;
-		}
-		auto&     page = m_impl->GetPage(*region, addr);
-		SpinGuard lock(page.lock);
-		if ((need_read && page.gpu_read_mappings == 0) ||
-		    (need_write && page.gpu_write_mappings == 0)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void PageManager::UpdatePageWatchers(bool track, uint64_t vaddr, uint64_t size,
-                                     PageWatchMode mode) {
-	if (g_in_fault_resolution) {
-		FailFast("page watchers changed during fault resolution");
-	}
-	if (mode != PageWatchMode::Write && mode != PageWatchMode::ReadWrite) {
-		Fatal("invalid watcher mode");
-	}
-	const auto end = PageEnd(vaddr, size);
-	for (auto page_vaddr = PageStart(vaddr); page_vaddr < end; page_vaddr += PAGE_SIZE) {
-		auto* region =
-		    track ? m_impl->GetOrCreateRegion(page_vaddr) : m_impl->FindRegion(page_vaddr);
-		if (region == nullptr) {
-			Fatal("untracking unknown page 0x%016" PRIx64, page_vaddr);
-		}
-		auto&     page = m_impl->GetPage(*region, page_vaddr);
-		SpinGuard lock(page.lock);
-		if (page.resolving && track) {
-			FailFast("new page watcher raced active fault resolution");
-		}
-		if (page.mappings == 0) {
-			Fatal("watching unmapped page 0x%016" PRIx64, page_vaddr);
-		}
-		auto& watchers =
-		    (mode == PageWatchMode::ReadWrite ? page.access_watchers : page.write_watchers);
-		if (track) {
-			if (watchers == std::numeric_limits<uint32_t>::max()) {
-				Fatal("watcher overflow at 0x%016" PRIx64, page_vaddr);
-			}
-			const bool first_watcher = page.write_watchers == 0 && page.access_watchers == 0;
-			if (first_watcher) {
-				page.original_protection = Impl::QueryProtection(page_vaddr);
-			}
-			const auto old_protection = Impl::WatcherProtection(page);
-			watchers++;
-			const auto new_protection = Impl::WatcherProtection(page);
-			if (new_protection != old_protection) {
-				Impl::Protect(page_vaddr, new_protection, old_protection, false);
-			}
-			switch (new_protection) {
-				case PAGE_NOACCESS:
-					page.late_read_pending  = false;
-					page.late_write_pending = false;
-					break;
-				case PAGE_READONLY: page.late_write_pending = false; break;
-				default: break;
-			}
-		} else {
-			if (watchers == 0) {
-				Fatal("watcher underflow at 0x%016" PRIx64, page_vaddr);
-			}
-			if (page.backing_writer != 0 && page.backing_writer != CurrentThread()) {
-				Fatal("backing write ownership changed at 0x%016" PRIx64, page_vaddr);
-			}
-			const auto old_protection = Impl::WatcherProtection(page);
-			watchers--;
-			const auto new_protection = Impl::WatcherProtection(page);
-			if (page.backing_writer == 0 && new_protection != old_protection) {
-				Impl::Protect(page_vaddr, new_protection, old_protection, false);
-			}
-			if (page.backing_writer == 0) {
-				Impl::PublishDelayedFaults(page, old_protection, new_protection);
-			}
-			if (page.backing_writer == 0 && page.write_watchers == 0 && page.access_watchers == 0) {
-				page.original_protection = 0;
-			}
-		}
-	}
-}
-
-void PageManager::OnGpuMap(uint64_t vaddr, uint64_t size, GpuAccess access) {
-	if (g_in_fault_resolution) {
-		FailFast("GPU mapping changed during fault resolution");
-	}
-	if (access != GpuAccess::Read && access != GpuAccess::Write && access != GpuAccess::ReadWrite) {
-		FailFast("GPU map received an invalid access mode");
-	}
-	const bool gpu_read  = access == GpuAccess::Read || access == GpuAccess::ReadWrite;
-	const bool gpu_write = access == GpuAccess::Write || access == GpuAccess::ReadWrite;
-	const auto end       = PageEnd(vaddr, size);
-	for (auto addr = PageStart(vaddr); addr < end; addr += PAGE_SIZE) {
-		auto&     page = m_impl->GetPage(*m_impl->GetOrCreateRegion(addr), addr);
-		SpinGuard lock(page.lock);
-		if (page.resolving || page.mappings == std::numeric_limits<uint32_t>::max() ||
-		    (gpu_read && page.gpu_read_mappings == std::numeric_limits<uint32_t>::max()) ||
-		    (gpu_write && page.gpu_write_mappings == std::numeric_limits<uint32_t>::max())) {
-			Fatal("invalid map state at 0x%016" PRIx64, addr);
-		}
-		page.mappings++;
-		page.gpu_read_mappings += gpu_read ? 1u : 0u;
-		page.gpu_write_mappings += gpu_write ? 1u : 0u;
-	}
-}
-
-void PageManager::OnGpuUnmap(uint64_t vaddr, uint64_t size, GpuAccess access) {
-	if (g_in_fault_resolution) {
-		FailFast("GPU unmapping changed during fault resolution");
-	}
-	if (access != GpuAccess::Read && access != GpuAccess::Write && access != GpuAccess::ReadWrite) {
-		FailFast("GPU unmap received an invalid access mode");
-	}
-	const bool gpu_read  = access == GpuAccess::Read || access == GpuAccess::ReadWrite;
-	const bool gpu_write = access == GpuAccess::Write || access == GpuAccess::ReadWrite;
-	const auto end       = PageEnd(vaddr, size);
-	for (auto page_vaddr = PageStart(vaddr); page_vaddr < end; page_vaddr += PAGE_SIZE) {
-		auto* region = m_impl->FindRegion(page_vaddr);
-		if (region == nullptr) {
-			Fatal("unmapping unknown page 0x%016" PRIx64, page_vaddr);
-		}
-		auto&     page = m_impl->GetPage(*region, page_vaddr);
-		SpinGuard lock(page.lock);
-		if (page.resolving || page.mappings == 0 || (gpu_read && page.gpu_read_mappings == 0) ||
-		    (gpu_write && page.gpu_write_mappings == 0) ||
-		    (page.mappings == 1 && (page.write_watchers != 0 || page.access_watchers != 0))) {
-			Fatal("invalid unmap state at 0x%016" PRIx64, page_vaddr);
-		}
-		page.mappings--;
-		page.gpu_read_mappings -= gpu_read ? 1u : 0u;
-		page.gpu_write_mappings -= gpu_write ? 1u : 0u;
-		if (page.mappings == 0) {
-			if (page.gpu_read_mappings != 0 || page.gpu_write_mappings != 0) {
-				FailFast("GPU unmap left nonzero GPU mapping counts");
-			}
-			page.late_read_pending  = false;
-			page.late_write_pending = false;
-		}
-	}
-}
-
-PageManager::BackingWrite::BackingWrite(PageManager& manager, uint64_t vaddr,
-                                        uint64_t size) noexcept
-    : m_manager(manager), m_vaddr(vaddr), m_size(size) {
-	m_manager.BeginBackingWrite(vaddr, size);
-}
-
-PageManager::BackingWrite::~BackingWrite() {
-	m_manager.EndBackingWrite(m_vaddr, m_size);
-}
-
-void PageManager::BeginBackingWrite(uint64_t vaddr, uint64_t size) noexcept {
-	if (g_in_fault_resolution) {
-		FailFast("backing write began during fault resolution");
-	}
-	const auto end    = PageEnd(vaddr, size);
-	const auto writer = CurrentThread();
-	for (auto address = PageStart(vaddr); address < end; address += PAGE_SIZE) {
-		auto* region = m_impl->FindRegion(address);
-		if (region == nullptr) {
-			Fatal("backing write reserves an unknown page at 0x%016" PRIx64, address);
-		}
-		auto&     page = m_impl->GetPage(*region, address);
-		SpinGuard lock(page.lock);
-		if (page.mappings == 0 || page.resolving || page.backing_writer != 0 ||
-		    page.access_watchers == 0) {
-			Fatal("backing write races page resolution at 0x%016" PRIx64, address);
-		}
-		page.resolving            = true;
-		page.resolving_read_write = true;
-		page.backing_writer       = writer;
-	}
-}
-
-void PageManager::EndBackingWrite(uint64_t vaddr, uint64_t size) noexcept {
-	if (g_in_fault_resolution) {
-		FailFast("backing write ended during fault resolution");
-	}
-	const auto end    = PageEnd(vaddr, size);
-	const auto writer = CurrentThread();
-	for (auto address = PageStart(vaddr); address < end; address += PAGE_SIZE) {
-		auto* region = m_impl->FindRegion(address);
-		if (region == nullptr) {
-			FailFast("backing write ended for an unknown page");
-		}
-		auto&     page = m_impl->GetPage(*region, address);
-		SpinGuard lock(page.lock);
-		if (!page.resolving || page.backing_writer != writer) {
-			FailFast("backing write ended without matching owner and resolving state");
-		}
-		const auto old_protection = PAGE_NOACCESS;
-		const auto new_protection = Impl::WatcherProtection(page);
-		if (new_protection != old_protection) {
-			Impl::Protect(address, new_protection, old_protection, false);
-		}
-		Impl::PublishDelayedFaults(page, old_protection, new_protection);
-		if (page.write_watchers == 0 && page.access_watchers == 0) {
-			page.original_protection = 0;
-		}
-		page.backing_writer       = 0;
-		page.resolving            = false;
-		page.resolving_read_write = false;
-	}
-}
-
-bool PageManager::HandleFault(PageFaultAccess access, uint64_t fault_vaddr) noexcept {
-	if (g_in_fault_resolution) {
-		FailFast("nested HandleFault call");
-	}
-	auto* region = m_impl->FindRegion(fault_vaddr);
-	if (region == nullptr) {
-		return false;
-	}
-	auto& page   = m_impl->GetPage(*region, fault_vaddr);
-	bool  waited = false;
-	while (true) {
-		SpinGuard lock(page.lock);
-		if (access == PageFaultAccess::Read && page.late_read_pending &&
-		    Impl::AllowsAccess(fault_vaddr, access)) {
-			page.late_read_pending = false;
-			return true;
-		}
-		if (access == PageFaultAccess::Write && page.late_write_pending &&
-		    Impl::AllowsAccess(fault_vaddr, access)) {
-			page.late_write_pending = false;
-			return true;
-		}
-		if (page.resolving) {
-			if (page.backing_writer == CurrentThread()) {
-				FailFast("backing writer faulted on its own reserved page");
-			}
-			if ((!page.resolving_read_write && access != PageFaultAccess::Write) ||
-			    (page.resolving_read_write && access != PageFaultAccess::Read &&
-			     access != PageFaultAccess::Write)) {
-				FailFast("fault access is incompatible with the active resolver");
-			}
-			waited = true;
-			continue;
-		}
-		if (page.write_watchers == 0 && page.access_watchers == 0) {
-			if (access != PageFaultAccess::Read && access != PageFaultAccess::Write) {
-				return false;
-			}
-			bool&      pending = (access == PageFaultAccess::Read ? page.late_read_pending
-			                                                      : page.late_write_pending);
-			const bool allowed = Impl::AllowsAccess(fault_vaddr, access);
-			pending            = false;
-			if (waited && !allowed) {
-				FailFast("page remained inaccessible after waiting for its resolver");
-			}
-			// More than one CPU can fault before a protection transition becomes visible. The first
-			// delayed fault consumes the hint bit; later faults must also resume once the mapped
-			// page already permits the requested access. A genuinely read-only/no-access page still
-			// falls through to the guest exception path.
-			return allowed;
-		}
-		if ((access != PageFaultAccess::Read && access != PageFaultAccess::Write) ||
-		    (access == PageFaultAccess::Read && page.access_watchers == 0)) {
-			FailFast("fault access is incompatible with active page watchers");
-		}
-		page.resolving            = true;
-		page.resolving_read_write = page.access_watchers != 0;
-		break;
-	}
-	g_in_fault_resolution = true;
-	const bool handled    = m_impl->fault_handler(m_impl->fault_context, access, fault_vaddr, 1,
-	                                              PageFaultPhase::Invalidate);
-	g_in_fault_resolution = false;
-	{
-		SpinGuard lock(page.lock);
-		if (!handled || !page.resolving) {
-			FailFast("fault invalidation did not preserve the resolving state");
-		}
-	}
-	g_in_fault_resolution = true;
-	const bool completed  = m_impl->fault_handler(m_impl->fault_context, access, fault_vaddr, 1,
-	                                              PageFaultPhase::Complete);
-	g_in_fault_resolution = false;
-	{
-		SpinGuard lock(page.lock);
-		if (!completed || !page.resolving) {
-			FailFast("fault completion did not preserve the resolving state");
-		}
-		if (page.write_watchers != 0 || page.access_watchers != 0) {
-			const auto old_protection  = Impl::WatcherProtection(page);
-			const bool read_only_fault = access == PageFaultAccess::Read;
-			if (read_only_fault && page.access_watchers == 0) {
-				FailFast("read fault completed without a read/write watcher");
-			}
-			page.access_watchers = 0;
-			if (!read_only_fault) {
-				page.write_watchers = 0;
-			}
-			const auto restored_protection = Impl::WatcherProtection(page);
-			Impl::Protect(PageStart(fault_vaddr), restored_protection, old_protection, true);
-			if (page.write_watchers == 0) {
-				page.original_protection = 0;
-			}
-			Impl::PublishDelayedFaults(page, old_protection, restored_protection);
-		} else if (!Impl::AllowsAccess(fault_vaddr, access)) {
-			FailFast("fault completion left the page inaccessible");
-		}
-		page.resolving            = false;
-		page.resolving_read_write = false;
-	}
-	g_in_fault_resolution = true;
-	const bool released   = m_impl->fault_handler(m_impl->fault_context, access, fault_vaddr, 1,
-	                                              PageFaultPhase::Release);
-	g_in_fault_resolution = false;
-	if (!released) {
-		FailFast("fault release callback failed");
-	}
-	return true;
-}
-
-bool PageManager::HandleWriteRange(uint64_t vaddr, uint64_t size) noexcept {
-	if (g_in_fault_resolution || vaddr == 0 || size == 0 || vaddr >= ADDRESS_SIZE ||
-	    size > ADDRESS_SIZE - vaddr) {
-		return false;
-	}
-	const auto end = PageEnd(vaddr, size);
-	for (auto page_vaddr = PageStart(vaddr); page_vaddr < end; page_vaddr += PAGE_SIZE) {
-		if (!IsMapped(page_vaddr, 1)) {
-			continue;
-		}
-		const auto fault_vaddr = std::max(page_vaddr, vaddr);
-		if (!HandleFault(PageFaultAccess::Write, fault_vaddr)) {
-			return false;
-		}
-	}
-	return true;
-}
+template void PageManager::UpdatePageWatchersForRegion<true, true>(uint64_t, RegionBits&);
+template void PageManager::UpdatePageWatchersForRegion<true, false>(uint64_t, RegionBits&);
+template void PageManager::UpdatePageWatchersForRegion<false, true>(uint64_t, RegionBits&);
+template void PageManager::UpdatePageWatchersForRegion<false, false>(uint64_t, RegionBits&);
 
 } // namespace Libs::Graphics