MemoryManagement: Change return types for Commit/Decommit to void (#5325)

* Replace return type with void for Commit/Decommit

* Small cleanup

.editorconfig

@@ -63,6 +63,10 @@ dotnet_code_quality_unused_parameters = all:suggestion
 
 #### C# Coding Conventions ####
 
+# Namespace preferences
+csharp_style_namespace_declarations = block_scoped:warning
+resharper_csharp_namespace_body = block_scoped
+
 # var preferences
 csharp_style_var_elsewhere = false:silent
 csharp_style_var_for_built_in_types = false:silent

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,31 +1,27 @@
 name: Bug Report
 description: File a bug report
+title: "[Bug]"
+labels: bug
 body:
-  - type: checkboxes
-    attributes:
-      label: Is there an existing issue for this?
-      description: Please search to see if an issue already exists for the bug you encountered.
-      options:
-      - label: I have searched the existing issues
-        required: true
   - type: textarea
     id: issue
     attributes:
-      label: Description of Issue
+      label: Description of the issue
       description: What's the issue you encountered?
     validations:
       required: true
   - type: textarea
     id: repro
     attributes:
-      label: Reproduction Steps
+      label: Reproduction steps
       description: How can the issue be reproduced?
+      placeholder: Describe each step as precisely as possible
     validations:
       required: true
   - type: textarea
     id: log
     attributes:
-      label: Log File
+      label: Log file
       description: A log file will help our developers to better diagnose and fix the issue.
       placeholder: Logs files can be found under "Logs" folder in Ryujinx program folder. You can drag and drop the log on to the text area
     validations:
@@ -34,36 +30,51 @@ body:
     id: os
     attributes:
       label: OS
-      placeholder: "Example: Windows 10"
+      placeholder: "e.g. Windows 10"
     validations:
       required: true
   - type: input
     id: ryujinx-version
     attributes:
       label: Ryujinx version
-      placeholder: |
-        - *(e.g. 1.0.470)*
+      placeholder: "e.g. 1.0.470"
     validations:
       required: true
   - type: input
     id: game-version
     attributes:
       label: Game version
-      placeholder: |
-        - *(e.g. 1.1.1)*
+      placeholder: "e.g. 1.1.1"
+    validations:
+      required: false
+  - type: input
+    id: cpu
+    attributes:
+      label: CPU
+      placeholder: "e.g. i7-6700"
+    validations:
+      required: false
+  - type: input
+    id: gpu
+    attributes:
+      label: GPU
+      placeholder: "e.g. NVIDIA RTX 2070"
+    validations:
+      required: false
+  - type: input
+    id: ram
+    attributes:
+      label: RAM
+      placeholder: "e.g. 16GB"
     validations:
       required: false
   - type: textarea
-    id: environment
+    id: mods
     attributes:
-      label: Environment?
-      value: |
-        - ##### CPU: *(e.g. i7-6700)*
-        - ##### GPU: *(e.g. NVIDIA RTX 2070)*
-        - ##### RAM: *(e.g. 16GB)*
-        - Applied Mods: [ Yes (Which ones) / No ]
+      label: List of applied mods
+      placeholder: You can list applied mods here.
     validations:
-      required: true
+      required: false
   - type: textarea
     id: additional-context
     attributes:

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,13 +1,7 @@
 name: Feature Request
 description: Suggest a new feature for Ryujinx.
+title: "[Feature Request]"
 body:
-  - type: checkboxes
-    attributes:
-      label: Is there an existing issue for this?
-      description: Please search to see if an issue already exists for the feature you are requesting.
-      options:
-      - label: I have searched the existing issues
-        required: true
   - type: textarea
     id: overview
     attributes:
@@ -18,14 +12,14 @@ body:
   - type: textarea
     id: details
     attributes:
-      label: Smaller Details
+      label: Smaller details
       description: These may include specific methods of implementation etc.
     validations:
       required: true
   - type: textarea
     id: request
     attributes:
-      label: Nature of Request
+      label: Nature of request
     validations:
       required: true
   - type: textarea

.github/ISSUE_TEMPLATE/missing_cpu_instruction.yml

@@ -1,13 +1,8 @@
 name: Missing CPU Instruction
 description: CPU Instruction is missing in Ryujinx.
+title: "[CPU]"
+labels: [cpu, not-implemented]
 body:
-  - type: checkboxes
-    attributes:
-      label: Is there an existing issue for this?
-      description: Please search for existing missing CPU instruction
-      options:
-      - label: I have searched the existing issues
-        required: true
   - type: textarea
     id: instruction
     attributes:

.github/ISSUE_TEMPLATE/missing_service_call.yml

@@ -1,17 +1,11 @@
 name: Missing Service Call
 description: Service call is missing in Ryujinx.
+labels: not-implemented
 body:
-  - type: checkboxes
-    attributes:
-      label: Is there an existing issue for this?
-      description: Please search for an [existing missing service call issue](https://github.com/Ryujinx/Ryujinx/issues) first.
-      options:
-      - label: I have searched the existing issues
-        required: true
   - type: textarea
     id: instruction
     attributes:
-      label: Service Call
+      label: Service call
       description: What service call is missing?
     validations:
       required: true

.github/ISSUE_TEMPLATE/missing_shader_instruction.yml

@@ -0,0 +1,19 @@
+name: Missing Shader Instruction
+description: Shader Instruction is missing in Ryujinx.
+title: "[GPU]"
+labels: [gpu, not-implemented]
+body:
+  - type: textarea
+    id: instruction
+    attributes:
+      label: Shader instruction
+      description: What shader instruction is missing?
+    validations:
+      required: true
+  - type: textarea
+    id: required
+    attributes:
+      label: Required by
+      description: Add links to the [compatibility list page(s)](https://github.com/Ryujinx/Ryujinx-Games-List/issues) of the game(s) that require this instruction.
+    validations:
+      required: true

.github/assign/audio.yml

@@ -0,0 +1,8 @@
+addReviewers: true
+
+reviewers:
+  - marysaka
+
+filterLabels:
+  include:
+    - audio

.github/assign/cpu.yml

@@ -0,0 +1,11 @@
+addReviewers: true
+
+reviewers:
+  - gdkchan
+  - riperiperi
+  - marysaka
+  - LDj3SNuD
+
+filterLabels:
+  include:
+    - cpu

.github/assign/global.yml

@@ -0,0 +1,4 @@
+addReviewers: true
+
+reviewers:
+  - Ryujinx/developers

.github/assign/gpu.yml

@@ -0,0 +1,10 @@
+addReviewers: true
+
+reviewers:
+  - gdkchan
+  - riperiperi
+  - marysaka
+
+filterLabels:
+  include:
+    - gpu

.github/assign/gui.yml

@@ -0,0 +1,11 @@
+addReviewers: true
+
+reviewers:
+  - Ack77
+  - emmauss
+  - TSRBerry
+  - marysaka
+
+filterLabels:
+  include:
+    - gui

.github/assign/horizon.yml

@@ -0,0 +1,11 @@
+addReviewers: true
+
+reviewers:
+  - gdkchan
+  - Ack77
+  - marysaka
+  - TSRBerry
+
+filterLabels:
+  include:
+    - horizon

.github/assign/infra.yml

@@ -0,0 +1,9 @@
+addReviewers: true
+
+reviewers:
+  - marysaka
+  - TSRBerry
+
+filterLabels:
+  include:
+    - infra

.github/labeler.yml

@@ -0,0 +1,33 @@
+audio: 'src/Ryujinx.Audio*/**'
+
+cpu:
+  - 'src/ARMeilleure/**'
+  - 'src/Ryujinx.Cpu/**'
+  - 'src/Ryujinx.Memory/**'
+
+gpu:
+  - 'src/Ryujinx.Graphics.*/**'
+  - 'src/Spv.Generator/**'
+  - 'src/Ryujinx.ShaderTools/**'
+
+'graphics-backend:opengl': 'src/Ryujinx.Graphics.OpenGL/**'
+'graphics-backend:vulkan':
+  - 'src/Ryujinx.Graphics.Vulkan/**'
+  - 'src/Spv.Generator/**'
+
+gui:
+  - 'src/Ryujinx/**'
+  - 'src/Ryujinx.Ui.Common/**'
+  - 'src/Ryujinx.Ui.LocaleGenerator/**'
+  - 'src/Ryujinx.Ava/**'
+
+horizon:
+  - 'src/Ryujinx.HLE/**'
+  - 'src/Ryujinx.Horizon*/**'
+
+kernel: 'src/Ryujinx.HLE/HOS/Kernel/**'
+
+infra:
+  - '.github/**'
+  - 'distribution/**'
+  - 'Directory.Packages.props'

.github/workflows/build.yml

@@ -3,25 +3,29 @@ name: Build job
 on:
   workflow_dispatch:
     inputs: {}
-  #push:
-  #  branches: [ master ]
-  #  paths-ignore:
-  #    - '.github/*'
-  #    - '.github/ISSUE_TEMPLATE/**'
-  #    - '*.yml'
-  #    - 'README.md'
   pull_request:
     branches: [ master ]
     paths-ignore:
-      - '.github/*'
-      - '.github/ISSUE_TEMPLATE/**'
+      - '.github/**'
       - '*.yml'
+      - '*.json'
+      - '*.config'
       - 'README.md'
 
+concurrency:
+  group: pr-checks-${{ github.event.number }}
+  cancel-in-progress: true
+
+env:
+  POWERSHELL_TELEMETRY_OPTOUT: 1
+  DOTNET_CLI_TELEMETRY_OPTOUT: 1
+  RYUJINX_BASE_VERSION: "1.1.0"
+
 jobs:
   build:
-    name: ${{ matrix.os }} (${{ matrix.configuration }})
+    name: ${{ matrix.OS_NAME }} (${{ matrix.configuration }})
     runs-on: ${{ matrix.os }}
+    timeout-minutes: 45
     strategy:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
@@ -33,7 +37,7 @@ jobs:
           RELEASE_ZIP_OS_NAME: linux_x64
 
         - os: macOS-latest
-          OS_NAME: MacOS x64
+          OS_NAME: macOS x64
           DOTNET_RUNTIME_IDENTIFIER: osx-x64
           RELEASE_ZIP_OS_NAME: osx_x64
 
@@ -43,47 +47,107 @@ jobs:
           RELEASE_ZIP_OS_NAME: win_x64
 
       fail-fast: false
-    env:
-      POWERSHELL_TELEMETRY_OPTOUT: 1
-      DOTNET_CLI_TELEMETRY_OPTOUT: 1
-      RYUJINX_BASE_VERSION: "1.1.0"
     steps:
       - uses: actions/checkout@v3
+
       - uses: actions/setup-dotnet@v3
         with:
-          dotnet-version: 7.0.x
+          global-json-file: global.json
+
       - name: Get git short hash
         id: git_short_hash
         run: echo "result=$(git rev-parse --short "${{ github.sha }}")" >> $GITHUB_OUTPUT
         shell: bash
+
       - name: Build
         run: dotnet build -c "${{ matrix.configuration }}" -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER
+
       - name: Test
         run: dotnet test --no-build -c "${{ matrix.configuration }}"
+
       - name: Publish Ryujinx
-        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER Ryujinx --self-contained true
-        if: github.event_name == 'pull_request'
+        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER src/Ryujinx --self-contained true
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
       - name: Publish Ryujinx.Headless.SDL2
-        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_sdl2_headless -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER Ryujinx.Headless.SDL2 --self-contained true
-        if: github.event_name == 'pull_request'
+        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_sdl2_headless -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER src/Ryujinx.Headless.SDL2 --self-contained true
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
       - name: Publish Ryujinx.Ava
-        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_ava -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER Ryujinx.Ava --self-contained true
-        if: github.event_name == 'pull_request'
+        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_ava -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER src/Ryujinx.Ava --self-contained true
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
+      - name: Set executable bit
+        run: |
+          chmod +x ./publish/Ryujinx ./publish/Ryujinx.sh
+          chmod +x ./publish_sdl2_headless/Ryujinx.Headless.SDL2 ./publish_sdl2_headless/Ryujinx.sh
+          chmod +x ./publish_ava/Ryujinx.Ava ./publish_ava/Ryujinx.sh
+        if: github.event_name == 'pull_request' && matrix.os == 'ubuntu-latest'
+
       - name: Upload Ryujinx artifact
         uses: actions/upload-artifact@v3
         with:
           name: ryujinx-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-${{ matrix.RELEASE_ZIP_OS_NAME }}
           path: publish
-        if: github.event_name == 'pull_request'
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
       - name: Upload Ryujinx.Headless.SDL2 artifact
         uses: actions/upload-artifact@v3
         with:
           name: sdl2-ryujinx-headless-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-${{ matrix.RELEASE_ZIP_OS_NAME }}
           path: publish_sdl2_headless
-        if: github.event_name == 'pull_request'
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
       - name: Upload Ryujinx.Ava artifact
         uses: actions/upload-artifact@v3
         with:
           name: ava-ryujinx-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-${{ matrix.RELEASE_ZIP_OS_NAME }}
           path: publish_ava
-        if: github.event_name == 'pull_request'
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
+  build_macos:
+    name: macOS Universal (${{ matrix.configuration }})
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    strategy:
+      matrix:
+        configuration: [ Debug, Release ]
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-dotnet@v3
+        with:
+          global-json-file: global.json
+
+      - name: Setup LLVM 14
+        run: |
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 14
+
+      - name: Install rcodesign
+        run: |
+          mkdir -p $HOME/.bin
+          gh release download -R indygreg/apple-platform-rs -O apple-codesign.tar.gz -p 'apple-codesign-*-x86_64-unknown-linux-musl.tar.gz'
+          tar -xzvf apple-codesign.tar.gz --wildcards '*/rcodesign' --strip-components=1
+          rm apple-codesign.tar.gz
+          mv rcodesign $HOME/.bin/
+          echo "$HOME/.bin" >> $GITHUB_PATH
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get git short hash
+        id: git_short_hash
+        run: echo "result=$(git rev-parse --short "${{ github.sha }}")" >> $GITHUB_OUTPUT
+
+      - name: Publish macOS
+        run: |
+          ./distribution/macos/create_macos_build.sh . publish_tmp publish_ava ./distribution/macos/entitlements.xml "${{ env.RYUJINX_BASE_VERSION }}" "${{ steps.git_short_hash.outputs.result }}" "${{ matrix.configuration }}" "-p:ExtraDefineConstants=DISABLE_UPDATER"
+
+      - name: Upload Ryujinx.Ava artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: ava-ryujinx-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-macos_universal
+          path: "publish_ava/*.tar.gz"
+        if: github.event_name == 'pull_request'

.github/workflows/flatpak.yml

@@ -0,0 +1,172 @@
+name: Flatpak release job
+
+on:
+  workflow_call:
+    inputs:
+      ryujinx_version:
+        required: true
+        type: string
+
+
+concurrency: flatpak-release
+
+jobs:
+  release:
+    timeout-minutes: ${{ fromJSON(vars.JOB_TIMEOUT) }}
+    runs-on: ubuntu-latest
+
+    env:
+      NUGET_PACKAGES: ${{ github.workspace }}/.nuget/packages
+      GIT_COMMITTER_NAME: "RyujinxBot"
+      GIT_COMMITTER_EMAIL: "61127645+RyujinxBot@users.noreply.github.com"
+      RYUJINX_PROJECT_FILE: "src/Ryujinx/Ryujinx.csproj"
+      NUGET_SOURCES_DESTDIR: "nuget-sources"
+      RYUJINX_VERSION: "${{ inputs.ryujinx_version }}"
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          path: Ryujinx
+
+      - uses: actions/setup-dotnet@v3
+        with:
+          global-json-file: Ryujinx/global.json
+
+      - name: Get version info
+        id: version_info
+        working-directory: Ryujinx
+        run: |
+          echo "git_hash=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
+
+      - uses: actions/checkout@v3
+        with:
+          repository: flathub/org.ryujinx.Ryujinx
+          token: ${{ secrets.RYUJINX_BOT_PAT }}
+          submodules: recursive
+          path: flathub
+
+      - name: Install dependencies
+        run: python -m pip install PyYAML lxml
+
+      - name: Restore Nuget packages
+        run: dotnet restore Ryujinx/${{ env.RYUJINX_PROJECT_FILE }}
+
+      - name: Generate nuget_sources.json
+        shell: python
+        run: |
+          from pathlib import Path
+          import base64
+          import binascii
+          import json
+          import os
+
+          sources = []
+
+          for path in Path(os.environ['NUGET_PACKAGES']).glob('**/*.nupkg.sha512'):
+            name = path.parent.parent.name
+            version = path.parent.name
+            filename = '{}.{}.nupkg'.format(name, version)
+            url = 'https://api.nuget.org/v3-flatcontainer/{}/{}/{}'.format(name, version, filename)
+
+            with path.open() as fp:
+                sha512 = binascii.hexlify(base64.b64decode(fp.read())).decode('ascii')
+
+            sources.append({
+                'type': 'file',
+                'url': url,
+                'sha512': sha512,
+                'dest': os.environ['NUGET_SOURCES_DESTDIR'],
+                'dest-filename': filename,
+            })
+
+          with open('flathub/nuget_sources.json', 'w') as fp:
+            json.dump(sources, fp, indent=4)
+
+      - name: Update flatpak metadata
+        id: metadata
+        env:
+          RYUJINX_GIT_HASH: ${{ steps.version_info.outputs.git_hash }}
+        shell: python
+        run: |
+          import hashlib
+          import hmac
+          import json
+          import os
+          import yaml
+          from datetime import datetime
+          from lxml import etree
+          
+          
+          # Ensure we don't destroy multiline strings
+          def str_presenter(dumper, data):
+            if len(data.splitlines()) > 1:
+              return dumper.represent_scalar("tag:yaml.org,2002:str", data, style="|")
+            return dumper.represent_scalar("tag:yaml.org,2002:str", data)
+            
+            
+          yaml.representer.SafeRepresenter.add_representer(str, str_presenter)
+  
+          yaml_file = "flathub/org.ryujinx.Ryujinx.yml"
+          xml_file = "flathub/org.ryujinx.Ryujinx.appdata.xml"
+
+          with open(yaml_file, "r") as f:
+            data = yaml.safe_load(f)
+
+          for source in data["modules"][0]["sources"]:
+            if type(source) is str:
+              continue
+            if (
+              source["type"] == "git"
+              and source["url"] == "https://github.com/Ryujinx/Ryujinx.git"
+            ):
+              source["commit"] = os.environ['RYUJINX_GIT_HASH']
+
+          is_same_version = data["modules"][0]["build-options"]["env"]["RYUJINX_VERSION"] == os.environ['RYUJINX_VERSION']
+
+          with open(os.environ['GITHUB_OUTPUT'], "a") as gh_out:
+            if is_same_version:
+              gh_out.write(f"commit_message=Retry update to {os.environ['RYUJINX_VERSION']}")
+            else:
+              gh_out.write(f"commit_message=Update to {os.environ['RYUJINX_VERSION']}")
+
+          if not is_same_version:
+            data["modules"][0]["build-options"]["env"]["RYUJINX_VERSION"] = os.environ['RYUJINX_VERSION']
+
+            with open(yaml_file, "w") as f:
+                yaml.safe_dump(data, f, sort_keys=False)
+
+            parser = etree.XMLParser(remove_blank_text=True)
+            tree = etree.parse(xml_file, parser)
+
+            root = tree.getroot()
+
+            releases = root.find("releases")
+
+            element = etree.Element("release")
+            element.set("version", os.environ['RYUJINX_VERSION'])
+            element.set("date", datetime.now().date().isoformat())
+            releases.insert(0, element)
+
+            # Ensure 4 spaces
+            etree.indent(root, space="    ")
+
+            with open(xml_file, "wb") as f:
+              f.write(
+                etree.tostring(
+                  tree,
+                  pretty_print=True,
+                  encoding="UTF-8",
+                  doctype='<?xml version="1.0" encoding="UTF-8"?>',
+                )
+              )
+
+      - name: Push flatpak update
+        working-directory: flathub
+        env:
+          COMMIT_MESSAGE: ${{ steps.metadata.outputs.commit_message }}
+        run: |
+          git config user.name "${{ env.GIT_COMMITTER_NAME }}"
+          git config user.email "${{ env.GIT_COMMITTER_EMAIL }}"
+          git add .
+          git commit -m "$COMMIT_MESSAGE"
+          git push origin master

.github/workflows/nightly_pr_comment.yml

@@ -7,6 +7,7 @@ jobs:
   pr_comment:
     if: github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion == 'success'
     runs-on: ubuntu-latest
+    timeout-minutes: ${{ fromJSON(vars.JOB_TIMEOUT) }}
     steps:
       - uses: actions/github-script@v6
         with:
@@ -65,4 +66,4 @@ jobs:
             } else {
               core.info(`Creating a comment`);
               await github.rest.issues.createComment({repo, owner, issue_number, body});
-            }
+            }

.github/workflows/pr_triage.yml

@@ -0,0 +1,54 @@
+name: "Pull Request Triage"
+on:
+  pull_request_target:
+    types: [opened, ready_for_review]
+
+jobs:
+  triage:
+    permissions:
+      contents: read
+      pull-requests: write
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Update labels based on changes
+        uses: actions/labeler@v4
+        with:
+          sync-labels: true
+          dot: true
+
+      - name: Auto Assign [Audio]
+        uses: kentaro-m/auto-assign-action@v1.2.5
+        with:
+          configuration-path: '.github/assign/audio.yml'
+
+      - name: Auto Assign [CPU]
+        uses: kentaro-m/auto-assign-action@v1.2.5
+        with:
+          configuration-path: '.github/assign/cpu.yml'
+
+      - name: Auto Assign [GPU]
+        uses: kentaro-m/auto-assign-action@v1.2.5
+        with:
+          configuration-path: '.github/assign/gpu.yml'
+
+      - name: Auto Assign [GUI]
+        uses: kentaro-m/auto-assign-action@v1.2.5
+        with:
+          configuration-path: '.github/assign/gui.yml'
+
+      - name: Auto Assign [Horizon]
+        uses: kentaro-m/auto-assign-action@v1.2.5
+        with:
+          configuration-path: '.github/assign/horizon.yml'
+
+      - name: Auto Assign [Infra]
+        uses: kentaro-m/auto-assign-action@v1.2.5
+        with:
+          configuration-path: '.github/assign/infra.yml'
+
+      - name: Auto Assign [Global]
+        uses: kentaro-m/auto-assign-action@v1.2.5
+        with:
+          configuration-path: '.github/assign/global.yml'

.github/workflows/release.yml

@@ -6,96 +6,125 @@ on:
   push:
     branches: [ master ]
     paths-ignore:
-      - '.github/*'
-      - '.github/ISSUE_TEMPLATE/**'
+      - '.github/**'
       - '*.yml'
+      - '*.json'
+      - '*.config'
       - 'README.md'
 
 concurrency: release
 
+env:
+  POWERSHELL_TELEMETRY_OPTOUT: 1
+  DOTNET_CLI_TELEMETRY_OPTOUT: 1
+  RYUJINX_BASE_VERSION: "1.1"
+  RYUJINX_TARGET_RELEASE_CHANNEL_NAME: "master"
+  RYUJINX_TARGET_RELEASE_CHANNEL_OWNER: "Ryujinx"
+  RYUJINX_TARGET_RELEASE_CHANNEL_REPO: "release-channel-master"
+
 jobs:
+  tag:
+    name: Create tag
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get version info
+        id: version_info
+        run: |
+          echo "build_version=${{ env.RYUJINX_BASE_VERSION }}.${{ github.run_number }}" >> $GITHUB_OUTPUT
+        shell: bash
+
+      - name: Create tag
+        uses: actions/github-script@v6
+        with:
+          script: |
+            github.rest.git.createRef({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              ref: 'refs/tags/${{ steps.version_info.outputs.build_version }}',
+              sha: context.sha
+            })
+
   release:
-    runs-on: windows-latest
-
-    env:
-      POWERSHELL_TELEMETRY_OPTOUT: 1
-      DOTNET_CLI_TELEMETRY_OPTOUT: 1
-      RYUJINX_BASE_VERSION: "1.1"
-      RYUJINX_TARGET_RELEASE_CHANNEL_NAME: "master"
-      RYUJINX_TARGET_RELEASE_CHANNEL_OWNER: "Ryujinx"
-      RYUJINX_TARGET_RELEASE_CHANNEL_REPO: "release-channel-master"
+    name: Release ${{ matrix.OS_NAME }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: ${{ fromJSON(vars.JOB_TIMEOUT) }}
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, windows-latest ]
+        include:
+          - os: ubuntu-latest
+            OS_NAME: Linux x64
+            DOTNET_RUNTIME_IDENTIFIER: linux-x64
+            RELEASE_ZIP_OS_NAME: linux_x64
 
+          - os: windows-latest
+            OS_NAME: Windows x64
+            DOTNET_RUNTIME_IDENTIFIER: win10-x64
+            RELEASE_ZIP_OS_NAME: win_x64
     steps:
       - uses: actions/checkout@v3
+
       - uses: actions/setup-dotnet@v3
         with:
-          dotnet-version: 7.0.x
+          global-json-file: global.json
+
       - name: Get version info
         id: version_info
         run: |
           echo "build_version=${{ env.RYUJINX_BASE_VERSION }}.${{ github.run_number }}" >> $GITHUB_OUTPUT
           echo "git_short_hash=$(git rev-parse --short "${{ github.sha }}")" >> $GITHUB_OUTPUT
         shell: bash
+
       - name: Configure for release
         run: |
-          sed -r --in-place 's/\%\%RYUJINX_BUILD_VERSION\%\%/${{ steps.version_info.outputs.build_version }}/g;' Ryujinx.Common/ReleaseInformation.cs
-          sed -r --in-place 's/\%\%RYUJINX_BUILD_GIT_HASH\%\%/${{ steps.version_info.outputs.git_short_hash }}/g;' Ryujinx.Common/ReleaseInformation.cs
-          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_NAME\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_NAME }}/g;' Ryujinx.Common/ReleaseInformation.cs
-          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_OWNER\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}/g;' Ryujinx.Common/ReleaseInformation.cs
-          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_REPO\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}/g;' Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_BUILD_VERSION\%\%/${{ steps.version_info.outputs.build_version }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_BUILD_GIT_HASH\%\%/${{ steps.version_info.outputs.git_short_hash }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_NAME\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_NAME }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_OWNER\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_REPO\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
         shell: bash
+
       - name: Create output dir
         run: "mkdir release_output"
-      - name: Publish Windows
+
+      - name: Publish
         run: |
-          dotnet publish -c Release -r win10-x64 -o ./publish_windows/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded Ryujinx --self-contained true
-          dotnet publish -c Release -r win10-x64 -o ./publish_windows_sdl2_headless/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded Ryujinx.Headless.SDL2 --self-contained true
-          dotnet publish -c Release -r win10-x64 -o ./publish_windows_ava/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded Ryujinx.Ava --self-contained true
+          dotnet publish -c Release -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_gtk/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded src/Ryujinx --self-contained true
+          dotnet publish -c Release -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_sdl2_headless/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded src/Ryujinx.Headless.SDL2 --self-contained true
+          dotnet publish -c Release -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_ava/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded src/Ryujinx.Ava --self-contained true
+
       - name: Packing Windows builds
+        if: matrix.os == 'windows-latest'
         run: |
-          pushd publish_windows
+          pushd publish_gtk
           7z a ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-win_x64.zip publish
           popd
 
-          pushd publish_windows_sdl2_headless
+          pushd publish_sdl2_headless
           7z a ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-win_x64.zip publish
           popd
 
-          pushd publish_windows_ava
+          pushd publish_ava
           7z a ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-win_x64.zip publish
           popd
         shell: bash
 
-      - name: Publish Linux
-        run: |
-          dotnet publish -c Release -r linux-x64 -o ./publish_linux/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded Ryujinx --self-contained true
-          dotnet publish -c Release -r linux-x64 -o ./publish_linux_sdl2_headless/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded Ryujinx.Headless.SDL2 --self-contained true
-          dotnet publish -c Release -r linux-x64 -o ./publish_linux_ava/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded Ryujinx.Ava --self-contained true
-
       - name: Packing Linux builds
+        if: matrix.os == 'ubuntu-latest'
         run: |
-          pushd publish_linux
-          tar --exclude "publish/Ryujinx" --exclude "publish/Ryujinx.sh" -cvf ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar publish
-          python3 ../distribution/misc/add_tar_exec.py ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar "publish/Ryujinx" "publish/Ryujinx"
-          python3 ../distribution/misc/add_tar_exec.py ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar "publish/Ryujinx.sh" "publish/Ryujinx.sh"
-          gzip -9 < ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar > ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar.gz
-          rm ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar
+          pushd publish_gtk
+          chmod +x publish/Ryujinx.sh publish/Ryujinx
+          tar -czvf ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar.gz publish
           popd
 
-          pushd publish_linux_sdl2_headless
-          tar --exclude "publish/Ryujinx.Headless.SDL2" --exclude "publish/Ryujinx.sh" -cvf ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar publish
-          python3 ../distribution/misc/add_tar_exec.py ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar "publish/Ryujinx.Headless.SDL2" "publish/Ryujinx.Headless.SDL2"
-          python3 ../distribution/misc/add_tar_exec.py ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar "publish/Ryujinx.sh" "publish/Ryujinx.sh"
-          gzip -9 < ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar > ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar.gz
-          rm ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar
+          pushd publish_sdl2_headless
+          chmod +x publish/Ryujinx.sh publish/Ryujinx.Headless.SDL2
+          tar -czvf ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar.gz publish
           popd
 
-          pushd publish_linux_ava
-          tar --exclude "publish/Ryujinx.Ava" --exclude "publish/Ryujinx.sh" -cvf ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar publish
-          python3 ../distribution/misc/add_tar_exec.py ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar "publish/Ryujinx.Ava" "publish/Ryujinx.Ava"
-          python3 ../distribution/misc/add_tar_exec.py ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar "publish/Ryujinx.sh" "publish/Ryujinx.sh"
-          gzip -9 < ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar > ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar.gz
-          rm ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar
+          pushd publish_ava
+          chmod +x publish/Ryujinx.sh publish/Ryujinx.Ava
+          tar -czvf ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar.gz publish
           popd
         shell: bash
 
@@ -105,10 +134,78 @@ jobs:
           name: ${{ steps.version_info.outputs.build_version }}
           artifacts: "release_output/*.tar.gz,release_output/*.zip"
           tag: ${{ steps.version_info.outputs.build_version }}
-          body: "For more informations about this release please check out the official [Changelog](https://github.com/Ryujinx/Ryujinx/wiki/Changelog)."
+          body: "For more information about this release please check out the official [Changelog](https://github.com/Ryujinx/Ryujinx/wiki/Changelog)."
+          omitBodyDuringUpdate: true
           allowUpdates: true
-          removeArtifacts: true
           replacesArtifacts: true
           owner: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}
           repo: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}
           token: ${{ secrets.RELEASE_TOKEN }}
+
+  macos_release:
+    name: Release MacOS universal
+    runs-on: ubuntu-latest
+    timeout-minutes: ${{ fromJSON(vars.JOB_TIMEOUT) }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-dotnet@v3
+        with:
+          global-json-file: global.json
+
+      - name: Setup LLVM 14
+        run: |
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 14
+
+      - name: Install rcodesign
+        run: |
+          mkdir -p $HOME/.bin
+          gh release download -R indygreg/apple-platform-rs -O apple-codesign.tar.gz -p 'apple-codesign-*-x86_64-unknown-linux-musl.tar.gz'
+          tar -xzvf apple-codesign.tar.gz --wildcards '*/rcodesign' --strip-components=1
+          rm apple-codesign.tar.gz
+          mv rcodesign $HOME/.bin/
+          echo "$HOME/.bin" >> $GITHUB_PATH
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get version info
+        id: version_info
+        run: |
+          echo "build_version=${{ env.RYUJINX_BASE_VERSION }}.${{ github.run_number }}" >> $GITHUB_OUTPUT
+          echo "git_short_hash=$(git rev-parse --short "${{ github.sha }}")" >> $GITHUB_OUTPUT
+
+      - name: Configure for release
+        run: |
+          sed -r --in-place 's/\%\%RYUJINX_BUILD_VERSION\%\%/${{ steps.version_info.outputs.build_version }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_BUILD_GIT_HASH\%\%/${{ steps.version_info.outputs.git_short_hash }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_NAME\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_NAME }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_OWNER\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_REPO\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+        shell: bash
+
+      - name: Publish macOS
+        run: |
+          ./distribution/macos/create_macos_build.sh . publish_tmp publish_ava ./distribution/macos/entitlements.xml "${{ steps.version_info.outputs.build_version }}" "${{ steps.version_info.outputs.git_short_hash }}" Release
+
+      - name: Pushing new release
+        uses: ncipollo/release-action@v1
+        with:
+          name: ${{ steps.version_info.outputs.build_version }}
+          artifacts: "publish_ava/*.tar.gz"
+          tag: ${{ steps.version_info.outputs.build_version }}
+          body: "For more information about this release please check out the official [Changelog](https://github.com/Ryujinx/Ryujinx/wiki/Changelog)."
+          omitBodyDuringUpdate: true
+          allowUpdates: true
+          replacesArtifacts: true
+          owner: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}
+          repo: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}
+          token: ${{ secrets.RELEASE_TOKEN }}
+
+  flatpak_release:
+    uses: ./.github/workflows/flatpak.yml
+    needs: release
+    with:
+      ryujinx_version: "1.1.${{ github.run_number }}"
+    secrets: inherit

ARMeilleure/ARMeilleure.csproj

@@ -1,25 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\Ryujinx.Common\Ryujinx.Common.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ContentWithTargetPath Include="Native\libs\libarmeilleure-jitsupport.dylib" Condition="'$(RuntimeIdentifier)' == '' OR '$(RuntimeIdentifier)' == 'osx-arm64'">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <TargetPath>libarmeilleure-jitsupport.dylib</TargetPath>
-    </ContentWithTargetPath>
-  </ItemGroup>
-
-  <ItemGroup>
-    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
-      <_Parameter1>Ryujinx.Tests</_Parameter1>
-    </AssemblyAttribute>
-  </ItemGroup>
-
-</Project>

ARMeilleure/CodeGen/Arm64/CodeGenContext.cs

@@ -1,286 +0,0 @@
-using ARMeilleure.CodeGen.Linking;
-using ARMeilleure.CodeGen.RegisterAllocators;
-using ARMeilleure.IntermediateRepresentation;
-using System;
-using System.Collections.Generic;
-using System.IO;
-
-namespace ARMeilleure.CodeGen.Arm64
-{
-    class CodeGenContext
-    {
-        private const int BccInstLength = 4;
-        private const int CbnzInstLength = 4;
-        private const int LdrLitInstLength = 4;
-
-        private Stream _stream;
-
-        public int StreamOffset => (int)_stream.Length;
-
-        public AllocationResult AllocResult { get; }
-
-        public Assembler Assembler { get; }
-
-        public BasicBlock CurrBlock { get; private set; }
-
-        public bool HasCall { get; }
-
-        public int CallArgsRegionSize { get; }
-        public int FpLrSaveRegionSize { get; }
-
-        private readonly Dictionary<BasicBlock, long> _visitedBlocks;
-        private readonly Dictionary<BasicBlock, List<(ArmCondition Condition, long BranchPos)>> _pendingBranches;
-
-        private struct ConstantPoolEntry
-        {
-            public readonly int Offset;
-            public readonly Symbol Symbol;
-            public readonly List<(Operand, int)> LdrOffsets;
-
-            public ConstantPoolEntry(int offset, Symbol symbol)
-            {
-                Offset = offset;
-                Symbol = symbol;
-                LdrOffsets = new List<(Operand, int)>();
-            }
-        }
-
-        private readonly Dictionary<ulong, ConstantPoolEntry> _constantPool;
-
-        private bool _constantPoolWritten;
-        private long _constantPoolOffset;
-
-        private ArmCondition _jNearCondition;
-        private Operand _jNearValue;
-
-        private long _jNearPosition;
-
-        private readonly bool _relocatable;
-
-        public CodeGenContext(AllocationResult allocResult, int maxCallArgs, int blocksCount, bool relocatable)
-        {
-            _stream = new MemoryStream();
-
-            AllocResult = allocResult;
-
-            Assembler = new Assembler(_stream);
-
-            bool hasCall = maxCallArgs >= 0;
-
-            HasCall = hasCall;
-
-            if (maxCallArgs < 0)
-            {
-                maxCallArgs = 0;
-            }
-
-            CallArgsRegionSize = maxCallArgs * 16;
-            FpLrSaveRegionSize = hasCall ? 16 : 0;
-
-            _visitedBlocks = new Dictionary<BasicBlock, long>();
-            _pendingBranches = new Dictionary<BasicBlock, List<(ArmCondition, long)>>();
-            _constantPool = new Dictionary<ulong, ConstantPoolEntry>();
-
-            _relocatable = relocatable;
-        }
-
-        public void EnterBlock(BasicBlock block)
-        {
-            CurrBlock = block;
-
-            long target = _stream.Position;
-
-            if (_pendingBranches.TryGetValue(block, out var list))
-            {
-                foreach (var tuple in list)
-                {
-                    _stream.Seek(tuple.BranchPos, SeekOrigin.Begin);
-                    WriteBranch(tuple.Condition, target);
-                }
-
-                _stream.Seek(target, SeekOrigin.Begin);
-                _pendingBranches.Remove(block);
-            }
-
-            _visitedBlocks.Add(block, target);
-        }
-
-        public void JumpTo(BasicBlock target)
-        {
-            JumpTo(ArmCondition.Al, target);
-        }
-
-        public void JumpTo(ArmCondition condition, BasicBlock target)
-        {
-            if (_visitedBlocks.TryGetValue(target, out long offset))
-            {
-                WriteBranch(condition, offset);
-            }
-            else
-            {
-                if (!_pendingBranches.TryGetValue(target, out var list))
-                {
-                    list = new List<(ArmCondition, long)>();
-                    _pendingBranches.Add(target, list);
-                }
-
-                list.Add((condition, _stream.Position));
-
-                _stream.Seek(BccInstLength, SeekOrigin.Current);
-            }
-        }
-
-        private void WriteBranch(ArmCondition condition, long to)
-        {
-            int imm = checked((int)(to - _stream.Position));
-
-            if (condition != ArmCondition.Al)
-            {
-                Assembler.B(condition, imm);
-            }
-            else
-            {
-                Assembler.B(imm);
-            }
-        }
-
-        public void JumpToNear(ArmCondition condition)
-        {
-            _jNearCondition = condition;
-            _jNearPosition = _stream.Position;
-
-            _stream.Seek(BccInstLength, SeekOrigin.Current);
-        }
-
-        public void JumpToNearIfNotZero(Operand value)
-        {
-            _jNearValue = value;
-            _jNearPosition = _stream.Position;
-
-            _stream.Seek(CbnzInstLength, SeekOrigin.Current);
-        }
-
-        public void JumpHere()
-        {
-            long currentPosition = _stream.Position;
-            long offset = currentPosition - _jNearPosition;
-
-            _stream.Seek(_jNearPosition, SeekOrigin.Begin);
-
-            if (_jNearValue != default)
-            {
-                Assembler.Cbnz(_jNearValue, checked((int)offset));
-                _jNearValue = default;
-            }
-            else
-            {
-                Assembler.B(_jNearCondition, checked((int)offset));
-            }
-
-            _stream.Seek(currentPosition, SeekOrigin.Begin);
-        }
-
-        public void ReserveRelocatableConstant(Operand rt, Symbol symbol, ulong value)
-        {
-            if (!_constantPool.TryGetValue(value, out ConstantPoolEntry cpe))
-            {
-                cpe = new ConstantPoolEntry(_constantPool.Count * sizeof(ulong), symbol);
-                _constantPool.Add(value, cpe);
-            }
-
-            cpe.LdrOffsets.Add((rt, (int)_stream.Position));
-            _stream.Seek(LdrLitInstLength, SeekOrigin.Current);
-        }
-
-        private long WriteConstantPool()
-        {
-            if (_constantPoolWritten)
-            {
-                return _constantPoolOffset;
-            }
-
-            long constantPoolBaseOffset = _stream.Position;
-
-            foreach (ulong value in _constantPool.Keys)
-            {
-                WriteUInt64(value);
-            }
-
-            foreach (ConstantPoolEntry cpe in _constantPool.Values)
-            {
-                foreach ((Operand rt, int ldrOffset) in cpe.LdrOffsets)
-                {
-                    _stream.Seek(ldrOffset, SeekOrigin.Begin);
-
-                    int absoluteOffset = checked((int)(constantPoolBaseOffset + cpe.Offset));
-                    int pcRelativeOffset = absoluteOffset - ldrOffset;
-
-                    Assembler.LdrLit(rt, pcRelativeOffset);
-                }
-            }
-
-            _stream.Seek(constantPoolBaseOffset + _constantPool.Count * sizeof(ulong), SeekOrigin.Begin);
-
-            _constantPoolOffset = constantPoolBaseOffset;
-            _constantPoolWritten = true;
-
-            return constantPoolBaseOffset;
-        }
-
-        public (byte[], RelocInfo) GetCode()
-        {
-            long constantPoolBaseOffset = WriteConstantPool();
-
-            byte[] code = new byte[_stream.Length];
-
-            long originalPosition = _stream.Position;
-
-            _stream.Seek(0, SeekOrigin.Begin);
-            _stream.Read(code, 0, code.Length);
-            _stream.Seek(originalPosition, SeekOrigin.Begin);
-
-            RelocInfo relocInfo;
-
-            if (_relocatable)
-            {
-                RelocEntry[] relocs = new RelocEntry[_constantPool.Count];
-
-                int index = 0;
-
-                foreach (ConstantPoolEntry cpe in _constantPool.Values)
-                {
-                    if (cpe.Symbol.Type != SymbolType.None)
-                    {
-                        int absoluteOffset = checked((int)(constantPoolBaseOffset + cpe.Offset));
-                        relocs[index++] = new RelocEntry(absoluteOffset, cpe.Symbol);
-                    }
-                }
-
-                if (index != relocs.Length)
-                {
-                    Array.Resize(ref relocs, index);
-                }
-
-                relocInfo = new RelocInfo(relocs);
-            }
-            else
-            {
-                relocInfo = new RelocInfo(new RelocEntry[0]);
-            }
-
-            return (code, relocInfo);
-        }
-
-        private void WriteUInt64(ulong value)
-        {
-            _stream.WriteByte((byte)(value >> 0));
-            _stream.WriteByte((byte)(value >> 8));
-            _stream.WriteByte((byte)(value >> 16));
-            _stream.WriteByte((byte)(value >> 24));
-            _stream.WriteByte((byte)(value >> 32));
-            _stream.WriteByte((byte)(value >> 40));
-            _stream.WriteByte((byte)(value >> 48));
-            _stream.WriteByte((byte)(value >> 56));
-        }
-    }
-}

ARMeilleure/CodeGen/Arm64/CodeGeneratorIntrinsic.cs

@@ -1,662 +0,0 @@
-using ARMeilleure.IntermediateRepresentation;
-using System;
-using System.Diagnostics;
-
-namespace ARMeilleure.CodeGen.Arm64
-{
-    static class CodeGeneratorIntrinsic
-    {
-        public static void GenerateOperation(CodeGenContext context, Operation operation)
-        {
-            Intrinsic intrin = operation.Intrinsic;
-
-            IntrinsicInfo info = IntrinsicTable.GetInfo(intrin & ~(Intrinsic.Arm64VTypeMask | Intrinsic.Arm64VSizeMask));
-
-            switch (info.Type)
-            {
-                case IntrinsicType.ScalarUnary:
-                    GenerateVectorUnary(
-                        context,
-                        0,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0));
-                    break;
-                case IntrinsicType.ScalarUnaryByElem:
-                    Debug.Assert(operation.GetSource(1).Kind == OperandKind.Constant);
-
-                    GenerateVectorUnaryByElem(
-                        context,
-                        0,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        (uint)operation.GetSource(1).AsInt32(),
-                        operation.Destination,
-                        operation.GetSource(0));
-                    break;
-                case IntrinsicType.ScalarBinary:
-                    GenerateVectorBinary(
-                        context,
-                        0,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0),
-                        operation.GetSource(1));
-                    break;
-                case IntrinsicType.ScalarBinaryFPByElem:
-                    Debug.Assert(operation.GetSource(2).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryFPByElem(
-                        context,
-                        0,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        (uint)operation.GetSource(2).AsInt32(),
-                        operation.Destination,
-                        operation.GetSource(0),
-                        operation.GetSource(1));
-                    break;
-                case IntrinsicType.ScalarBinaryRd:
-                    GenerateVectorUnary(
-                        context,
-                        0,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(1));
-                    break;
-                case IntrinsicType.ScalarBinaryShl:
-                    Debug.Assert(operation.GetSource(1).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryShlImm(
-                        context,
-                        0,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0),
-                        (uint)operation.GetSource(1).AsInt32());
-                    break;
-                case IntrinsicType.ScalarBinaryShr:
-                    Debug.Assert(operation.GetSource(1).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryShrImm(
-                        context,
-                        0,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0),
-                        (uint)operation.GetSource(1).AsInt32());
-                    break;
-                case IntrinsicType.ScalarFPCompare:
-                    GenerateScalarFPCompare(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0),
-                        operation.GetSource(1));
-                    break;
-                case IntrinsicType.ScalarFPConvFixed:
-                    Debug.Assert(operation.GetSource(1).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryShrImm(
-                        context,
-                        0,
-                        ((uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift) + 2u,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0),
-                        (uint)operation.GetSource(1).AsInt32());
-                    break;
-                case IntrinsicType.ScalarFPConvFixedGpr:
-                    Debug.Assert(operation.GetSource(1).Kind == OperandKind.Constant);
-
-                    GenerateScalarFPConvGpr(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0),
-                        (uint)operation.GetSource(1).AsInt32());
-                    break;
-                case IntrinsicType.ScalarFPConvGpr:
-                    GenerateScalarFPConvGpr(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0));
-                    break;
-                case IntrinsicType.ScalarTernary:
-                    GenerateScalarTernary(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(1),
-                        operation.GetSource(2),
-                        operation.GetSource(0));
-                    break;
-                case IntrinsicType.ScalarTernaryFPRdByElem:
-                    Debug.Assert(operation.GetSource(3).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryFPByElem(
-                        context,
-                        0,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        (uint)operation.GetSource(3).AsInt32(),
-                        operation.Destination,
-                        operation.GetSource(1),
-                        operation.GetSource(2));
-                    break;
-                case IntrinsicType.ScalarTernaryShlRd:
-                    Debug.Assert(operation.GetSource(2).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryShlImm(
-                        context,
-                        0,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(1),
-                        (uint)operation.GetSource(2).AsInt32());
-                    break;
-                case IntrinsicType.ScalarTernaryShrRd:
-                    Debug.Assert(operation.GetSource(2).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryShrImm(
-                        context,
-                        0,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(1),
-                        (uint)operation.GetSource(2).AsInt32());
-                    break;
-
-                case IntrinsicType.VectorUnary:
-                    GenerateVectorUnary(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0));
-                    break;
-                case IntrinsicType.VectorUnaryByElem:
-                    Debug.Assert(operation.GetSource(1).Kind == OperandKind.Constant);
-
-                    GenerateVectorUnaryByElem(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        (uint)operation.GetSource(1).AsInt32(),
-                        operation.Destination,
-                        operation.GetSource(0));
-                    break;
-                case IntrinsicType.VectorBinary:
-                    GenerateVectorBinary(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0),
-                        operation.GetSource(1));
-                    break;
-                case IntrinsicType.VectorBinaryBitwise:
-                    GenerateVectorBinary(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0),
-                        operation.GetSource(1));
-                    break;
-                case IntrinsicType.VectorBinaryByElem:
-                    Debug.Assert(operation.GetSource(2).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryByElem(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        (uint)operation.GetSource(2).AsInt32(),
-                        operation.Destination,
-                        operation.GetSource(0),
-                        operation.GetSource(1));
-                    break;
-                case IntrinsicType.VectorBinaryFPByElem:
-                    Debug.Assert(operation.GetSource(2).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryFPByElem(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        (uint)operation.GetSource(2).AsInt32(),
-                        operation.Destination,
-                        operation.GetSource(0),
-                        operation.GetSource(1));
-                    break;
-                case IntrinsicType.VectorBinaryRd:
-                    GenerateVectorUnary(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(1));
-                    break;
-                case IntrinsicType.VectorBinaryShl:
-                    Debug.Assert(operation.GetSource(1).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryShlImm(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0),
-                        (uint)operation.GetSource(1).AsInt32());
-                    break;
-                case IntrinsicType.VectorBinaryShr:
-                    Debug.Assert(operation.GetSource(1).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryShrImm(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0),
-                        (uint)operation.GetSource(1).AsInt32());
-                    break;
-                case IntrinsicType.VectorFPConvFixed:
-                    Debug.Assert(operation.GetSource(1).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryShrImm(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        ((uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift) + 2u,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(0),
-                        (uint)operation.GetSource(1).AsInt32());
-                    break;
-                case IntrinsicType.VectorInsertByElem:
-                    Debug.Assert(operation.GetSource(1).Kind == OperandKind.Constant);
-                    Debug.Assert(operation.GetSource(3).Kind == OperandKind.Constant);
-
-                    GenerateVectorInsertByElem(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        (uint)operation.GetSource(3).AsInt32(),
-                        (uint)operation.GetSource(1).AsInt32(),
-                        operation.Destination,
-                        operation.GetSource(2));
-                    break;
-                case IntrinsicType.VectorLookupTable:
-                    Debug.Assert((uint)(operation.SourcesCount - 2) <= 3);
-
-                    for (int i = 1; i < operation.SourcesCount - 1; i++)
-                    {
-                        Register currReg = operation.GetSource(i).GetRegister();
-                        Register prevReg = operation.GetSource(i - 1).GetRegister();
-
-                        Debug.Assert(prevReg.Index + 1 == currReg.Index && currReg.Type == RegisterType.Vector);
-                    }
-
-                    GenerateVectorBinary(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        info.Inst | ((uint)(operation.SourcesCount - 2) << 13),
-                        operation.Destination,
-                        operation.GetSource(0),
-                        operation.GetSource(operation.SourcesCount - 1));
-                    break;
-                case IntrinsicType.VectorTernaryFPRdByElem:
-                    Debug.Assert(operation.GetSource(3).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryFPByElem(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        (uint)operation.GetSource(3).AsInt32(),
-                        operation.Destination,
-                        operation.GetSource(1),
-                        operation.GetSource(2));
-                    break;
-                case IntrinsicType.VectorTernaryRd:
-                    GenerateVectorBinary(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(1),
-                        operation.GetSource(2));
-                    break;
-                case IntrinsicType.VectorTernaryRdBitwise:
-                    GenerateVectorBinary(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(1),
-                        operation.GetSource(2));
-                    break;
-                case IntrinsicType.VectorTernaryRdByElem:
-                    Debug.Assert(operation.GetSource(3).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryByElem(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        (uint)operation.GetSource(3).AsInt32(),
-                        operation.Destination,
-                        operation.GetSource(1),
-                        operation.GetSource(2));
-                    break;
-                case IntrinsicType.VectorTernaryShlRd:
-                    Debug.Assert(operation.GetSource(2).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryShlImm(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(1),
-                        (uint)operation.GetSource(2).AsInt32());
-                    break;
-                case IntrinsicType.VectorTernaryShrRd:
-                    Debug.Assert(operation.GetSource(2).Kind == OperandKind.Constant);
-
-                    GenerateVectorBinaryShrImm(
-                        context,
-                        (uint)(intrin & Intrinsic.Arm64VTypeMask) >> (int)Intrinsic.Arm64VTypeShift,
-                        (uint)(intrin & Intrinsic.Arm64VSizeMask) >> (int)Intrinsic.Arm64VSizeShift,
-                        info.Inst,
-                        operation.Destination,
-                        operation.GetSource(1),
-                        (uint)operation.GetSource(2).AsInt32());
-                    break;
-
-                case IntrinsicType.GetRegister:
-                    context.Assembler.WriteInstruction(info.Inst, operation.Destination);
-                    break;
-                case IntrinsicType.SetRegister:
-                    context.Assembler.WriteInstruction(info.Inst, operation.GetSource(0));
-                    break;
-
-                default:
-                    throw new NotImplementedException(info.Type.ToString());
-            }
-        }
-
-        private static void GenerateScalarFPCompare(
-            CodeGenContext context,
-            uint sz,
-            uint instruction,
-            Operand dest,
-            Operand rn,
-            Operand rm)
-        {
-            instruction |= (sz << 22);
-
-            if (rm.Kind == OperandKind.Constant && rm.Value == 0)
-            {
-                instruction |= 0b1000;
-                rm = rn;
-            }
-
-            context.Assembler.WriteInstructionRm16NoRet(instruction, rn, rm);
-            context.Assembler.Mrs(dest, 1, 3, 4, 2, 0);
-        }
-
-        private static void GenerateScalarFPConvGpr(
-            CodeGenContext context,
-            uint sz,
-            uint instruction,
-            Operand rd,
-            Operand rn)
-        {
-            instruction |= (sz << 22);
-
-            if (rd.Type.IsInteger())
-            {
-                context.Assembler.WriteInstructionAuto(instruction, rd, rn);
-            }
-            else
-            {
-                if (rn.Type == OperandType.I64)
-                {
-                    instruction |= Assembler.SfFlag;
-                }
-
-                context.Assembler.WriteInstruction(instruction, rd, rn);
-            }
-        }
-
-        private static void GenerateScalarFPConvGpr(
-            CodeGenContext context,
-            uint sz,
-            uint instruction,
-            Operand rd,
-            Operand rn,
-            uint fBits)
-        {
-            Debug.Assert(fBits <= 64);
-
-            instruction |= (sz << 22);
-            instruction |= (64 - fBits) << 10;
-
-            if (rd.Type.IsInteger())
-            {
-                Debug.Assert(rd.Type != OperandType.I32 || fBits <= 32);
-
-                context.Assembler.WriteInstructionAuto(instruction, rd, rn);
-            }
-            else
-            {
-                if (rn.Type == OperandType.I64)
-                {
-                    instruction |= Assembler.SfFlag;
-                }
-                else
-                {
-                    Debug.Assert(fBits <= 32);
-                }
-
-                context.Assembler.WriteInstruction(instruction, rd, rn);
-            }
-
-        }
-
-        private static void GenerateScalarTernary(
-            CodeGenContext context,
-            uint sz,
-            uint instruction,
-            Operand rd,
-            Operand rn,
-            Operand rm,
-            Operand ra)
-        {
-            instruction |= (sz << 22);
-
-            context.Assembler.WriteInstruction(instruction, rd, rn, rm, ra);
-        }
-
-        private static void GenerateVectorUnary(
-            CodeGenContext context,
-            uint q,
-            uint sz,
-            uint instruction,
-            Operand rd,
-            Operand rn)
-        {
-            instruction |= (q << 30) | (sz << 22);
-
-            context.Assembler.WriteInstruction(instruction, rd, rn);
-        }
-
-        private static void GenerateVectorUnaryByElem(
-            CodeGenContext context,
-            uint q,
-            uint sz,
-            uint instruction,
-            uint srcIndex,
-            Operand rd,
-            Operand rn)
-        {
-            uint imm5 = (srcIndex << ((int)sz + 1)) | (1u << (int)sz);
-
-            instruction |= (q << 30) | (imm5 << 16);
-
-            context.Assembler.WriteInstruction(instruction, rd, rn);
-        }
-
-        private static void GenerateVectorBinary(
-            CodeGenContext context,
-            uint q,
-            uint instruction,
-            Operand rd,
-            Operand rn,
-            Operand rm)
-        {
-            instruction |= (q << 30);
-
-            context.Assembler.WriteInstructionRm16(instruction, rd, rn, rm);
-        }
-
-        private static void GenerateVectorBinary(
-            CodeGenContext context,
-            uint q,
-            uint sz,
-            uint instruction,
-            Operand rd,
-            Operand rn,
-            Operand rm)
-        {
-            instruction |= (q << 30) | (sz << 22);
-
-            context.Assembler.WriteInstructionRm16(instruction, rd, rn, rm);
-        }
-
-        private static void GenerateVectorBinaryByElem(
-            CodeGenContext context,
-            uint q,
-            uint size,
-            uint instruction,
-            uint srcIndex,
-            Operand rd,
-            Operand rn,
-            Operand rm)
-        {
-            instruction |= (q << 30) | (size << 22);
-
-            if (size == 2)
-            {
-                instruction |= ((srcIndex & 1) << 21) | ((srcIndex & 2) << 10);
-            }
-            else
-            {
-                instruction |= ((srcIndex & 3) << 20) | ((srcIndex & 4) << 9);
-            }
-
-            context.Assembler.WriteInstructionRm16(instruction, rd, rn, rm);
-        }
-
-        private static void GenerateVectorBinaryFPByElem(
-            CodeGenContext context,
-            uint q,
-            uint sz,
-            uint instruction,
-            uint srcIndex,
-            Operand rd,
-            Operand rn,
-            Operand rm)
-        {
-            instruction |= (q << 30) | (sz << 22);
-
-            if (sz != 0)
-            {
-                instruction |= (srcIndex & 1) << 11;
-            }
-            else
-            {
-                instruction |= ((srcIndex & 1) << 21) | ((srcIndex & 2) << 10);
-            }
-
-            context.Assembler.WriteInstructionRm16(instruction, rd, rn, rm);
-        }
-
-        private static void GenerateVectorBinaryShlImm(
-            CodeGenContext context,
-            uint q,
-            uint sz,
-            uint instruction,
-            Operand rd,
-            Operand rn,
-            uint shift)
-        {
-            instruction |= (q << 30);
-
-            Debug.Assert(shift >= 0 && shift < (8u << (int)sz));
-
-            uint imm = (8u << (int)sz) | (shift & (0x3fu >> (int)(3 - sz)));
-
-            instruction |= (imm << 16);
-
-            context.Assembler.WriteInstruction(instruction, rd, rn);
-        }
-
-        private static void GenerateVectorBinaryShrImm(
-            CodeGenContext context,
-            uint q,
-            uint sz,
-            uint instruction,
-            Operand rd,
-            Operand rn,
-            uint shift)
-        {
-            instruction |= (q << 30);
-
-            Debug.Assert(shift > 0 && shift <= (8u << (int)sz));
-
-            uint imm = (8u << (int)sz) | ((8u << (int)sz) - shift);
-
-            instruction |= (imm << 16);
-
-            context.Assembler.WriteInstruction(instruction, rd, rn);
-        }
-
-        private static void GenerateVectorInsertByElem(
-            CodeGenContext context,
-            uint sz,
-            uint instruction,
-            uint srcIndex,
-            uint dstIndex,
-            Operand rd,
-            Operand rn)
-        {
-            uint imm4 = srcIndex << (int)sz;
-            uint imm5 = (dstIndex << ((int)sz + 1)) | (1u << (int)sz);
-
-            instruction |= imm4 << 11;
-            instruction |= imm5 << 16;
-
-            context.Assembler.WriteInstruction(instruction, rd, rn);
-        }
-    }
-}

ARMeilleure/CodeGen/Arm64/IntrinsicTable.cs

@@ -1,461 +0,0 @@
-using ARMeilleure.Common;
-using ARMeilleure.IntermediateRepresentation;
-
-namespace ARMeilleure.CodeGen.Arm64
-{
-    static class IntrinsicTable
-    {
-        private static IntrinsicInfo[] _intrinTable;
-
-        static IntrinsicTable()
-        {
-            _intrinTable = new IntrinsicInfo[EnumUtils.GetCount(typeof(Intrinsic))];
-
-            Add(Intrinsic.Arm64AbsS,          new IntrinsicInfo(0x5e20b800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64AbsV,          new IntrinsicInfo(0x0e20b800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64AddhnV,        new IntrinsicInfo(0x0e204000u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64AddpS,         new IntrinsicInfo(0x5e31b800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64AddpV,         new IntrinsicInfo(0x0e20bc00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64AddvV,         new IntrinsicInfo(0x0e31b800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64AddS,          new IntrinsicInfo(0x5e208400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64AddV,          new IntrinsicInfo(0x0e208400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64AesdV,         new IntrinsicInfo(0x4e285800u, IntrinsicType.Vector128Unary));
-            Add(Intrinsic.Arm64AeseV,         new IntrinsicInfo(0x4e284800u, IntrinsicType.Vector128Unary));
-            Add(Intrinsic.Arm64AesimcV,       new IntrinsicInfo(0x4e287800u, IntrinsicType.Vector128Unary));
-            Add(Intrinsic.Arm64AesmcV,        new IntrinsicInfo(0x4e286800u, IntrinsicType.Vector128Unary));
-            Add(Intrinsic.Arm64AndV,          new IntrinsicInfo(0x0e201c00u, IntrinsicType.VectorBinaryBitwise));
-            Add(Intrinsic.Arm64BicVi,         new IntrinsicInfo(0x2f001400u, IntrinsicType.VectorBinaryBitwiseImm));
-            Add(Intrinsic.Arm64BicV,          new IntrinsicInfo(0x0e601c00u, IntrinsicType.VectorBinaryBitwise));
-            Add(Intrinsic.Arm64BifV,          new IntrinsicInfo(0x2ee01c00u, IntrinsicType.VectorTernaryRdBitwise));
-            Add(Intrinsic.Arm64BitV,          new IntrinsicInfo(0x2ea01c00u, IntrinsicType.VectorTernaryRdBitwise));
-            Add(Intrinsic.Arm64BslV,          new IntrinsicInfo(0x2e601c00u, IntrinsicType.VectorTernaryRdBitwise));
-            Add(Intrinsic.Arm64ClsV,          new IntrinsicInfo(0x0e204800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64ClzV,          new IntrinsicInfo(0x2e204800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64CmeqS,         new IntrinsicInfo(0x7e208c00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64CmeqV,         new IntrinsicInfo(0x2e208c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64CmeqSz,        new IntrinsicInfo(0x5e209800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64CmeqVz,        new IntrinsicInfo(0x0e209800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64CmgeS,         new IntrinsicInfo(0x5e203c00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64CmgeV,         new IntrinsicInfo(0x0e203c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64CmgeSz,        new IntrinsicInfo(0x7e208800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64CmgeVz,        new IntrinsicInfo(0x2e208800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64CmgtS,         new IntrinsicInfo(0x5e203400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64CmgtV,         new IntrinsicInfo(0x0e203400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64CmgtSz,        new IntrinsicInfo(0x5e208800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64CmgtVz,        new IntrinsicInfo(0x0e208800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64CmhiS,         new IntrinsicInfo(0x7e203400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64CmhiV,         new IntrinsicInfo(0x2e203400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64CmhsS,         new IntrinsicInfo(0x7e203c00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64CmhsV,         new IntrinsicInfo(0x2e203c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64CmleSz,        new IntrinsicInfo(0x7e209800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64CmleVz,        new IntrinsicInfo(0x2e209800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64CmltSz,        new IntrinsicInfo(0x5e20a800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64CmltVz,        new IntrinsicInfo(0x0e20a800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64CmtstS,        new IntrinsicInfo(0x5e208c00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64CmtstV,        new IntrinsicInfo(0x0e208c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64CntV,          new IntrinsicInfo(0x0e205800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64DupSe,         new IntrinsicInfo(0x5e000400u, IntrinsicType.ScalarUnaryByElem));
-            Add(Intrinsic.Arm64DupVe,         new IntrinsicInfo(0x0e000400u, IntrinsicType.VectorUnaryByElem));
-            Add(Intrinsic.Arm64DupGp,         new IntrinsicInfo(0x0e000c00u, IntrinsicType.VectorUnaryByElem));
-            Add(Intrinsic.Arm64EorV,          new IntrinsicInfo(0x2e201c00u, IntrinsicType.VectorBinaryBitwise));
-            Add(Intrinsic.Arm64ExtV,          new IntrinsicInfo(0x2e000000u, IntrinsicType.VectorExt));
-            Add(Intrinsic.Arm64FabdS,         new IntrinsicInfo(0x7ea0d400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FabdV,         new IntrinsicInfo(0x2ea0d400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FabsV,         new IntrinsicInfo(0x0ea0f800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FabsS,         new IntrinsicInfo(0x1e20c000u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FacgeS,        new IntrinsicInfo(0x7e20ec00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FacgeV,        new IntrinsicInfo(0x2e20ec00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FacgtS,        new IntrinsicInfo(0x7ea0ec00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FacgtV,        new IntrinsicInfo(0x2ea0ec00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FaddpS,        new IntrinsicInfo(0x7e30d800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FaddpV,        new IntrinsicInfo(0x2e20d400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FaddV,         new IntrinsicInfo(0x0e20d400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FaddS,         new IntrinsicInfo(0x1e202800u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FccmpeS,       new IntrinsicInfo(0x1e200410u, IntrinsicType.ScalarFPCompareCond));
-            Add(Intrinsic.Arm64FccmpS,        new IntrinsicInfo(0x1e200400u, IntrinsicType.ScalarFPCompareCond));
-            Add(Intrinsic.Arm64FcmeqS,        new IntrinsicInfo(0x5e20e400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FcmeqV,        new IntrinsicInfo(0x0e20e400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FcmeqSz,       new IntrinsicInfo(0x5ea0d800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcmeqVz,       new IntrinsicInfo(0x0ea0d800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcmgeS,        new IntrinsicInfo(0x7e20e400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FcmgeV,        new IntrinsicInfo(0x2e20e400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FcmgeSz,       new IntrinsicInfo(0x7ea0c800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcmgeVz,       new IntrinsicInfo(0x2ea0c800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcmgtS,        new IntrinsicInfo(0x7ea0e400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FcmgtV,        new IntrinsicInfo(0x2ea0e400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FcmgtSz,       new IntrinsicInfo(0x5ea0c800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcmgtVz,       new IntrinsicInfo(0x0ea0c800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcmleSz,       new IntrinsicInfo(0x7ea0d800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcmleVz,       new IntrinsicInfo(0x2ea0d800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcmltSz,       new IntrinsicInfo(0x5ea0e800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcmltVz,       new IntrinsicInfo(0x0ea0e800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcmpeS,        new IntrinsicInfo(0x1e202010u, IntrinsicType.ScalarFPCompare));
-            Add(Intrinsic.Arm64FcmpS,         new IntrinsicInfo(0x1e202000u, IntrinsicType.ScalarFPCompare));
-            Add(Intrinsic.Arm64FcselS,        new IntrinsicInfo(0x1e200c00u, IntrinsicType.ScalarFcsel));
-            Add(Intrinsic.Arm64FcvtasS,       new IntrinsicInfo(0x5e21c800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcvtasV,       new IntrinsicInfo(0x0e21c800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcvtasGp,      new IntrinsicInfo(0x1e240000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64FcvtauS,       new IntrinsicInfo(0x7e21c800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcvtauV,       new IntrinsicInfo(0x2e21c800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcvtauGp,      new IntrinsicInfo(0x1e250000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64FcvtlV,        new IntrinsicInfo(0x0e217800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcvtmsS,       new IntrinsicInfo(0x5e21b800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcvtmsV,       new IntrinsicInfo(0x0e21b800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcvtmsGp,      new IntrinsicInfo(0x1e300000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64FcvtmuS,       new IntrinsicInfo(0x7e21b800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcvtmuV,       new IntrinsicInfo(0x2e21b800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcvtmuGp,      new IntrinsicInfo(0x1e310000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64FcvtnsS,       new IntrinsicInfo(0x5e21a800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcvtnsV,       new IntrinsicInfo(0x0e21a800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcvtnsGp,      new IntrinsicInfo(0x1e200000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64FcvtnuS,       new IntrinsicInfo(0x7e21a800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcvtnuV,       new IntrinsicInfo(0x2e21a800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcvtnuGp,      new IntrinsicInfo(0x1e210000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64FcvtnV,        new IntrinsicInfo(0x0e216800u, IntrinsicType.VectorBinaryRd));
-            Add(Intrinsic.Arm64FcvtpsS,       new IntrinsicInfo(0x5ea1a800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcvtpsV,       new IntrinsicInfo(0x0ea1a800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcvtpsGp,      new IntrinsicInfo(0x1e280000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64FcvtpuS,       new IntrinsicInfo(0x7ea1a800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcvtpuV,       new IntrinsicInfo(0x2ea1a800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcvtpuGp,      new IntrinsicInfo(0x1e290000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64FcvtxnS,       new IntrinsicInfo(0x7e216800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcvtxnV,       new IntrinsicInfo(0x2e216800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcvtzsSFixed,  new IntrinsicInfo(0x5f00fc00u, IntrinsicType.ScalarFPConvFixed));
-            Add(Intrinsic.Arm64FcvtzsVFixed,  new IntrinsicInfo(0x0f00fc00u, IntrinsicType.VectorFPConvFixed));
-            Add(Intrinsic.Arm64FcvtzsS,       new IntrinsicInfo(0x5ea1b800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcvtzsV,       new IntrinsicInfo(0x0ea1b800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcvtzsGpFixed, new IntrinsicInfo(0x1e180000u, IntrinsicType.ScalarFPConvFixedGpr));
-            Add(Intrinsic.Arm64FcvtzsGp,      new IntrinsicInfo(0x1e380000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64FcvtzuSFixed,  new IntrinsicInfo(0x7f00fc00u, IntrinsicType.ScalarFPConvFixed));
-            Add(Intrinsic.Arm64FcvtzuVFixed,  new IntrinsicInfo(0x2f00fc00u, IntrinsicType.VectorFPConvFixed));
-            Add(Intrinsic.Arm64FcvtzuS,       new IntrinsicInfo(0x7ea1b800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FcvtzuV,       new IntrinsicInfo(0x2ea1b800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FcvtzuGpFixed, new IntrinsicInfo(0x1e190000u, IntrinsicType.ScalarFPConvFixedGpr));
-            Add(Intrinsic.Arm64FcvtzuGp,      new IntrinsicInfo(0x1e390000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64FcvtS,         new IntrinsicInfo(0x1e224000u, IntrinsicType.ScalarFPConv));
-            Add(Intrinsic.Arm64FdivV,         new IntrinsicInfo(0x2e20fc00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FdivS,         new IntrinsicInfo(0x1e201800u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FmaddS,        new IntrinsicInfo(0x1f000000u, IntrinsicType.ScalarTernary));
-            Add(Intrinsic.Arm64FmaxnmpS,      new IntrinsicInfo(0x7e30c800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FmaxnmpV,      new IntrinsicInfo(0x2e20c400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FmaxnmvV,      new IntrinsicInfo(0x2e30c800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FmaxnmV,       new IntrinsicInfo(0x0e20c400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FmaxnmS,       new IntrinsicInfo(0x1e206800u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FmaxpS,        new IntrinsicInfo(0x7e30f800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FmaxpV,        new IntrinsicInfo(0x2e20f400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FmaxvV,        new IntrinsicInfo(0x2e30f800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FmaxV,         new IntrinsicInfo(0x0e20f400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FmaxS,         new IntrinsicInfo(0x1e204800u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FminnmpS,      new IntrinsicInfo(0x7eb0c800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FminnmpV,      new IntrinsicInfo(0x2ea0c400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FminnmvV,      new IntrinsicInfo(0x2eb0c800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FminnmV,       new IntrinsicInfo(0x0ea0c400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FminnmS,       new IntrinsicInfo(0x1e207800u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FminpS,        new IntrinsicInfo(0x7eb0f800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FminpV,        new IntrinsicInfo(0x2ea0f400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FminvV,        new IntrinsicInfo(0x2eb0f800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FminV,         new IntrinsicInfo(0x0ea0f400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FminS,         new IntrinsicInfo(0x1e205800u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FmlaSe,        new IntrinsicInfo(0x5f801000u, IntrinsicType.ScalarTernaryFPRdByElem));
-            Add(Intrinsic.Arm64FmlaVe,        new IntrinsicInfo(0x0f801000u, IntrinsicType.VectorTernaryFPRdByElem));
-            Add(Intrinsic.Arm64FmlaV,         new IntrinsicInfo(0x0e20cc00u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64FmlsSe,        new IntrinsicInfo(0x5f805000u, IntrinsicType.ScalarTernaryFPRdByElem));
-            Add(Intrinsic.Arm64FmlsVe,        new IntrinsicInfo(0x0f805000u, IntrinsicType.VectorTernaryFPRdByElem));
-            Add(Intrinsic.Arm64FmlsV,         new IntrinsicInfo(0x0ea0cc00u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64FmovVi,        new IntrinsicInfo(0x0f00f400u, IntrinsicType.VectorFmovi));
-            Add(Intrinsic.Arm64FmovS,         new IntrinsicInfo(0x1e204000u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FmovGp,        new IntrinsicInfo(0x1e260000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64FmovSi,        new IntrinsicInfo(0x1e201000u, IntrinsicType.ScalarFmovi));
-            Add(Intrinsic.Arm64FmsubS,        new IntrinsicInfo(0x1f008000u, IntrinsicType.ScalarTernary));
-            Add(Intrinsic.Arm64FmulxSe,       new IntrinsicInfo(0x7f809000u, IntrinsicType.ScalarBinaryFPByElem));
-            Add(Intrinsic.Arm64FmulxVe,       new IntrinsicInfo(0x2f809000u, IntrinsicType.VectorBinaryFPByElem));
-            Add(Intrinsic.Arm64FmulxS,        new IntrinsicInfo(0x5e20dc00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FmulxV,        new IntrinsicInfo(0x0e20dc00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FmulSe,        new IntrinsicInfo(0x5f809000u, IntrinsicType.ScalarBinaryFPByElem));
-            Add(Intrinsic.Arm64FmulVe,        new IntrinsicInfo(0x0f809000u, IntrinsicType.VectorBinaryFPByElem));
-            Add(Intrinsic.Arm64FmulV,         new IntrinsicInfo(0x2e20dc00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FmulS,         new IntrinsicInfo(0x1e200800u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FnegV,         new IntrinsicInfo(0x2ea0f800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FnegS,         new IntrinsicInfo(0x1e214000u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FnmaddS,       new IntrinsicInfo(0x1f200000u, IntrinsicType.ScalarTernary));
-            Add(Intrinsic.Arm64FnmsubS,       new IntrinsicInfo(0x1f208000u, IntrinsicType.ScalarTernary));
-            Add(Intrinsic.Arm64FnmulS,        new IntrinsicInfo(0x1e208800u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FrecpeS,       new IntrinsicInfo(0x5ea1d800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FrecpeV,       new IntrinsicInfo(0x0ea1d800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FrecpsS,       new IntrinsicInfo(0x5e20fc00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FrecpsV,       new IntrinsicInfo(0x0e20fc00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FrecpxS,       new IntrinsicInfo(0x5ea1f800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FrintaV,       new IntrinsicInfo(0x2e218800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FrintaS,       new IntrinsicInfo(0x1e264000u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FrintiV,       new IntrinsicInfo(0x2ea19800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FrintiS,       new IntrinsicInfo(0x1e27c000u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FrintmV,       new IntrinsicInfo(0x0e219800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FrintmS,       new IntrinsicInfo(0x1e254000u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FrintnV,       new IntrinsicInfo(0x0e218800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FrintnS,       new IntrinsicInfo(0x1e244000u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FrintpV,       new IntrinsicInfo(0x0ea18800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FrintpS,       new IntrinsicInfo(0x1e24c000u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FrintxV,       new IntrinsicInfo(0x2e219800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FrintxS,       new IntrinsicInfo(0x1e274000u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FrintzV,       new IntrinsicInfo(0x0ea19800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FrintzS,       new IntrinsicInfo(0x1e25c000u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FrsqrteS,      new IntrinsicInfo(0x7ea1d800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FrsqrteV,      new IntrinsicInfo(0x2ea1d800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FrsqrtsS,      new IntrinsicInfo(0x5ea0fc00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64FrsqrtsV,      new IntrinsicInfo(0x0ea0fc00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FsqrtV,        new IntrinsicInfo(0x2ea1f800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64FsqrtS,        new IntrinsicInfo(0x1e21c000u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64FsubV,         new IntrinsicInfo(0x0ea0d400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64FsubS,         new IntrinsicInfo(0x1e203800u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64InsVe,         new IntrinsicInfo(0x6e000400u, IntrinsicType.VectorInsertByElem));
-            Add(Intrinsic.Arm64InsGp,         new IntrinsicInfo(0x4e001c00u, IntrinsicType.ScalarUnaryByElem));
-            Add(Intrinsic.Arm64Ld1rV,         new IntrinsicInfo(0x0d40c000u, IntrinsicType.VectorLdSt));
-            Add(Intrinsic.Arm64Ld1Vms,        new IntrinsicInfo(0x0c402000u, IntrinsicType.VectorLdSt));
-            Add(Intrinsic.Arm64Ld1Vss,        new IntrinsicInfo(0x0d400000u, IntrinsicType.VectorLdStSs));
-            Add(Intrinsic.Arm64Ld2rV,         new IntrinsicInfo(0x0d60c000u, IntrinsicType.VectorLdSt));
-            Add(Intrinsic.Arm64Ld2Vms,        new IntrinsicInfo(0x0c408000u, IntrinsicType.VectorLdSt));
-            Add(Intrinsic.Arm64Ld2Vss,        new IntrinsicInfo(0x0d600000u, IntrinsicType.VectorLdStSs));
-            Add(Intrinsic.Arm64Ld3rV,         new IntrinsicInfo(0x0d40e000u, IntrinsicType.VectorLdSt));
-            Add(Intrinsic.Arm64Ld3Vms,        new IntrinsicInfo(0x0c404000u, IntrinsicType.VectorLdSt));
-            Add(Intrinsic.Arm64Ld3Vss,        new IntrinsicInfo(0x0d402000u, IntrinsicType.VectorLdStSs));
-            Add(Intrinsic.Arm64Ld4rV,         new IntrinsicInfo(0x0d60e000u, IntrinsicType.VectorLdSt));
-            Add(Intrinsic.Arm64Ld4Vms,        new IntrinsicInfo(0x0c400000u, IntrinsicType.VectorLdSt));
-            Add(Intrinsic.Arm64Ld4Vss,        new IntrinsicInfo(0x0d602000u, IntrinsicType.VectorLdStSs));
-            Add(Intrinsic.Arm64MlaVe,         new IntrinsicInfo(0x2f000000u, IntrinsicType.VectorTernaryRdByElem));
-            Add(Intrinsic.Arm64MlaV,          new IntrinsicInfo(0x0e209400u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64MlsVe,         new IntrinsicInfo(0x2f004000u, IntrinsicType.VectorTernaryRdByElem));
-            Add(Intrinsic.Arm64MlsV,          new IntrinsicInfo(0x2e209400u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64MoviV,         new IntrinsicInfo(0x0f000400u, IntrinsicType.VectorMovi));
-            Add(Intrinsic.Arm64MrsFpsr,       new IntrinsicInfo(0xd53b4420u, IntrinsicType.GetRegister));
-            Add(Intrinsic.Arm64MsrFpsr,       new IntrinsicInfo(0xd51b4420u, IntrinsicType.SetRegister));
-            Add(Intrinsic.Arm64MulVe,         new IntrinsicInfo(0x0f008000u, IntrinsicType.VectorBinaryByElem));
-            Add(Intrinsic.Arm64MulV,          new IntrinsicInfo(0x0e209c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64MvniV,         new IntrinsicInfo(0x2f000400u, IntrinsicType.VectorMvni));
-            Add(Intrinsic.Arm64NegS,          new IntrinsicInfo(0x7e20b800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64NegV,          new IntrinsicInfo(0x2e20b800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64NotV,          new IntrinsicInfo(0x2e205800u, IntrinsicType.VectorUnaryBitwise));
-            Add(Intrinsic.Arm64OrnV,          new IntrinsicInfo(0x0ee01c00u, IntrinsicType.VectorBinaryBitwise));
-            Add(Intrinsic.Arm64OrrVi,         new IntrinsicInfo(0x0f001400u, IntrinsicType.VectorBinaryBitwiseImm));
-            Add(Intrinsic.Arm64OrrV,          new IntrinsicInfo(0x0ea01c00u, IntrinsicType.VectorBinaryBitwise));
-            Add(Intrinsic.Arm64PmullV,        new IntrinsicInfo(0x0e20e000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64PmulV,         new IntrinsicInfo(0x2e209c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64RaddhnV,       new IntrinsicInfo(0x2e204000u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64RbitV,         new IntrinsicInfo(0x2e605800u, IntrinsicType.VectorUnaryBitwise));
-            Add(Intrinsic.Arm64Rev16V,        new IntrinsicInfo(0x0e201800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64Rev32V,        new IntrinsicInfo(0x2e200800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64Rev64V,        new IntrinsicInfo(0x0e200800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64RshrnV,        new IntrinsicInfo(0x0f008c00u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64RsubhnV,       new IntrinsicInfo(0x2e206000u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64SabalV,        new IntrinsicInfo(0x0e205000u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64SabaV,         new IntrinsicInfo(0x0e207c00u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64SabdlV,        new IntrinsicInfo(0x0e207000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SabdV,         new IntrinsicInfo(0x0e207400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SadalpV,       new IntrinsicInfo(0x0e206800u, IntrinsicType.VectorBinaryRd));
-            Add(Intrinsic.Arm64SaddlpV,       new IntrinsicInfo(0x0e202800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64SaddlvV,       new IntrinsicInfo(0x0e303800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64SaddlV,        new IntrinsicInfo(0x0e200000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SaddwV,        new IntrinsicInfo(0x0e201000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64ScvtfSFixed,   new IntrinsicInfo(0x5f00e400u, IntrinsicType.ScalarFPConvFixed));
-            Add(Intrinsic.Arm64ScvtfVFixed,   new IntrinsicInfo(0x0f00e400u, IntrinsicType.VectorFPConvFixed));
-            Add(Intrinsic.Arm64ScvtfS,        new IntrinsicInfo(0x5e21d800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64ScvtfV,        new IntrinsicInfo(0x0e21d800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64ScvtfGpFixed,  new IntrinsicInfo(0x1e020000u, IntrinsicType.ScalarFPConvFixedGpr));
-            Add(Intrinsic.Arm64ScvtfGp,       new IntrinsicInfo(0x1e220000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64Sha1cV,        new IntrinsicInfo(0x5e000000u, IntrinsicType.Vector128Binary));
-            Add(Intrinsic.Arm64Sha1hV,        new IntrinsicInfo(0x5e280800u, IntrinsicType.Vector128Unary));
-            Add(Intrinsic.Arm64Sha1mV,        new IntrinsicInfo(0x5e002000u, IntrinsicType.Vector128Binary));
-            Add(Intrinsic.Arm64Sha1pV,        new IntrinsicInfo(0x5e001000u, IntrinsicType.Vector128Binary));
-            Add(Intrinsic.Arm64Sha1su0V,      new IntrinsicInfo(0x5e003000u, IntrinsicType.Vector128Binary));
-            Add(Intrinsic.Arm64Sha1su1V,      new IntrinsicInfo(0x5e281800u, IntrinsicType.Vector128Unary));
-            Add(Intrinsic.Arm64Sha256h2V,     new IntrinsicInfo(0x5e005000u, IntrinsicType.Vector128Binary));
-            Add(Intrinsic.Arm64Sha256hV,      new IntrinsicInfo(0x5e004000u, IntrinsicType.Vector128Binary));
-            Add(Intrinsic.Arm64Sha256su0V,    new IntrinsicInfo(0x5e282800u, IntrinsicType.Vector128Unary));
-            Add(Intrinsic.Arm64Sha256su1V,    new IntrinsicInfo(0x5e006000u, IntrinsicType.Vector128Binary));
-            Add(Intrinsic.Arm64ShaddV,        new IntrinsicInfo(0x0e200400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64ShllV,         new IntrinsicInfo(0x2e213800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64ShlS,          new IntrinsicInfo(0x5f005400u, IntrinsicType.ScalarBinaryShl));
-            Add(Intrinsic.Arm64ShlV,          new IntrinsicInfo(0x0f005400u, IntrinsicType.VectorBinaryShl));
-            Add(Intrinsic.Arm64ShrnV,         new IntrinsicInfo(0x0f008400u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64ShsubV,        new IntrinsicInfo(0x0e202400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SliS,          new IntrinsicInfo(0x7f005400u, IntrinsicType.ScalarTernaryShlRd));
-            Add(Intrinsic.Arm64SliV,          new IntrinsicInfo(0x2f005400u, IntrinsicType.VectorTernaryShlRd));
-            Add(Intrinsic.Arm64SmaxpV,        new IntrinsicInfo(0x0e20a400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SmaxvV,        new IntrinsicInfo(0x0e30a800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64SmaxV,         new IntrinsicInfo(0x0e206400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SminpV,        new IntrinsicInfo(0x0e20ac00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SminvV,        new IntrinsicInfo(0x0e31a800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64SminV,         new IntrinsicInfo(0x0e206c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SmlalVe,       new IntrinsicInfo(0x0f002000u, IntrinsicType.VectorTernaryRdByElem));
-            Add(Intrinsic.Arm64SmlalV,        new IntrinsicInfo(0x0e208000u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64SmlslVe,       new IntrinsicInfo(0x0f006000u, IntrinsicType.VectorTernaryRdByElem));
-            Add(Intrinsic.Arm64SmlslV,        new IntrinsicInfo(0x0e20a000u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64SmovV,         new IntrinsicInfo(0x0e002c00u, IntrinsicType.VectorUnaryByElem));
-            Add(Intrinsic.Arm64SmullVe,       new IntrinsicInfo(0x0f00a000u, IntrinsicType.VectorBinaryByElem));
-            Add(Intrinsic.Arm64SmullV,        new IntrinsicInfo(0x0e20c000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SqabsS,        new IntrinsicInfo(0x5e207800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64SqabsV,        new IntrinsicInfo(0x0e207800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64SqaddS,        new IntrinsicInfo(0x5e200c00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64SqaddV,        new IntrinsicInfo(0x0e200c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SqdmlalSe,     new IntrinsicInfo(0x5f003000u, IntrinsicType.ScalarBinaryByElem));
-            Add(Intrinsic.Arm64SqdmlalVe,     new IntrinsicInfo(0x0f003000u, IntrinsicType.VectorBinaryByElem));
-            Add(Intrinsic.Arm64SqdmlalS,      new IntrinsicInfo(0x5e209000u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64SqdmlalV,      new IntrinsicInfo(0x0e209000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SqdmlslSe,     new IntrinsicInfo(0x5f007000u, IntrinsicType.ScalarBinaryByElem));
-            Add(Intrinsic.Arm64SqdmlslVe,     new IntrinsicInfo(0x0f007000u, IntrinsicType.VectorBinaryByElem));
-            Add(Intrinsic.Arm64SqdmlslS,      new IntrinsicInfo(0x5e20b000u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64SqdmlslV,      new IntrinsicInfo(0x0e20b000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SqdmulhSe,     new IntrinsicInfo(0x5f00c000u, IntrinsicType.ScalarBinaryByElem));
-            Add(Intrinsic.Arm64SqdmulhVe,     new IntrinsicInfo(0x0f00c000u, IntrinsicType.VectorBinaryByElem));
-            Add(Intrinsic.Arm64SqdmulhS,      new IntrinsicInfo(0x5e20b400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64SqdmulhV,      new IntrinsicInfo(0x0e20b400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SqdmullSe,     new IntrinsicInfo(0x5f00b000u, IntrinsicType.ScalarBinaryByElem));
-            Add(Intrinsic.Arm64SqdmullVe,     new IntrinsicInfo(0x0f00b000u, IntrinsicType.VectorBinaryByElem));
-            Add(Intrinsic.Arm64SqdmullS,      new IntrinsicInfo(0x5e20d000u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64SqdmullV,      new IntrinsicInfo(0x0e20d000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SqnegS,        new IntrinsicInfo(0x7e207800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64SqnegV,        new IntrinsicInfo(0x2e207800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64SqrdmulhSe,    new IntrinsicInfo(0x5f00d000u, IntrinsicType.ScalarBinaryByElem));
-            Add(Intrinsic.Arm64SqrdmulhVe,    new IntrinsicInfo(0x0f00d000u, IntrinsicType.VectorBinaryByElem));
-            Add(Intrinsic.Arm64SqrdmulhS,     new IntrinsicInfo(0x7e20b400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64SqrdmulhV,     new IntrinsicInfo(0x2e20b400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SqrshlS,       new IntrinsicInfo(0x5e205c00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64SqrshlV,       new IntrinsicInfo(0x0e205c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SqrshrnS,      new IntrinsicInfo(0x5f009c00u, IntrinsicType.ScalarTernaryShrRd));
-            Add(Intrinsic.Arm64SqrshrnV,      new IntrinsicInfo(0x0f009c00u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64SqrshrunS,     new IntrinsicInfo(0x7f008c00u, IntrinsicType.ScalarTernaryShrRd));
-            Add(Intrinsic.Arm64SqrshrunV,     new IntrinsicInfo(0x2f008c00u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64SqshluS,       new IntrinsicInfo(0x7f006400u, IntrinsicType.ScalarBinaryShl));
-            Add(Intrinsic.Arm64SqshluV,       new IntrinsicInfo(0x2f006400u, IntrinsicType.VectorBinaryShl));
-            Add(Intrinsic.Arm64SqshlSi,       new IntrinsicInfo(0x5f007400u, IntrinsicType.ScalarBinaryShl));
-            Add(Intrinsic.Arm64SqshlVi,       new IntrinsicInfo(0x0f007400u, IntrinsicType.VectorBinaryShl));
-            Add(Intrinsic.Arm64SqshlS,        new IntrinsicInfo(0x5e204c00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64SqshlV,        new IntrinsicInfo(0x0e204c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SqshrnS,       new IntrinsicInfo(0x5f009400u, IntrinsicType.ScalarTernaryShrRd));
-            Add(Intrinsic.Arm64SqshrnV,       new IntrinsicInfo(0x0f009400u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64SqshrunS,      new IntrinsicInfo(0x7f008400u, IntrinsicType.ScalarTernaryShrRd));
-            Add(Intrinsic.Arm64SqshrunV,      new IntrinsicInfo(0x2f008400u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64SqsubS,        new IntrinsicInfo(0x5e202c00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64SqsubV,        new IntrinsicInfo(0x0e202c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SqxtnS,        new IntrinsicInfo(0x5e214800u, IntrinsicType.ScalarBinaryRd));
-            Add(Intrinsic.Arm64SqxtnV,        new IntrinsicInfo(0x0e214800u, IntrinsicType.VectorBinaryRd));
-            Add(Intrinsic.Arm64SqxtunS,       new IntrinsicInfo(0x7e212800u, IntrinsicType.ScalarBinaryRd));
-            Add(Intrinsic.Arm64SqxtunV,       new IntrinsicInfo(0x2e212800u, IntrinsicType.VectorBinaryRd));
-            Add(Intrinsic.Arm64SrhaddV,       new IntrinsicInfo(0x0e201400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SriS,          new IntrinsicInfo(0x7f004400u, IntrinsicType.ScalarTernaryShrRd));
-            Add(Intrinsic.Arm64SriV,          new IntrinsicInfo(0x2f004400u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64SrshlS,        new IntrinsicInfo(0x5e205400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64SrshlV,        new IntrinsicInfo(0x0e205400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SrshrS,        new IntrinsicInfo(0x5f002400u, IntrinsicType.ScalarBinaryShr));
-            Add(Intrinsic.Arm64SrshrV,        new IntrinsicInfo(0x0f002400u, IntrinsicType.VectorBinaryShr));
-            Add(Intrinsic.Arm64SrsraS,        new IntrinsicInfo(0x5f003400u, IntrinsicType.ScalarTernaryShrRd));
-            Add(Intrinsic.Arm64SrsraV,        new IntrinsicInfo(0x0f003400u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64SshllV,        new IntrinsicInfo(0x0f00a400u, IntrinsicType.VectorBinaryShl));
-            Add(Intrinsic.Arm64SshlS,         new IntrinsicInfo(0x5e204400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64SshlV,         new IntrinsicInfo(0x0e204400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SshrS,         new IntrinsicInfo(0x5f000400u, IntrinsicType.ScalarBinaryShr));
-            Add(Intrinsic.Arm64SshrV,         new IntrinsicInfo(0x0f000400u, IntrinsicType.VectorBinaryShr));
-            Add(Intrinsic.Arm64SsraS,         new IntrinsicInfo(0x5f001400u, IntrinsicType.ScalarTernaryShrRd));
-            Add(Intrinsic.Arm64SsraV,         new IntrinsicInfo(0x0f001400u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64SsublV,        new IntrinsicInfo(0x0e202000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SsubwV,        new IntrinsicInfo(0x0e203000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64St1Vms,        new IntrinsicInfo(0x0c002000u, IntrinsicType.VectorLdSt));
-            Add(Intrinsic.Arm64St1Vss,        new IntrinsicInfo(0x0d000000u, IntrinsicType.VectorLdStSs));
-            Add(Intrinsic.Arm64St2Vms,        new IntrinsicInfo(0x0c008000u, IntrinsicType.VectorLdSt));
-            Add(Intrinsic.Arm64St2Vss,        new IntrinsicInfo(0x0d200000u, IntrinsicType.VectorLdStSs));
-            Add(Intrinsic.Arm64St3Vms,        new IntrinsicInfo(0x0c004000u, IntrinsicType.VectorLdSt));
-            Add(Intrinsic.Arm64St3Vss,        new IntrinsicInfo(0x0d002000u, IntrinsicType.VectorLdStSs));
-            Add(Intrinsic.Arm64St4Vms,        new IntrinsicInfo(0x0c000000u, IntrinsicType.VectorLdSt));
-            Add(Intrinsic.Arm64St4Vss,        new IntrinsicInfo(0x0d202000u, IntrinsicType.VectorLdStSs));
-            Add(Intrinsic.Arm64SubhnV,        new IntrinsicInfo(0x0e206000u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64SubS,          new IntrinsicInfo(0x7e208400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64SubV,          new IntrinsicInfo(0x2e208400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64SuqaddS,       new IntrinsicInfo(0x5e203800u, IntrinsicType.ScalarBinaryRd));
-            Add(Intrinsic.Arm64SuqaddV,       new IntrinsicInfo(0x0e203800u, IntrinsicType.VectorBinaryRd));
-            Add(Intrinsic.Arm64TblV,          new IntrinsicInfo(0x0e000000u, IntrinsicType.VectorLookupTable));
-            Add(Intrinsic.Arm64TbxV,          new IntrinsicInfo(0x0e001000u, IntrinsicType.VectorLookupTable));
-            Add(Intrinsic.Arm64Trn1V,         new IntrinsicInfo(0x0e002800u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64Trn2V,         new IntrinsicInfo(0x0e006800u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UabalV,        new IntrinsicInfo(0x2e205000u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64UabaV,         new IntrinsicInfo(0x2e207c00u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64UabdlV,        new IntrinsicInfo(0x2e207000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UabdV,         new IntrinsicInfo(0x2e207400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UadalpV,       new IntrinsicInfo(0x2e206800u, IntrinsicType.VectorBinaryRd));
-            Add(Intrinsic.Arm64UaddlpV,       new IntrinsicInfo(0x2e202800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64UaddlvV,       new IntrinsicInfo(0x2e303800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64UaddlV,        new IntrinsicInfo(0x2e200000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UaddwV,        new IntrinsicInfo(0x2e201000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UcvtfSFixed,   new IntrinsicInfo(0x7f00e400u, IntrinsicType.ScalarFPConvFixed));
-            Add(Intrinsic.Arm64UcvtfVFixed,   new IntrinsicInfo(0x2f00e400u, IntrinsicType.VectorFPConvFixed));
-            Add(Intrinsic.Arm64UcvtfS,        new IntrinsicInfo(0x7e21d800u, IntrinsicType.ScalarUnary));
-            Add(Intrinsic.Arm64UcvtfV,        new IntrinsicInfo(0x2e21d800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64UcvtfGpFixed,  new IntrinsicInfo(0x1e030000u, IntrinsicType.ScalarFPConvFixedGpr));
-            Add(Intrinsic.Arm64UcvtfGp,       new IntrinsicInfo(0x1e230000u, IntrinsicType.ScalarFPConvGpr));
-            Add(Intrinsic.Arm64UhaddV,        new IntrinsicInfo(0x2e200400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UhsubV,        new IntrinsicInfo(0x2e202400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UmaxpV,        new IntrinsicInfo(0x2e20a400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UmaxvV,        new IntrinsicInfo(0x2e30a800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64UmaxV,         new IntrinsicInfo(0x2e206400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UminpV,        new IntrinsicInfo(0x2e20ac00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UminvV,        new IntrinsicInfo(0x2e31a800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64UminV,         new IntrinsicInfo(0x2e206c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UmlalVe,       new IntrinsicInfo(0x2f002000u, IntrinsicType.VectorTernaryRdByElem));
-            Add(Intrinsic.Arm64UmlalV,        new IntrinsicInfo(0x2e208000u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64UmlslVe,       new IntrinsicInfo(0x2f006000u, IntrinsicType.VectorTernaryRdByElem));
-            Add(Intrinsic.Arm64UmlslV,        new IntrinsicInfo(0x2e20a000u, IntrinsicType.VectorTernaryRd));
-            Add(Intrinsic.Arm64UmovV,         new IntrinsicInfo(0x0e003c00u, IntrinsicType.VectorUnaryByElem));
-            Add(Intrinsic.Arm64UmullVe,       new IntrinsicInfo(0x2f00a000u, IntrinsicType.VectorBinaryByElem));
-            Add(Intrinsic.Arm64UmullV,        new IntrinsicInfo(0x2e20c000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UqaddS,        new IntrinsicInfo(0x7e200c00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64UqaddV,        new IntrinsicInfo(0x2e200c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UqrshlS,       new IntrinsicInfo(0x7e205c00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64UqrshlV,       new IntrinsicInfo(0x2e205c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UqrshrnS,      new IntrinsicInfo(0x7f009c00u, IntrinsicType.ScalarTernaryShrRd));
-            Add(Intrinsic.Arm64UqrshrnV,      new IntrinsicInfo(0x2f009c00u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64UqshlSi,       new IntrinsicInfo(0x7f007400u, IntrinsicType.ScalarBinaryShl));
-            Add(Intrinsic.Arm64UqshlVi,       new IntrinsicInfo(0x2f007400u, IntrinsicType.VectorBinaryShl));
-            Add(Intrinsic.Arm64UqshlS,        new IntrinsicInfo(0x7e204c00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64UqshlV,        new IntrinsicInfo(0x2e204c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UqshrnS,       new IntrinsicInfo(0x7f009400u, IntrinsicType.ScalarTernaryShrRd));
-            Add(Intrinsic.Arm64UqshrnV,       new IntrinsicInfo(0x2f009400u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64UqsubS,        new IntrinsicInfo(0x7e202c00u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64UqsubV,        new IntrinsicInfo(0x2e202c00u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UqxtnS,        new IntrinsicInfo(0x7e214800u, IntrinsicType.ScalarBinaryRd));
-            Add(Intrinsic.Arm64UqxtnV,        new IntrinsicInfo(0x2e214800u, IntrinsicType.VectorBinaryRd));
-            Add(Intrinsic.Arm64UrecpeV,       new IntrinsicInfo(0x0ea1c800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64UrhaddV,       new IntrinsicInfo(0x2e201400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UrshlS,        new IntrinsicInfo(0x7e205400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64UrshlV,        new IntrinsicInfo(0x2e205400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UrshrS,        new IntrinsicInfo(0x7f002400u, IntrinsicType.ScalarBinaryShr));
-            Add(Intrinsic.Arm64UrshrV,        new IntrinsicInfo(0x2f002400u, IntrinsicType.VectorBinaryShr));
-            Add(Intrinsic.Arm64UrsqrteV,      new IntrinsicInfo(0x2ea1c800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64UrsraS,        new IntrinsicInfo(0x7f003400u, IntrinsicType.ScalarTernaryShrRd));
-            Add(Intrinsic.Arm64UrsraV,        new IntrinsicInfo(0x2f003400u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64UshllV,        new IntrinsicInfo(0x2f00a400u, IntrinsicType.VectorBinaryShl));
-            Add(Intrinsic.Arm64UshlS,         new IntrinsicInfo(0x7e204400u, IntrinsicType.ScalarBinary));
-            Add(Intrinsic.Arm64UshlV,         new IntrinsicInfo(0x2e204400u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UshrS,         new IntrinsicInfo(0x7f000400u, IntrinsicType.ScalarBinaryShr));
-            Add(Intrinsic.Arm64UshrV,         new IntrinsicInfo(0x2f000400u, IntrinsicType.VectorBinaryShr));
-            Add(Intrinsic.Arm64UsqaddS,       new IntrinsicInfo(0x7e203800u, IntrinsicType.ScalarBinaryRd));
-            Add(Intrinsic.Arm64UsqaddV,       new IntrinsicInfo(0x2e203800u, IntrinsicType.VectorBinaryRd));
-            Add(Intrinsic.Arm64UsraS,         new IntrinsicInfo(0x7f001400u, IntrinsicType.ScalarTernaryShrRd));
-            Add(Intrinsic.Arm64UsraV,         new IntrinsicInfo(0x2f001400u, IntrinsicType.VectorTernaryShrRd));
-            Add(Intrinsic.Arm64UsublV,        new IntrinsicInfo(0x2e202000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64UsubwV,        new IntrinsicInfo(0x2e203000u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64Uzp1V,         new IntrinsicInfo(0x0e001800u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64Uzp2V,         new IntrinsicInfo(0x0e005800u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64XtnV,          new IntrinsicInfo(0x0e212800u, IntrinsicType.VectorUnary));
-            Add(Intrinsic.Arm64Zip1V,         new IntrinsicInfo(0x0e003800u, IntrinsicType.VectorBinary));
-            Add(Intrinsic.Arm64Zip2V,         new IntrinsicInfo(0x0e007800u, IntrinsicType.VectorBinary));
-        }
-
-        private static void Add(Intrinsic intrin, IntrinsicInfo info)
-        {
-            _intrinTable[(int)intrin] = info;
-        }
-
-        public static IntrinsicInfo GetInfo(Intrinsic intrin)
-        {
-            return _intrinTable[(int)intrin];
-        }
-    }
-}

ARMeilleure/CodeGen/Arm64/IntrinsicType.cs

@@ -1,59 +0,0 @@
-namespace ARMeilleure.CodeGen.Arm64
-{
-    enum IntrinsicType
-    {
-        ScalarUnary,
-        ScalarUnaryByElem,
-        ScalarBinary,
-        ScalarBinaryByElem,
-        ScalarBinaryFPByElem,
-        ScalarBinaryRd,
-        ScalarBinaryShl,
-        ScalarBinaryShr,
-        ScalarFcsel,
-        ScalarFmovi,
-        ScalarFPCompare,
-        ScalarFPCompareCond,
-        ScalarFPConv,
-        ScalarFPConvFixed,
-        ScalarFPConvFixedGpr,
-        ScalarFPConvGpr,
-        ScalarTernary,
-        ScalarTernaryFPRdByElem,
-        ScalarTernaryShlRd,
-        ScalarTernaryShrRd,
-
-        VectorUnary,
-        VectorUnaryBitwise,
-        VectorUnaryByElem,
-        VectorBinary,
-        VectorBinaryBitwise,
-        VectorBinaryBitwiseImm,
-        VectorBinaryByElem,
-        VectorBinaryFPByElem,
-        VectorBinaryRd,
-        VectorBinaryShl,
-        VectorBinaryShr,
-        VectorExt,
-        VectorFmovi,
-        VectorFPConvFixed,
-        VectorInsertByElem,
-        VectorLdSt,
-        VectorLdStSs,
-        VectorLookupTable,
-        VectorMovi,
-        VectorMvni,
-        VectorTernaryFPRdByElem,
-        VectorTernaryRd,
-        VectorTernaryRdBitwise,
-        VectorTernaryRdByElem,
-        VectorTernaryShlRd,
-        VectorTernaryShrRd,
-
-        Vector128Unary,
-        Vector128Binary,
-
-        GetRegister,
-        SetRegister
-    }
-}

ARMeilleure/CodeGen/Arm64/PreAllocator.cs

@@ -1,940 +0,0 @@
-using ARMeilleure.CodeGen.RegisterAllocators;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Translation;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-using static ARMeilleure.IntermediateRepresentation.Operation.Factory;
-
-namespace ARMeilleure.CodeGen.Arm64
-{
-    class PreAllocator
-    {
-        private class ConstantDict
-        {
-            private readonly Dictionary<(ulong, OperandType), Operand> _constants;
-
-            public ConstantDict()
-            {
-                _constants = new Dictionary<(ulong, OperandType), Operand>();
-            }
-
-            public void Add(ulong value, OperandType type, Operand local)
-            {
-                _constants.Add((value, type), local);
-            }
-
-            public bool TryGetValue(ulong value, OperandType type, out Operand local)
-            {
-                return _constants.TryGetValue((value, type), out local);
-            }
-        }
-
-        public static void RunPass(CompilerContext cctx, StackAllocator stackAlloc, out int maxCallArgs)
-        {
-            maxCallArgs = -1;
-
-            Span<Operation> buffer = default;
-
-            Operand[] preservedArgs = new Operand[CallingConvention.GetArgumentsOnRegsCount()];
-
-            for (BasicBlock block = cctx.Cfg.Blocks.First; block != null; block = block.ListNext)
-            {
-                ConstantDict constants = new ConstantDict();
-
-                Operation nextNode;
-
-                for (Operation node = block.Operations.First; node != default; node = nextNode)
-                {
-                    nextNode = node.ListNext;
-
-                    if (node.Instruction == Instruction.Phi)
-                    {
-                        continue;
-                    }
-
-                    HandleConstantRegCopy(constants, block.Operations, node);
-                    HandleDestructiveRegCopy(block.Operations, node);
-
-                    switch (node.Instruction)
-                    {
-                        case Instruction.Call:
-                            // Get the maximum number of arguments used on a call.
-                            // On windows, when a struct is returned from the call,
-                            // we also need to pass the pointer where the struct
-                            // should be written on the first argument.
-                            int argsCount = node.SourcesCount - 1;
-
-                            if (node.Destination != default && node.Destination.Type == OperandType.V128)
-                            {
-                                argsCount++;
-                            }
-
-                            if (maxCallArgs < argsCount)
-                            {
-                                maxCallArgs = argsCount;
-                            }
-
-                            // Copy values to registers expected by the function
-                            // being called, as mandated by the ABI.
-                            HandleCall(constants, block.Operations, node);
-                            break;
-                        case Instruction.CompareAndSwap:
-                        case Instruction.CompareAndSwap16:
-                        case Instruction.CompareAndSwap8:
-                            nextNode = HandleCompareAndSwap(block.Operations, node);
-                            break;
-                        case Instruction.LoadArgument:
-                            nextNode = HandleLoadArgument(cctx, ref buffer, block.Operations, preservedArgs, node);
-                            break;
-                        case Instruction.Return:
-                            HandleReturn(block.Operations, node);
-                            break;
-                        case Instruction.Tailcall:
-                            HandleTailcall(constants, block.Operations, stackAlloc, node, node);
-                            break;
-                    }
-                }
-            }
-        }
-
-        private static void HandleConstantRegCopy(ConstantDict constants, IntrusiveList<Operation> nodes, Operation node)
-        {
-            if (node.SourcesCount == 0 || IsIntrinsicWithConst(node))
-            {
-                return;
-            }
-
-            Instruction inst = node.Instruction;
-
-            Operand src1 = node.GetSource(0);
-            Operand src2;
-
-            if (src1.Kind == OperandKind.Constant)
-            {
-                if (!src1.Type.IsInteger())
-                {
-                    // Handle non-integer types (FP32, FP64 and V128).
-                    // For instructions without an immediate operand, we do the following:
-                    // - Insert a copy with the constant value (as integer) to a GPR.
-                    // - Insert a copy from the GPR to a XMM register.
-                    // - Replace the constant use with the XMM register.
-                    src1 = AddFloatConstantCopy(constants, nodes, node, src1);
-
-                    node.SetSource(0, src1);
-                }
-                else if (!HasConstSrc1(node, src1.Value))
-                {
-                    // Handle integer types.
-                    // Most ALU instructions accepts a 32-bits immediate on the second operand.
-                    // We need to ensure the following:
-                    // - If the constant is on operand 1, we need to move it.
-                    // -- But first, we try to swap operand 1 and 2 if the instruction is commutative.
-                    // -- Doing so may allow us to encode the constant as operand 2 and avoid a copy.
-                    // - If the constant is on operand 2, we check if the instruction supports it,
-                    // if not, we also add a copy. 64-bits constants are usually not supported.
-                    if (IsCommutative(node))
-                    {
-                        src2 = node.GetSource(1);
-
-                        Operand temp = src1;
-
-                        src1 = src2;
-                        src2 = temp;
-
-                        node.SetSource(0, src1);
-                        node.SetSource(1, src2);
-                    }
-
-                    if (src1.Kind == OperandKind.Constant)
-                    {
-                        src1 = AddIntConstantCopy(constants, nodes, node, src1);
-
-                        node.SetSource(0, src1);
-                    }
-                }
-            }
-
-            if (node.SourcesCount < 2)
-            {
-                return;
-            }
-
-            src2 = node.GetSource(1);
-
-            if (src2.Kind == OperandKind.Constant)
-            {
-                if (!src2.Type.IsInteger())
-                {
-                    src2 = AddFloatConstantCopy(constants, nodes, node, src2);
-
-                    node.SetSource(1, src2);
-                }
-                else if (!HasConstSrc2(inst, src2))
-                {
-                    src2 = AddIntConstantCopy(constants, nodes, node, src2);
-
-                    node.SetSource(1, src2);
-                }
-            }
-
-            if (node.SourcesCount < 3 ||
-                node.Instruction == Instruction.BranchIf ||
-                node.Instruction == Instruction.Compare ||
-                node.Instruction == Instruction.VectorInsert ||
-                node.Instruction == Instruction.VectorInsert16 ||
-                node.Instruction == Instruction.VectorInsert8)
-            {
-                return;
-            }
-
-            for (int srcIndex = 2; srcIndex < node.SourcesCount; srcIndex++)
-            {
-                Operand src = node.GetSource(srcIndex);
-
-                if (src.Kind == OperandKind.Constant)
-                {
-                    if (!src.Type.IsInteger())
-                    {
-                        src = AddFloatConstantCopy(constants, nodes, node, src);
-
-                        node.SetSource(srcIndex, src);
-                    }
-                    else
-                    {
-                        src = AddIntConstantCopy(constants, nodes, node, src);
-
-                        node.SetSource(srcIndex, src);
-                    }
-                }
-            }
-        }
-
-        private static void HandleDestructiveRegCopy(IntrusiveList<Operation> nodes, Operation node)
-        {
-            if (node.Destination == default || node.SourcesCount == 0)
-            {
-                return;
-            }
-
-            Operand dest = node.Destination;
-            Operand src1 = node.GetSource(0);
-
-            if (IsSameOperandDestSrc1(node) && src1.Kind == OperandKind.LocalVariable)
-            {
-                bool useNewLocal = false;
-
-                for (int srcIndex = 1; srcIndex < node.SourcesCount; srcIndex++)
-                {
-                    if (node.GetSource(srcIndex) == dest)
-                    {
-                        useNewLocal = true;
-
-                        break;
-                    }
-                }
-
-                if (useNewLocal)
-                {
-                    // Dest is being used as some source already, we need to use a new
-                    // local to store the temporary value, otherwise the value on dest
-                    // local would be overwritten.
-                    Operand temp = Local(dest.Type);
-
-                    nodes.AddBefore(node, Operation(Instruction.Copy, temp, src1));
-
-                    node.SetSource(0, temp);
-
-                    nodes.AddAfter(node, Operation(Instruction.Copy, dest, temp));
-
-                    node.Destination = temp;
-                }
-                else
-                {
-                    nodes.AddBefore(node, Operation(Instruction.Copy, dest, src1));
-
-                    node.SetSource(0, dest);
-                }
-            }
-        }
-
-        private static void HandleCall(ConstantDict constants, IntrusiveList<Operation> nodes, Operation node)
-        {
-            Operation operation = node;
-
-            Operand dest = operation.Destination;
-
-            List<Operand> sources = new List<Operand>
-            {
-                operation.GetSource(0)
-            };
-
-            int argsCount = operation.SourcesCount - 1;
-
-            int intMax = CallingConvention.GetArgumentsOnRegsCount();
-            int vecMax = CallingConvention.GetArgumentsOnRegsCount();
-
-            int intCount = 0;
-            int vecCount = 0;
-
-            int stackOffset = 0;
-
-            for (int index = 0; index < argsCount; index++)
-            {
-                Operand source = operation.GetSource(index + 1);
-
-                bool passOnReg;
-
-                if (source.Type.IsInteger())
-                {
-                    passOnReg = intCount < intMax;
-                }
-                else if (source.Type == OperandType.V128)
-                {
-                    passOnReg = intCount + 1 < intMax;
-                }
-                else
-                {
-                    passOnReg = vecCount < vecMax;
-                }
-
-                if (source.Type == OperandType.V128 && passOnReg)
-                {
-                    // V128 is a struct, we pass each half on a GPR if possible.
-                    Operand argReg  = Gpr(CallingConvention.GetIntArgumentRegister(intCount++), OperandType.I64);
-                    Operand argReg2 = Gpr(CallingConvention.GetIntArgumentRegister(intCount++), OperandType.I64);
-
-                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, argReg,  source, Const(0)));
-                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, argReg2, source, Const(1)));
-
-                    continue;
-                }
-
-                if (passOnReg)
-                {
-                    Operand argReg = source.Type.IsInteger()
-                        ? Gpr(CallingConvention.GetIntArgumentRegister(intCount++), source.Type)
-                        : Xmm(CallingConvention.GetVecArgumentRegister(vecCount++), source.Type);
-
-                    Operation copyOp = Operation(Instruction.Copy, argReg, source);
-
-                    HandleConstantRegCopy(constants, nodes, nodes.AddBefore(node, copyOp));
-
-                    sources.Add(argReg);
-                }
-                else
-                {
-                    Operand offset = Const(stackOffset);
-
-                    Operation spillOp = Operation(Instruction.SpillArg, default, offset, source);
-
-                    HandleConstantRegCopy(constants, nodes, nodes.AddBefore(node, spillOp));
-
-                    stackOffset += source.Type.GetSizeInBytes();
-                }
-            }
-
-            if (dest != default)
-            {
-                if (dest.Type == OperandType.V128)
-                {
-                    Operand retLReg = Gpr(CallingConvention.GetIntReturnRegister(),     OperandType.I64);
-                    Operand retHReg = Gpr(CallingConvention.GetIntReturnRegisterHigh(), OperandType.I64);
-
-                    node = nodes.AddAfter(node, Operation(Instruction.VectorCreateScalar, dest, retLReg));
-                    nodes.AddAfter(node, Operation(Instruction.VectorInsert, dest, dest, retHReg, Const(1)));
-
-                    operation.Destination = default;
-                }
-                else
-                {
-                    Operand retReg = dest.Type.IsInteger()
-                        ? Gpr(CallingConvention.GetIntReturnRegister(), dest.Type)
-                        : Xmm(CallingConvention.GetVecReturnRegister(), dest.Type);
-
-                    Operation copyOp = Operation(Instruction.Copy, dest, retReg);
-
-                    nodes.AddAfter(node, copyOp);
-
-                    operation.Destination = retReg;
-                }
-            }
-
-            operation.SetSources(sources.ToArray());
-        }
-
-        private static void HandleTailcall(
-            ConstantDict constants,
-            IntrusiveList<Operation> nodes,
-            StackAllocator stackAlloc,
-            Operation node,
-            Operation operation)
-        {
-            List<Operand> sources = new List<Operand>
-            {
-                operation.GetSource(0)
-            };
-
-            int argsCount = operation.SourcesCount - 1;
-
-            int intMax = CallingConvention.GetArgumentsOnRegsCount();
-            int vecMax = CallingConvention.GetArgumentsOnRegsCount();
-
-            int intCount = 0;
-            int vecCount = 0;
-
-            // Handle arguments passed on registers.
-            for (int index = 0; index < argsCount; index++)
-            {
-                Operand source = operation.GetSource(1 + index);
-
-                bool passOnReg;
-
-                if (source.Type.IsInteger())
-                {
-                    passOnReg = intCount + 1 < intMax;
-                }
-                else
-                {
-                    passOnReg = vecCount < vecMax;
-                }
-
-                if (source.Type == OperandType.V128 && passOnReg)
-                {
-                    // V128 is a struct, we pass each half on a GPR if possible.
-                    Operand argReg  = Gpr(CallingConvention.GetIntArgumentRegister(intCount++), OperandType.I64);
-                    Operand argReg2 = Gpr(CallingConvention.GetIntArgumentRegister(intCount++), OperandType.I64);
-
-                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, argReg, source, Const(0)));
-                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, argReg2, source, Const(1)));
-
-                    continue;
-                }
-
-                if (passOnReg)
-                {
-                    Operand argReg = source.Type.IsInteger()
-                        ? Gpr(CallingConvention.GetIntArgumentRegister(intCount++), source.Type)
-                        : Xmm(CallingConvention.GetVecArgumentRegister(vecCount++), source.Type);
-
-                    Operation copyOp = Operation(Instruction.Copy, argReg, source);
-
-                    HandleConstantRegCopy(constants, nodes, nodes.AddBefore(node, copyOp));
-
-                    sources.Add(argReg);
-                }
-                else
-                {
-                    throw new NotImplementedException("Spilling is not currently supported for tail calls. (too many arguments)");
-                }
-            }
-
-            // The target address must be on the return registers, since we
-            // don't return anything and it is guaranteed to not be a
-            // callee saved register (which would be trashed on the epilogue).
-            Operand tcAddress = Gpr(CodeGenCommon.TcAddressRegister, OperandType.I64);
-
-            Operation addrCopyOp = Operation(Instruction.Copy, tcAddress, operation.GetSource(0));
-
-            nodes.AddBefore(node, addrCopyOp);
-
-            sources[0] = tcAddress;
-
-            operation.SetSources(sources.ToArray());
-        }
-
-        private static Operation HandleCompareAndSwap(IntrusiveList<Operation> nodes, Operation node)
-        {
-            Operand expected = node.GetSource(1);
-
-            if (expected.Type == OperandType.V128)
-            {
-                Operand dest = node.Destination;
-                Operand expectedLow = Local(OperandType.I64);
-                Operand expectedHigh = Local(OperandType.I64);
-                Operand desiredLow = Local(OperandType.I64);
-                Operand desiredHigh = Local(OperandType.I64);
-                Operand actualLow = Local(OperandType.I64);
-                Operand actualHigh = Local(OperandType.I64);
-
-                Operand address = node.GetSource(0);
-                Operand desired = node.GetSource(2);
-
-                void SplitOperand(Operand source, Operand low, Operand high)
-                {
-                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, low, source, Const(0)));
-                    nodes.AddBefore(node, Operation(Instruction.VectorExtract, high, source, Const(1)));
-                }
-
-                SplitOperand(expected, expectedLow, expectedHigh);
-                SplitOperand(desired, desiredLow, desiredHigh);
-
-                Operation operation = node;
-
-                // Update the sources and destinations with split 64-bit halfs of the whole 128-bit values.
-                // We also need a additional registers that will be used to store temporary information.
-                operation.SetDestinations(new[] { actualLow, actualHigh, Local(OperandType.I64), Local(OperandType.I64) });
-                operation.SetSources(new[] { address, expectedLow, expectedHigh, desiredLow, desiredHigh });
-
-                // Add some dummy uses of the input operands, as the CAS operation will be a loop,
-                // so they can't be used as destination operand.
-                for (int i = 0; i < operation.SourcesCount; i++)
-                {
-                    Operand src = operation.GetSource(i);
-                    node = nodes.AddAfter(node, Operation(Instruction.Copy, src, src));
-                }
-
-                // Assemble the vector with the 64-bit values at the given memory location.
-                node = nodes.AddAfter(node, Operation(Instruction.VectorCreateScalar, dest, actualLow));
-                node = nodes.AddAfter(node, Operation(Instruction.VectorInsert, dest, dest, actualHigh, Const(1)));
-            }
-            else
-            {
-                // We need a additional register where the store result will be written to.
-                node.SetDestinations(new[] { node.Destination, Local(OperandType.I32) });
-
-                // Add some dummy uses of the input operands, as the CAS operation will be a loop,
-                // so they can't be used as destination operand.
-                Operation operation = node;
-
-                for (int i = 0; i < operation.SourcesCount; i++)
-                {
-                    Operand src = operation.GetSource(i);
-                    node = nodes.AddAfter(node, Operation(Instruction.Copy, src, src));
-                }
-            }
-
-            return node.ListNext;
-        }
-
-        private static void HandleReturn(IntrusiveList<Operation> nodes, Operation node)
-        {
-            if (node.SourcesCount == 0)
-            {
-                return;
-            }
-
-            Operand source = node.GetSource(0);
-
-            if (source.Type == OperandType.V128)
-            {
-                Operand retLReg = Gpr(CallingConvention.GetIntReturnRegister(),     OperandType.I64);
-                Operand retHReg = Gpr(CallingConvention.GetIntReturnRegisterHigh(), OperandType.I64);
-
-                nodes.AddBefore(node, Operation(Instruction.VectorExtract, retLReg, source, Const(0)));
-                nodes.AddBefore(node, Operation(Instruction.VectorExtract, retHReg, source, Const(1)));
-            }
-            else
-            {
-                Operand retReg = source.Type.IsInteger()
-                    ? Gpr(CallingConvention.GetIntReturnRegister(), source.Type)
-                    : Xmm(CallingConvention.GetVecReturnRegister(), source.Type);
-
-                Operation retCopyOp = Operation(Instruction.Copy, retReg, source);
-
-                nodes.AddBefore(node, retCopyOp);
-            }
-        }
-
-        private static Operation HandleLoadArgument(
-            CompilerContext cctx,
-            ref Span<Operation> buffer,
-            IntrusiveList<Operation> nodes,
-            Operand[] preservedArgs,
-            Operation node)
-        {
-            Operand source = node.GetSource(0);
-
-            Debug.Assert(source.Kind == OperandKind.Constant, "Non-constant LoadArgument source kind.");
-
-            int index = source.AsInt32();
-
-            int intCount = 0;
-            int vecCount = 0;
-
-            for (int cIndex = 0; cIndex < index; cIndex++)
-            {
-                OperandType argType = cctx.FuncArgTypes[cIndex];
-
-                if (argType.IsInteger())
-                {
-                    intCount++;
-                }
-                else if (argType == OperandType.V128)
-                {
-                    intCount += 2;
-                }
-                else
-                {
-                    vecCount++;
-                }
-            }
-
-            bool passOnReg;
-
-            if (source.Type.IsInteger())
-            {
-                passOnReg = intCount < CallingConvention.GetArgumentsOnRegsCount();
-            }
-            else if (source.Type == OperandType.V128)
-            {
-                passOnReg = intCount + 1 < CallingConvention.GetArgumentsOnRegsCount();
-            }
-            else
-            {
-                passOnReg = vecCount < CallingConvention.GetArgumentsOnRegsCount();
-            }
-
-            if (passOnReg)
-            {
-                Operand dest = node.Destination;
-
-                if (preservedArgs[index] == default)
-                {
-                    if (dest.Type == OperandType.V128)
-                    {
-                        // V128 is a struct, we pass each half on a GPR if possible.
-                        Operand pArg = Local(OperandType.V128);
-
-                        Operand argLReg = Gpr(CallingConvention.GetIntArgumentRegister(intCount), OperandType.I64);
-                        Operand argHReg = Gpr(CallingConvention.GetIntArgumentRegister(intCount + 1), OperandType.I64);
-
-                        Operation copyL = Operation(Instruction.VectorCreateScalar, pArg, argLReg);
-                        Operation copyH = Operation(Instruction.VectorInsert, pArg, pArg, argHReg, Const(1));
-
-                        cctx.Cfg.Entry.Operations.AddFirst(copyH);
-                        cctx.Cfg.Entry.Operations.AddFirst(copyL);
-
-                        preservedArgs[index] = pArg;
-                    }
-                    else
-                    {
-                        Operand pArg = Local(dest.Type);
-
-                        Operand argReg = dest.Type.IsInteger()
-                            ? Gpr(CallingConvention.GetIntArgumentRegister(intCount), dest.Type)
-                            : Xmm(CallingConvention.GetVecArgumentRegister(vecCount), dest.Type);
-
-                        Operation copyOp = Operation(Instruction.Copy, pArg, argReg);
-
-                        cctx.Cfg.Entry.Operations.AddFirst(copyOp);
-
-                        preservedArgs[index] = pArg;
-                    }
-                }
-
-                Operation nextNode;
-
-                if (dest.AssignmentsCount == 1)
-                {
-                    // Let's propagate the argument if we can to avoid copies.
-                    Propagate(ref buffer, dest, preservedArgs[index]);
-                    nextNode = node.ListNext;
-                }
-                else
-                {
-                    Operation argCopyOp = Operation(Instruction.Copy, dest, preservedArgs[index]);
-                    nextNode = nodes.AddBefore(node, argCopyOp);
-                }
-
-                Delete(nodes, node);
-                return nextNode;
-            }
-            else
-            {
-                // TODO: Pass on stack.
-                return node;
-            }
-        }
-
-        private static void Propagate(ref Span<Operation> buffer, Operand dest, Operand value)
-        {
-            ReadOnlySpan<Operation> uses = dest.GetUses(ref buffer);
-
-            foreach (Operation use in uses)
-            {
-                for (int srcIndex = 0; srcIndex < use.SourcesCount; srcIndex++)
-                {
-                    Operand useSrc = use.GetSource(srcIndex);
-
-                    if (useSrc == dest)
-                    {
-                        use.SetSource(srcIndex, value);
-                    }
-                    else if (useSrc.Kind == OperandKind.Memory)
-                    {
-                        MemoryOperand memoryOp = useSrc.GetMemory();
-
-                        Operand baseAddr = memoryOp.BaseAddress;
-                        Operand index = memoryOp.Index;
-                        bool changed = false;
-
-                        if (baseAddr == dest)
-                        {
-                            baseAddr = value;
-                            changed = true;
-                        }
-
-                        if (index == dest)
-                        {
-                            index = value;
-                            changed = true;
-                        }
-
-                        if (changed)
-                        {
-                            use.SetSource(srcIndex, MemoryOp(
-                                useSrc.Type,
-                                baseAddr,
-                                index,
-                                memoryOp.Scale,
-                                memoryOp.Displacement));
-                        }
-                    }
-                }
-            }
-        }
-
-        private static Operand AddFloatConstantCopy(
-            ConstantDict constants,
-            IntrusiveList<Operation> nodes,
-            Operation node,
-            Operand source)
-        {
-            Operand temp = Local(source.Type);
-
-            Operand intConst = AddIntConstantCopy(constants, nodes, node, GetIntConst(source));
-
-            Operation copyOp = Operation(Instruction.VectorCreateScalar, temp, intConst);
-
-            nodes.AddBefore(node, copyOp);
-
-            return temp;
-        }
-
-        private static Operand AddIntConstantCopy(
-            ConstantDict constants,
-            IntrusiveList<Operation> nodes,
-            Operation node,
-            Operand source)
-        {
-            if (constants.TryGetValue(source.Value, source.Type, out Operand temp))
-            {
-                return temp;
-            }
-
-            temp = Local(source.Type);
-
-            Operation copyOp = Operation(Instruction.Copy, temp, source);
-
-            nodes.AddBefore(node, copyOp);
-
-            constants.Add(source.Value, source.Type, temp);
-
-            return temp;
-        }
-
-        private static Operand GetIntConst(Operand value)
-        {
-            if (value.Type == OperandType.FP32)
-            {
-                return Const(value.AsInt32());
-            }
-            else if (value.Type == OperandType.FP64)
-            {
-                return Const(value.AsInt64());
-            }
-
-            return value;
-        }
-
-        private static void Delete(IntrusiveList<Operation> nodes, Operation node)
-        {
-            node.Destination = default;
-
-            for (int index = 0; index < node.SourcesCount; index++)
-            {
-                node.SetSource(index, default);
-            }
-
-            nodes.Remove(node);
-        }
-
-        private static Operand Gpr(int register, OperandType type)
-        {
-            return Register(register, RegisterType.Integer, type);
-        }
-
-        private static Operand Xmm(int register, OperandType type)
-        {
-            return Register(register, RegisterType.Vector, type);
-        }
-
-        private static bool IsSameOperandDestSrc1(Operation operation)
-        {
-            switch (operation.Instruction)
-            {
-                case Instruction.Extended:
-                    return IsSameOperandDestSrc1(operation.Intrinsic);
-                case Instruction.VectorInsert:
-                case Instruction.VectorInsert16:
-                case Instruction.VectorInsert8:
-                    return true;
-            }
-
-            return false;
-        }
-
-        private static bool IsSameOperandDestSrc1(Intrinsic intrinsic)
-        {
-            IntrinsicInfo info = IntrinsicTable.GetInfo(intrinsic & ~(Intrinsic.Arm64VTypeMask | Intrinsic.Arm64VSizeMask));
-
-            return info.Type == IntrinsicType.ScalarBinaryRd ||
-                   info.Type == IntrinsicType.ScalarTernaryFPRdByElem ||
-                   info.Type == IntrinsicType.ScalarTernaryShlRd ||
-                   info.Type == IntrinsicType.ScalarTernaryShrRd ||
-                   info.Type == IntrinsicType.VectorBinaryRd ||
-                   info.Type == IntrinsicType.VectorInsertByElem ||
-                   info.Type == IntrinsicType.VectorTernaryRd ||
-                   info.Type == IntrinsicType.VectorTernaryRdBitwise ||
-                   info.Type == IntrinsicType.VectorTernaryFPRdByElem ||
-                   info.Type == IntrinsicType.VectorTernaryRdByElem ||
-                   info.Type == IntrinsicType.VectorTernaryShlRd ||
-                   info.Type == IntrinsicType.VectorTernaryShrRd;
-        }
-
-        private static bool HasConstSrc1(Operation node, ulong value)
-        {
-            switch (node.Instruction)
-            {
-                case Instruction.Add:
-                case Instruction.BranchIf:
-                case Instruction.Compare:
-                case Instruction.Subtract:
-                    // The immediate encoding of those instructions does not allow Rn to be
-                    // XZR (it will be SP instead), so we can't allow a Rn constant in this case.
-                    return value == 0 && NotConstOrConst0(node.GetSource(1));
-                case Instruction.BitwiseAnd:
-                case Instruction.BitwiseExclusiveOr:
-                case Instruction.BitwiseNot:
-                case Instruction.BitwiseOr:
-                case Instruction.ByteSwap:
-                case Instruction.CountLeadingZeros:
-                case Instruction.Multiply:
-                case Instruction.Negate:
-                case Instruction.RotateRight:
-                case Instruction.ShiftLeft:
-                case Instruction.ShiftRightSI:
-                case Instruction.ShiftRightUI:
-                    return value == 0;
-                case Instruction.Copy:
-                case Instruction.LoadArgument:
-                case Instruction.Spill:
-                case Instruction.SpillArg:
-                    return true;
-                case Instruction.Extended:
-                    return value == 0;
-            }
-
-            return false;
-        }
-
-        private static bool NotConstOrConst0(Operand operand)
-        {
-            return operand.Kind != OperandKind.Constant || operand.Value == 0;
-        }
-
-        private static bool HasConstSrc2(Instruction inst, Operand operand)
-        {
-            ulong value = operand.Value;
-
-            switch (inst)
-            {
-                case Instruction.Add:
-                case Instruction.BranchIf:
-                case Instruction.Compare:
-                case Instruction.Subtract:
-                    return ConstFitsOnUImm12Sh(value);
-                case Instruction.BitwiseAnd:
-                case Instruction.BitwiseExclusiveOr:
-                case Instruction.BitwiseOr:
-                    return value == 0 || CodeGenCommon.TryEncodeBitMask(operand, out _, out _, out _);
-                case Instruction.Multiply:
-                case Instruction.Store:
-                case Instruction.Store16:
-                case Instruction.Store8:
-                    return value == 0;
-                case Instruction.RotateRight:
-                case Instruction.ShiftLeft:
-                case Instruction.ShiftRightSI:
-                case Instruction.ShiftRightUI:
-                case Instruction.VectorExtract:
-                case Instruction.VectorExtract16:
-                case Instruction.VectorExtract8:
-                    return true;
-                case Instruction.Extended:
-                    // TODO: Check if actual intrinsic is supposed to have consts here?
-                    // Right now we only hit this case for fixed-point int <-> FP conversion instructions.
-                    return true;
-            }
-
-            return false;
-        }
-
-        private static bool IsCommutative(Operation operation)
-        {
-            switch (operation.Instruction)
-            {
-                case Instruction.Add:
-                case Instruction.BitwiseAnd:
-                case Instruction.BitwiseExclusiveOr:
-                case Instruction.BitwiseOr:
-                case Instruction.Multiply:
-                    return true;
-
-                case Instruction.BranchIf:
-                case Instruction.Compare:
-                    {
-                        Operand comp = operation.GetSource(2);
-
-                        Debug.Assert(comp.Kind == OperandKind.Constant);
-
-                        var compType = (Comparison)comp.AsInt32();
-
-                        return compType == Comparison.Equal || compType == Comparison.NotEqual;
-                    }
-            }
-
-            return false;
-        }
-
-        private static bool ConstFitsOnUImm12Sh(ulong value)
-        {
-            return (value & ~0xfffUL) == 0 || (value & ~0xfff000UL) == 0;
-        }
-
-        private static bool IsIntrinsicWithConst(Operation operation)
-        {
-            bool isIntrinsic = IsIntrinsic(operation.Instruction);
-
-            if (isIntrinsic)
-            {
-                Intrinsic intrinsic = operation.Intrinsic;
-                IntrinsicInfo info = IntrinsicTable.GetInfo(intrinsic & ~(Intrinsic.Arm64VTypeMask | Intrinsic.Arm64VSizeMask));
-
-                // Those have integer inputs that don't support consts.
-                return info.Type != IntrinsicType.ScalarFPConvGpr &&
-                       info.Type != IntrinsicType.ScalarFPConvFixedGpr &&
-                       info.Type != IntrinsicType.SetRegister;
-            }
-
-            return false;
-        }
-
-        private static bool IsIntrinsic(Instruction inst)
-        {
-            return inst == Instruction.Extended;
-        }
-    }
-}

ARMeilleure/CodeGen/X86/AssemblerTable.cs

@@ -1,291 +0,0 @@
-using System;
-
-namespace ARMeilleure.CodeGen.X86
-{
-    partial class Assembler
-    {
-        public static bool SupportsVexPrefix(X86Instruction inst)
-        {
-            return _instTable[(int)inst].Flags.HasFlag(InstructionFlags.Vex);
-        }
-
-        private const int BadOp = 0;
-
-        [Flags]
-        private enum InstructionFlags
-        {
-            None     = 0,
-            RegOnly  = 1 << 0,
-            Reg8Src  = 1 << 1,
-            Reg8Dest = 1 << 2,
-            RexW     = 1 << 3,
-            Vex      = 1 << 4,
-
-            PrefixBit  = 16,
-            PrefixMask = 7 << PrefixBit,
-            Prefix66   = 1 << PrefixBit,
-            PrefixF3   = 2 << PrefixBit,
-            PrefixF2   = 4 << PrefixBit
-        }
-
-        private readonly struct InstructionInfo
-        {
-            public int OpRMR     { get; }
-            public int OpRMImm8  { get; }
-            public int OpRMImm32 { get; }
-            public int OpRImm64  { get; }
-            public int OpRRM     { get; }
-
-            public InstructionFlags Flags { get; }
-
-            public InstructionInfo(
-                int              opRMR,
-                int              opRMImm8,
-                int              opRMImm32,
-                int              opRImm64,
-                int              opRRM,
-                InstructionFlags flags)
-            {
-                OpRMR     = opRMR;
-                OpRMImm8  = opRMImm8;
-                OpRMImm32 = opRMImm32;
-                OpRImm64  = opRImm64;
-                OpRRM     = opRRM;
-                Flags     = flags;
-            }
-        }
-
-        private readonly static InstructionInfo[] _instTable;
-
-        static Assembler()
-        {
-            _instTable = new InstructionInfo[(int)X86Instruction.Count];
-
-            //  Name                                             RM/R        RM/I8       RM/I32      R/I64       R/RM        Flags
-            Add(X86Instruction.Add,           new InstructionInfo(0x00000001, 0x00000083, 0x00000081, BadOp,      0x00000003, InstructionFlags.None));
-            Add(X86Instruction.Addpd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f58, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Addps,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f58, InstructionFlags.Vex));
-            Add(X86Instruction.Addsd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f58, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Addss,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f58, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Aesdec,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38de, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Aesdeclast,    new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38df, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Aesenc,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38dc, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Aesenclast,    new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38dd, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Aesimc,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38db, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.And,           new InstructionInfo(0x00000021, 0x04000083, 0x04000081, BadOp,      0x00000023, InstructionFlags.None));
-            Add(X86Instruction.Andnpd,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f55, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Andnps,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f55, InstructionFlags.Vex));
-            Add(X86Instruction.Andpd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f54, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Andps,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f54, InstructionFlags.Vex));
-            Add(X86Instruction.Blendvpd,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3815, InstructionFlags.Prefix66));
-            Add(X86Instruction.Blendvps,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3814, InstructionFlags.Prefix66));
-            Add(X86Instruction.Bsr,           new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fbd, InstructionFlags.None));
-            Add(X86Instruction.Bswap,         new InstructionInfo(0x00000fc8, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.RegOnly));
-            Add(X86Instruction.Call,          new InstructionInfo(0x020000ff, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.None));
-            Add(X86Instruction.Cmovcc,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f40, InstructionFlags.None));
-            Add(X86Instruction.Cmp,           new InstructionInfo(0x00000039, 0x07000083, 0x07000081, BadOp,      0x0000003b, InstructionFlags.None));
-            Add(X86Instruction.Cmppd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fc2, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Cmpps,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fc2, InstructionFlags.Vex));
-            Add(X86Instruction.Cmpsd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fc2, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Cmpss,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fc2, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Cmpxchg,       new InstructionInfo(0x00000fb1, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.None));
-            Add(X86Instruction.Cmpxchg16b,    new InstructionInfo(0x01000fc7, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.RexW));
-            Add(X86Instruction.Cmpxchg8,      new InstructionInfo(0x00000fb0, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.Reg8Src));
-            Add(X86Instruction.Comisd,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f2f, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Comiss,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f2f, InstructionFlags.Vex));
-            Add(X86Instruction.Crc32,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38f1, InstructionFlags.PrefixF2));
-            Add(X86Instruction.Crc32_16,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38f1, InstructionFlags.PrefixF2 | InstructionFlags.Prefix66));
-            Add(X86Instruction.Crc32_8,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38f0, InstructionFlags.PrefixF2 | InstructionFlags.Reg8Src));
-            Add(X86Instruction.Cvtdq2pd,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fe6, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Cvtdq2ps,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5b, InstructionFlags.Vex));
-            Add(X86Instruction.Cvtpd2dq,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fe6, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Cvtpd2ps,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5a, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Cvtps2dq,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5b, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Cvtps2pd,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5a, InstructionFlags.Vex));
-            Add(X86Instruction.Cvtsd2si,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f2d, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Cvtsd2ss,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5a, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Cvtsi2sd,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f2a, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Cvtsi2ss,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f2a, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Cvtss2sd,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5a, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Cvtss2si,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f2d, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Div,           new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x060000f7, InstructionFlags.None));
-            Add(X86Instruction.Divpd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5e, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Divps,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5e, InstructionFlags.Vex));
-            Add(X86Instruction.Divsd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5e, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Divss,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5e, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Gf2p8affineqb, new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3ace, InstructionFlags.Prefix66));
-            Add(X86Instruction.Haddpd,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f7c, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Haddps,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f7c, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Idiv,          new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x070000f7, InstructionFlags.None));
-            Add(X86Instruction.Imul,          new InstructionInfo(BadOp,      0x0000006b, 0x00000069, BadOp,      0x00000faf, InstructionFlags.None));
-            Add(X86Instruction.Imul128,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x050000f7, InstructionFlags.None));
-            Add(X86Instruction.Insertps,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a21, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Jmp,           new InstructionInfo(0x040000ff, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.None));
-            Add(X86Instruction.Ldmxcsr,       new InstructionInfo(0x02000fae, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.Vex));
-            Add(X86Instruction.Lea,           new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x0000008d, InstructionFlags.None));
-            Add(X86Instruction.Maxpd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5f, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Maxps,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5f, InstructionFlags.Vex));
-            Add(X86Instruction.Maxsd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5f, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Maxss,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5f, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Minpd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5d, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Minps,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5d, InstructionFlags.Vex));
-            Add(X86Instruction.Minsd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5d, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Minss,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5d, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Mov,           new InstructionInfo(0x00000089, BadOp,      0x000000c7, 0x000000b8, 0x0000008b, InstructionFlags.None));
-            Add(X86Instruction.Mov16,         new InstructionInfo(0x00000089, BadOp,      0x000000c7, BadOp,      0x0000008b, InstructionFlags.Prefix66));
-            Add(X86Instruction.Mov8,          new InstructionInfo(0x00000088, 0x000000c6, BadOp,      BadOp,      0x0000008a, InstructionFlags.Reg8Src | InstructionFlags.Reg8Dest));
-            Add(X86Instruction.Movd,          new InstructionInfo(0x00000f7e, BadOp,      BadOp,      BadOp,      0x00000f6e, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Movdqu,        new InstructionInfo(0x00000f7f, BadOp,      BadOp,      BadOp,      0x00000f6f, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Movhlps,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f12, InstructionFlags.Vex));
-            Add(X86Instruction.Movlhps,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f16, InstructionFlags.Vex));
-            Add(X86Instruction.Movq,          new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f7e, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Movsd,         new InstructionInfo(0x00000f11, BadOp,      BadOp,      BadOp,      0x00000f10, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Movss,         new InstructionInfo(0x00000f11, BadOp,      BadOp,      BadOp,      0x00000f10, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Movsx16,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fbf, InstructionFlags.None));
-            Add(X86Instruction.Movsx32,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000063, InstructionFlags.None));
-            Add(X86Instruction.Movsx8,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fbe, InstructionFlags.Reg8Src));
-            Add(X86Instruction.Movzx16,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fb7, InstructionFlags.None));
-            Add(X86Instruction.Movzx8,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fb6, InstructionFlags.Reg8Src));
-            Add(X86Instruction.Mul128,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x040000f7, InstructionFlags.None));
-            Add(X86Instruction.Mulpd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f59, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Mulps,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f59, InstructionFlags.Vex));
-            Add(X86Instruction.Mulsd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f59, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Mulss,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f59, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Neg,           new InstructionInfo(0x030000f7, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.None));
-            Add(X86Instruction.Not,           new InstructionInfo(0x020000f7, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.None));
-            Add(X86Instruction.Or,            new InstructionInfo(0x00000009, 0x01000083, 0x01000081, BadOp,      0x0000000b, InstructionFlags.None));
-            Add(X86Instruction.Paddb,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000ffc, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Paddd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000ffe, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Paddq,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fd4, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Paddw,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000ffd, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Palignr,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a0f, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pand,          new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fdb, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pandn,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fdf, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pavgb,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fe0, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pavgw,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fe3, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pblendvb,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3810, InstructionFlags.Prefix66));
-            Add(X86Instruction.Pclmulqdq,     new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a44, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pcmpeqb,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f74, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pcmpeqd,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f76, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pcmpeqq,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3829, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pcmpeqw,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f75, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pcmpgtb,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f64, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pcmpgtd,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f66, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pcmpgtq,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3837, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pcmpgtw,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f65, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pextrb,        new InstructionInfo(0x000f3a14, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pextrd,        new InstructionInfo(0x000f3a16, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pextrq,        new InstructionInfo(0x000f3a16, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.Vex | InstructionFlags.RexW | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pextrw,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fc5, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pinsrb,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a20, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pinsrd,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a22, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pinsrq,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a22, InstructionFlags.Vex | InstructionFlags.RexW | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pinsrw,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fc4, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmaxsb,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f383c, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmaxsd,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f383d, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmaxsw,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fee, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmaxub,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fde, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmaxud,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f383f, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmaxuw,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f383e, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pminsb,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3838, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pminsd,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3839, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pminsw,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fea, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pminub,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fda, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pminud,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f383b, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pminuw,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f383a, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmovsxbw,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3820, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmovsxdq,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3825, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmovsxwd,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3823, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmovzxbw,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3830, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmovzxdq,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3835, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmovzxwd,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3833, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmulld,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3840, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pmullw,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fd5, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pop,           new InstructionInfo(0x0000008f, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.None));
-            Add(X86Instruction.Popcnt,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fb8, InstructionFlags.PrefixF3));
-            Add(X86Instruction.Por,           new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000feb, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pshufb,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3800, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pshufd,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f70, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pslld,         new InstructionInfo(BadOp,      0x06000f72, BadOp,      BadOp,      0x00000ff2, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Pslldq,        new InstructionInfo(BadOp,      0x07000f73, BadOp,      BadOp,      BadOp,      InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Psllq,         new InstructionInfo(BadOp,      0x06000f73, BadOp,      BadOp,      0x00000ff3, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Psllw,         new InstructionInfo(BadOp,      0x06000f71, BadOp,      BadOp,      0x00000ff1, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Psrad,         new InstructionInfo(BadOp,      0x04000f72, BadOp,      BadOp,      0x00000fe2, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Psraw,         new InstructionInfo(BadOp,      0x04000f71, BadOp,      BadOp,      0x00000fe1, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Psrld,         new InstructionInfo(BadOp,      0x02000f72, BadOp,      BadOp,      0x00000fd2, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Psrlq,         new InstructionInfo(BadOp,      0x02000f73, BadOp,      BadOp,      0x00000fd3, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Psrldq,        new InstructionInfo(BadOp,      0x03000f73, BadOp,      BadOp,      BadOp,      InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Psrlw,         new InstructionInfo(BadOp,      0x02000f71, BadOp,      BadOp,      0x00000fd1, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Psubb,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000ff8, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Psubd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000ffa, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Psubq,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000ffb, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Psubw,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000ff9, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Punpckhbw,     new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f68, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Punpckhdq,     new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f6a, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Punpckhqdq,    new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f6d, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Punpckhwd,     new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f69, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Punpcklbw,     new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f60, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Punpckldq,     new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f62, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Punpcklqdq,    new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f6c, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Punpcklwd,     new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f61, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Push,          new InstructionInfo(BadOp,      0x0000006a, 0x00000068, BadOp,      0x060000ff, InstructionFlags.None));
-            Add(X86Instruction.Pxor,          new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fef, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Rcpps,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f53, InstructionFlags.Vex));
-            Add(X86Instruction.Rcpss,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f53, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Ror,           new InstructionInfo(0x010000d3, 0x010000c1, BadOp,      BadOp,      BadOp,      InstructionFlags.None));
-            Add(X86Instruction.Roundpd,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a09, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Roundps,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a08, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Roundsd,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a0b, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Roundss,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a0a, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Rsqrtps,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f52, InstructionFlags.Vex));
-            Add(X86Instruction.Rsqrtss,       new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f52, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Sar,           new InstructionInfo(0x070000d3, 0x070000c1, BadOp,      BadOp,      BadOp,      InstructionFlags.None));
-            Add(X86Instruction.Setcc,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f90, InstructionFlags.Reg8Dest));
-            Add(X86Instruction.Sha256Msg1,    new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38cc, InstructionFlags.None));
-            Add(X86Instruction.Sha256Msg2,    new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38cd, InstructionFlags.None));
-            Add(X86Instruction.Sha256Rnds2,   new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38cb, InstructionFlags.None));
-            Add(X86Instruction.Shl,           new InstructionInfo(0x040000d3, 0x040000c1, BadOp,      BadOp,      BadOp,      InstructionFlags.None));
-            Add(X86Instruction.Shr,           new InstructionInfo(0x050000d3, 0x050000c1, BadOp,      BadOp,      BadOp,      InstructionFlags.None));
-            Add(X86Instruction.Shufpd,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fc6, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Shufps,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000fc6, InstructionFlags.Vex));
-            Add(X86Instruction.Sqrtpd,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f51, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Sqrtps,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f51, InstructionFlags.Vex));
-            Add(X86Instruction.Sqrtsd,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f51, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Sqrtss,        new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f51, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Stmxcsr,       new InstructionInfo(0x03000fae, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.Vex));
-            Add(X86Instruction.Sub,           new InstructionInfo(0x00000029, 0x05000083, 0x05000081, BadOp,      0x0000002b, InstructionFlags.None));
-            Add(X86Instruction.Subpd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5c, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Subps,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5c, InstructionFlags.Vex));
-            Add(X86Instruction.Subsd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5c, InstructionFlags.Vex | InstructionFlags.PrefixF2));
-            Add(X86Instruction.Subss,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f5c, InstructionFlags.Vex | InstructionFlags.PrefixF3));
-            Add(X86Instruction.Test,          new InstructionInfo(0x00000085, BadOp,      0x000000f7, BadOp,      BadOp,      InstructionFlags.None));
-            Add(X86Instruction.Unpckhpd,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f15, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Unpckhps,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f15, InstructionFlags.Vex));
-            Add(X86Instruction.Unpcklpd,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f14, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Unpcklps,      new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f14, InstructionFlags.Vex));
-            Add(X86Instruction.Vblendvpd,     new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a4b, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Vblendvps,     new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a4a, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Vcvtph2ps,     new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3813, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Vcvtps2ph,     new InstructionInfo(0x000f3a1d, BadOp,      BadOp,      BadOp,      BadOp,      InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Vfmadd231ps,   new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38b8, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Vfmadd231sd,   new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38b9, InstructionFlags.Vex | InstructionFlags.Prefix66 | InstructionFlags.RexW));
-            Add(X86Instruction.Vfmadd231ss,   new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38b9, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Vfmsub231sd,   new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38bb, InstructionFlags.Vex | InstructionFlags.Prefix66 | InstructionFlags.RexW));
-            Add(X86Instruction.Vfmsub231ss,   new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38bb, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Vfnmadd231ps,  new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38bc, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Vfnmadd231sd,  new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38bd, InstructionFlags.Vex | InstructionFlags.Prefix66 | InstructionFlags.RexW));
-            Add(X86Instruction.Vfnmadd231ss,  new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38bd, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Vfnmsub231sd,  new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38bf, InstructionFlags.Vex | InstructionFlags.Prefix66 | InstructionFlags.RexW));
-            Add(X86Instruction.Vfnmsub231ss,  new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f38bf, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Vpblendvb,     new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x000f3a4c, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Xor,           new InstructionInfo(0x00000031, 0x06000083, 0x06000081, BadOp,      0x00000033, InstructionFlags.None));
-            Add(X86Instruction.Xorpd,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f57, InstructionFlags.Vex | InstructionFlags.Prefix66));
-            Add(X86Instruction.Xorps,         new InstructionInfo(BadOp,      BadOp,      BadOp,      BadOp,      0x00000f57, InstructionFlags.Vex));
-
-            static void Add(X86Instruction inst, in InstructionInfo info)
-            {
-                _instTable[(int)inst] = info;
-            }
-        }
-    }
-}

ARMeilleure/CodeGen/X86/CodeGenContext.cs

@@ -1,104 +0,0 @@
-using ARMeilleure.CodeGen.RegisterAllocators;
-using ARMeilleure.IntermediateRepresentation;
-using System.IO;
-using System.Numerics;
-
-namespace ARMeilleure.CodeGen.X86
-{
-    class CodeGenContext
-    {
-        private readonly Stream _stream;
-        private readonly Operand[] _blockLabels;
-
-        public int StreamOffset => (int)_stream.Length;
-
-        public AllocationResult AllocResult { get; }
-
-        public Assembler Assembler { get; }
-        public BasicBlock CurrBlock { get; private set; }
-
-        public int CallArgsRegionSize { get; }
-        public int XmmSaveRegionSize { get; }
-
-        public CodeGenContext(AllocationResult allocResult, int maxCallArgs, int blocksCount, bool relocatable)
-        {
-            _stream = new MemoryStream();
-            _blockLabels = new Operand[blocksCount];
-
-            AllocResult = allocResult;
-            Assembler = new Assembler(_stream, relocatable);
-
-            CallArgsRegionSize = GetCallArgsRegionSize(allocResult, maxCallArgs, out int xmmSaveRegionSize);
-            XmmSaveRegionSize  = xmmSaveRegionSize;
-        }
-
-        private static int GetCallArgsRegionSize(AllocationResult allocResult, int maxCallArgs, out int xmmSaveRegionSize)
-        {
-            // We need to add 8 bytes to the total size, as the call to this function already pushed 8 bytes (the
-            // return address).
-            int intMask = CallingConvention.GetIntCalleeSavedRegisters() & allocResult.IntUsedRegisters;
-            int vecMask = CallingConvention.GetVecCalleeSavedRegisters() & allocResult.VecUsedRegisters;
-
-            xmmSaveRegionSize = BitOperations.PopCount((uint)vecMask) * 16;
-
-            int calleeSaveRegionSize = BitOperations.PopCount((uint)intMask) * 8 + xmmSaveRegionSize + 8;
-
-            int argsCount = maxCallArgs;
-
-            if (argsCount < 0)
-            {
-                // When the function has no calls, argsCount is -1. In this case, we don't need to allocate the shadow
-                // space.
-                argsCount = 0;
-            }
-            else if (argsCount < 4)
-            {
-                // The ABI mandates that the space for at least 4 arguments is reserved on the stack (this is called
-                // shadow space).
-                argsCount = 4;
-            }
-
-            // TODO: Align XMM save region to 16 bytes because unwinding on Windows requires it.
-            int frameSize = calleeSaveRegionSize + allocResult.SpillRegionSize;
-
-            // TODO: Instead of always multiplying by 16 (the largest possible size of a variable, since a V128 has 16
-            // bytes), we should calculate the exact size consumed by the arguments passed to the called functions on
-            // the stack.
-            int callArgsAndFrameSize = frameSize + argsCount * 16;
-
-            // Ensure that the Stack Pointer will be aligned to 16 bytes.
-            callArgsAndFrameSize = (callArgsAndFrameSize + 0xf) & ~0xf;
-
-            return callArgsAndFrameSize - frameSize;
-        }
-
-        public void EnterBlock(BasicBlock block)
-        {
-            Assembler.MarkLabel(GetLabel(block));
-
-            CurrBlock = block;
-        }
-
-        public void JumpTo(BasicBlock target)
-        {
-            Assembler.Jmp(GetLabel(target));
-        }
-
-        public void JumpTo(X86Condition condition, BasicBlock target)
-        {
-            Assembler.Jcc(condition, GetLabel(target));
-        }
-
-        private Operand GetLabel(BasicBlock block)
-        {
-            ref Operand label = ref _blockLabels[block.Index];
-
-            if (label == default)
-            {
-                label = Operand.Factory.Label();
-            }
-
-            return label;
-        }
-    }
-}

ARMeilleure/CodeGen/X86/HardwareCapabilities.cs

@@ -1,89 +0,0 @@
-using System;
-using System.Runtime.Intrinsics.X86;
-
-namespace ARMeilleure.CodeGen.X86
-{
-    static class HardwareCapabilities
-    {
-        static HardwareCapabilities()
-        {
-            if (!X86Base.IsSupported)
-            {
-                return;
-            }
-
-            (int maxNum, _, _, _) = X86Base.CpuId(0x00000000, 0x00000000);
-
-            (_, _, int ecx1, int edx1) = X86Base.CpuId(0x00000001, 0x00000000);
-            FeatureInfo1Edx = (FeatureFlags1Edx)edx1;
-            FeatureInfo1Ecx = (FeatureFlags1Ecx)ecx1;
-
-            if (maxNum >= 7)
-            {
-                (_, int ebx7, int ecx7, _) = X86Base.CpuId(0x00000007, 0x00000000);
-                FeatureInfo7Ebx = (FeatureFlags7Ebx)ebx7;
-                FeatureInfo7Ecx = (FeatureFlags7Ecx)ecx7;
-            }
-        }
-
-        [Flags]
-        public enum FeatureFlags1Edx
-        {
-            Sse = 1 << 25,
-            Sse2 = 1 << 26
-        }
-
-        [Flags]
-        public enum FeatureFlags1Ecx
-        {
-            Sse3 = 1 << 0,
-            Pclmulqdq = 1 << 1,
-            Ssse3 = 1 << 9,
-            Fma = 1 << 12,
-            Sse41 = 1 << 19,
-            Sse42 = 1 << 20,
-            Popcnt = 1 << 23,
-            Aes = 1 << 25,
-            Avx = 1 << 28,
-            F16c = 1 << 29
-        }
-
-        [Flags]
-        public enum FeatureFlags7Ebx
-        {
-            Avx2 = 1 << 5,
-            Sha = 1 << 29
-        }
-
-        [Flags]
-        public enum FeatureFlags7Ecx
-        {
-            Gfni = 1 << 8,
-        }
-
-        public static FeatureFlags1Edx FeatureInfo1Edx { get; }
-        public static FeatureFlags1Ecx FeatureInfo1Ecx { get; }
-        public static FeatureFlags7Ebx FeatureInfo7Ebx { get; } = 0;
-        public static FeatureFlags7Ecx FeatureInfo7Ecx { get; } = 0;
-
-        public static bool SupportsSse => FeatureInfo1Edx.HasFlag(FeatureFlags1Edx.Sse);
-        public static bool SupportsSse2 => FeatureInfo1Edx.HasFlag(FeatureFlags1Edx.Sse2);
-        public static bool SupportsSse3 => FeatureInfo1Ecx.HasFlag(FeatureFlags1Ecx.Sse3);
-        public static bool SupportsPclmulqdq => FeatureInfo1Ecx.HasFlag(FeatureFlags1Ecx.Pclmulqdq);
-        public static bool SupportsSsse3 => FeatureInfo1Ecx.HasFlag(FeatureFlags1Ecx.Ssse3);
-        public static bool SupportsFma => FeatureInfo1Ecx.HasFlag(FeatureFlags1Ecx.Fma);
-        public static bool SupportsSse41 => FeatureInfo1Ecx.HasFlag(FeatureFlags1Ecx.Sse41);
-        public static bool SupportsSse42 => FeatureInfo1Ecx.HasFlag(FeatureFlags1Ecx.Sse42);
-        public static bool SupportsPopcnt => FeatureInfo1Ecx.HasFlag(FeatureFlags1Ecx.Popcnt);
-        public static bool SupportsAesni => FeatureInfo1Ecx.HasFlag(FeatureFlags1Ecx.Aes);
-        public static bool SupportsAvx => FeatureInfo1Ecx.HasFlag(FeatureFlags1Ecx.Avx);
-        public static bool SupportsAvx2 => FeatureInfo7Ebx.HasFlag(FeatureFlags7Ebx.Avx2) && SupportsAvx;
-        public static bool SupportsF16c => FeatureInfo1Ecx.HasFlag(FeatureFlags1Ecx.F16c);
-        public static bool SupportsSha => FeatureInfo7Ebx.HasFlag(FeatureFlags7Ebx.Sha);
-        public static bool SupportsGfni => FeatureInfo7Ecx.HasFlag(FeatureFlags7Ecx.Gfni);
-
-        public static bool ForceLegacySse { get; set; }
-
-        public static bool SupportsVexEncoding => SupportsAvx && !ForceLegacySse;
-    }
-}

ARMeilleure/CodeGen/X86/IntrinsicTable.cs

@@ -1,197 +0,0 @@
-using ARMeilleure.Common;
-using ARMeilleure.IntermediateRepresentation;
-
-namespace ARMeilleure.CodeGen.X86
-{
-    static class IntrinsicTable
-    {
-        private static IntrinsicInfo[] _intrinTable;
-
-        static IntrinsicTable()
-        {
-            _intrinTable = new IntrinsicInfo[EnumUtils.GetCount(typeof(Intrinsic))];
-
-            Add(Intrinsic.X86Addpd,         new IntrinsicInfo(X86Instruction.Addpd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Addps,         new IntrinsicInfo(X86Instruction.Addps,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Addsd,         new IntrinsicInfo(X86Instruction.Addsd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Addss,         new IntrinsicInfo(X86Instruction.Addss,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Aesdec,        new IntrinsicInfo(X86Instruction.Aesdec,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Aesdeclast,    new IntrinsicInfo(X86Instruction.Aesdeclast,    IntrinsicType.Binary));
-            Add(Intrinsic.X86Aesenc,        new IntrinsicInfo(X86Instruction.Aesenc,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Aesenclast,    new IntrinsicInfo(X86Instruction.Aesenclast,    IntrinsicType.Binary));
-            Add(Intrinsic.X86Aesimc,        new IntrinsicInfo(X86Instruction.Aesimc,        IntrinsicType.Unary));
-            Add(Intrinsic.X86Andnpd,        new IntrinsicInfo(X86Instruction.Andnpd,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Andnps,        new IntrinsicInfo(X86Instruction.Andnps,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Andpd,         new IntrinsicInfo(X86Instruction.Andpd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Andps,         new IntrinsicInfo(X86Instruction.Andps,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Blendvpd,      new IntrinsicInfo(X86Instruction.Blendvpd,      IntrinsicType.Ternary));
-            Add(Intrinsic.X86Blendvps,      new IntrinsicInfo(X86Instruction.Blendvps,      IntrinsicType.Ternary));
-            Add(Intrinsic.X86Cmppd,         new IntrinsicInfo(X86Instruction.Cmppd,         IntrinsicType.TernaryImm));
-            Add(Intrinsic.X86Cmpps,         new IntrinsicInfo(X86Instruction.Cmpps,         IntrinsicType.TernaryImm));
-            Add(Intrinsic.X86Cmpsd,         new IntrinsicInfo(X86Instruction.Cmpsd,         IntrinsicType.TernaryImm));
-            Add(Intrinsic.X86Cmpss,         new IntrinsicInfo(X86Instruction.Cmpss,         IntrinsicType.TernaryImm));
-            Add(Intrinsic.X86Comisdeq,      new IntrinsicInfo(X86Instruction.Comisd,        IntrinsicType.Comis_));
-            Add(Intrinsic.X86Comisdge,      new IntrinsicInfo(X86Instruction.Comisd,        IntrinsicType.Comis_));
-            Add(Intrinsic.X86Comisdlt,      new IntrinsicInfo(X86Instruction.Comisd,        IntrinsicType.Comis_));
-            Add(Intrinsic.X86Comisseq,      new IntrinsicInfo(X86Instruction.Comiss,        IntrinsicType.Comis_));
-            Add(Intrinsic.X86Comissge,      new IntrinsicInfo(X86Instruction.Comiss,        IntrinsicType.Comis_));
-            Add(Intrinsic.X86Comisslt,      new IntrinsicInfo(X86Instruction.Comiss,        IntrinsicType.Comis_));
-            Add(Intrinsic.X86Crc32,         new IntrinsicInfo(X86Instruction.Crc32,         IntrinsicType.Crc32));
-            Add(Intrinsic.X86Crc32_16,      new IntrinsicInfo(X86Instruction.Crc32_16,      IntrinsicType.Crc32));
-            Add(Intrinsic.X86Crc32_8,       new IntrinsicInfo(X86Instruction.Crc32_8,       IntrinsicType.Crc32));
-            Add(Intrinsic.X86Cvtdq2pd,      new IntrinsicInfo(X86Instruction.Cvtdq2pd,      IntrinsicType.Unary));
-            Add(Intrinsic.X86Cvtdq2ps,      new IntrinsicInfo(X86Instruction.Cvtdq2ps,      IntrinsicType.Unary));
-            Add(Intrinsic.X86Cvtpd2dq,      new IntrinsicInfo(X86Instruction.Cvtpd2dq,      IntrinsicType.Unary));
-            Add(Intrinsic.X86Cvtpd2ps,      new IntrinsicInfo(X86Instruction.Cvtpd2ps,      IntrinsicType.Unary));
-            Add(Intrinsic.X86Cvtps2dq,      new IntrinsicInfo(X86Instruction.Cvtps2dq,      IntrinsicType.Unary));
-            Add(Intrinsic.X86Cvtps2pd,      new IntrinsicInfo(X86Instruction.Cvtps2pd,      IntrinsicType.Unary));
-            Add(Intrinsic.X86Cvtsd2si,      new IntrinsicInfo(X86Instruction.Cvtsd2si,      IntrinsicType.UnaryToGpr));
-            Add(Intrinsic.X86Cvtsd2ss,      new IntrinsicInfo(X86Instruction.Cvtsd2ss,      IntrinsicType.Binary));
-            Add(Intrinsic.X86Cvtsi2sd,      new IntrinsicInfo(X86Instruction.Cvtsi2sd,      IntrinsicType.BinaryGpr));
-            Add(Intrinsic.X86Cvtsi2si,      new IntrinsicInfo(X86Instruction.Movd,          IntrinsicType.UnaryToGpr));
-            Add(Intrinsic.X86Cvtsi2ss,      new IntrinsicInfo(X86Instruction.Cvtsi2ss,      IntrinsicType.BinaryGpr));
-            Add(Intrinsic.X86Cvtss2sd,      new IntrinsicInfo(X86Instruction.Cvtss2sd,      IntrinsicType.Binary));
-            Add(Intrinsic.X86Cvtss2si,      new IntrinsicInfo(X86Instruction.Cvtss2si,      IntrinsicType.UnaryToGpr));
-            Add(Intrinsic.X86Divpd,         new IntrinsicInfo(X86Instruction.Divpd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Divps,         new IntrinsicInfo(X86Instruction.Divps,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Divsd,         new IntrinsicInfo(X86Instruction.Divsd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Divss,         new IntrinsicInfo(X86Instruction.Divss,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Gf2p8affineqb, new IntrinsicInfo(X86Instruction.Gf2p8affineqb, IntrinsicType.TernaryImm));
-            Add(Intrinsic.X86Haddpd,        new IntrinsicInfo(X86Instruction.Haddpd,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Haddps,        new IntrinsicInfo(X86Instruction.Haddps,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Insertps,      new IntrinsicInfo(X86Instruction.Insertps,      IntrinsicType.TernaryImm));
-            Add(Intrinsic.X86Maxpd,         new IntrinsicInfo(X86Instruction.Maxpd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Maxps,         new IntrinsicInfo(X86Instruction.Maxps,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Maxsd,         new IntrinsicInfo(X86Instruction.Maxsd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Maxss,         new IntrinsicInfo(X86Instruction.Maxss,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Minpd,         new IntrinsicInfo(X86Instruction.Minpd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Minps,         new IntrinsicInfo(X86Instruction.Minps,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Minsd,         new IntrinsicInfo(X86Instruction.Minsd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Minss,         new IntrinsicInfo(X86Instruction.Minss,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Movhlps,       new IntrinsicInfo(X86Instruction.Movhlps,       IntrinsicType.Binary));
-            Add(Intrinsic.X86Movlhps,       new IntrinsicInfo(X86Instruction.Movlhps,       IntrinsicType.Binary));
-            Add(Intrinsic.X86Movss,         new IntrinsicInfo(X86Instruction.Movss,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Mulpd,         new IntrinsicInfo(X86Instruction.Mulpd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Mulps,         new IntrinsicInfo(X86Instruction.Mulps,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Mulsd,         new IntrinsicInfo(X86Instruction.Mulsd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Mulss,         new IntrinsicInfo(X86Instruction.Mulss,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Mxcsrmb,       new IntrinsicInfo(X86Instruction.None,          IntrinsicType.Mxcsr)); // Mask bits.
-            Add(Intrinsic.X86Mxcsrub,       new IntrinsicInfo(X86Instruction.None,          IntrinsicType.Mxcsr)); // Unmask bits.
-            Add(Intrinsic.X86Paddb,         new IntrinsicInfo(X86Instruction.Paddb,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Paddd,         new IntrinsicInfo(X86Instruction.Paddd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Paddq,         new IntrinsicInfo(X86Instruction.Paddq,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Paddw,         new IntrinsicInfo(X86Instruction.Paddw,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Palignr,       new IntrinsicInfo(X86Instruction.Palignr,       IntrinsicType.TernaryImm));
-            Add(Intrinsic.X86Pand,          new IntrinsicInfo(X86Instruction.Pand,          IntrinsicType.Binary));
-            Add(Intrinsic.X86Pandn,         new IntrinsicInfo(X86Instruction.Pandn,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Pavgb,         new IntrinsicInfo(X86Instruction.Pavgb,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Pavgw,         new IntrinsicInfo(X86Instruction.Pavgw,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Pblendvb,      new IntrinsicInfo(X86Instruction.Pblendvb,      IntrinsicType.Ternary));
-            Add(Intrinsic.X86Pclmulqdq,     new IntrinsicInfo(X86Instruction.Pclmulqdq,     IntrinsicType.TernaryImm));
-            Add(Intrinsic.X86Pcmpeqb,       new IntrinsicInfo(X86Instruction.Pcmpeqb,       IntrinsicType.Binary));
-            Add(Intrinsic.X86Pcmpeqd,       new IntrinsicInfo(X86Instruction.Pcmpeqd,       IntrinsicType.Binary));
-            Add(Intrinsic.X86Pcmpeqq,       new IntrinsicInfo(X86Instruction.Pcmpeqq,       IntrinsicType.Binary));
-            Add(Intrinsic.X86Pcmpeqw,       new IntrinsicInfo(X86Instruction.Pcmpeqw,       IntrinsicType.Binary));
-            Add(Intrinsic.X86Pcmpgtb,       new IntrinsicInfo(X86Instruction.Pcmpgtb,       IntrinsicType.Binary));
-            Add(Intrinsic.X86Pcmpgtd,       new IntrinsicInfo(X86Instruction.Pcmpgtd,       IntrinsicType.Binary));
-            Add(Intrinsic.X86Pcmpgtq,       new IntrinsicInfo(X86Instruction.Pcmpgtq,       IntrinsicType.Binary));
-            Add(Intrinsic.X86Pcmpgtw,       new IntrinsicInfo(X86Instruction.Pcmpgtw,       IntrinsicType.Binary));
-            Add(Intrinsic.X86Pmaxsb,        new IntrinsicInfo(X86Instruction.Pmaxsb,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pmaxsd,        new IntrinsicInfo(X86Instruction.Pmaxsd,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pmaxsw,        new IntrinsicInfo(X86Instruction.Pmaxsw,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pmaxub,        new IntrinsicInfo(X86Instruction.Pmaxub,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pmaxud,        new IntrinsicInfo(X86Instruction.Pmaxud,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pmaxuw,        new IntrinsicInfo(X86Instruction.Pmaxuw,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pminsb,        new IntrinsicInfo(X86Instruction.Pminsb,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pminsd,        new IntrinsicInfo(X86Instruction.Pminsd,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pminsw,        new IntrinsicInfo(X86Instruction.Pminsw,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pminub,        new IntrinsicInfo(X86Instruction.Pminub,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pminud,        new IntrinsicInfo(X86Instruction.Pminud,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pminuw,        new IntrinsicInfo(X86Instruction.Pminuw,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pmovsxbw,      new IntrinsicInfo(X86Instruction.Pmovsxbw,      IntrinsicType.Unary));
-            Add(Intrinsic.X86Pmovsxdq,      new IntrinsicInfo(X86Instruction.Pmovsxdq,      IntrinsicType.Unary));
-            Add(Intrinsic.X86Pmovsxwd,      new IntrinsicInfo(X86Instruction.Pmovsxwd,      IntrinsicType.Unary));
-            Add(Intrinsic.X86Pmovzxbw,      new IntrinsicInfo(X86Instruction.Pmovzxbw,      IntrinsicType.Unary));
-            Add(Intrinsic.X86Pmovzxdq,      new IntrinsicInfo(X86Instruction.Pmovzxdq,      IntrinsicType.Unary));
-            Add(Intrinsic.X86Pmovzxwd,      new IntrinsicInfo(X86Instruction.Pmovzxwd,      IntrinsicType.Unary));
-            Add(Intrinsic.X86Pmulld,        new IntrinsicInfo(X86Instruction.Pmulld,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pmullw,        new IntrinsicInfo(X86Instruction.Pmullw,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Popcnt,        new IntrinsicInfo(X86Instruction.Popcnt,        IntrinsicType.PopCount));
-            Add(Intrinsic.X86Por,           new IntrinsicInfo(X86Instruction.Por,           IntrinsicType.Binary));
-            Add(Intrinsic.X86Pshufb,        new IntrinsicInfo(X86Instruction.Pshufb,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Pshufd,        new IntrinsicInfo(X86Instruction.Pshufd,        IntrinsicType.BinaryImm));
-            Add(Intrinsic.X86Pslld,         new IntrinsicInfo(X86Instruction.Pslld,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Pslldq,        new IntrinsicInfo(X86Instruction.Pslldq,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Psllq,         new IntrinsicInfo(X86Instruction.Psllq,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Psllw,         new IntrinsicInfo(X86Instruction.Psllw,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Psrad,         new IntrinsicInfo(X86Instruction.Psrad,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Psraw,         new IntrinsicInfo(X86Instruction.Psraw,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Psrld,         new IntrinsicInfo(X86Instruction.Psrld,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Psrlq,         new IntrinsicInfo(X86Instruction.Psrlq,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Psrldq,        new IntrinsicInfo(X86Instruction.Psrldq,        IntrinsicType.Binary));
-            Add(Intrinsic.X86Psrlw,         new IntrinsicInfo(X86Instruction.Psrlw,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Psubb,         new IntrinsicInfo(X86Instruction.Psubb,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Psubd,         new IntrinsicInfo(X86Instruction.Psubd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Psubq,         new IntrinsicInfo(X86Instruction.Psubq,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Psubw,         new IntrinsicInfo(X86Instruction.Psubw,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Punpckhbw,     new IntrinsicInfo(X86Instruction.Punpckhbw,     IntrinsicType.Binary));
-            Add(Intrinsic.X86Punpckhdq,     new IntrinsicInfo(X86Instruction.Punpckhdq,     IntrinsicType.Binary));
-            Add(Intrinsic.X86Punpckhqdq,    new IntrinsicInfo(X86Instruction.Punpckhqdq,    IntrinsicType.Binary));
-            Add(Intrinsic.X86Punpckhwd,     new IntrinsicInfo(X86Instruction.Punpckhwd,     IntrinsicType.Binary));
-            Add(Intrinsic.X86Punpcklbw,     new IntrinsicInfo(X86Instruction.Punpcklbw,     IntrinsicType.Binary));
-            Add(Intrinsic.X86Punpckldq,     new IntrinsicInfo(X86Instruction.Punpckldq,     IntrinsicType.Binary));
-            Add(Intrinsic.X86Punpcklqdq,    new IntrinsicInfo(X86Instruction.Punpcklqdq,    IntrinsicType.Binary));
-            Add(Intrinsic.X86Punpcklwd,     new IntrinsicInfo(X86Instruction.Punpcklwd,     IntrinsicType.Binary));
-            Add(Intrinsic.X86Pxor,          new IntrinsicInfo(X86Instruction.Pxor,          IntrinsicType.Binary));
-            Add(Intrinsic.X86Rcpps,         new IntrinsicInfo(X86Instruction.Rcpps,         IntrinsicType.Unary));
-            Add(Intrinsic.X86Rcpss,         new IntrinsicInfo(X86Instruction.Rcpss,         IntrinsicType.Unary));
-            Add(Intrinsic.X86Roundpd,       new IntrinsicInfo(X86Instruction.Roundpd,       IntrinsicType.BinaryImm));
-            Add(Intrinsic.X86Roundps,       new IntrinsicInfo(X86Instruction.Roundps,       IntrinsicType.BinaryImm));
-            Add(Intrinsic.X86Roundsd,       new IntrinsicInfo(X86Instruction.Roundsd,       IntrinsicType.BinaryImm));
-            Add(Intrinsic.X86Roundss,       new IntrinsicInfo(X86Instruction.Roundss,       IntrinsicType.BinaryImm));
-            Add(Intrinsic.X86Rsqrtps,       new IntrinsicInfo(X86Instruction.Rsqrtps,       IntrinsicType.Unary));
-            Add(Intrinsic.X86Rsqrtss,       new IntrinsicInfo(X86Instruction.Rsqrtss,       IntrinsicType.Unary));
-            Add(Intrinsic.X86Sha256Msg1,    new IntrinsicInfo(X86Instruction.Sha256Msg1,    IntrinsicType.Binary));
-            Add(Intrinsic.X86Sha256Msg2,    new IntrinsicInfo(X86Instruction.Sha256Msg2,    IntrinsicType.Binary));
-            Add(Intrinsic.X86Sha256Rnds2,   new IntrinsicInfo(X86Instruction.Sha256Rnds2,   IntrinsicType.Ternary));
-            Add(Intrinsic.X86Shufpd,        new IntrinsicInfo(X86Instruction.Shufpd,        IntrinsicType.TernaryImm));
-            Add(Intrinsic.X86Shufps,        new IntrinsicInfo(X86Instruction.Shufps,        IntrinsicType.TernaryImm));
-            Add(Intrinsic.X86Sqrtpd,        new IntrinsicInfo(X86Instruction.Sqrtpd,        IntrinsicType.Unary));
-            Add(Intrinsic.X86Sqrtps,        new IntrinsicInfo(X86Instruction.Sqrtps,        IntrinsicType.Unary));
-            Add(Intrinsic.X86Sqrtsd,        new IntrinsicInfo(X86Instruction.Sqrtsd,        IntrinsicType.Unary));
-            Add(Intrinsic.X86Sqrtss,        new IntrinsicInfo(X86Instruction.Sqrtss,        IntrinsicType.Unary));
-            Add(Intrinsic.X86Subpd,         new IntrinsicInfo(X86Instruction.Subpd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Subps,         new IntrinsicInfo(X86Instruction.Subps,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Subsd,         new IntrinsicInfo(X86Instruction.Subsd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Subss,         new IntrinsicInfo(X86Instruction.Subss,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Unpckhpd,      new IntrinsicInfo(X86Instruction.Unpckhpd,      IntrinsicType.Binary));
-            Add(Intrinsic.X86Unpckhps,      new IntrinsicInfo(X86Instruction.Unpckhps,      IntrinsicType.Binary));
-            Add(Intrinsic.X86Unpcklpd,      new IntrinsicInfo(X86Instruction.Unpcklpd,      IntrinsicType.Binary));
-            Add(Intrinsic.X86Unpcklps,      new IntrinsicInfo(X86Instruction.Unpcklps,      IntrinsicType.Binary));
-            Add(Intrinsic.X86Vcvtph2ps,     new IntrinsicInfo(X86Instruction.Vcvtph2ps,     IntrinsicType.Unary));
-            Add(Intrinsic.X86Vcvtps2ph,     new IntrinsicInfo(X86Instruction.Vcvtps2ph,     IntrinsicType.BinaryImm));
-            Add(Intrinsic.X86Vfmadd231ps,   new IntrinsicInfo(X86Instruction.Vfmadd231ps,   IntrinsicType.Fma));
-            Add(Intrinsic.X86Vfmadd231sd,   new IntrinsicInfo(X86Instruction.Vfmadd231sd,   IntrinsicType.Fma));
-            Add(Intrinsic.X86Vfmadd231ss,   new IntrinsicInfo(X86Instruction.Vfmadd231ss,   IntrinsicType.Fma));
-            Add(Intrinsic.X86Vfmsub231sd,   new IntrinsicInfo(X86Instruction.Vfmsub231sd,   IntrinsicType.Fma));
-            Add(Intrinsic.X86Vfmsub231ss,   new IntrinsicInfo(X86Instruction.Vfmsub231ss,   IntrinsicType.Fma));
-            Add(Intrinsic.X86Vfnmadd231ps,  new IntrinsicInfo(X86Instruction.Vfnmadd231ps,  IntrinsicType.Fma));
-            Add(Intrinsic.X86Vfnmadd231sd,  new IntrinsicInfo(X86Instruction.Vfnmadd231sd,  IntrinsicType.Fma));
-            Add(Intrinsic.X86Vfnmadd231ss,  new IntrinsicInfo(X86Instruction.Vfnmadd231ss,  IntrinsicType.Fma));
-            Add(Intrinsic.X86Vfnmsub231sd,  new IntrinsicInfo(X86Instruction.Vfnmsub231sd,  IntrinsicType.Fma));
-            Add(Intrinsic.X86Vfnmsub231ss,  new IntrinsicInfo(X86Instruction.Vfnmsub231ss,  IntrinsicType.Fma));
-            Add(Intrinsic.X86Xorpd,         new IntrinsicInfo(X86Instruction.Xorpd,         IntrinsicType.Binary));
-            Add(Intrinsic.X86Xorps,         new IntrinsicInfo(X86Instruction.Xorps,         IntrinsicType.Binary));
-        }
-
-        private static void Add(Intrinsic intrin, IntrinsicInfo info)
-        {
-            _intrinTable[(int)intrin] = info;
-        }
-
-        public static IntrinsicInfo GetInfo(Intrinsic intrin)
-        {
-            return _intrinTable[(int)intrin];
-        }
-    }
-}

ARMeilleure/CodeGen/X86/X86Instruction.cs

@@ -1,228 +0,0 @@
-namespace ARMeilleure.CodeGen.X86
-{
-    enum X86Instruction
-    {
-        None,
-        Add,
-        Addpd,
-        Addps,
-        Addsd,
-        Addss,
-        Aesdec,
-        Aesdeclast,
-        Aesenc,
-        Aesenclast,
-        Aesimc,
-        And,
-        Andnpd,
-        Andnps,
-        Andpd,
-        Andps,
-        Blendvpd,
-        Blendvps,
-        Bsr,
-        Bswap,
-        Call,
-        Cmovcc,
-        Cmp,
-        Cmppd,
-        Cmpps,
-        Cmpsd,
-        Cmpss,
-        Cmpxchg,
-        Cmpxchg16b,
-        Cmpxchg8,
-        Comisd,
-        Comiss,
-        Crc32,
-        Crc32_16,
-        Crc32_8,
-        Cvtdq2pd,
-        Cvtdq2ps,
-        Cvtpd2dq,
-        Cvtpd2ps,
-        Cvtps2dq,
-        Cvtps2pd,
-        Cvtsd2si,
-        Cvtsd2ss,
-        Cvtsi2sd,
-        Cvtsi2ss,
-        Cvtss2sd,
-        Cvtss2si,
-        Div,
-        Divpd,
-        Divps,
-        Divsd,
-        Divss,
-        Gf2p8affineqb,
-        Haddpd,
-        Haddps,
-        Idiv,
-        Imul,
-        Imul128,
-        Insertps,
-        Jmp,
-        Ldmxcsr,
-        Lea,
-        Maxpd,
-        Maxps,
-        Maxsd,
-        Maxss,
-        Minpd,
-        Minps,
-        Minsd,
-        Minss,
-        Mov,
-        Mov16,
-        Mov8,
-        Movd,
-        Movdqu,
-        Movhlps,
-        Movlhps,
-        Movq,
-        Movsd,
-        Movss,
-        Movsx16,
-        Movsx32,
-        Movsx8,
-        Movzx16,
-        Movzx8,
-        Mul128,
-        Mulpd,
-        Mulps,
-        Mulsd,
-        Mulss,
-        Neg,
-        Not,
-        Or,
-        Paddb,
-        Paddd,
-        Paddq,
-        Paddw,
-        Palignr,
-        Pand,
-        Pandn,
-        Pavgb,
-        Pavgw,
-        Pblendvb,
-        Pclmulqdq,
-        Pcmpeqb,
-        Pcmpeqd,
-        Pcmpeqq,
-        Pcmpeqw,
-        Pcmpgtb,
-        Pcmpgtd,
-        Pcmpgtq,
-        Pcmpgtw,
-        Pextrb,
-        Pextrd,
-        Pextrq,
-        Pextrw,
-        Pinsrb,
-        Pinsrd,
-        Pinsrq,
-        Pinsrw,
-        Pmaxsb,
-        Pmaxsd,
-        Pmaxsw,
-        Pmaxub,
-        Pmaxud,
-        Pmaxuw,
-        Pminsb,
-        Pminsd,
-        Pminsw,
-        Pminub,
-        Pminud,
-        Pminuw,
-        Pmovsxbw,
-        Pmovsxdq,
-        Pmovsxwd,
-        Pmovzxbw,
-        Pmovzxdq,
-        Pmovzxwd,
-        Pmulld,
-        Pmullw,
-        Pop,
-        Popcnt,
-        Por,
-        Pshufb,
-        Pshufd,
-        Pslld,
-        Pslldq,
-        Psllq,
-        Psllw,
-        Psrad,
-        Psraw,
-        Psrld,
-        Psrlq,
-        Psrldq,
-        Psrlw,
-        Psubb,
-        Psubd,
-        Psubq,
-        Psubw,
-        Punpckhbw,
-        Punpckhdq,
-        Punpckhqdq,
-        Punpckhwd,
-        Punpcklbw,
-        Punpckldq,
-        Punpcklqdq,
-        Punpcklwd,
-        Push,
-        Pxor,
-        Rcpps,
-        Rcpss,
-        Ror,
-        Roundpd,
-        Roundps,
-        Roundsd,
-        Roundss,
-        Rsqrtps,
-        Rsqrtss,
-        Sar,
-        Setcc,
-        Sha256Msg1,
-        Sha256Msg2,
-        Sha256Rnds2,
-        Shl,
-        Shr,
-        Shufpd,
-        Shufps,
-        Sqrtpd,
-        Sqrtps,
-        Sqrtsd,
-        Sqrtss,
-        Stmxcsr,
-        Sub,
-        Subpd,
-        Subps,
-        Subsd,
-        Subss,
-        Test,
-        Unpckhpd,
-        Unpckhps,
-        Unpcklpd,
-        Unpcklps,
-        Vblendvpd,
-        Vblendvps,
-        Vcvtph2ps,
-        Vcvtps2ph,
-        Vfmadd231ps,
-        Vfmadd231sd,
-        Vfmadd231ss,
-        Vfmsub231sd,
-        Vfmsub231ss,
-        Vfnmadd231ps,
-        Vfnmadd231sd,
-        Vfnmadd231ss,
-        Vfnmsub231sd,
-        Vfnmsub231ss,
-        Vpblendvb,
-        Xor,
-        Xorpd,
-        Xorps,
-
-        Count
-    }
-}

ARMeilleure/Decoders/DecoderHelper.cs

@@ -1,167 +0,0 @@
-using ARMeilleure.Common;
-
-namespace ARMeilleure.Decoders
-{
-    static class DecoderHelper
-    {
-        static DecoderHelper()
-        {
-            Imm8ToFP32Table = BuildImm8ToFP32Table();
-            Imm8ToFP64Table = BuildImm8ToFP64Table();
-        }
-
-        public static readonly uint[]  Imm8ToFP32Table;
-        public static readonly ulong[] Imm8ToFP64Table;
-
-        private static uint[] BuildImm8ToFP32Table()
-        {
-            uint[] tbl = new uint[256];
-
-            for (int idx = 0; idx < 256; idx++)
-            {
-                tbl[idx] = ExpandImm8ToFP32((uint)idx);
-            }
-
-            return tbl;
-        }
-
-        private static ulong[] BuildImm8ToFP64Table()
-        {
-            ulong[] tbl = new ulong[256];
-
-            for (int idx = 0; idx < 256; idx++)
-            {
-                tbl[idx] = ExpandImm8ToFP64((ulong)idx);
-            }
-
-            return tbl;
-        }
-
-        // abcdefgh -> aBbbbbbc defgh000 00000000 00000000 (B = ~b)
-        private static uint ExpandImm8ToFP32(uint imm)
-        {
-            uint MoveBit(uint bits, int from, int to)
-            {
-                return ((bits >> from) & 1U) << to;
-            }
-
-            return MoveBit(imm, 7, 31) | MoveBit(~imm, 6, 30) |
-                   MoveBit(imm, 6, 29) | MoveBit( imm, 6, 28) |
-                   MoveBit(imm, 6, 27) | MoveBit( imm, 6, 26) |
-                   MoveBit(imm, 6, 25) | MoveBit( imm, 5, 24) |
-                   MoveBit(imm, 4, 23) | MoveBit( imm, 3, 22) |
-                   MoveBit(imm, 2, 21) | MoveBit( imm, 1, 20) |
-                   MoveBit(imm, 0, 19);
-        }
-
-        // abcdefgh -> aBbbbbbb bbcdefgh 00000000 00000000 00000000 00000000 00000000 00000000 (B = ~b)
-        private static ulong ExpandImm8ToFP64(ulong imm)
-        {
-            ulong MoveBit(ulong bits, int from, int to)
-            {
-                return ((bits >> from) & 1UL) << to;
-            }
-
-            return MoveBit(imm, 7, 63) | MoveBit(~imm, 6, 62) |
-                   MoveBit(imm, 6, 61) | MoveBit( imm, 6, 60) |
-                   MoveBit(imm, 6, 59) | MoveBit( imm, 6, 58) |
-                   MoveBit(imm, 6, 57) | MoveBit( imm, 6, 56) |
-                   MoveBit(imm, 6, 55) | MoveBit( imm, 6, 54) |
-                   MoveBit(imm, 5, 53) | MoveBit( imm, 4, 52) |
-                   MoveBit(imm, 3, 51) | MoveBit( imm, 2, 50) |
-                   MoveBit(imm, 1, 49) | MoveBit( imm, 0, 48);
-        }
-
-        public struct BitMask
-        {
-            public long WMask;
-            public long TMask;
-            public int  Pos;
-            public int  Shift;
-            public bool IsUndefined;
-
-            public static BitMask Invalid => new BitMask { IsUndefined = true };
-        }
-
-        public static BitMask DecodeBitMask(int opCode, bool immediate)
-        {
-            int immS = (opCode >> 10) & 0x3f;
-            int immR = (opCode >> 16) & 0x3f;
-
-            int n  = (opCode >> 22) & 1;
-            int sf = (opCode >> 31) & 1;
-
-            int length = BitUtils.HighestBitSet((~immS & 0x3f) | (n << 6));
-
-            if (length < 1 || (sf == 0 && n != 0))
-            {
-                return BitMask.Invalid;
-            }
-
-            int size = 1 << length;
-
-            int levels = size - 1;
-
-            int s = immS & levels;
-            int r = immR & levels;
-
-            if (immediate && s == levels)
-            {
-                return BitMask.Invalid;
-            }
-
-            long wMask = BitUtils.FillWithOnes(s + 1);
-            long tMask = BitUtils.FillWithOnes(((s - r) & levels) + 1);
-
-            if (r > 0)
-            {
-                wMask  = BitUtils.RotateRight(wMask, r, size);
-                wMask &= BitUtils.FillWithOnes(size);
-            }
-
-            return new BitMask()
-            {
-                WMask = BitUtils.Replicate(wMask, size),
-                TMask = BitUtils.Replicate(tMask, size),
-
-                Pos   = immS,
-                Shift = immR
-            };
-        }
-
-        public static long DecodeImm24_2(int opCode)
-        {
-            return ((long)opCode << 40) >> 38;
-        }
-
-        public static long DecodeImm26_2(int opCode)
-        {
-            return ((long)opCode << 38) >> 36;
-        }
-
-        public static long DecodeImmS19_2(int opCode)
-        {
-            return (((long)opCode << 40) >> 43) & ~3;
-        }
-
-        public static long DecodeImmS14_2(int opCode)
-        {
-            return (((long)opCode << 45) >> 48) & ~3;
-        }
-
-        public static bool VectorArgumentsInvalid(bool q, params int[] args)
-        {
-            if (q)
-            {
-                for (int i = 0; i < args.Length; i++)
-                {
-                    if ((args[i] & 1) == 1)
-                    {
-                        return true;
-                    }
-                }
-            }
-            return false;
-        }
-    }
-}

ARMeilleure/Decoders/IOpCode32Exception.cs

@@ -1,6 +0,0 @@
-namespace ARMeilleure.Decoders;
-
-interface IOpCode32Exception
-{
-    int Id { get; }
-}

ARMeilleure/Decoders/OpCode32SimdSel.cs

@@ -1,23 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    class OpCode32SimdSel : OpCode32SimdRegS
-    {
-        public OpCode32SimdSelMode Cc { get; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCode32SimdSel(inst, address, opCode, false);
-        public new static OpCode CreateT32(InstDescriptor inst, ulong address, int opCode) => new OpCode32SimdSel(inst, address, opCode, true);
-
-        public OpCode32SimdSel(InstDescriptor inst, ulong address, int opCode, bool isThumb) : base(inst, address, opCode, isThumb)
-        {
-            Cc = (OpCode32SimdSelMode)((opCode >> 20) & 3);
-        }
-    }
-
-    enum OpCode32SimdSelMode : int
-    {
-        Eq = 0,
-        Vs,
-        Ge,
-        Gt
-    }
-}

ARMeilleure/Instructions/InstEmitHash32.cs

@@ -1,54 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Translation;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.Instructions.InstEmitHashHelper;
-
-namespace ARMeilleure.Instructions
-{
-    static partial class InstEmit32
-    {
-        public static void Crc32b(ArmEmitterContext context)
-        {
-            EmitCrc32Call(context, ByteSizeLog2, false);
-        }
-
-        public static void Crc32h(ArmEmitterContext context)
-        {
-            EmitCrc32Call(context, HWordSizeLog2, false);
-        }
-
-        public static void Crc32w(ArmEmitterContext context)
-        {
-            EmitCrc32Call(context, WordSizeLog2, false);
-        }
-
-        public static void Crc32cb(ArmEmitterContext context)
-        {
-            EmitCrc32Call(context, ByteSizeLog2, true);
-        }
-
-        public static void Crc32ch(ArmEmitterContext context)
-        {
-            EmitCrc32Call(context, HWordSizeLog2, true);
-        }
-
-        public static void Crc32cw(ArmEmitterContext context)
-        {
-            EmitCrc32Call(context, WordSizeLog2, true);
-        }
-
-        private static void EmitCrc32Call(ArmEmitterContext context, int size, bool c)
-        {
-            IOpCode32AluReg op = (IOpCode32AluReg)context.CurrOp;
-
-            Operand n = GetIntA32(context, op.Rn);
-            Operand m = GetIntA32(context, op.Rm);
-
-            Operand d = EmitCrc32(context, n, m, size, c);
-
-            EmitAluStore(context, d);
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitHashHelper.cs

@@ -1,119 +0,0 @@
-// https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf
-
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Translation;
-using System;
-using System.Diagnostics;
-
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-using static ARMeilleure.Instructions.InstEmitSimdHelper;
-
-namespace ARMeilleure.Instructions
-{
-    static class InstEmitHashHelper
-    {
-        public const uint Crc32RevPoly = 0xedb88320;
-        public const uint Crc32cRevPoly = 0x82f63b78;
-
-        public static Operand EmitCrc32(ArmEmitterContext context, Operand crc, Operand value, int size, bool castagnoli)
-        {
-            Debug.Assert(crc.Type.IsInteger() && value.Type.IsInteger());
-            Debug.Assert(size >= 0 && size < 4);
-            Debug.Assert((size < 3) || (value.Type == OperandType.I64));
-
-            if (castagnoli && Optimizations.UseSse42)
-            {
-                // The CRC32 instruction does not have an immediate variant, so ensure both inputs are in registers.
-                value = (value.Kind == OperandKind.Constant) ? context.Copy(value) : value;
-                crc = (crc.Kind == OperandKind.Constant) ? context.Copy(crc) : crc;
-
-                Intrinsic op = size switch
-                {
-                    0 => Intrinsic.X86Crc32_8,
-                    1 => Intrinsic.X86Crc32_16,
-                    _ => Intrinsic.X86Crc32,
-                };
-
-                return (size == 3) ? context.ConvertI64ToI32(context.AddIntrinsicLong(op, crc, value)) : context.AddIntrinsicInt(op, crc, value);
-            }
-            else if (Optimizations.UsePclmulqdq)
-            {
-                return size switch
-                {
-                    3 => EmitCrc32Optimized64(context, crc, value, castagnoli),
-                    _ => EmitCrc32Optimized(context, crc, value, castagnoli, size),
-                };
-            }
-            else
-            {
-                string name = (size, castagnoli) switch 
-                {
-                    (0, false) => nameof(SoftFallback.Crc32b),
-                    (1, false) => nameof(SoftFallback.Crc32h),
-                    (2, false) => nameof(SoftFallback.Crc32w),
-                    (3, false) => nameof(SoftFallback.Crc32x),
-                    (0, true) => nameof(SoftFallback.Crc32cb),
-                    (1, true) => nameof(SoftFallback.Crc32ch),
-                    (2, true) => nameof(SoftFallback.Crc32cw),
-                    (3, true) => nameof(SoftFallback.Crc32cx),
-                    _ => throw new ArgumentOutOfRangeException(nameof(size))
-                };
-
-                return context.Call(typeof(SoftFallback).GetMethod(name), crc, value);
-            }
-        }
-
-        private static Operand EmitCrc32Optimized(ArmEmitterContext context, Operand crc, Operand data, bool castagnoli, int size)
-        {
-            long mu = castagnoli ? 0x0DEA713F1 : 0x1F7011641; // mu' = floor(x^64/P(x))'
-            long polynomial = castagnoli ? 0x105EC76F0 : 0x1DB710641; // P'(x) << 1
-
-            crc = context.VectorInsert(context.VectorZero(), crc, 0);
-
-            switch (size)
-            {
-                case 0: data = context.VectorInsert8(context.VectorZero(), data, 0); break;
-                case 1: data = context.VectorInsert16(context.VectorZero(), data, 0); break;
-                case 2: data = context.VectorInsert(context.VectorZero(), data, 0); break;
-            }
-
-            int bitsize = 8 << size;
-
-            Operand tmp = context.AddIntrinsic(Intrinsic.X86Pxor, crc, data);
-            tmp = context.AddIntrinsic(Intrinsic.X86Psllq, tmp, Const(64 - bitsize));
-            tmp = context.AddIntrinsic(Intrinsic.X86Pclmulqdq, tmp, X86GetScalar(context, mu), Const(0));
-            tmp = context.AddIntrinsic(Intrinsic.X86Pclmulqdq, tmp, X86GetScalar(context, polynomial), Const(0));
-
-            if (bitsize < 32)
-            {
-                crc = context.AddIntrinsic(Intrinsic.X86Pslldq, crc, Const((64 - bitsize) / 8));
-                tmp = context.AddIntrinsic(Intrinsic.X86Pxor, tmp, crc);
-            }
-
-            return context.VectorExtract(OperandType.I32, tmp, 2);
-        }
-
-        private static Operand EmitCrc32Optimized64(ArmEmitterContext context, Operand crc, Operand data, bool castagnoli)
-        {
-            long mu = castagnoli ? 0x0DEA713F1 : 0x1F7011641; // mu' = floor(x^64/P(x))'
-            long polynomial = castagnoli ? 0x105EC76F0 : 0x1DB710641; // P'(x) << 1
-
-            crc = context.VectorInsert(context.VectorZero(), crc, 0);
-            data = context.VectorInsert(context.VectorZero(), data, 0);
-
-            Operand tmp = context.AddIntrinsic(Intrinsic.X86Pxor, crc, data);
-            Operand res = context.AddIntrinsic(Intrinsic.X86Pslldq, tmp, Const(4));
-
-            tmp = context.AddIntrinsic(Intrinsic.X86Pclmulqdq, res, X86GetScalar(context, mu), Const(0));
-            tmp = context.AddIntrinsic(Intrinsic.X86Pclmulqdq, tmp, X86GetScalar(context, polynomial), Const(0));
-
-            tmp = context.AddIntrinsic(Intrinsic.X86Pxor, tmp, res);
-            tmp = context.AddIntrinsic(Intrinsic.X86Psllq, tmp, Const(32));
-
-            tmp = context.AddIntrinsic(Intrinsic.X86Pclmulqdq, tmp, X86GetScalar(context, mu), Const(1));
-            tmp = context.AddIntrinsic(Intrinsic.X86Pclmulqdq, tmp, X86GetScalar(context, polynomial), Const(0));
-
-            return context.VectorExtract(OperandType.I32, tmp, 2);
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitSimdCrypto.cs

@@ -1,99 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Translation;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-
-namespace ARMeilleure.Instructions
-{
-    static partial class InstEmit
-    {
-        public static void Aesd_V(ArmEmitterContext context)
-        {
-            OpCodeSimd op = (OpCodeSimd)context.CurrOp;
-
-            Operand d = GetVec(op.Rd);
-            Operand n = GetVec(op.Rn);
-
-            Operand res;
-
-            if (Optimizations.UseAesni)
-            {
-                res = context.AddIntrinsic(Intrinsic.X86Aesdeclast, context.AddIntrinsic(Intrinsic.X86Xorpd, d, n), context.VectorZero());
-            }
-            else
-            {
-                res = context.Call(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Decrypt)), d, n);
-            }
-
-            context.Copy(d, res);
-        }
-
-        public static void Aese_V(ArmEmitterContext context)
-        {
-            OpCodeSimd op = (OpCodeSimd)context.CurrOp;
-
-            Operand d = GetVec(op.Rd);
-            Operand n = GetVec(op.Rn);
-
-            Operand res;
-
-            if (Optimizations.UseAesni)
-            {
-                res = context.AddIntrinsic(Intrinsic.X86Aesenclast, context.AddIntrinsic(Intrinsic.X86Xorpd, d, n), context.VectorZero());
-            }
-            else
-            {
-                res = context.Call(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Encrypt)), d, n);
-            }
-
-            context.Copy(d, res);
-        }
-
-        public static void Aesimc_V(ArmEmitterContext context)
-        {
-            OpCodeSimd op = (OpCodeSimd)context.CurrOp;
-
-            Operand n = GetVec(op.Rn);
-
-            Operand res;
-
-            if (Optimizations.UseAesni)
-            {
-                res = context.AddIntrinsic(Intrinsic.X86Aesimc, n);
-            }
-            else
-            {
-                res = context.Call(typeof(SoftFallback).GetMethod(nameof(SoftFallback.InverseMixColumns)), n);
-            }
-
-            context.Copy(GetVec(op.Rd), res);
-        }
-
-        public static void Aesmc_V(ArmEmitterContext context)
-        {
-            OpCodeSimd op = (OpCodeSimd)context.CurrOp;
-
-            Operand n = GetVec(op.Rn);
-
-            Operand res;
-
-            if (Optimizations.UseAesni)
-            {
-                Operand roundKey = context.VectorZero();
-
-                // Inverse Shift Rows, Inverse Sub Bytes, xor 0 so nothing happens
-                res = context.AddIntrinsic(Intrinsic.X86Aesdeclast, n, roundKey);
-
-                // Shift Rows, Sub Bytes, Mix Columns (!), xor 0 so nothing happens
-                res = context.AddIntrinsic(Intrinsic.X86Aesenc, res, roundKey);
-            }
-            else
-            {
-                res = context.Call(typeof(SoftFallback).GetMethod(nameof(SoftFallback.MixColumns)), n);
-            }
-
-            context.Copy(GetVec(op.Rd), res);
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitSimdCrypto32.cs

@@ -1,99 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Translation;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-
-namespace ARMeilleure.Instructions
-{
-    partial class InstEmit32
-    {
-        public static void Aesd_V(ArmEmitterContext context)
-        {
-            OpCode32Simd op = (OpCode32Simd)context.CurrOp;
-
-            Operand d = GetVecA32(op.Qd);
-            Operand n = GetVecA32(op.Qm);
-
-            Operand res;
-
-            if (Optimizations.UseAesni)
-            {
-                res = context.AddIntrinsic(Intrinsic.X86Aesdeclast, context.AddIntrinsic(Intrinsic.X86Xorpd, d, n), context.VectorZero());
-            }
-            else
-            {
-                res = context.Call(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Decrypt)), d, n);
-            }
-
-            context.Copy(d, res);
-        }
-
-        public static void Aese_V(ArmEmitterContext context)
-        {
-            OpCode32Simd op = (OpCode32Simd)context.CurrOp;
-
-            Operand d = GetVecA32(op.Qd);
-            Operand n = GetVecA32(op.Qm);
-
-            Operand res;
-
-            if (Optimizations.UseAesni)
-            {
-                res = context.AddIntrinsic(Intrinsic.X86Aesenclast, context.AddIntrinsic(Intrinsic.X86Xorpd, d, n), context.VectorZero());
-            }
-            else
-            {
-                res = context.Call(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Encrypt)), d, n);
-            }
-
-            context.Copy(d, res);
-        }
-
-        public static void Aesimc_V(ArmEmitterContext context)
-        {
-            OpCode32Simd op = (OpCode32Simd)context.CurrOp;
-
-            Operand n = GetVecA32(op.Qm);
-
-            Operand res;
-
-            if (Optimizations.UseAesni)
-            {
-                res = context.AddIntrinsic(Intrinsic.X86Aesimc, n);
-            }
-            else
-            {
-                res = context.Call(typeof(SoftFallback).GetMethod(nameof(SoftFallback.InverseMixColumns)), n);
-            }
-
-            context.Copy(GetVecA32(op.Qd), res);
-        }
-
-        public static void Aesmc_V(ArmEmitterContext context)
-        {
-            OpCode32Simd op = (OpCode32Simd)context.CurrOp;
-
-            Operand n = GetVecA32(op.Qm);
-
-            Operand res;
-
-            if (Optimizations.UseAesni)
-            {
-                Operand roundKey = context.VectorZero();
-
-                // Inverse Shift Rows, Inverse Sub Bytes, xor 0 so nothing happens.
-                res = context.AddIntrinsic(Intrinsic.X86Aesdeclast, n, roundKey);
-
-                // Shift Rows, Sub Bytes, Mix Columns (!), xor 0 so nothing happens.
-                res = context.AddIntrinsic(Intrinsic.X86Aesenc, res, roundKey);
-            }
-            else
-            {
-                res = context.Call(typeof(SoftFallback).GetMethod(nameof(SoftFallback.MixColumns)), n);
-            }
-
-            context.Copy(GetVecA32(op.Qd), res);
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitSimdCvt32.cs

@@ -1,789 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.State;
-using ARMeilleure.Translation;
-using System;
-using System.Diagnostics;
-using System.Reflection;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.Instructions.InstEmitSimdHelper;
-using static ARMeilleure.Instructions.InstEmitSimdHelper32;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static partial class InstEmit32
-    {
-        private static int FlipVdBits(int vd, bool lowBit)
-        {
-            if (lowBit)
-            {
-                // Move the low bit to the top.
-                return ((vd & 0x1) << 4) | (vd >> 1);
-            }
-            else
-            {
-                // Move the high bit to the bottom.
-                return ((vd & 0xf) << 1) | (vd >> 4);
-            }
-        }
-
-        private static Operand EmitSaturateFloatToInt(ArmEmitterContext context, Operand op1, bool unsigned)
-        {
-            MethodInfo info;
-
-            if (op1.Type == OperandType.FP64)
-            {
-                info = unsigned
-                    ? typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToU32))
-                    : typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToS32));
-            }
-            else
-            {
-                info = unsigned
-                    ? typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToU32))
-                    : typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToS32));
-            }
-
-            return context.Call(info, op1);
-        }
-
-        public static void Vcvt_V(ArmEmitterContext context)
-        {
-            OpCode32Simd op = (OpCode32Simd)context.CurrOp;
-
-            bool unsigned = (op.Opc & 1) != 0;
-            bool toInteger = (op.Opc & 2) != 0;
-            OperandType floatSize = (op.Size == 2) ? OperandType.FP32 : OperandType.FP64;
-
-            if (toInteger)
-            {
-                if (Optimizations.UseAdvSimd)
-                {
-                    InstEmitSimdHelper32Arm64.EmitVectorUnaryOpF32(context, unsigned ? Intrinsic.Arm64FcvtzuV : Intrinsic.Arm64FcvtzsV);
-                }
-                else if (Optimizations.UseSse41)
-                {
-                    EmitSse41ConvertVector32(context, FPRoundingMode.TowardsZero, !unsigned);
-                }
-                else
-                {
-                    EmitVectorUnaryOpF32(context, (op1) =>
-                    {
-                        return EmitSaturateFloatToInt(context, op1, unsigned);
-                    });
-                }
-            }
-            else
-            {
-                if (Optimizations.UseSse2)
-                {
-                    EmitVectorUnaryOpSimd32(context, (n) =>
-                    {
-                        if (unsigned)
-                        {
-                            Operand mask = X86GetAllElements(context, 0x47800000);
-
-                            Operand res = context.AddIntrinsic(Intrinsic.X86Psrld, n, Const(16));
-                            res = context.AddIntrinsic(Intrinsic.X86Cvtdq2ps, res);
-                            res = context.AddIntrinsic(Intrinsic.X86Mulps, res, mask);
-
-                            Operand res2 = context.AddIntrinsic(Intrinsic.X86Pslld, n, Const(16));
-                            res2 = context.AddIntrinsic(Intrinsic.X86Psrld, res2, Const(16));
-                            res2 = context.AddIntrinsic(Intrinsic.X86Cvtdq2ps, res2);
-
-                            return context.AddIntrinsic(Intrinsic.X86Addps, res, res2);
-                        }
-                        else
-                        {
-                            return context.AddIntrinsic(Intrinsic.X86Cvtdq2ps, n);
-                        }
-                    });
-                }
-                else
-                {
-                    if (unsigned)
-                    {
-                        EmitVectorUnaryOpZx32(context, (op1) => EmitFPConvert(context, op1, floatSize, false));
-                    }
-                    else
-                    {
-                        EmitVectorUnaryOpSx32(context, (op1) => EmitFPConvert(context, op1, floatSize, true));
-                    }
-                }
-            }
-        }
-
-        public static void Vcvt_FD(ArmEmitterContext context)
-        {
-            OpCode32SimdS op = (OpCode32SimdS)context.CurrOp;
-
-            int vm = op.Vm;
-            int vd;
-            if (op.Size == 3)
-            {
-                vd = FlipVdBits(op.Vd, false);
-                // Double to single.
-                Operand fp = ExtractScalar(context, OperandType.FP64, vm);
-
-                Operand res = context.ConvertToFP(OperandType.FP32, fp);
-
-                InsertScalar(context, vd, res);
-            }
-            else
-            {
-                vd = FlipVdBits(op.Vd, true);
-                // Single to double.
-                Operand fp = ExtractScalar(context, OperandType.FP32, vm);
-
-                Operand res = context.ConvertToFP(OperandType.FP64, fp);
-
-                InsertScalar(context, vd, res);
-            }
-        }
-
-        // VCVT (floating-point to integer, floating-point) | VCVT (integer to floating-point, floating-point).
-        public static void Vcvt_FI(ArmEmitterContext context)
-        {
-            OpCode32SimdCvtFI op = (OpCode32SimdCvtFI)context.CurrOp;
-
-            bool toInteger = (op.Opc2 & 0b100) != 0;
-
-            OperandType floatSize = op.RegisterSize == RegisterSize.Int64 ? OperandType.FP64 : OperandType.FP32;
-
-            if (toInteger)
-            {
-                bool unsigned = (op.Opc2 & 1) == 0;
-                bool roundWithFpscr = op.Opc != 1;
-
-                if (!roundWithFpscr && Optimizations.UseAdvSimd)
-                {
-                    bool doubleSize = floatSize == OperandType.FP64;
-
-                    if (doubleSize)
-                    {
-                        Operand m = GetVecA32(op.Vm >> 1);
-
-                        Operand toConvert = InstEmitSimdHelper32Arm64.EmitExtractScalar(context, m, op.Vm, doubleSize);
-
-                        Intrinsic inst = (unsigned ? Intrinsic.Arm64FcvtzuGp : Intrinsic.Arm64FcvtzsGp) | Intrinsic.Arm64VDouble;
-
-                        Operand asInteger = context.AddIntrinsicInt(inst, toConvert);
-
-                        InsertScalar(context, op.Vd, asInteger);
-                    }
-                    else
-                    {
-                        InstEmitSimdHelper32Arm64.EmitScalarUnaryOpF32(context, unsigned ? Intrinsic.Arm64FcvtzuS : Intrinsic.Arm64FcvtzsS);
-                    }
-                }
-                else if (!roundWithFpscr && Optimizations.UseSse41)
-                {
-                    EmitSse41ConvertInt32(context, FPRoundingMode.TowardsZero, !unsigned);
-                }
-                else
-                {
-                    Operand toConvert = ExtractScalar(context, floatSize, op.Vm);
-
-                    // TODO: Fast Path.
-                    if (roundWithFpscr)
-                    {
-                        toConvert = EmitRoundByRMode(context, toConvert);
-                    }
-
-                    // Round towards zero.
-                    Operand asInteger = EmitSaturateFloatToInt(context, toConvert, unsigned);
-
-                    InsertScalar(context, op.Vd, asInteger);
-                }
-            }
-            else
-            {
-                bool unsigned = op.Opc == 0;
-
-                Operand toConvert = ExtractScalar(context, OperandType.I32, op.Vm);
-
-                Operand asFloat = EmitFPConvert(context, toConvert, floatSize, !unsigned);
-
-                InsertScalar(context, op.Vd, asFloat);
-            }
-        }
-
-        private static Operand EmitRoundMathCall(ArmEmitterContext context, MidpointRounding roundMode, Operand n)
-        {
-            IOpCode32Simd op = (IOpCode32Simd)context.CurrOp;
-
-            string name = nameof(Math.Round);
-
-            MethodInfo info = (op.Size & 1) == 0
-                ? typeof(MathF).GetMethod(name, new Type[] { typeof(float),  typeof(MidpointRounding) })
-                : typeof(Math). GetMethod(name, new Type[] { typeof(double), typeof(MidpointRounding) });
-
-            return context.Call(info, n, Const((int)roundMode));
-        }
-
-        private static FPRoundingMode RMToRoundMode(int rm)
-        {
-            FPRoundingMode roundMode;
-            switch (rm)
-            {
-                case 0b00:
-                    roundMode = FPRoundingMode.ToNearestAway;
-                    break;
-                case 0b01:
-                    roundMode = FPRoundingMode.ToNearest;
-                    break;
-                case 0b10:
-                    roundMode = FPRoundingMode.TowardsPlusInfinity;
-                    break;
-                case 0b11:
-                    roundMode = FPRoundingMode.TowardsMinusInfinity;
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(rm));
-            }
-            return roundMode;
-        }
-
-        // VCVTA/M/N/P (floating-point).
-        public static void Vcvt_RM(ArmEmitterContext context)
-        {
-            OpCode32SimdCvtFI op = (OpCode32SimdCvtFI)context.CurrOp; // toInteger == true (opCode<18> == 1 => Opc2<2> == 1).
-
-            OperandType floatSize = op.RegisterSize == RegisterSize.Int64 ? OperandType.FP64 : OperandType.FP32;
-
-            bool unsigned = op.Opc == 0;
-            int rm = op.Opc2 & 3;
-
-            Intrinsic inst;
-
-            if (Optimizations.UseAdvSimd)
-            {
-                if (unsigned)
-                {
-                    inst = rm switch {
-                        0b00 => Intrinsic.Arm64FcvtauS,
-                        0b01 => Intrinsic.Arm64FcvtnuS,
-                        0b10 => Intrinsic.Arm64FcvtpuS,
-                        0b11 => Intrinsic.Arm64FcvtmuS,
-                        _ => throw new ArgumentOutOfRangeException(nameof(rm))
-                    };
-                }
-                else
-                {
-                    inst = rm switch {
-                        0b00 => Intrinsic.Arm64FcvtasS,
-                        0b01 => Intrinsic.Arm64FcvtnsS,
-                        0b10 => Intrinsic.Arm64FcvtpsS,
-                        0b11 => Intrinsic.Arm64FcvtmsS,
-                        _ => throw new ArgumentOutOfRangeException(nameof(rm))
-                    };
-                }
-
-                InstEmitSimdHelper32Arm64.EmitScalarUnaryOpF32(context, inst);
-            }
-            else if (Optimizations.UseSse41)
-            {
-                EmitSse41ConvertInt32(context, RMToRoundMode(rm), !unsigned);
-            }
-            else
-            {
-                Operand toConvert = ExtractScalar(context, floatSize, op.Vm);
-
-                switch (rm)
-                {
-                    case 0b00: // Away
-                        toConvert = EmitRoundMathCall(context, MidpointRounding.AwayFromZero, toConvert);
-                        break;
-                    case 0b01: // Nearest
-                        toConvert = EmitRoundMathCall(context, MidpointRounding.ToEven, toConvert);
-                        break;
-                    case 0b10: // Towards positive infinity
-                        toConvert = EmitUnaryMathCall(context, nameof(Math.Ceiling), toConvert);
-                        break;
-                    case 0b11: // Towards negative infinity
-                        toConvert = EmitUnaryMathCall(context, nameof(Math.Floor), toConvert);
-                        break;
-                }
-
-                Operand asInteger = EmitSaturateFloatToInt(context, toConvert, unsigned);
-
-                InsertScalar(context, op.Vd, asInteger);
-            }
-        }
-
-        public static void Vcvt_TB(ArmEmitterContext context)
-        {
-            OpCode32SimdCvtTB op = (OpCode32SimdCvtTB)context.CurrOp;
-
-            if (Optimizations.UseF16c)
-            {
-                Debug.Assert(!Optimizations.ForceLegacySse);
-
-                if (op.Op)
-                {
-                    Operand res = ExtractScalar(context, op.Size == 1 ? OperandType.FP64 : OperandType.FP32, op.Vm);
-                    if (op.Size == 1)
-                    {
-                        res = context.AddIntrinsic(Intrinsic.X86Cvtsd2ss, context.VectorZero(), res);
-                    }
-                    res = context.AddIntrinsic(Intrinsic.X86Vcvtps2ph, res, Const(X86GetRoundControl(FPRoundingMode.ToNearest)));
-                    res = context.VectorExtract16(res, 0);
-                    InsertScalar16(context, op.Vd, op.T, res);
-                }
-                else
-                {
-                    Operand res = context.VectorCreateScalar(ExtractScalar16(context, op.Vm, op.T));
-                    res = context.AddIntrinsic(Intrinsic.X86Vcvtph2ps, res);
-                    if (op.Size == 1)
-                    {
-                        res = context.AddIntrinsic(Intrinsic.X86Cvtss2sd, context.VectorZero(), res);
-                    }
-                    res = context.VectorExtract(op.Size == 1 ? OperandType.I64 : OperandType.I32, res, 0);
-                    InsertScalar(context, op.Vd, res);
-                }
-            }
-            else
-            {
-                if (op.Op)
-                {
-                    // Convert to half.
-
-                    Operand src = ExtractScalar(context, op.Size == 1 ? OperandType.FP64 : OperandType.FP32, op.Vm);
-
-                    MethodInfo method = op.Size == 1
-                        ? typeof(SoftFloat64_16).GetMethod(nameof(SoftFloat64_16.FPConvert))
-                        : typeof(SoftFloat32_16).GetMethod(nameof(SoftFloat32_16.FPConvert));
-
-                    context.StoreToContext();
-                    Operand res = context.Call(method, src);
-                    context.LoadFromContext();
-
-                    InsertScalar16(context, op.Vd, op.T, res);
-                }
-                else
-                {
-                    // Convert from half.
-
-                    Operand src = ExtractScalar16(context, op.Vm, op.T);
-
-                    MethodInfo method = op.Size == 1
-                        ? typeof(SoftFloat16_64).GetMethod(nameof(SoftFloat16_64.FPConvert))
-                        : typeof(SoftFloat16_32).GetMethod(nameof(SoftFloat16_32.FPConvert));
-
-                    context.StoreToContext();
-                    Operand res = context.Call(method, src);
-                    context.LoadFromContext();
-
-                    InsertScalar(context, op.Vd, res);
-                }
-            }
-        }
-
-        // VRINTA/M/N/P (floating-point).
-        public static void Vrint_RM(ArmEmitterContext context)
-        {
-            OpCode32SimdS op = (OpCode32SimdS)context.CurrOp;
-
-            OperandType floatSize = op.RegisterSize == RegisterSize.Int64 ? OperandType.FP64 : OperandType.FP32;
-
-            int rm = op.Opc2 & 3;
-
-            if (Optimizations.UseAdvSimd)
-            {
-                Intrinsic inst = rm switch {
-                    0b00 => Intrinsic.Arm64FrintaS,
-                    0b01 => Intrinsic.Arm64FrintnS,
-                    0b10 => Intrinsic.Arm64FrintpS,
-                    0b11 => Intrinsic.Arm64FrintmS,
-                    _ => throw new ArgumentOutOfRangeException(nameof(rm))
-                };
-
-                InstEmitSimdHelper32Arm64.EmitScalarUnaryOpF32(context, inst);
-            }
-            else if (Optimizations.UseSse41)
-            {
-                EmitScalarUnaryOpSimd32(context, (m) =>
-                {
-                    FPRoundingMode roundMode = RMToRoundMode(rm);
-
-                    if (roundMode != FPRoundingMode.ToNearestAway)
-                    {
-                        Intrinsic inst = (op.Size & 1) == 0 ? Intrinsic.X86Roundss : Intrinsic.X86Roundsd;
-                        return context.AddIntrinsic(inst, m, Const(X86GetRoundControl(roundMode)));
-                    }
-                    else
-                    {
-                        return EmitSse41RoundToNearestWithTiesToAwayOpF(context, m, scalar: true);
-                    }
-                });
-            }
-            else
-            {
-                Operand toConvert = ExtractScalar(context, floatSize, op.Vm);
-
-                switch (rm)
-                {
-                    case 0b00: // Away
-                        toConvert = EmitRoundMathCall(context, MidpointRounding.AwayFromZero, toConvert);
-                        break;
-                    case 0b01: // Nearest
-                        toConvert = EmitRoundMathCall(context, MidpointRounding.ToEven, toConvert);
-                        break;
-                    case 0b10: // Towards positive infinity
-                        toConvert = EmitUnaryMathCall(context, nameof(Math.Ceiling), toConvert);
-                        break;
-                    case 0b11: // Towards negative infinity
-                        toConvert = EmitUnaryMathCall(context, nameof(Math.Floor), toConvert);
-                        break;
-                }
-
-                InsertScalar(context, op.Vd, toConvert);
-            }
-        }
-
-        // VRINTA (vector).
-        public static void Vrinta_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitVectorUnaryOpF32(context, Intrinsic.Arm64FrintaS);
-            }
-            else
-            {
-                EmitVectorUnaryOpF32(context, (m) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, m));
-            }
-        }
-
-        // VRINTM (vector).
-        public static void Vrintm_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitVectorUnaryOpF32(context, Intrinsic.Arm64FrintmS);
-            }
-            else if (Optimizations.UseSse2)
-            {
-                EmitVectorUnaryOpSimd32(context, (m) =>
-                {
-                    return context.AddIntrinsic(Intrinsic.X86Roundps, m, Const(X86GetRoundControl(FPRoundingMode.TowardsMinusInfinity)));
-                });
-            }
-            else
-            {
-                EmitVectorUnaryOpF32(context, (m) => EmitUnaryMathCall(context, nameof(Math.Floor), m));
-            }
-        }
-
-        // VRINTN (vector).
-        public static void Vrintn_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitVectorUnaryOpF32(context, Intrinsic.Arm64FrintnS);
-            }
-            else if (Optimizations.UseSse2)
-            {
-                EmitVectorUnaryOpSimd32(context, (m) =>
-                {
-                    return context.AddIntrinsic(Intrinsic.X86Roundps, m, Const(X86GetRoundControl(FPRoundingMode.ToNearest)));
-                });
-            }
-            else
-            {
-                EmitVectorUnaryOpF32(context, (m) => EmitRoundMathCall(context, MidpointRounding.ToEven, m));
-            }
-        }
-
-        // VRINTP (vector).
-        public static void Vrintp_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitVectorUnaryOpF32(context, Intrinsic.Arm64FrintpS);
-            }
-            else if (Optimizations.UseSse2)
-            {
-                EmitVectorUnaryOpSimd32(context, (m) =>
-                {
-                    return context.AddIntrinsic(Intrinsic.X86Roundps, m, Const(X86GetRoundControl(FPRoundingMode.TowardsPlusInfinity)));
-                });
-            }
-            else
-            {
-                EmitVectorUnaryOpF32(context, (m) => EmitUnaryMathCall(context, nameof(Math.Ceiling), m));
-            }
-        }
-
-        // VRINTZ (floating-point).
-        public static void Vrint_Z(ArmEmitterContext context)
-        {
-            OpCode32SimdS op = (OpCode32SimdS)context.CurrOp;
-
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitScalarUnaryOpF32(context, Intrinsic.Arm64FrintzS);
-            }
-            else if (Optimizations.UseSse2)
-            {
-                EmitScalarUnaryOpSimd32(context, (m) =>
-                {
-                    Intrinsic inst = (op.Size & 1) == 0 ? Intrinsic.X86Roundss : Intrinsic.X86Roundsd;
-                    return context.AddIntrinsic(inst, m, Const(X86GetRoundControl(FPRoundingMode.TowardsZero)));
-                });
-            }
-            else
-            {
-                EmitScalarUnaryOpF32(context, (op1) => EmitUnaryMathCall(context, nameof(Math.Truncate), op1));
-            }
-        }
-
-        // VRINTX (floating-point).
-        public static void Vrintx_S(ArmEmitterContext context)
-        {
-            EmitScalarUnaryOpF32(context, (op1) =>
-            {
-                return EmitRoundByRMode(context, op1);
-            });
-        }
-
-        private static Operand EmitFPConvert(ArmEmitterContext context, Operand value, OperandType type, bool signed)
-        {
-            Debug.Assert(value.Type == OperandType.I32 || value.Type == OperandType.I64);
-
-            if (signed)
-            {
-                return context.ConvertToFP(type, value);
-            }
-            else
-            {
-                return context.ConvertToFPUI(type, value);
-            }
-        }
-
-        private static void EmitSse41ConvertInt32(ArmEmitterContext context, FPRoundingMode roundMode, bool signed)
-        {
-            // A port of the similar round function in InstEmitSimdCvt.
-            OpCode32SimdCvtFI op = (OpCode32SimdCvtFI)context.CurrOp;
-
-            bool doubleSize = (op.Size & 1) != 0;
-            int shift = doubleSize ? 1 : 2;
-            Operand n = GetVecA32(op.Vm >> shift);
-            n = EmitSwapScalar(context, n, op.Vm, doubleSize);
-
-            if (!doubleSize)
-            {
-                Operand nRes = context.AddIntrinsic(Intrinsic.X86Cmpss, n, n, Const((int)CmpCondition.OrderedQ));
-                nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, n);
-
-                if (roundMode != FPRoundingMode.ToNearestAway)
-                {
-                    nRes = context.AddIntrinsic(Intrinsic.X86Roundss, nRes, Const(X86GetRoundControl(roundMode)));
-                }
-                else
-                {
-                    nRes = EmitSse41RoundToNearestWithTiesToAwayOpF(context, nRes, scalar: true);
-                }
-
-                Operand zero = context.VectorZero();
-
-                Operand nCmp;
-                Operand nIntOrLong2 = default;
-
-                if (!signed)
-                {
-                    nCmp = context.AddIntrinsic(Intrinsic.X86Cmpss, nRes, zero, Const((int)CmpCondition.NotLessThanOrEqual));
-                    nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, nCmp);
-                }
-
-                int fpMaxVal = 0x4F000000; // 2.14748365E9f (2147483648)
-
-                Operand fpMaxValMask = X86GetScalar(context, fpMaxVal);
-
-                Operand nIntOrLong = context.AddIntrinsicInt(Intrinsic.X86Cvtss2si, nRes);
-
-                if (!signed)
-                {
-                    nRes = context.AddIntrinsic(Intrinsic.X86Subss, nRes, fpMaxValMask);
-
-                    nCmp = context.AddIntrinsic(Intrinsic.X86Cmpss, nRes, zero, Const((int)CmpCondition.NotLessThanOrEqual));
-                    nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, nCmp);
-
-                    nIntOrLong2 = context.AddIntrinsicInt(Intrinsic.X86Cvtss2si, nRes);
-                }
-
-                nRes = context.AddIntrinsic(Intrinsic.X86Cmpss, nRes, fpMaxValMask, Const((int)CmpCondition.NotLessThan));
-
-                Operand nInt = context.AddIntrinsicInt(Intrinsic.X86Cvtsi2si, nRes);
-
-                Operand dRes;
-                if (signed)
-                {
-                    dRes = context.BitwiseExclusiveOr(nIntOrLong, nInt);
-                }
-                else
-                {
-                    dRes = context.BitwiseExclusiveOr(nIntOrLong2, nInt);
-                    dRes = context.Add(dRes, nIntOrLong);
-                }
-
-                InsertScalar(context, op.Vd, dRes);
-            }
-            else
-            {
-                Operand nRes = context.AddIntrinsic(Intrinsic.X86Cmpsd, n, n, Const((int)CmpCondition.OrderedQ));
-                nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, n);
-
-                if (roundMode != FPRoundingMode.ToNearestAway)
-                {
-                    nRes = context.AddIntrinsic(Intrinsic.X86Roundsd, nRes, Const(X86GetRoundControl(roundMode)));
-                }
-                else
-                {
-                    nRes = EmitSse41RoundToNearestWithTiesToAwayOpF(context, nRes, scalar: true);
-                }
-
-                Operand zero = context.VectorZero();
-
-                Operand nCmp;
-                Operand nIntOrLong2 = default;
-
-                if (!signed)
-                {
-                    nCmp = context.AddIntrinsic(Intrinsic.X86Cmpsd, nRes, zero, Const((int)CmpCondition.NotLessThanOrEqual));
-                    nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, nCmp);
-                }
-
-                long fpMaxVal = 0x41E0000000000000L; // 2147483648.0000000d (2147483648)
-
-                Operand fpMaxValMask = X86GetScalar(context, fpMaxVal);
-
-                Operand nIntOrLong = context.AddIntrinsicInt(Intrinsic.X86Cvtsd2si, nRes);
-
-                if (!signed)
-                {
-                    nRes = context.AddIntrinsic(Intrinsic.X86Subsd, nRes, fpMaxValMask);
-
-                    nCmp = context.AddIntrinsic(Intrinsic.X86Cmpsd, nRes, zero, Const((int)CmpCondition.NotLessThanOrEqual));
-                    nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, nCmp);
-
-                    nIntOrLong2 = context.AddIntrinsicInt(Intrinsic.X86Cvtsd2si, nRes);
-                }
-
-                nRes = context.AddIntrinsic(Intrinsic.X86Cmpsd, nRes, fpMaxValMask, Const((int)CmpCondition.NotLessThan));
-
-                Operand nLong = context.AddIntrinsicLong(Intrinsic.X86Cvtsi2si, nRes);
-                nLong = context.ConvertI64ToI32(nLong);
-
-                Operand dRes;
-                if (signed)
-                {
-                    dRes = context.BitwiseExclusiveOr(nIntOrLong, nLong);
-                }
-                else
-                {
-                    dRes = context.BitwiseExclusiveOr(nIntOrLong2, nLong);
-                    dRes = context.Add(dRes, nIntOrLong);
-                }
-
-                InsertScalar(context, op.Vd, dRes);
-            }
-        }
-
-        private static void EmitSse41ConvertVector32(ArmEmitterContext context, FPRoundingMode roundMode, bool signed)
-        {
-            OpCode32Simd op = (OpCode32Simd)context.CurrOp;
-
-            EmitVectorUnaryOpSimd32(context, (n) =>
-            {
-                int sizeF = op.Size & 1;
-
-                if (sizeF == 0)
-                {
-                    Operand nRes = context.AddIntrinsic(Intrinsic.X86Cmpps, n, n, Const((int)CmpCondition.OrderedQ));
-                    nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, n);
-
-                    nRes = context.AddIntrinsic(Intrinsic.X86Roundps, nRes, Const(X86GetRoundControl(roundMode)));
-
-                    Operand zero = context.VectorZero();
-                    Operand nCmp;
-                    if (!signed)
-                    {
-                        nCmp = context.AddIntrinsic(Intrinsic.X86Cmpps, nRes, zero, Const((int)CmpCondition.NotLessThanOrEqual));
-                        nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, nCmp);
-                    }
-
-                    Operand fpMaxValMask = X86GetAllElements(context, 0x4F000000); // 2.14748365E9f (2147483648)
-
-                    Operand nInt = context.AddIntrinsic(Intrinsic.X86Cvtps2dq, nRes);
-                    Operand nInt2 = default;
-
-                    if (!signed)
-                    {
-                        nRes = context.AddIntrinsic(Intrinsic.X86Subps, nRes, fpMaxValMask);
-
-                        nCmp = context.AddIntrinsic(Intrinsic.X86Cmpps, nRes, zero, Const((int)CmpCondition.NotLessThanOrEqual));
-                        nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, nCmp);
-
-                        nInt2 = context.AddIntrinsic(Intrinsic.X86Cvtps2dq, nRes);
-                    }
-
-                    nRes = context.AddIntrinsic(Intrinsic.X86Cmpps, nRes, fpMaxValMask, Const((int)CmpCondition.NotLessThan));
-
-                    if (signed)
-                    {
-                        return context.AddIntrinsic(Intrinsic.X86Pxor, nInt, nRes);
-                    }
-                    else
-                    {
-                        Operand dRes = context.AddIntrinsic(Intrinsic.X86Pxor, nInt2, nRes);
-                        return context.AddIntrinsic(Intrinsic.X86Paddd, dRes, nInt);
-                    }
-                }
-                else /* if (sizeF == 1) */
-                {
-                    Operand nRes = context.AddIntrinsic(Intrinsic.X86Cmppd, n, n, Const((int)CmpCondition.OrderedQ));
-                    nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, n);
-
-                    nRes = context.AddIntrinsic(Intrinsic.X86Roundpd, nRes, Const(X86GetRoundControl(roundMode)));
-
-                    Operand zero = context.VectorZero();
-                    Operand nCmp;
-                    if (!signed)
-                    {
-                        nCmp = context.AddIntrinsic(Intrinsic.X86Cmppd, nRes, zero, Const((int)CmpCondition.NotLessThanOrEqual));
-                        nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, nCmp);
-                    }
-
-                    Operand fpMaxValMask = X86GetAllElements(context, 0x43E0000000000000L); // 9.2233720368547760E18d (9223372036854775808)
-
-                    Operand nLong = InstEmit.EmitSse2CvtDoubleToInt64OpF(context, nRes, false);
-                    Operand nLong2 = default;
-
-                    if (!signed)
-                    {
-                        nRes = context.AddIntrinsic(Intrinsic.X86Subpd, nRes, fpMaxValMask);
-
-                        nCmp = context.AddIntrinsic(Intrinsic.X86Cmppd, nRes, zero, Const((int)CmpCondition.NotLessThanOrEqual));
-                        nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, nCmp);
-
-                        nLong2 = InstEmit.EmitSse2CvtDoubleToInt64OpF(context, nRes, false);
-                    }
-
-                    nRes = context.AddIntrinsic(Intrinsic.X86Cmppd, nRes, fpMaxValMask, Const((int)CmpCondition.NotLessThan));
-
-                    if (signed)
-                    {
-                        return context.AddIntrinsic(Intrinsic.X86Pxor, nLong, nRes);
-                    }
-                    else
-                    {
-                        Operand dRes = context.AddIntrinsic(Intrinsic.X86Pxor, nLong2, nRes);
-                        return context.AddIntrinsic(Intrinsic.X86Paddq, dRes, nLong);
-                    }
-                }
-            });
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitSimdHelper32Arm64.cs

@@ -1,366 +0,0 @@
-
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.State;
-using ARMeilleure.Translation;
-using System;
-using System.Diagnostics;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.Instructions.InstEmitSimdHelper;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    using Func1I = Func<Operand, Operand>;
-    using Func2I = Func<Operand, Operand, Operand>;
-    using Func3I = Func<Operand, Operand, Operand, Operand>;
-
-    static class InstEmitSimdHelper32Arm64
-    {
-        // Intrinsic Helpers
-
-        public static Operand EmitMoveDoubleWordToSide(ArmEmitterContext context, Operand input, int originalV, int targetV)
-        {
-            Debug.Assert(input.Type == OperandType.V128);
-
-            int originalSide = originalV & 1;
-            int targetSide = targetV & 1;
-
-            if (originalSide == targetSide)
-            {
-                return input;
-            }
-
-            Intrinsic vType = Intrinsic.Arm64VDWord | Intrinsic.Arm64V128;
-
-            if (targetSide == 1)
-            {
-                return context.AddIntrinsic(Intrinsic.Arm64DupVe | vType, input, Const(OperandType.I32, 0)); // Low to high.
-            }
-            else
-            {
-                return context.AddIntrinsic(Intrinsic.Arm64DupVe | vType, input, Const(OperandType.I32, 1)); // High to low.
-            }
-        }
-
-        public static Operand EmitDoubleWordInsert(ArmEmitterContext context, Operand target, Operand value, int targetV)
-        {
-            Debug.Assert(target.Type == OperandType.V128 && value.Type == OperandType.V128);
-
-            int targetSide = targetV & 1;
-            Operand idx = Const(targetSide);
-
-            return context.AddIntrinsic(Intrinsic.Arm64InsVe | Intrinsic.Arm64VDWord, target, idx, value, idx);
-        }
-
-        public static Operand EmitScalarInsert(ArmEmitterContext context, Operand target, Operand value, int reg, bool doubleWidth)
-        {
-            Debug.Assert(target.Type == OperandType.V128 && value.Type == OperandType.V128);
-
-            // Insert from index 0 in value to index in target.
-            int index = reg & (doubleWidth ? 1 : 3);
-
-            if (doubleWidth)
-            {
-                return context.AddIntrinsic(Intrinsic.Arm64InsVe | Intrinsic.Arm64VDWord, target, Const(index), value, Const(0));
-            }
-            else
-            {
-                return context.AddIntrinsic(Intrinsic.Arm64InsVe | Intrinsic.Arm64VWord, target, Const(index), value, Const(0));
-            }
-        }
-
-        public static Operand EmitExtractScalar(ArmEmitterContext context, Operand target, int reg, bool doubleWidth)
-        {
-            int index = reg & (doubleWidth ? 1 : 3);
-            if (index == 0) return target; // Element is already at index 0, so just return the vector directly.
-
-            if (doubleWidth)
-            {
-                return context.AddIntrinsic(Intrinsic.Arm64DupSe | Intrinsic.Arm64VDWord, target, Const(1)); // Extract high (index 1).
-            }
-            else
-            {
-                return context.AddIntrinsic(Intrinsic.Arm64DupSe | Intrinsic.Arm64VWord, target, Const(index)); // Extract element at index.
-            }
-        }
-
-        // Vector Operand Templates
-
-        public static void EmitVectorUnaryOpSimd32(ArmEmitterContext context, Func1I vectorFunc)
-        {
-            OpCode32Simd op = (OpCode32Simd)context.CurrOp;
-
-            Operand m = GetVecA32(op.Qm);
-            Operand d = GetVecA32(op.Qd);
-
-            if (!op.Q) // Register swap: move relevant doubleword to destination side.
-            {
-                m = EmitMoveDoubleWordToSide(context, m, op.Vm, op.Vd);
-            }
-
-            Operand res = vectorFunc(m);
-
-            if (!op.Q) // Register insert.
-            {
-                res = EmitDoubleWordInsert(context, d, res, op.Vd);
-            }
-
-            context.Copy(d, res);
-        }
-
-        public static void EmitVectorUnaryOpF32(ArmEmitterContext context, Intrinsic inst)
-        {
-            OpCode32Simd op = (OpCode32Simd)context.CurrOp;
-
-            inst |= ((op.Size & 1) != 0 ? Intrinsic.Arm64VDouble : Intrinsic.Arm64VFloat) | Intrinsic.Arm64V128;
-            EmitVectorUnaryOpSimd32(context, (m) => context.AddIntrinsic(inst, m));
-        }
-
-        public static void EmitVectorBinaryOpSimd32(ArmEmitterContext context, Func2I vectorFunc, int side = -1)
-        {
-            OpCode32SimdReg op = (OpCode32SimdReg)context.CurrOp;
-
-            Operand n = GetVecA32(op.Qn);
-            Operand m = GetVecA32(op.Qm);
-            Operand d = GetVecA32(op.Qd);
-
-            if (side == -1)
-            {
-                side = op.Vd;
-            }
-
-            if (!op.Q) // Register swap: move relevant doubleword to destination side.
-            {
-                n = EmitMoveDoubleWordToSide(context, n, op.Vn, side);
-                m = EmitMoveDoubleWordToSide(context, m, op.Vm, side);
-            }
-
-            Operand res = vectorFunc(n, m);
-
-            if (!op.Q) // Register insert.
-            {
-                if (side != op.Vd)
-                {
-                    res = EmitMoveDoubleWordToSide(context, res, side, op.Vd);
-                }
-                res = EmitDoubleWordInsert(context, d, res, op.Vd);
-            }
-
-            context.Copy(d, res);
-        }
-
-        public static void EmitVectorBinaryOpF32(ArmEmitterContext context, Intrinsic inst)
-        {
-            OpCode32SimdReg op = (OpCode32SimdReg)context.CurrOp;
-
-            inst |= ((op.Size & 1) != 0 ? Intrinsic.Arm64VDouble : Intrinsic.Arm64VFloat) | Intrinsic.Arm64V128;
-            EmitVectorBinaryOpSimd32(context, (n, m) => context.AddIntrinsic(inst, n, m));
-        }
-
-        public static void EmitVectorTernaryOpSimd32(ArmEmitterContext context, Func3I vectorFunc)
-        {
-            OpCode32SimdReg op = (OpCode32SimdReg)context.CurrOp;
-
-            Operand n = GetVecA32(op.Qn);
-            Operand m = GetVecA32(op.Qm);
-            Operand d = GetVecA32(op.Qd);
-            Operand initialD = d;
-
-            if (!op.Q) // Register swap: move relevant doubleword to destination side.
-            {
-                n = EmitMoveDoubleWordToSide(context, n, op.Vn, op.Vd);
-                m = EmitMoveDoubleWordToSide(context, m, op.Vm, op.Vd);
-            }
-
-            Operand res = vectorFunc(d, n, m);
-
-            if (!op.Q) // Register insert.
-            {
-                res = EmitDoubleWordInsert(context, initialD, res, op.Vd);
-            }
-
-            context.Copy(initialD, res);
-        }
-
-        public static void EmitVectorTernaryOpF32(ArmEmitterContext context, Intrinsic inst)
-        {
-            OpCode32SimdReg op = (OpCode32SimdReg)context.CurrOp;
-
-            inst |= ((op.Size & 1) != 0 ? Intrinsic.Arm64VDouble : Intrinsic.Arm64VFloat) | Intrinsic.Arm64V128;
-            EmitVectorTernaryOpSimd32(context, (d, n, m) => context.AddIntrinsic(inst, d, n, m));
-        }
-
-        public static void EmitScalarUnaryOpSimd32(ArmEmitterContext context, Func1I scalarFunc)
-        {
-            OpCode32SimdS op = (OpCode32SimdS)context.CurrOp;
-
-            bool doubleSize = (op.Size & 1) != 0;
-            int shift = doubleSize ? 1 : 2;
-            Operand m = GetVecA32(op.Vm >> shift);
-            Operand d = GetVecA32(op.Vd >> shift);
-
-            m = EmitExtractScalar(context, m, op.Vm, doubleSize);
-
-            Operand res = scalarFunc(m);
-
-            // Insert scalar into vector.
-            res = EmitScalarInsert(context, d, res, op.Vd, doubleSize);
-
-            context.Copy(d, res);
-        }
-
-        public static void EmitScalarUnaryOpF32(ArmEmitterContext context, Intrinsic inst)
-        {
-            OpCode32SimdS op = (OpCode32SimdS)context.CurrOp;
-
-            inst |= ((op.Size & 1) != 0 ? Intrinsic.Arm64VDouble : Intrinsic.Arm64VFloat) | Intrinsic.Arm64V128;
-            EmitScalarUnaryOpSimd32(context, (m) => (inst == 0) ? m : context.AddIntrinsic(inst, m));
-        }
-
-        public static void EmitScalarBinaryOpSimd32(ArmEmitterContext context, Func2I scalarFunc)
-        {
-            OpCode32SimdRegS op = (OpCode32SimdRegS)context.CurrOp;
-
-            bool doubleSize = (op.Size & 1) != 0;
-            int shift = doubleSize ? 1 : 2;
-            Operand n = GetVecA32(op.Vn >> shift);
-            Operand m = GetVecA32(op.Vm >> shift);
-            Operand d = GetVecA32(op.Vd >> shift);
-
-            n = EmitExtractScalar(context, n, op.Vn, doubleSize);
-            m = EmitExtractScalar(context, m, op.Vm, doubleSize);
-
-            Operand res = scalarFunc(n, m);
-
-            // Insert scalar into vector.
-            res = EmitScalarInsert(context, d, res, op.Vd, doubleSize);
-
-            context.Copy(d, res);
-        }
-
-        public static void EmitScalarBinaryOpF32(ArmEmitterContext context, Intrinsic inst)
-        {
-            OpCode32SimdRegS op = (OpCode32SimdRegS)context.CurrOp;
-
-            inst |= ((op.Size & 1) != 0 ? Intrinsic.Arm64VDouble : Intrinsic.Arm64VFloat) | Intrinsic.Arm64V128;
-            EmitScalarBinaryOpSimd32(context, (n, m) =>  context.AddIntrinsic(inst, n, m));
-        }
-
-        public static void EmitScalarTernaryOpSimd32(ArmEmitterContext context, Func3I scalarFunc)
-        {
-            OpCode32SimdRegS op = (OpCode32SimdRegS)context.CurrOp;
-
-            bool doubleSize = (op.Size & 1) != 0;
-            int shift = doubleSize ? 1 : 2;
-            Operand n = GetVecA32(op.Vn >> shift);
-            Operand m = GetVecA32(op.Vm >> shift);
-            Operand d = GetVecA32(op.Vd >> shift);
-            Operand initialD = d;
-
-            n = EmitExtractScalar(context, n, op.Vn, doubleSize);
-            m = EmitExtractScalar(context, m, op.Vm, doubleSize);
-            d = EmitExtractScalar(context, d, op.Vd, doubleSize);
-
-            Operand res = scalarFunc(d, n, m);
-
-            // Insert scalar into vector.
-            res = EmitScalarInsert(context, initialD, res, op.Vd, doubleSize);
-
-            context.Copy(initialD, res);
-        }
-
-        public static void EmitScalarTernaryOpF32(ArmEmitterContext context, Intrinsic inst)
-        {
-            OpCode32SimdRegS op = (OpCode32SimdRegS)context.CurrOp;
-
-            inst |= ((op.Size & 1) != 0 ? Intrinsic.Arm64VDouble : Intrinsic.Arm64VFloat) | Intrinsic.Arm64V128;
-            EmitScalarTernaryOpSimd32(context, (d, n, m) => context.AddIntrinsic(inst, d, n, m));
-        }
-
-        // Pairwise
-
-        public static void EmitVectorPairwiseOpF32(ArmEmitterContext context, Intrinsic inst32)
-        {
-            OpCode32SimdReg op = (OpCode32SimdReg)context.CurrOp;
-
-            inst32 |= Intrinsic.Arm64V64 | Intrinsic.Arm64VFloat;
-            EmitVectorBinaryOpSimd32(context, (n, m) => context.AddIntrinsic(inst32, n, m), 0);
-        }
-
-        public static void EmitVcmpOrVcmpe(ArmEmitterContext context, bool signalNaNs)
-        {
-            OpCode32SimdS op = (OpCode32SimdS)context.CurrOp;
-
-            bool cmpWithZero = (op.Opc & 2) != 0;
-
-            Intrinsic inst = signalNaNs ? Intrinsic.Arm64FcmpeS : Intrinsic.Arm64FcmpS;
-            inst |= ((op.Size & 1) != 0 ? Intrinsic.Arm64VDouble : Intrinsic.Arm64VFloat) | Intrinsic.Arm64V128;
-
-            bool doubleSize = (op.Size & 1) != 0;
-            int shift = doubleSize ? 1 : 2;
-            Operand n = GetVecA32(op.Vd >> shift);
-            Operand m = GetVecA32(op.Vm >> shift);
-
-            n = EmitExtractScalar(context, n, op.Vd, doubleSize);
-            m = cmpWithZero ? Const(0) : EmitExtractScalar(context, m, op.Vm, doubleSize);
-
-            Operand nzcv = context.AddIntrinsicInt(inst, n, m);
-
-            Operand one = Const(1);
-
-            SetFpFlag(context, FPState.VFlag, context.BitwiseAnd(context.ShiftRightUI(nzcv, Const(28)), one));
-            SetFpFlag(context, FPState.CFlag, context.BitwiseAnd(context.ShiftRightUI(nzcv, Const(29)), one));
-            SetFpFlag(context, FPState.ZFlag, context.BitwiseAnd(context.ShiftRightUI(nzcv, Const(30)), one));
-            SetFpFlag(context, FPState.NFlag, context.BitwiseAnd(context.ShiftRightUI(nzcv, Const(31)), one));
-        }
-
-        public static void EmitCmpOpF32(ArmEmitterContext context, CmpCondition cond, bool zero)
-        {
-            OpCode32Simd op = (OpCode32Simd)context.CurrOp;
-
-            int sizeF = op.Size & 1;
-
-            Intrinsic inst;
-            if (zero)
-            {
-                inst = cond switch
-                {
-                    CmpCondition.Equal => Intrinsic.Arm64FcmeqVz,
-                    CmpCondition.GreaterThan => Intrinsic.Arm64FcmgtVz,
-                    CmpCondition.GreaterThanOrEqual => Intrinsic.Arm64FcmgeVz,
-                    CmpCondition.LessThan => Intrinsic.Arm64FcmltVz,
-                    CmpCondition.LessThanOrEqual => Intrinsic.Arm64FcmleVz,
-                    _ => throw new InvalidOperationException()
-                };
-            }
-            else {
-                inst = cond switch
-                {
-                    CmpCondition.Equal => Intrinsic.Arm64FcmeqV,
-                    CmpCondition.GreaterThan => Intrinsic.Arm64FcmgtV,
-                    CmpCondition.GreaterThanOrEqual => Intrinsic.Arm64FcmgeV,
-                    _ => throw new InvalidOperationException()
-                };
-            }
-
-            inst |= (sizeF != 0 ? Intrinsic.Arm64VDouble : Intrinsic.Arm64VFloat) | Intrinsic.Arm64V128;
-
-            if (zero)
-            {
-                EmitVectorUnaryOpSimd32(context, (m) =>
-                {
-                    return context.AddIntrinsic(inst, m);
-                });
-            }
-            else
-            {
-                EmitVectorBinaryOpSimd32(context, (n, m) =>
-                {
-                    return context.AddIntrinsic(inst, n, m);
-                });
-            }
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitSimdLogical.cs

@@ -1,581 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Translation;
-using System;
-using System.Diagnostics;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.Instructions.InstEmitSimdHelper;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static partial class InstEmit
-    {
-        public static void And_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelperArm64.EmitVectorBinaryOp(context, Intrinsic.Arm64AndV);
-            }
-            else if (Optimizations.UseSse2)
-            {
-                OpCodeSimdReg op = (OpCodeSimdReg)context.CurrOp;
-
-                Operand n = GetVec(op.Rn);
-                Operand m = GetVec(op.Rm);
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Pand, n, m);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-            else
-            {
-                EmitVectorBinaryOpZx(context, (op1, op2) => context.BitwiseAnd(op1, op2));
-            }
-        }
-
-        public static void Bic_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelperArm64.EmitVectorBinaryOp(context, Intrinsic.Arm64BicV);
-            }
-            else if (Optimizations.UseSse2)
-            {
-                OpCodeSimdReg op = (OpCodeSimdReg)context.CurrOp;
-
-                Operand n = GetVec(op.Rn);
-                Operand m = GetVec(op.Rm);
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Pandn, m, n);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-            else
-            {
-                EmitVectorBinaryOpZx(context, (op1, op2) =>
-                {
-                    return context.BitwiseAnd(op1, context.BitwiseNot(op2));
-                });
-            }
-        }
-
-        public static void Bic_Vi(ArmEmitterContext context)
-        {
-            if (Optimizations.UseSse2)
-            {
-                OpCodeSimdImm op = (OpCodeSimdImm)context.CurrOp;
-
-                int eSize = 8 << op.Size;
-
-                Operand d = GetVec(op.Rd);
-                Operand imm = eSize switch {
-                    16 => X86GetAllElements(context, (short)~op.Immediate),
-                    32 => X86GetAllElements(context, (int)~op.Immediate),
-                    _ => throw new InvalidOperationException($"Invalid element size {eSize}.")
-                };
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Pand, d, imm);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-            else
-            {
-                EmitVectorImmBinaryOp(context, (op1, op2) =>
-                {
-                    return context.BitwiseAnd(op1, context.BitwiseNot(op2));
-                });
-            }
-        }
-
-        public static void Bif_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelperArm64.EmitVectorTernaryOpRd(context, Intrinsic.Arm64BifV);
-            }
-            else
-            {
-                EmitBifBit(context, notRm: true);
-            }
-        }
-
-        public static void Bit_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelperArm64.EmitVectorTernaryOpRd(context, Intrinsic.Arm64BitV);
-            }
-            else
-            {
-                EmitBifBit(context, notRm: false);
-            }
-        }
-
-        private static void EmitBifBit(ArmEmitterContext context, bool notRm)
-        {
-            OpCodeSimdReg op = (OpCodeSimdReg)context.CurrOp;
-
-            if (Optimizations.UseSse2)
-            {
-                Operand d = GetVec(op.Rd);
-                Operand n = GetVec(op.Rn);
-                Operand m = GetVec(op.Rm);
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Pxor, n, d);
-
-                if (notRm)
-                {
-                    res = context.AddIntrinsic(Intrinsic.X86Pandn, m, res);
-                }
-                else
-                {
-                    res = context.AddIntrinsic(Intrinsic.X86Pand, m, res);
-                }
-
-                res = context.AddIntrinsic(Intrinsic.X86Pxor, d, res);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(d, res);
-            }
-            else
-            {
-                Operand res = context.VectorZero();
-
-                int elems = op.RegisterSize == RegisterSize.Simd128 ? 2 : 1;
-
-                for (int index = 0; index < elems; index++)
-                {
-                    Operand d = EmitVectorExtractZx(context, op.Rd, index, 3);
-                    Operand n = EmitVectorExtractZx(context, op.Rn, index, 3);
-                    Operand m = EmitVectorExtractZx(context, op.Rm, index, 3);
-
-                    if (notRm)
-                    {
-                        m = context.BitwiseNot(m);
-                    }
-
-                    Operand e = context.BitwiseExclusiveOr(d, n);
-
-                    e = context.BitwiseAnd(e, m);
-                    e = context.BitwiseExclusiveOr(e, d);
-
-                    res = EmitVectorInsert(context, res, e, index, 3);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-        }
-
-        public static void Bsl_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelperArm64.EmitVectorTernaryOpRd(context, Intrinsic.Arm64BslV);
-            }
-            else if (Optimizations.UseSse2)
-            {
-                OpCodeSimdReg op = (OpCodeSimdReg)context.CurrOp;
-
-                Operand d = GetVec(op.Rd);
-                Operand n = GetVec(op.Rn);
-                Operand m = GetVec(op.Rm);
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Pxor, n, m);
-
-                res = context.AddIntrinsic(Intrinsic.X86Pand, res, d);
-                res = context.AddIntrinsic(Intrinsic.X86Pxor, res, m);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(d, res);
-            }
-            else
-            {
-                EmitVectorTernaryOpZx(context, (op1, op2, op3) =>
-                {
-                    return context.BitwiseExclusiveOr(
-                        context.BitwiseAnd(op1,
-                        context.BitwiseExclusiveOr(op2, op3)), op3);
-                });
-            }
-        }
-
-        public static void Eor_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelperArm64.EmitVectorBinaryOp(context, Intrinsic.Arm64EorV);
-            }
-            else if (Optimizations.UseSse2)
-            {
-                OpCodeSimdReg op = (OpCodeSimdReg)context.CurrOp;
-
-                Operand n = GetVec(op.Rn);
-                Operand m = GetVec(op.Rm);
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Pxor, n, m);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-            else
-            {
-                EmitVectorBinaryOpZx(context, (op1, op2) => context.BitwiseExclusiveOr(op1, op2));
-            }
-        }
-
-        public static void Not_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseSse2)
-            {
-                OpCodeSimd op = (OpCodeSimd)context.CurrOp;
-
-                Operand n = GetVec(op.Rn);
-
-                Operand mask = X86GetAllElements(context, -1L);
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Pandn, n, mask);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-            else
-            {
-                EmitVectorUnaryOpZx(context, (op1) => context.BitwiseNot(op1));
-            }
-        }
-
-        public static void Orn_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelperArm64.EmitVectorBinaryOp(context, Intrinsic.Arm64OrnV);
-            }
-            else if (Optimizations.UseSse2)
-            {
-                OpCodeSimdReg op = (OpCodeSimdReg)context.CurrOp;
-
-                Operand n = GetVec(op.Rn);
-                Operand m = GetVec(op.Rm);
-
-                Operand mask = X86GetAllElements(context, -1L);
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Pandn, m, mask);
-
-                res = context.AddIntrinsic(Intrinsic.X86Por, res, n);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-            else
-            {
-                EmitVectorBinaryOpZx(context, (op1, op2) =>
-                {
-                    return context.BitwiseOr(op1, context.BitwiseNot(op2));
-                });
-            }
-        }
-
-        public static void Orr_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelperArm64.EmitVectorBinaryOp(context, Intrinsic.Arm64OrrV);
-            }
-            else if (Optimizations.UseSse2)
-            {
-                OpCodeSimdReg op = (OpCodeSimdReg)context.CurrOp;
-
-                Operand n = GetVec(op.Rn);
-                Operand m = GetVec(op.Rm);
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Por, n, m);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-            else
-            {
-                EmitVectorBinaryOpZx(context, (op1, op2) => context.BitwiseOr(op1, op2));
-            }
-        }
-
-        public static void Orr_Vi(ArmEmitterContext context)
-        {
-            if (Optimizations.UseSse2)
-            {
-                OpCodeSimdImm op = (OpCodeSimdImm)context.CurrOp;
-
-                int eSize = 8 << op.Size;
-
-                Operand d = GetVec(op.Rd);
-                Operand imm = eSize switch {
-                    16 => X86GetAllElements(context, (short)op.Immediate),
-                    32 => X86GetAllElements(context, (int)op.Immediate),
-                    _ => throw new InvalidOperationException($"Invalid element size {eSize}.")
-                };
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Por, d, imm);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-            else
-            {
-                EmitVectorImmBinaryOp(context, (op1, op2) => context.BitwiseOr(op1, op2));
-            }
-        }
-
-        public static void Rbit_V(ArmEmitterContext context)
-        {
-            OpCodeSimd op = (OpCodeSimd)context.CurrOp;
-
-            if (Optimizations.UseGfni)
-            {
-                const long bitMatrix =
-                    (0b10000000L << 56) |
-                    (0b01000000L << 48) |
-                    (0b00100000L << 40) |
-                    (0b00010000L << 32) |
-                    (0b00001000L << 24) |
-                    (0b00000100L << 16) |
-                    (0b00000010L <<  8) |
-                    (0b00000001L <<  0);
-
-                Operand vBitMatrix = X86GetAllElements(context, bitMatrix);
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Gf2p8affineqb, GetVec(op.Rn), vBitMatrix, Const(0));
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-            else
-            {
-                Operand res = context.VectorZero();
-                int elems = op.RegisterSize == RegisterSize.Simd128 ? 16 : 8;
-
-                for (int index = 0; index < elems; index++)
-                {
-                    Operand ne = EmitVectorExtractZx(context, op.Rn, index, 0);
-
-                    Operand de = EmitReverseBits8Op(context, ne);
-
-                    res = EmitVectorInsert(context, res, de, index, 0);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-        }
-
-        private static Operand EmitReverseBits8Op(ArmEmitterContext context, Operand op)
-        {
-            Debug.Assert(op.Type == OperandType.I64);
-
-            Operand val = context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(op, Const(0xaaul)), Const(1)),
-                                            context.ShiftLeft   (context.BitwiseAnd(op, Const(0x55ul)), Const(1)));
-
-            val = context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(val, Const(0xccul)), Const(2)),
-                                    context.ShiftLeft   (context.BitwiseAnd(val, Const(0x33ul)), Const(2)));
-
-            return context.BitwiseOr(context.ShiftRightUI(val, Const(4)),
-                                     context.ShiftLeft   (context.BitwiseAnd(val, Const(0x0ful)), Const(4)));
-        }
-
-        public static void Rev16_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseSsse3)
-            {
-                OpCodeSimd op = (OpCodeSimd)context.CurrOp;
-
-                Operand n = GetVec(op.Rn);
-
-                const long maskE0 = 06L << 56 | 07L << 48 | 04L << 40 | 05L << 32 | 02L << 24 | 03L << 16 | 00L << 8 | 01L << 0;
-                const long maskE1 = 14L << 56 | 15L << 48 | 12L << 40 | 13L << 32 | 10L << 24 | 11L << 16 | 08L << 8 | 09L << 0;
-
-                Operand mask = X86GetScalar(context, maskE0);
-
-                mask = EmitVectorInsert(context, mask, Const(maskE1), 1, 3);
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Pshufb, n, mask);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-            else
-            {
-                EmitRev_V(context, containerSize: 1);
-            }
-        }
-
-        public static void Rev32_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseSsse3)
-            {
-                OpCodeSimd op = (OpCodeSimd)context.CurrOp;
-
-                Operand n = GetVec(op.Rn);
-
-                Operand mask;
-
-                if (op.Size == 0)
-                {
-                    const long maskE0 = 04L << 56 | 05L << 48 | 06L << 40 | 07L << 32 | 00L << 24 | 01L << 16 | 02L << 8 | 03L << 0;
-                    const long maskE1 = 12L << 56 | 13L << 48 | 14L << 40 | 15L << 32 | 08L << 24 | 09L << 16 | 10L << 8 | 11L << 0;
-
-                    mask = X86GetScalar(context, maskE0);
-
-                    mask = EmitVectorInsert(context, mask, Const(maskE1), 1, 3);
-                }
-                else /* if (op.Size == 1) */
-                {
-                    const long maskE0 = 05L << 56 | 04L << 48 | 07L << 40 | 06L << 32 | 01L << 24 | 00L << 16 | 03L << 8 | 02L << 0;
-                    const long maskE1 = 13L << 56 | 12L << 48 | 15L << 40 | 14L << 32 | 09L << 24 | 08L << 16 | 11L << 8 | 10L << 0;
-
-                    mask = X86GetScalar(context, maskE0);
-
-                    mask = EmitVectorInsert(context, mask, Const(maskE1), 1, 3);
-                }
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Pshufb, n, mask);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-            else
-            {
-                EmitRev_V(context, containerSize: 2);
-            }
-        }
-
-        public static void Rev64_V(ArmEmitterContext context)
-        {
-            if (Optimizations.UseSsse3)
-            {
-                OpCodeSimd op = (OpCodeSimd)context.CurrOp;
-
-                Operand n = GetVec(op.Rn);
-
-                Operand mask;
-
-                if (op.Size == 0)
-                {
-                    const long maskE0 = 00L << 56 | 01L << 48 | 02L << 40 | 03L << 32 | 04L << 24 | 05L << 16 | 06L << 8 | 07L << 0;
-                    const long maskE1 = 08L << 56 | 09L << 48 | 10L << 40 | 11L << 32 | 12L << 24 | 13L << 16 | 14L << 8 | 15L << 0;
-
-                    mask = X86GetScalar(context, maskE0);
-
-                    mask = EmitVectorInsert(context, mask, Const(maskE1), 1, 3);
-                }
-                else if (op.Size == 1)
-                {
-                    const long maskE0 = 01L << 56 | 00L << 48 | 03L << 40 | 02L << 32 | 05L << 24 | 04L << 16 | 07L << 8 | 06L << 0;
-                    const long maskE1 = 09L << 56 | 08L << 48 | 11L << 40 | 10L << 32 | 13L << 24 | 12L << 16 | 15L << 8 | 14L << 0;
-
-                    mask = X86GetScalar(context, maskE0);
-
-                    mask = EmitVectorInsert(context, mask, Const(maskE1), 1, 3);
-                }
-                else /* if (op.Size == 2) */
-                {
-                    const long maskE0 = 03L << 56 | 02L << 48 | 01L << 40 | 00L << 32 | 07L << 24 | 06L << 16 | 05L << 8 | 04L << 0;
-                    const long maskE1 = 11L << 56 | 10L << 48 | 09L << 40 | 08L << 32 | 15L << 24 | 14L << 16 | 13L << 8 | 12L << 0;
-
-                    mask = X86GetScalar(context, maskE0);
-
-                    mask = EmitVectorInsert(context, mask, Const(maskE1), 1, 3);
-                }
-
-                Operand res = context.AddIntrinsic(Intrinsic.X86Pshufb, n, mask);
-
-                if (op.RegisterSize == RegisterSize.Simd64)
-                {
-                    res = context.VectorZeroUpper64(res);
-                }
-
-                context.Copy(GetVec(op.Rd), res);
-            }
-            else
-            {
-                EmitRev_V(context, containerSize: 3);
-            }
-        }
-
-        private static void EmitRev_V(ArmEmitterContext context, int containerSize)
-        {
-            OpCodeSimd op = (OpCodeSimd)context.CurrOp;
-
-            Operand res = context.VectorZero();
-
-            int elems = op.GetBytesCount() >> op.Size;
-
-            int containerMask = (1 << (containerSize - op.Size)) - 1;
-
-            for (int index = 0; index < elems; index++)
-            {
-                int revIndex = index ^ containerMask;
-
-                Operand ne = EmitVectorExtractZx(context, op.Rn, revIndex, op.Size);
-
-                res = EmitVectorInsert(context, res, ne, index, op.Size);
-            }
-
-            context.Copy(GetVec(op.Rd), res);
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitSimdLogical32.cs

@@ -1,259 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Translation;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.Instructions.InstEmitSimdHelper;
-using static ARMeilleure.Instructions.InstEmitSimdHelper32;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static partial class InstEmit32
-    {
-        public static void Vand_I(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitVectorBinaryOpSimd32(context, (n, m) => context.AddIntrinsic(Intrinsic.Arm64AndV | Intrinsic.Arm64V128, n, m));
-            }
-            else if (Optimizations.UseSse2)
-            {
-                EmitVectorBinaryOpSimd32(context, (n, m) => context.AddIntrinsic(Intrinsic.X86Pand, n, m));
-            }
-            else
-            {
-                EmitVectorBinaryOpZx32(context, (op1, op2) => context.BitwiseAnd(op1, op2));
-            }
-        }
-
-        public static void Vbic_I(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitVectorBinaryOpSimd32(context, (n, m) => context.AddIntrinsic(Intrinsic.Arm64BicV | Intrinsic.Arm64V128, n, m));
-            }
-            else if (Optimizations.UseSse2)
-            {
-                EmitVectorBinaryOpSimd32(context, (n, m) => context.AddIntrinsic(Intrinsic.X86Pandn, m, n));
-            }
-            else
-            {
-                EmitVectorBinaryOpZx32(context, (op1, op2) => context.BitwiseAnd(op1, context.BitwiseNot(op2)));
-            }
-        }
-
-        public static void Vbic_II(ArmEmitterContext context)
-        {
-            OpCode32SimdImm op = (OpCode32SimdImm)context.CurrOp;
-
-            long immediate = op.Immediate;
-
-            // Replicate fields to fill the 64-bits, if size is < 64-bits.
-            switch (op.Size)
-            {
-                case 0: immediate *= 0x0101010101010101L; break;
-                case 1: immediate *= 0x0001000100010001L; break;
-                case 2: immediate *= 0x0000000100000001L; break;
-            }
-
-            Operand imm = Const(immediate);
-            Operand res = GetVecA32(op.Qd);
-
-            if (op.Q)
-            {
-                for (int elem = 0; elem < 2; elem++)
-                {
-                    Operand de = EmitVectorExtractZx(context, op.Qd, elem, 3);
-
-                    res = EmitVectorInsert(context, res, context.BitwiseAnd(de, context.BitwiseNot(imm)), elem, 3);
-                }
-            }
-            else
-            {
-                Operand de = EmitVectorExtractZx(context, op.Qd, op.Vd & 1, 3);
-
-                res = EmitVectorInsert(context, res, context.BitwiseAnd(de, context.BitwiseNot(imm)), op.Vd & 1, 3);
-            }
-
-            context.Copy(GetVecA32(op.Qd), res);
-        }
-
-        public static void Vbif(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitVectorTernaryOpSimd32(context, (d, n, m) => context.AddIntrinsic(Intrinsic.Arm64BifV | Intrinsic.Arm64V128, d, n, m));
-            }
-            else
-            {
-                EmitBifBit(context, true);
-            }
-        }
-
-        public static void Vbit(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitVectorTernaryOpSimd32(context, (d, n, m) => context.AddIntrinsic(Intrinsic.Arm64BitV | Intrinsic.Arm64V128, d, n, m));
-            }
-            else
-            {
-                EmitBifBit(context, false);
-            }
-        }
-
-        public static void Vbsl(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitVectorTernaryOpSimd32(context, (d, n, m) => context.AddIntrinsic(Intrinsic.Arm64BslV | Intrinsic.Arm64V128, d, n, m));
-            }
-            else if (Optimizations.UseSse2)
-            {
-                EmitVectorTernaryOpSimd32(context, (d, n, m) =>
-                {
-                    Operand res = context.AddIntrinsic(Intrinsic.X86Pxor, n, m);
-                    res = context.AddIntrinsic(Intrinsic.X86Pand, res, d);
-                    return context.AddIntrinsic(Intrinsic.X86Pxor, res, m);
-                });
-            }
-            else
-            {
-                EmitVectorTernaryOpZx32(context, (op1, op2, op3) =>
-                {
-                    return context.BitwiseExclusiveOr(
-                        context.BitwiseAnd(op1,
-                        context.BitwiseExclusiveOr(op2, op3)), op3);
-                });
-            }
-        }
-
-        public static void Veor_I(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitVectorBinaryOpSimd32(context, (n, m) => context.AddIntrinsic(Intrinsic.Arm64EorV | Intrinsic.Arm64V128, n, m));
-            }
-            else if (Optimizations.UseSse2)
-            {
-                EmitVectorBinaryOpSimd32(context, (n, m) => context.AddIntrinsic(Intrinsic.X86Pxor, n, m));
-            }
-            else
-            {
-                EmitVectorBinaryOpZx32(context, (op1, op2) => context.BitwiseExclusiveOr(op1, op2));
-            }
-        }
-
-        public static void Vorn_I(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitVectorBinaryOpSimd32(context, (n, m) => context.AddIntrinsic(Intrinsic.Arm64OrnV | Intrinsic.Arm64V128, n, m));
-            }
-            else if (Optimizations.UseSse2)
-            {
-                Operand mask = context.VectorOne();
-
-                EmitVectorBinaryOpSimd32(context, (n, m) =>
-                {
-                    m = context.AddIntrinsic(Intrinsic.X86Pandn, m, mask);
-                    return context.AddIntrinsic(Intrinsic.X86Por, n, m);
-                });
-            }
-            else
-            {
-                EmitVectorBinaryOpZx32(context, (op1, op2) => context.BitwiseOr(op1, context.BitwiseNot(op2)));
-            }
-        }
-
-        public static void Vorr_I(ArmEmitterContext context)
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                InstEmitSimdHelper32Arm64.EmitVectorBinaryOpSimd32(context, (n, m) => context.AddIntrinsic(Intrinsic.Arm64OrrV | Intrinsic.Arm64V128, n, m));
-            }
-            else if (Optimizations.UseSse2)
-            {
-                EmitVectorBinaryOpSimd32(context, (n, m) => context.AddIntrinsic(Intrinsic.X86Por, n, m));
-            }
-            else
-            {
-                EmitVectorBinaryOpZx32(context, (op1, op2) => context.BitwiseOr(op1, op2));
-            }
-        }
-
-        public static void Vorr_II(ArmEmitterContext context)
-        {
-            OpCode32SimdImm op = (OpCode32SimdImm)context.CurrOp;
-
-            long immediate = op.Immediate;
-
-            // Replicate fields to fill the 64-bits, if size is < 64-bits.
-            switch (op.Size)
-            {
-                case 0: immediate *= 0x0101010101010101L; break;
-                case 1: immediate *= 0x0001000100010001L; break;
-                case 2: immediate *= 0x0000000100000001L; break;
-            }
-
-            Operand imm = Const(immediate);
-            Operand res = GetVecA32(op.Qd);
-
-            if (op.Q)
-            {
-                for (int elem = 0; elem < 2; elem++)
-                {
-                    Operand de = EmitVectorExtractZx(context, op.Qd, elem, 3);
-
-                    res = EmitVectorInsert(context, res, context.BitwiseOr(de, imm), elem, 3);
-                }
-            }
-            else
-            {
-                Operand de = EmitVectorExtractZx(context, op.Qd, op.Vd & 1, 3);
-
-                res = EmitVectorInsert(context, res, context.BitwiseOr(de, imm), op.Vd & 1, 3);
-            }
-
-            context.Copy(GetVecA32(op.Qd), res);
-        }
-
-        public static void Vtst(ArmEmitterContext context)
-        {
-            EmitVectorBinaryOpZx32(context, (op1, op2) =>
-            {
-                Operand isZero = context.ICompareEqual(context.BitwiseAnd(op1, op2), Const(0));
-                return context.ConditionalSelect(isZero, Const(0), Const(-1));
-            });
-        }
-
-        private static void EmitBifBit(ArmEmitterContext context, bool notRm)
-        {
-            OpCode32SimdReg op = (OpCode32SimdReg)context.CurrOp;
-
-            if (Optimizations.UseSse2)
-            {
-                EmitVectorTernaryOpSimd32(context, (d, n, m) =>
-                {
-                    Operand res = context.AddIntrinsic(Intrinsic.X86Pxor, n, d);
-                    res = context.AddIntrinsic((notRm) ? Intrinsic.X86Pandn : Intrinsic.X86Pand, m, res);
-                    return context.AddIntrinsic(Intrinsic.X86Pxor, d, res);
-                });
-            }
-            else
-            {
-                EmitVectorTernaryOpZx32(context, (d, n, m) =>
-                {
-                    if (notRm)
-                    {
-                        m = context.BitwiseNot(m);
-                    }
-                    return context.BitwiseExclusiveOr(
-                        context.BitwiseAnd(m,
-                        context.BitwiseExclusiveOr(d, n)), d);
-                });
-            }
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitSimdMove32.cs

@@ -1,649 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Translation;
-using System;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.Instructions.InstEmitSimdHelper;
-using static ARMeilleure.Instructions.InstEmitSimdHelper32;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static partial class InstEmit32
-    {
-        #region "Masks"
-        // Same as InstEmitSimdMove, as the instructions do the same thing.
-        private static readonly long[] _masksE0_Uzp = new long[]
-        {
-            13L << 56 | 09L << 48 | 05L << 40 | 01L << 32 | 12L << 24 | 08L << 16 | 04L << 8 | 00L << 0,
-            11L << 56 | 10L << 48 | 03L << 40 | 02L << 32 | 09L << 24 | 08L << 16 | 01L << 8 | 00L << 0
-        };
-
-        private static readonly long[] _masksE1_Uzp = new long[]
-        {
-            15L << 56 | 11L << 48 | 07L << 40 | 03L << 32 | 14L << 24 | 10L << 16 | 06L << 8 | 02L << 0,
-            15L << 56 | 14L << 48 | 07L << 40 | 06L << 32 | 13L << 24 | 12L << 16 | 05L << 8 | 04L << 0
-        };
-        #endregion
-
-        public static void Vmov_I(ArmEmitterContext context)
-        {
-            EmitVectorImmUnaryOp32(context, (op1) => op1);
-        }
-
-        public static void Vmvn_I(ArmEmitterContext context)
-        {
-            if (Optimizations.UseSse2)
-            {
-                EmitVectorUnaryOpSimd32(context, (op1) =>
-                {
-                    Operand mask = X86GetAllElements(context, -1L);
-                    return context.AddIntrinsic(Intrinsic.X86Pandn, op1, mask);
-                });
-            }
-            else
-            {
-                EmitVectorUnaryOpZx32(context, (op1) => context.BitwiseNot(op1));
-            }
-        }
-
-        public static void Vmvn_II(ArmEmitterContext context)
-        {
-            EmitVectorImmUnaryOp32(context, (op1) => context.BitwiseNot(op1));
-        }
-
-        public static void Vmov_GS(ArmEmitterContext context)
-        {
-            OpCode32SimdMovGp op = (OpCode32SimdMovGp)context.CurrOp;
-
-            Operand vec = GetVecA32(op.Vn >> 2);
-            if (op.Op == 1)
-            {
-                // To general purpose.
-                Operand value = context.VectorExtract(OperandType.I32, vec, op.Vn & 0x3);
-                SetIntA32(context, op.Rt, value);
-            }
-            else
-            {
-                // From general purpose.
-                Operand value = GetIntA32(context, op.Rt);
-                context.Copy(vec, context.VectorInsert(vec, value, op.Vn & 0x3));
-            }
-        }
-
-        public static void Vmov_G1(ArmEmitterContext context)
-        {
-            OpCode32SimdMovGpElem op = (OpCode32SimdMovGpElem)context.CurrOp;
-
-            int index = op.Index + ((op.Vd & 1) << (3 - op.Size));
-            if (op.Op == 1)
-            {
-                // To general purpose.
-                Operand value = EmitVectorExtract32(context, op.Vd >> 1, index, op.Size, !op.U);
-                SetIntA32(context, op.Rt, value);
-            }
-            else
-            {
-                // From general purpose.
-                Operand vec = GetVecA32(op.Vd >> 1);
-                Operand value = GetIntA32(context, op.Rt);
-                context.Copy(vec, EmitVectorInsert(context, vec, value, index, op.Size));
-            }
-        }
-
-        public static void Vmov_G2(ArmEmitterContext context)
-        {
-            OpCode32SimdMovGpDouble op = (OpCode32SimdMovGpDouble)context.CurrOp;
-
-            Operand vec = GetVecA32(op.Vm >> 2);
-            int vm1 = op.Vm + 1;
-            bool sameOwnerVec = (op.Vm >> 2) == (vm1 >> 2);
-            Operand vec2 = sameOwnerVec ? vec : GetVecA32(vm1 >> 2);
-            if (op.Op == 1)
-            {
-                // To general purpose.
-                Operand lowValue = context.VectorExtract(OperandType.I32, vec, op.Vm & 3);
-                SetIntA32(context, op.Rt, lowValue);
-
-                Operand highValue = context.VectorExtract(OperandType.I32, vec2, vm1 & 3);
-                SetIntA32(context, op.Rt2, highValue);
-            }
-            else
-            {
-                // From general purpose.
-                Operand lowValue = GetIntA32(context, op.Rt);
-                Operand resultVec = context.VectorInsert(vec, lowValue, op.Vm & 3);
-
-                Operand highValue = GetIntA32(context, op.Rt2);
-
-                if (sameOwnerVec)
-                {
-                    context.Copy(vec, context.VectorInsert(resultVec, highValue, vm1 & 3));
-                }
-                else
-                {
-                    context.Copy(vec, resultVec);
-                    context.Copy(vec2, context.VectorInsert(vec2, highValue, vm1 & 3));
-                }
-            }
-        }
-
-        public static void Vmov_GD(ArmEmitterContext context)
-        {
-            OpCode32SimdMovGpDouble op = (OpCode32SimdMovGpDouble)context.CurrOp;
-
-            Operand vec = GetVecA32(op.Vm >> 1);
-            if (op.Op == 1)
-            {
-                // To general purpose.
-                Operand value = context.VectorExtract(OperandType.I64, vec, op.Vm & 1);
-                SetIntA32(context, op.Rt, context.ConvertI64ToI32(value));
-                SetIntA32(context, op.Rt2, context.ConvertI64ToI32(context.ShiftRightUI(value, Const(32))));
-            }
-            else
-            {
-                // From general purpose.
-                Operand lowValue = GetIntA32(context, op.Rt);
-                Operand highValue = GetIntA32(context, op.Rt2);
-
-                Operand value = context.BitwiseOr(
-                    context.ZeroExtend32(OperandType.I64, lowValue),
-                    context.ShiftLeft(context.ZeroExtend32(OperandType.I64, highValue), Const(32)));
-
-                context.Copy(vec, context.VectorInsert(vec, value, op.Vm & 1));
-            }
-        }
-
-        public static void Vmovl(ArmEmitterContext context)
-        {
-            OpCode32SimdLong op = (OpCode32SimdLong)context.CurrOp;
-
-            Operand res = context.VectorZero();
-
-            int elems = op.GetBytesCount() >> op.Size;
-
-            for (int index = 0; index < elems; index++)
-            {
-                Operand me = EmitVectorExtract32(context, op.Qm, op.Im + index, op.Size, !op.U);
-
-                if (op.Size == 2)
-                {
-                    if (op.U)
-                    {
-                        me = context.ZeroExtend32(OperandType.I64, me);
-                    }
-                    else
-                    {
-                        me = context.SignExtend32(OperandType.I64, me);
-                    }
-                }
-
-                res = EmitVectorInsert(context, res, me, index, op.Size + 1);
-            }
-
-            context.Copy(GetVecA32(op.Qd), res);
-        }
-
-        public static void Vtbl(ArmEmitterContext context)
-        {
-            OpCode32SimdTbl op = (OpCode32SimdTbl)context.CurrOp;
-
-            bool extension = op.Opc == 1;
-            int length = op.Length + 1;
-
-            if (Optimizations.UseSsse3)
-            {
-                Operand d = GetVecA32(op.Qd);
-                Operand m = EmitMoveDoubleWordToSide(context, GetVecA32(op.Qm), op.Vm, 0);
-
-                Operand res;
-                Operand mask = X86GetAllElements(context, 0x0707070707070707L);
-
-                // Fast path for single register table.
-                {
-                    Operand n = EmitMoveDoubleWordToSide(context, GetVecA32(op.Qn), op.Vn, 0);
-
-                    Operand mMask = context.AddIntrinsic(Intrinsic.X86Pcmpgtb, m, mask);
-                    mMask = context.AddIntrinsic(Intrinsic.X86Por, mMask, m);
-
-                    res = context.AddIntrinsic(Intrinsic.X86Pshufb, n, mMask);
-                }
-
-                for (int index = 1; index < length; index++)
-                {
-                    int newVn = (op.Vn + index) & 0x1F;
-                    (int qn, int ind) = GetQuadwordAndSubindex(newVn, op.RegisterSize);
-                    Operand ni = EmitMoveDoubleWordToSide(context, GetVecA32(qn), newVn, 0);
-
-                    Operand idxMask = X86GetAllElements(context, 0x0808080808080808L * index);
-
-                    Operand mSubMask = context.AddIntrinsic(Intrinsic.X86Psubb, m, idxMask);
-
-                    Operand mMask = context.AddIntrinsic(Intrinsic.X86Pcmpgtb, mSubMask, mask);
-                    mMask = context.AddIntrinsic(Intrinsic.X86Por, mMask, mSubMask);
-
-                    Operand res2 = context.AddIntrinsic(Intrinsic.X86Pshufb, ni, mMask);
-
-                    res = context.AddIntrinsic(Intrinsic.X86Por, res, res2);
-                }
-
-                if (extension)
-                {
-                    Operand idxMask = X86GetAllElements(context, (0x0808080808080808L * length) - 0x0101010101010101L);
-                    Operand zeroMask = context.VectorZero();
-
-                    Operand mPosMask = context.AddIntrinsic(Intrinsic.X86Pcmpgtb, m, idxMask);
-                    Operand mNegMask = context.AddIntrinsic(Intrinsic.X86Pcmpgtb, zeroMask, m);
-
-                    Operand mMask = context.AddIntrinsic(Intrinsic.X86Por, mPosMask, mNegMask);
-
-                    Operand dMask = context.AddIntrinsic(Intrinsic.X86Pand, EmitMoveDoubleWordToSide(context, d, op.Vd, 0), mMask);
-
-                    res = context.AddIntrinsic(Intrinsic.X86Por, res, dMask);
-                }
-
-                res = EmitMoveDoubleWordToSide(context, res, 0, op.Vd);
-
-                context.Copy(d, EmitDoubleWordInsert(context, d, res, op.Vd));
-            }
-            else
-            {
-                int elems = op.GetBytesCount() >> op.Size;
-
-                (int Qx, int Ix)[] tableTuples = new (int, int)[length];
-                for (int i = 0; i < length; i++)
-                {
-                    tableTuples[i] = GetQuadwordAndSubindex(op.Vn + i, op.RegisterSize);
-                }
-
-                int byteLength = length * 8;
-
-                Operand res = GetVecA32(op.Qd);
-                Operand m = GetVecA32(op.Qm);
-
-                for (int index = 0; index < elems; index++)
-                {
-                    Operand selectedIndex = context.ZeroExtend8(OperandType.I32, context.VectorExtract8(m, index + op.Im));
-
-                    Operand inRange = context.ICompareLess(selectedIndex, Const(byteLength));
-                    Operand elemRes = default; // Note: This is I64 for ease of calculation.
-
-                    // TODO: Branching rather than conditional select.
-
-                    // Get indexed byte.
-                    // To simplify (ha) the il, we get bytes from every vector and use a nested conditional select to choose the right result.
-                    // This does have to extract `length` times for every element but certainly not as bad as it could be.
-
-                    // Which vector number is the index on.
-                    Operand vecIndex = context.ShiftRightUI(selectedIndex, Const(3));
-                    // What should we shift by to extract it.
-                    Operand subVecIndexShift = context.ShiftLeft(context.BitwiseAnd(selectedIndex, Const(7)), Const(3));
-
-                    for (int i = 0; i < length; i++)
-                    {
-                        (int qx, int ix) = tableTuples[i];
-                        // Get the whole vector, we'll get a byte out of it.
-                        Operand lookupResult;
-                        if (qx == op.Qd)
-                        {
-                            // Result contains the current state of the vector.
-                            lookupResult = context.VectorExtract(OperandType.I64, res, ix);
-                        }
-                        else
-                        {
-                            lookupResult = EmitVectorExtract32(context, qx, ix, 3, false); // I64
-                        }
-
-                        lookupResult = context.ShiftRightUI(lookupResult, subVecIndexShift); // Get the relevant byte from this vector.
-
-                        if (i == 0)
-                        {
-                            elemRes = lookupResult; // First result is always default.
-                        }
-                        else
-                        {
-                            Operand isThisElem = context.ICompareEqual(vecIndex, Const(i));
-                            elemRes = context.ConditionalSelect(isThisElem, lookupResult, elemRes);
-                        }
-                    }
-
-                    Operand fallback = (extension) ? context.ZeroExtend32(OperandType.I64, EmitVectorExtract32(context, op.Qd, index + op.Id, 0, false)) : Const(0L);
-
-                    res = EmitVectorInsert(context, res, context.ConditionalSelect(inRange, elemRes, fallback), index + op.Id, 0);
-                }
-
-                context.Copy(GetVecA32(op.Qd), res);
-            }
-        }
-
-        public static void Vtrn(ArmEmitterContext context)
-        {
-            OpCode32SimdCmpZ op = (OpCode32SimdCmpZ)context.CurrOp;
-
-            if (Optimizations.UseSsse3)
-            {
-                EmitVectorShuffleOpSimd32(context, (m, d) =>
-                {
-                    Operand mask = default;
-
-                    if (op.Size < 3)
-                    {
-                        long maskE0 = EvenMasks[op.Size];
-                        long maskE1 = OddMasks[op.Size];
-
-                        mask = X86GetScalar(context, maskE0);
-
-                        mask = EmitVectorInsert(context, mask, Const(maskE1), 1, 3);
-                    }
-
-                    if (op.Size < 3)
-                    {
-                        d = context.AddIntrinsic(Intrinsic.X86Pshufb, d, mask);
-                        m = context.AddIntrinsic(Intrinsic.X86Pshufb, m, mask);
-                    }
-
-                    Operand resD = context.AddIntrinsic(X86PunpcklInstruction[op.Size], d, m);
-                    Operand resM = context.AddIntrinsic(X86PunpckhInstruction[op.Size], d, m);
-
-                    return (resM, resD);
-                });
-            }
-            else
-            {
-                int elems = op.GetBytesCount() >> op.Size;
-                int pairs = elems >> 1;
-
-                bool overlap = op.Qm == op.Qd;
-
-                Operand resD = GetVecA32(op.Qd);
-                Operand resM = GetVecA32(op.Qm);
-
-                for (int index = 0; index < pairs; index++)
-                {
-                    int pairIndex = index << 1;
-                    Operand d2 = EmitVectorExtract32(context, op.Qd, pairIndex + 1 + op.Id, op.Size, false);
-                    Operand m1 = EmitVectorExtract32(context, op.Qm, pairIndex + op.Im, op.Size, false);
-
-                    resD = EmitVectorInsert(context, resD, m1, pairIndex + 1 + op.Id, op.Size);
-
-                    if (overlap)
-                    {
-                        resM = resD;
-                    }
-
-                    resM = EmitVectorInsert(context, resM, d2, pairIndex + op.Im, op.Size);
-
-                    if (overlap)
-                    {
-                        resD = resM;
-                    }
-                }
-
-                context.Copy(GetVecA32(op.Qd), resD);
-                if (!overlap)
-                {
-                    context.Copy(GetVecA32(op.Qm), resM);
-                }
-            }
-        }
-
-        public static void Vzip(ArmEmitterContext context)
-        {
-            OpCode32SimdCmpZ op = (OpCode32SimdCmpZ)context.CurrOp;
-
-            if (Optimizations.UseAdvSimd)
-            {
-                EmitVectorZipUzpOpSimd32(context, Intrinsic.Arm64Zip1V, Intrinsic.Arm64Zip2V);
-            }
-            else if (Optimizations.UseSse2)
-            {
-                EmitVectorShuffleOpSimd32(context, (m, d) =>
-                {
-                    if (op.RegisterSize == RegisterSize.Simd128)
-                    {
-                        Operand resD = context.AddIntrinsic(X86PunpcklInstruction[op.Size], d, m);
-                        Operand resM = context.AddIntrinsic(X86PunpckhInstruction[op.Size], d, m);
-
-                        return (resM, resD);
-                    }
-                    else
-                    {
-                        Operand res = context.AddIntrinsic(X86PunpcklInstruction[op.Size], d, m);
-
-                        Operand resD = context.AddIntrinsic(Intrinsic.X86Punpcklqdq, res, context.VectorZero());
-                        Operand resM = context.AddIntrinsic(Intrinsic.X86Punpckhqdq, res, context.VectorZero());
-                        return (resM, resD);
-                    }
-                });
-            }
-            else
-            {
-                int elems = op.GetBytesCount() >> op.Size;
-                int pairs = elems >> 1;
-
-                bool overlap = op.Qm == op.Qd;
-
-                Operand resD = GetVecA32(op.Qd);
-                Operand resM = GetVecA32(op.Qm);
-
-                for (int index = 0; index < pairs; index++)
-                {
-                    int pairIndex = index << 1;
-                    Operand dRowD = EmitVectorExtract32(context, op.Qd, index + op.Id, op.Size, false);
-                    Operand mRowD = EmitVectorExtract32(context, op.Qm, index + op.Im, op.Size, false);
-
-                    Operand dRowM = EmitVectorExtract32(context, op.Qd, index + op.Id + pairs, op.Size, false);
-                    Operand mRowM = EmitVectorExtract32(context, op.Qm, index + op.Im + pairs, op.Size, false);
-
-                    resD = EmitVectorInsert(context, resD, dRowD, pairIndex + op.Id, op.Size);
-                    resD = EmitVectorInsert(context, resD, mRowD, pairIndex + 1 + op.Id, op.Size);
-
-                    if (overlap)
-                    {
-                        resM = resD;
-                    }
-
-                    resM = EmitVectorInsert(context, resM, dRowM, pairIndex + op.Im, op.Size);
-                    resM = EmitVectorInsert(context, resM, mRowM, pairIndex + 1 + op.Im, op.Size);
-
-                    if (overlap)
-                    {
-                        resD = resM;
-                    }
-                }
-
-                context.Copy(GetVecA32(op.Qd), resD);
-                if (!overlap)
-                {
-                    context.Copy(GetVecA32(op.Qm), resM);
-                }
-            }
-        }
-
-        public static void Vuzp(ArmEmitterContext context)
-        {
-            OpCode32SimdCmpZ op = (OpCode32SimdCmpZ)context.CurrOp;
-
-            if (Optimizations.UseAdvSimd)
-            {
-                EmitVectorZipUzpOpSimd32(context, Intrinsic.Arm64Uzp1V, Intrinsic.Arm64Uzp2V);
-            }
-            else if (Optimizations.UseSsse3)
-            {
-                EmitVectorShuffleOpSimd32(context, (m, d) =>
-                {
-                    if (op.RegisterSize == RegisterSize.Simd128)
-                    {
-                        Operand mask = default;
-
-                        if (op.Size < 3)
-                        {
-                            long maskE0 = EvenMasks[op.Size];
-                            long maskE1 = OddMasks[op.Size];
-
-                            mask = X86GetScalar(context, maskE0);
-                            mask = EmitVectorInsert(context, mask, Const(maskE1), 1, 3);
-
-                            d = context.AddIntrinsic(Intrinsic.X86Pshufb, d, mask);
-                            m = context.AddIntrinsic(Intrinsic.X86Pshufb, m, mask);
-                        }
-
-                        Operand resD = context.AddIntrinsic(Intrinsic.X86Punpcklqdq, d, m);
-                        Operand resM = context.AddIntrinsic(Intrinsic.X86Punpckhqdq, d, m);
-
-                        return (resM, resD);
-                    }
-                    else
-                    {
-                        Intrinsic punpcklInst = X86PunpcklInstruction[op.Size];
-
-                        Operand res = context.AddIntrinsic(punpcklInst, d, m);
-
-                        if (op.Size < 2)
-                        {
-                            long maskE0 = _masksE0_Uzp[op.Size];
-                            long maskE1 = _masksE1_Uzp[op.Size];
-
-                            Operand mask = X86GetScalar(context, maskE0);
-
-                            mask = EmitVectorInsert(context, mask, Const(maskE1), 1, 3);
-
-                            res = context.AddIntrinsic(Intrinsic.X86Pshufb, res, mask);
-                        }
-
-                        Operand resD = context.AddIntrinsic(Intrinsic.X86Punpcklqdq, res, context.VectorZero());
-                        Operand resM = context.AddIntrinsic(Intrinsic.X86Punpckhqdq, res, context.VectorZero());
-
-                        return (resM, resD);
-                    }
-                });
-            }
-            else
-            {
-                int elems = op.GetBytesCount() >> op.Size;
-                int pairs = elems >> 1;
-
-                bool overlap = op.Qm == op.Qd;
-
-                Operand resD = GetVecA32(op.Qd);
-                Operand resM = GetVecA32(op.Qm);
-
-                for (int index = 0; index < elems; index++)
-                {
-                    Operand dIns, mIns;
-                    if (index >= pairs)
-                    {
-                        int pairIndex = index - pairs;
-                        dIns = EmitVectorExtract32(context, op.Qm, (pairIndex << 1) + op.Im, op.Size, false);
-                        mIns = EmitVectorExtract32(context, op.Qm, ((pairIndex << 1) | 1) + op.Im, op.Size, false);
-                    }
-                    else
-                    {
-                        dIns = EmitVectorExtract32(context, op.Qd, (index << 1) + op.Id, op.Size, false);
-                        mIns = EmitVectorExtract32(context, op.Qd, ((index << 1) | 1) + op.Id, op.Size, false);
-                    }
-
-                    resD = EmitVectorInsert(context, resD, dIns, index + op.Id, op.Size);
-
-                    if (overlap)
-                    {
-                        resM = resD;
-                    }
-
-                    resM = EmitVectorInsert(context, resM, mIns, index + op.Im, op.Size);
-
-                    if (overlap)
-                    {
-                        resD = resM;
-                    }
-                }
-
-                context.Copy(GetVecA32(op.Qd), resD);
-                if (!overlap)
-                {
-                    context.Copy(GetVecA32(op.Qm), resM);
-                }
-            }
-        }
-
-        private static void EmitVectorZipUzpOpSimd32(ArmEmitterContext context, Intrinsic inst1, Intrinsic inst2)
-        {
-            OpCode32SimdCmpZ op = (OpCode32SimdCmpZ)context.CurrOp;
-
-            bool overlap = op.Qm == op.Qd;
-
-            Operand d = GetVecA32(op.Qd);
-            Operand m = GetVecA32(op.Qm);
-
-            Operand dPart = d;
-            Operand mPart = m;
-
-            if (!op.Q) // Register swap: move relevant doubleword to destination side.
-            {
-                dPart = InstEmitSimdHelper32Arm64.EmitMoveDoubleWordToSide(context, d, op.Vd, 0);
-                mPart = InstEmitSimdHelper32Arm64.EmitMoveDoubleWordToSide(context, m, op.Vm, 0);
-            }
-
-            Intrinsic vSize = op.Q ? Intrinsic.Arm64V128 : Intrinsic.Arm64V64;
-
-            vSize |= (Intrinsic)(op.Size << (int)Intrinsic.Arm64VSizeShift);
-
-            Operand resD = context.AddIntrinsic(inst1 | vSize, dPart, mPart);
-            Operand resM = context.AddIntrinsic(inst2 | vSize, dPart, mPart);
-
-            if (!op.Q) // Register insert.
-            {
-                resD = context.AddIntrinsic(Intrinsic.Arm64InsVe | Intrinsic.Arm64VDWord, d, Const(op.Vd & 1), resD, Const(0));
-
-                if (overlap)
-                {
-                    resD = context.AddIntrinsic(Intrinsic.Arm64InsVe | Intrinsic.Arm64VDWord, resD, Const(op.Vm & 1), resM, Const(0));
-                }
-                else
-                {
-                    resM = context.AddIntrinsic(Intrinsic.Arm64InsVe | Intrinsic.Arm64VDWord, m, Const(op.Vm & 1), resM, Const(0));
-                }
-            }
-
-            context.Copy(d, resD);
-            if (!overlap)
-            {
-                context.Copy(m, resM);
-            }
-        }
-
-        private static void EmitVectorShuffleOpSimd32(ArmEmitterContext context, Func<Operand, Operand, (Operand, Operand)> shuffleFunc)
-        {
-            OpCode32Simd op = (OpCode32Simd)context.CurrOp;
-
-            Operand m = GetVecA32(op.Qm);
-            Operand d = GetVecA32(op.Qd);
-            Operand initialM = m;
-            Operand initialD = d;
-
-            if (!op.Q) // Register swap: move relevant doubleword to side 0, for consistency.
-            {
-                m = EmitMoveDoubleWordToSide(context, m, op.Vm, 0);
-                d = EmitMoveDoubleWordToSide(context, d, op.Vd, 0);
-            }
-
-            (Operand resM, Operand resD) = shuffleFunc(m, d);
-
-            bool overlap = op.Qm == op.Qd;
-
-            if (!op.Q) // Register insert.
-            {
-                resM = EmitDoubleWordInsert(context, initialM, EmitMoveDoubleWordToSide(context, resM, 0, op.Vm), op.Vm);
-                resD = EmitDoubleWordInsert(context, overlap ? resM : initialD, EmitMoveDoubleWordToSide(context, resD, 0, op.Vd), op.Vd);
-            }
-
-            if (!overlap)
-            {
-                context.Copy(initialM, resM);
-            }
-
-            context.Copy(initialD, resD);
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitSystem.cs

@@ -1,215 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.State;
-using ARMeilleure.Translation;
-using System;
-using System.Reflection;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static partial class InstEmit
-    {
-        private const int DczSizeLog2 = 4; // Log2 size in words
-        public const int DczSizeInBytes = 4 << DczSizeLog2;
-
-        public static void Isb(ArmEmitterContext context)
-        {
-            // Execute as no-op.
-        }
-
-        public static void Mrs(ArmEmitterContext context)
-        {
-            OpCodeSystem op = (OpCodeSystem)context.CurrOp;
-
-            MethodInfo info;
-
-            switch (GetPackedId(op))
-            {
-                case 0b11_011_0000_0000_001: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCtrEl0)); break;
-                case 0b11_011_0000_0000_111: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetDczidEl0)); break;
-                case 0b11_011_0100_0010_000: EmitGetNzcv(context); return;
-                case 0b11_011_0100_0100_000: EmitGetFpcr(context); return;
-                case 0b11_011_0100_0100_001: EmitGetFpsr(context); return;
-                case 0b11_011_1101_0000_010: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidrEl0)); break;
-                case 0b11_011_1101_0000_011: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidrroEl0)); break;
-                case 0b11_011_1110_0000_000: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntfrqEl0)); break;
-                case 0b11_011_1110_0000_001: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntpctEl0)); break;
-                case 0b11_011_1110_0000_010: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntvctEl0)); break;
-
-                default: throw new NotImplementedException($"Unknown MRS 0x{op.RawOpCode:X8} at 0x{op.Address:X16}.");
-            }
-
-            SetIntOrZR(context, op.Rt, context.Call(info));
-        }
-
-        public static void Msr(ArmEmitterContext context)
-        {
-            OpCodeSystem op = (OpCodeSystem)context.CurrOp;
-
-            MethodInfo info;
-
-            switch (GetPackedId(op))
-            {
-                case 0b11_011_0100_0010_000: EmitSetNzcv(context); return;
-                case 0b11_011_0100_0100_000: EmitSetFpcr(context); return;
-                case 0b11_011_0100_0100_001: EmitSetFpsr(context); return;
-                case 0b11_011_1101_0000_010: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.SetTpidrEl0)); break;
-
-                default: throw new NotImplementedException($"Unknown MSR 0x{op.RawOpCode:X8} at 0x{op.Address:X16}.");
-            }
-
-            context.Call(info, GetIntOrZR(context, op.Rt));
-        }
-
-        public static void Nop(ArmEmitterContext context)
-        {
-            // Do nothing.
-        }
-
-        public static void Sys(ArmEmitterContext context)
-        {
-            // This instruction is used to do some operations on the CPU like cache invalidation,
-            // address translation and the like.
-            // We treat it as no-op here since we don't have any cache being emulated anyway.
-            OpCodeSystem op = (OpCodeSystem)context.CurrOp;
-
-            switch (GetPackedId(op))
-            {
-                case 0b11_011_0111_0100_001:
-                {
-                    // DC ZVA
-                    Operand t = GetIntOrZR(context, op.Rt);
-
-                    for (long offset = 0; offset < DczSizeInBytes; offset += 8)
-                    {
-                        Operand address = context.Add(t, Const(offset));
-
-                        InstEmitMemoryHelper.EmitStore(context, address, RegisterConsts.ZeroIndex, 3);
-                    }
-
-                    break;
-                }
-
-                // No-op
-                case 0b11_011_0111_1110_001: // DC CIVAC
-                    break;
-
-                case 0b11_011_0111_0101_001: // IC IVAU
-                    Operand target = Register(op.Rt, RegisterType.Integer, OperandType.I64);
-                    context.Call(typeof(NativeInterface).GetMethod(nameof(NativeInterface.InvalidateCacheLine)), target);
-                    break;
-            }
-        }
-
-        private static int GetPackedId(OpCodeSystem op)
-        {
-            int id;
-
-            id  = op.Op2 << 0;
-            id |= op.CRm << 3;
-            id |= op.CRn << 7;
-            id |= op.Op1 << 11;
-            id |= op.Op0 << 14;
-
-            return id;
-        }
-
-        private static void EmitGetNzcv(ArmEmitterContext context)
-        {
-            OpCodeSystem op = (OpCodeSystem)context.CurrOp;
-
-            Operand nzcv = context.ShiftLeft(GetFlag(PState.VFlag), Const((int)PState.VFlag));
-            nzcv = context.BitwiseOr(nzcv, context.ShiftLeft(GetFlag(PState.CFlag), Const((int)PState.CFlag)));
-            nzcv = context.BitwiseOr(nzcv, context.ShiftLeft(GetFlag(PState.ZFlag), Const((int)PState.ZFlag)));
-            nzcv = context.BitwiseOr(nzcv, context.ShiftLeft(GetFlag(PState.NFlag), Const((int)PState.NFlag)));
-
-            SetIntOrZR(context, op.Rt, nzcv);
-        }
-
-        private static void EmitGetFpcr(ArmEmitterContext context)
-        {
-            OpCodeSystem op = (OpCodeSystem)context.CurrOp;
-
-            Operand fpcr = Const(0);
-
-            for (int flag = 0; flag < RegisterConsts.FpFlagsCount; flag++)
-            {
-                if (FPCR.Mask.HasFlag((FPCR)(1u << flag)))
-                {
-                    fpcr = context.BitwiseOr(fpcr, context.ShiftLeft(GetFpFlag((FPState)flag), Const(flag)));
-                }
-            }
-
-            SetIntOrZR(context, op.Rt, fpcr);
-        }
-
-        private static void EmitGetFpsr(ArmEmitterContext context)
-        {
-            OpCodeSystem op = (OpCodeSystem)context.CurrOp;
-
-            context.SyncQcFlag();
-
-            Operand fpsr = Const(0);
-
-            for (int flag = 0; flag < RegisterConsts.FpFlagsCount; flag++)
-            {
-                if (FPSR.Mask.HasFlag((FPSR)(1u << flag)))
-                {
-                    fpsr = context.BitwiseOr(fpsr, context.ShiftLeft(GetFpFlag((FPState)flag), Const(flag)));
-                }
-            }
-
-            SetIntOrZR(context, op.Rt, fpsr);
-        }
-
-        private static void EmitSetNzcv(ArmEmitterContext context)
-        {
-            OpCodeSystem op = (OpCodeSystem)context.CurrOp;
-
-            Operand nzcv = GetIntOrZR(context, op.Rt);
-                    nzcv = context.ConvertI64ToI32(nzcv);
-
-            SetFlag(context, PState.VFlag, context.BitwiseAnd(context.ShiftRightUI(nzcv, Const((int)PState.VFlag)), Const(1)));
-            SetFlag(context, PState.CFlag, context.BitwiseAnd(context.ShiftRightUI(nzcv, Const((int)PState.CFlag)), Const(1)));
-            SetFlag(context, PState.ZFlag, context.BitwiseAnd(context.ShiftRightUI(nzcv, Const((int)PState.ZFlag)), Const(1)));
-            SetFlag(context, PState.NFlag, context.BitwiseAnd(context.ShiftRightUI(nzcv, Const((int)PState.NFlag)), Const(1)));
-        }
-
-        private static void EmitSetFpcr(ArmEmitterContext context)
-        {
-            OpCodeSystem op = (OpCodeSystem)context.CurrOp;
-
-            Operand fpcr = GetIntOrZR(context, op.Rt);
-                    fpcr = context.ConvertI64ToI32(fpcr);
-
-            for (int flag = 0; flag < RegisterConsts.FpFlagsCount; flag++)
-            {
-                if (FPCR.Mask.HasFlag((FPCR)(1u << flag)))
-                {
-                    SetFpFlag(context, (FPState)flag, context.BitwiseAnd(context.ShiftRightUI(fpcr, Const(flag)), Const(1)));
-                }
-            }
-        }
-
-        private static void EmitSetFpsr(ArmEmitterContext context)
-        {
-            OpCodeSystem op = (OpCodeSystem)context.CurrOp;
-
-            context.ClearQcFlagIfModified();
-
-            Operand fpsr = GetIntOrZR(context, op.Rt);
-                    fpsr = context.ConvertI64ToI32(fpsr);
-
-            for (int flag = 0; flag < RegisterConsts.FpFlagsCount; flag++)
-            {
-                if (FPSR.Mask.HasFlag((FPSR)(1u << flag)))
-                {
-                    SetFpFlag(context, (FPState)flag, context.BitwiseAnd(context.ShiftRightUI(fpsr, Const(flag)), Const(1)));
-                }
-            }
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitSystem32.cs

@@ -1,326 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.State;
-using ARMeilleure.Translation;
-using System;
-using System.Reflection;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static partial class InstEmit32
-    {
-        public static void Mcr(ArmEmitterContext context)
-        {
-            OpCode32System op = (OpCode32System)context.CurrOp;
-
-            if (op.Coproc != 15 || op.Opc1 != 0)
-            {
-                InstEmit.Und(context);
-
-                return;
-            }
-
-            MethodInfo info;
-
-            switch (op.CRn)
-            {
-                case 13: // Process and Thread Info.
-                    if (op.CRm != 0)
-                    {
-                        throw new NotImplementedException($"Unknown MRC CRm 0x{op.CRm:X} at 0x{op.Address:X} (0x{op.RawOpCode:X}).");
-                    }
-
-                    switch (op.Opc2)
-                    {
-                        case 2:
-                            info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.SetTpidrEl032)); break;
-
-                        default:
-                            throw new NotImplementedException($"Unknown MRC Opc2 0x{op.Opc2:X} at 0x{op.Address:X} (0x{op.RawOpCode:X}).");
-                    }
-
-                    break;
-
-                case 7:
-                    switch (op.CRm) // Cache and Memory barrier.
-                    {
-                        case 10:
-                            switch (op.Opc2)
-                            {
-                                case 5: // Data Memory Barrier Register.
-                                    return; // No-op.
-
-                                default:
-                                    throw new NotImplementedException($"Unknown MRC Opc2 0x{op.Opc2:X16} at 0x{op.Address:X16} (0x{op.RawOpCode:X}).");
-                            }
-
-                        default:
-                            throw new NotImplementedException($"Unknown MRC CRm 0x{op.CRm:X16} at 0x{op.Address:X16} (0x{op.RawOpCode:X}).");
-                    }
-
-                default:
-                    throw new NotImplementedException($"Unknown MRC 0x{op.RawOpCode:X8} at 0x{op.Address:X16}.");
-            }
-
-            context.Call(info, GetIntA32(context, op.Rt));
-        }
-
-        public static void Mrc(ArmEmitterContext context)
-        {
-            OpCode32System op = (OpCode32System)context.CurrOp;
-
-            if (op.Coproc != 15 || op.Opc1 != 0)
-            {
-                InstEmit.Und(context);
-
-                return;
-            }
-
-            MethodInfo info;
-
-            switch (op.CRn)
-            {
-                case 13: // Process and Thread Info.
-                    if (op.CRm != 0)
-                    {
-                        throw new NotImplementedException($"Unknown MRC CRm 0x{op.CRm:X} at 0x{op.Address:X} (0x{op.RawOpCode:X}).");
-                    }
-
-                    switch (op.Opc2)
-                    {
-                        case 2:
-                            info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidrEl032)); break;
-
-                        case 3:
-                            info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidr32)); break;
-
-                        default:
-                            throw new NotImplementedException($"Unknown MRC Opc2 0x{op.Opc2:X} at 0x{op.Address:X} (0x{op.RawOpCode:X}).");
-                    }
-
-                    break;
-
-                default:
-                    throw new NotImplementedException($"Unknown MRC 0x{op.RawOpCode:X} at 0x{op.Address:X}.");
-            }
-
-            if (op.Rt == RegisterAlias.Aarch32Pc)
-            {
-                // Special behavior: copy NZCV flags into APSR.
-                EmitSetNzcv(context, context.Call(info));
-
-                return;
-            }
-            else
-            {
-                SetIntA32(context, op.Rt, context.Call(info));
-            }
-        }
-
-        public static void Mrrc(ArmEmitterContext context)
-        {
-            OpCode32System op = (OpCode32System)context.CurrOp;
-
-            if (op.Coproc != 15)
-            {
-                InstEmit.Und(context);
-
-                return;
-            }
-
-            int opc = op.MrrcOp;
-
-            MethodInfo info;
-
-            switch (op.CRm)
-            {
-                case 14: // Timer.
-                    switch (opc)
-                    {
-                        case 0:
-                            info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntpctEl0)); break;
-
-                        default:
-                            throw new NotImplementedException($"Unknown MRRC Opc1 0x{opc:X} at 0x{op.Address:X} (0x{op.RawOpCode:X}).");
-                    }
-
-                    break;
-
-                default:
-                    throw new NotImplementedException($"Unknown MRRC 0x{op.RawOpCode:X} at 0x{op.Address:X}.");
-            }
-
-            Operand result = context.Call(info);
-
-            SetIntA32(context, op.Rt, context.ConvertI64ToI32(result));
-            SetIntA32(context, op.CRn, context.ConvertI64ToI32(context.ShiftRightUI(result, Const(32))));
-        }
-
-        public static void Mrs(ArmEmitterContext context)
-        {
-            OpCode32Mrs op = (OpCode32Mrs)context.CurrOp;
-
-            if (op.R)
-            {
-                throw new NotImplementedException("SPSR");
-            }
-            else
-            {
-                Operand spsr = context.ShiftLeft(GetFlag(PState.VFlag), Const((int)PState.VFlag));
-                spsr = context.BitwiseOr(spsr, context.ShiftLeft(GetFlag(PState.CFlag), Const((int)PState.CFlag)));
-                spsr = context.BitwiseOr(spsr, context.ShiftLeft(GetFlag(PState.ZFlag), Const((int)PState.ZFlag)));
-                spsr = context.BitwiseOr(spsr, context.ShiftLeft(GetFlag(PState.NFlag), Const((int)PState.NFlag)));
-                spsr = context.BitwiseOr(spsr, context.ShiftLeft(GetFlag(PState.QFlag), Const((int)PState.QFlag)));
-
-                // TODO: Remaining flags.
-
-                SetIntA32(context, op.Rd, spsr);
-            }
-        }
-
-        public static void Msr(ArmEmitterContext context)
-        {
-            OpCode32MsrReg op = (OpCode32MsrReg)context.CurrOp;
-
-            if (op.R)
-            {
-                throw new NotImplementedException("SPSR");
-            }
-            else
-            {
-                if ((op.Mask & 8) != 0)
-                {
-                    Operand value = GetIntA32(context, op.Rn);
-
-                    EmitSetNzcv(context, value);
-
-                    Operand q = context.BitwiseAnd(context.ShiftRightUI(value, Const((int)PState.QFlag)), Const(1));
-
-                    SetFlag(context, PState.QFlag, q);
-                }
-
-                if ((op.Mask & 4) != 0)
-                {
-                    throw new NotImplementedException("APSR_g");
-                }
-
-                if ((op.Mask & 2) != 0)
-                {
-                    throw new NotImplementedException("CPSR_x");
-                }
-
-                if ((op.Mask & 1) != 0)
-                {
-                    throw new NotImplementedException("CPSR_c");
-                }
-            }
-        }
-
-        public static void Nop(ArmEmitterContext context) { }
-
-        public static void Vmrs(ArmEmitterContext context)
-        {
-            OpCode32SimdSpecial op = (OpCode32SimdSpecial)context.CurrOp;
-
-            if (op.Rt == RegisterAlias.Aarch32Pc && op.Sreg == 0b0001)
-            {
-                // Special behavior: copy NZCV flags into APSR.
-                SetFlag(context, PState.VFlag, GetFpFlag(FPState.VFlag));
-                SetFlag(context, PState.CFlag, GetFpFlag(FPState.CFlag));
-                SetFlag(context, PState.ZFlag, GetFpFlag(FPState.ZFlag));
-                SetFlag(context, PState.NFlag, GetFpFlag(FPState.NFlag));
-
-                return;
-            }
-
-            switch (op.Sreg)
-            {
-                case 0b0000: // FPSID
-                    throw new NotImplementedException("Supervisor Only");
-                case 0b0001: // FPSCR
-                    EmitGetFpscr(context); return;
-                case 0b0101: // MVFR2
-                    throw new NotImplementedException("MVFR2");
-                case 0b0110: // MVFR1
-                    throw new NotImplementedException("MVFR1");
-                case 0b0111: // MVFR0
-                    throw new NotImplementedException("MVFR0");
-                case 0b1000: // FPEXC
-                    throw new NotImplementedException("Supervisor Only");
-                default:
-                    throw new NotImplementedException($"Unknown VMRS 0x{op.RawOpCode:X} at 0x{op.Address:X}.");
-            }
-        }
-
-        public static void Vmsr(ArmEmitterContext context)
-        {
-            OpCode32SimdSpecial op = (OpCode32SimdSpecial)context.CurrOp;
-
-            switch (op.Sreg)
-            {
-                case 0b0000: // FPSID
-                    throw new NotImplementedException("Supervisor Only");
-                case 0b0001: // FPSCR
-                    EmitSetFpscr(context); return;
-                case 0b0101: // MVFR2
-                    throw new NotImplementedException("MVFR2");
-                case 0b0110: // MVFR1
-                    throw new NotImplementedException("MVFR1");
-                case 0b0111: // MVFR0
-                    throw new NotImplementedException("MVFR0");
-                case 0b1000: // FPEXC
-                    throw new NotImplementedException("Supervisor Only");
-                default:
-                    throw new NotImplementedException($"Unknown VMSR 0x{op.RawOpCode:X} at 0x{op.Address:X}.");
-            }
-        }
-
-        private static void EmitSetNzcv(ArmEmitterContext context, Operand t)
-        {
-            Operand v = context.BitwiseAnd(context.ShiftRightUI(t, Const((int)PState.VFlag)), Const(1));
-            Operand c = context.BitwiseAnd(context.ShiftRightUI(t, Const((int)PState.CFlag)), Const(1));
-            Operand z = context.BitwiseAnd(context.ShiftRightUI(t, Const((int)PState.ZFlag)), Const(1));
-            Operand n = context.BitwiseAnd(context.ShiftRightUI(t, Const((int)PState.NFlag)), Const(1));
-
-            SetFlag(context, PState.VFlag, v);
-            SetFlag(context, PState.CFlag, c);
-            SetFlag(context, PState.ZFlag, z);
-            SetFlag(context, PState.NFlag, n);
-        }
-
-        private static void EmitGetFpscr(ArmEmitterContext context)
-        {
-            OpCode32SimdSpecial op = (OpCode32SimdSpecial)context.CurrOp;
-
-            Operand fpscr = Const(0);
-
-            for (int flag = 0; flag < RegisterConsts.FpFlagsCount; flag++)
-            {
-                if (FPSCR.Mask.HasFlag((FPSCR)(1u << flag)))
-                {
-                    fpscr = context.BitwiseOr(fpscr, context.ShiftLeft(GetFpFlag((FPState)flag), Const(flag)));
-                }
-            }
-
-            SetIntA32(context, op.Rt, fpscr);
-        }
-
-        private static void EmitSetFpscr(ArmEmitterContext context)
-        {
-            OpCode32SimdSpecial op = (OpCode32SimdSpecial)context.CurrOp;
-
-            Operand fpscr = GetIntA32(context, op.Rt);
-
-            for (int flag = 0; flag < RegisterConsts.FpFlagsCount; flag++)
-            {
-                if (FPSCR.Mask.HasFlag((FPSCR)(1u << flag)))
-                {
-                    SetFpFlag(context, (FPState)flag, context.BitwiseAnd(context.ShiftRightUI(fpscr, Const(flag)), Const(1)));
-                }
-            }
-        }
-    }
-}

ARMeilleure/Instructions/NativeInterface.cs

@@ -1,225 +0,0 @@
-using ARMeilleure.Memory;
-using ARMeilleure.State;
-using ARMeilleure.Translation;
-using System;
-
-namespace ARMeilleure.Instructions
-{
-    static class NativeInterface
-    {
-        private class ThreadContext
-        {
-            public ExecutionContext Context { get; }
-            public IMemoryManager Memory { get; }
-            public Translator Translator { get; }
-
-            public ThreadContext(ExecutionContext context, IMemoryManager memory, Translator translator)
-            {
-                Context = context;
-                Memory = memory;
-                Translator = translator;
-            }
-        }
-
-        [ThreadStatic]
-        private static ThreadContext Context;
-
-        public static void RegisterThread(ExecutionContext context, IMemoryManager memory, Translator translator)
-        {
-            Context = new ThreadContext(context, memory, translator);
-        }
-
-        public static void UnregisterThread()
-        {
-            Context = null;
-        }
-
-        public static void Break(ulong address, int imm)
-        {
-            Statistics.PauseTimer();
-
-            GetContext().OnBreak(address, imm);
-
-            Statistics.ResumeTimer();
-        }
-
-        public static void SupervisorCall(ulong address, int imm)
-        {
-            Statistics.PauseTimer();
-
-            GetContext().OnSupervisorCall(address, imm);
-
-            Statistics.ResumeTimer();
-        }
-
-        public static void Undefined(ulong address, int opCode)
-        {
-            Statistics.PauseTimer();
-
-            GetContext().OnUndefined(address, opCode);
-
-            Statistics.ResumeTimer();
-        }
-
-        #region "System registers"
-        public static ulong GetCtrEl0()
-        {
-            return (ulong)GetContext().CtrEl0;
-        }
-
-        public static ulong GetDczidEl0()
-        {
-            return (ulong)GetContext().DczidEl0;
-        }
-
-        public static ulong GetTpidrEl0()
-        {
-            return (ulong)GetContext().TpidrEl0;
-        }
-
-        public static uint GetTpidrEl032()
-        {
-            return (uint)GetContext().TpidrEl0;
-        }
-
-        public static ulong GetTpidrroEl0()
-        {
-            return (ulong)GetContext().TpidrroEl0;
-        }
-
-        public static uint GetTpidr32()
-        {
-            return (uint)GetContext().TpidrroEl0;
-        }
-
-        public static ulong GetCntfrqEl0()
-        {
-            return GetContext().CntfrqEl0;
-        }
-
-        public static ulong GetCntpctEl0()
-        {
-            return GetContext().CntpctEl0;
-        }
-
-        public static ulong GetCntvctEl0()
-        {
-            return GetContext().CntvctEl0;
-        }
-
-        public static void SetTpidrEl0(ulong value)
-        {
-            GetContext().TpidrEl0 = (long)value;
-        }
-
-        public static void SetTpidrEl032(uint value)
-        {
-            GetContext().TpidrEl0 = (long)value;
-        }
-        #endregion
-
-        #region "Read"
-        public static byte ReadByte(ulong address)
-        {
-            return GetMemoryManager().ReadTracked<byte>(address);
-        }
-
-        public static ushort ReadUInt16(ulong address)
-        {
-            return GetMemoryManager().ReadTracked<ushort>(address);
-        }
-
-        public static uint ReadUInt32(ulong address)
-        {
-            return GetMemoryManager().ReadTracked<uint>(address);
-        }
-
-        public static ulong ReadUInt64(ulong address)
-        {
-            return GetMemoryManager().ReadTracked<ulong>(address);
-        }
-
-        public static V128 ReadVector128(ulong address)
-        {
-            return GetMemoryManager().ReadTracked<V128>(address);
-        }
-        #endregion
-
-        #region "Write"
-        public static void WriteByte(ulong address, byte value)
-        {
-            GetMemoryManager().Write(address, value);
-        }
-
-        public static void WriteUInt16(ulong address, ushort value)
-        {
-            GetMemoryManager().Write(address, value);
-        }
-
-        public static void WriteUInt32(ulong address, uint value)
-        {
-            GetMemoryManager().Write(address, value);
-        }
-
-        public static void WriteUInt64(ulong address, ulong value)
-        {
-            GetMemoryManager().Write(address, value);
-        }
-
-        public static void WriteVector128(ulong address, V128 value)
-        {
-            GetMemoryManager().Write(address, value);
-        }
-        #endregion
-
-        public static void EnqueueForRejit(ulong address)
-        {
-            Context.Translator.EnqueueForRejit(address, GetContext().ExecutionMode);
-        }
-
-        public static void SignalMemoryTracking(ulong address, ulong size, bool write)
-        {
-            GetMemoryManager().SignalMemoryTracking(address, size, write);
-        }
-
-        public static void ThrowInvalidMemoryAccess(ulong address)
-        {
-            throw new InvalidAccessException(address);
-        }
-
-        public static ulong GetFunctionAddress(ulong address)
-        {
-            TranslatedFunction function = Context.Translator.GetOrTranslate(address, GetContext().ExecutionMode);
-
-            return (ulong)function.FuncPointer.ToInt64();
-        }
-
-        public static void InvalidateCacheLine(ulong address)
-        {
-            Context.Translator.InvalidateJitCacheRegion(address, InstEmit.DczSizeInBytes);
-        }
-
-        public static bool CheckSynchronization()
-        {
-            Statistics.PauseTimer();
-
-            ExecutionContext context = GetContext();
-
-            context.CheckInterrupt();
-
-            Statistics.ResumeTimer();
-
-            return context.Running;
-        }
-
-        public static ExecutionContext GetContext()
-        {
-            return Context.Context;
-        }
-
-        public static IMemoryManager GetMemoryManager()
-        {
-            return Context.Memory;
-        }
-    }
-}

ARMeilleure/IntermediateRepresentation/Intrinsic.cs

@@ -1,631 +0,0 @@
-namespace ARMeilleure.IntermediateRepresentation
-{
-    enum Intrinsic : ushort
-    {
-        // X86 (SSE and AVX)
-
-        X86Addpd,
-        X86Addps,
-        X86Addsd,
-        X86Addss,
-        X86Aesdec,
-        X86Aesdeclast,
-        X86Aesenc,
-        X86Aesenclast,
-        X86Aesimc,
-        X86Andnpd,
-        X86Andnps,
-        X86Andpd,
-        X86Andps,
-        X86Blendvpd,
-        X86Blendvps,
-        X86Cmppd,
-        X86Cmpps,
-        X86Cmpsd,
-        X86Cmpss,
-        X86Comisdeq,
-        X86Comisdge,
-        X86Comisdlt,
-        X86Comisseq,
-        X86Comissge,
-        X86Comisslt,
-        X86Crc32,
-        X86Crc32_16,
-        X86Crc32_8,
-        X86Cvtdq2pd,
-        X86Cvtdq2ps,
-        X86Cvtpd2dq,
-        X86Cvtpd2ps,
-        X86Cvtps2dq,
-        X86Cvtps2pd,
-        X86Cvtsd2si,
-        X86Cvtsd2ss,
-        X86Cvtsi2sd,
-        X86Cvtsi2si,
-        X86Cvtsi2ss,
-        X86Cvtss2sd,
-        X86Cvtss2si,
-        X86Divpd,
-        X86Divps,
-        X86Divsd,
-        X86Divss,
-        X86Gf2p8affineqb,
-        X86Haddpd,
-        X86Haddps,
-        X86Insertps,
-        X86Maxpd,
-        X86Maxps,
-        X86Maxsd,
-        X86Maxss,
-        X86Minpd,
-        X86Minps,
-        X86Minsd,
-        X86Minss,
-        X86Movhlps,
-        X86Movlhps,
-        X86Movss,
-        X86Mulpd,
-        X86Mulps,
-        X86Mulsd,
-        X86Mulss,
-        X86Mxcsrmb,
-        X86Mxcsrub,
-        X86Paddb,
-        X86Paddd,
-        X86Paddq,
-        X86Paddw,
-        X86Palignr,
-        X86Pand,
-        X86Pandn,
-        X86Pavgb,
-        X86Pavgw,
-        X86Pblendvb,
-        X86Pclmulqdq,
-        X86Pcmpeqb,
-        X86Pcmpeqd,
-        X86Pcmpeqq,
-        X86Pcmpeqw,
-        X86Pcmpgtb,
-        X86Pcmpgtd,
-        X86Pcmpgtq,
-        X86Pcmpgtw,
-        X86Pmaxsb,
-        X86Pmaxsd,
-        X86Pmaxsw,
-        X86Pmaxub,
-        X86Pmaxud,
-        X86Pmaxuw,
-        X86Pminsb,
-        X86Pminsd,
-        X86Pminsw,
-        X86Pminub,
-        X86Pminud,
-        X86Pminuw,
-        X86Pmovsxbw,
-        X86Pmovsxdq,
-        X86Pmovsxwd,
-        X86Pmovzxbw,
-        X86Pmovzxdq,
-        X86Pmovzxwd,
-        X86Pmulld,
-        X86Pmullw,
-        X86Popcnt,
-        X86Por,
-        X86Pshufb,
-        X86Pshufd,
-        X86Pslld,
-        X86Pslldq,
-        X86Psllq,
-        X86Psllw,
-        X86Psrad,
-        X86Psraw,
-        X86Psrld,
-        X86Psrlq,
-        X86Psrldq,
-        X86Psrlw,
-        X86Psubb,
-        X86Psubd,
-        X86Psubq,
-        X86Psubw,
-        X86Punpckhbw,
-        X86Punpckhdq,
-        X86Punpckhqdq,
-        X86Punpckhwd,
-        X86Punpcklbw,
-        X86Punpckldq,
-        X86Punpcklqdq,
-        X86Punpcklwd,
-        X86Pxor,
-        X86Rcpps,
-        X86Rcpss,
-        X86Roundpd,
-        X86Roundps,
-        X86Roundsd,
-        X86Roundss,
-        X86Rsqrtps,
-        X86Rsqrtss,
-        X86Sha256Msg1,
-        X86Sha256Msg2,
-        X86Sha256Rnds2,
-        X86Shufpd,
-        X86Shufps,
-        X86Sqrtpd,
-        X86Sqrtps,
-        X86Sqrtsd,
-        X86Sqrtss,
-        X86Subpd,
-        X86Subps,
-        X86Subsd,
-        X86Subss,
-        X86Unpckhpd,
-        X86Unpckhps,
-        X86Unpcklpd,
-        X86Unpcklps,
-        X86Vcvtph2ps,
-        X86Vcvtps2ph,
-        X86Vfmadd231ps,
-        X86Vfmadd231sd,
-        X86Vfmadd231ss,
-        X86Vfmsub231sd,
-        X86Vfmsub231ss,
-        X86Vfnmadd231ps,
-        X86Vfnmadd231sd,
-        X86Vfnmadd231ss,
-        X86Vfnmsub231sd,
-        X86Vfnmsub231ss,
-        X86Xorpd,
-        X86Xorps,
-
-        // Arm64 (FP and Advanced SIMD)
-
-        Arm64AbsS,
-        Arm64AbsV,
-        Arm64AddhnV,
-        Arm64AddpS,
-        Arm64AddpV,
-        Arm64AddvV,
-        Arm64AddS,
-        Arm64AddV,
-        Arm64AesdV,
-        Arm64AeseV,
-        Arm64AesimcV,
-        Arm64AesmcV,
-        Arm64AndV,
-        Arm64BicVi,
-        Arm64BicV,
-        Arm64BifV,
-        Arm64BitV,
-        Arm64BslV,
-        Arm64ClsV,
-        Arm64ClzV,
-        Arm64CmeqS,
-        Arm64CmeqV,
-        Arm64CmeqSz,
-        Arm64CmeqVz,
-        Arm64CmgeS,
-        Arm64CmgeV,
-        Arm64CmgeSz,
-        Arm64CmgeVz,
-        Arm64CmgtS,
-        Arm64CmgtV,
-        Arm64CmgtSz,
-        Arm64CmgtVz,
-        Arm64CmhiS,
-        Arm64CmhiV,
-        Arm64CmhsS,
-        Arm64CmhsV,
-        Arm64CmleSz,
-        Arm64CmleVz,
-        Arm64CmltSz,
-        Arm64CmltVz,
-        Arm64CmtstS,
-        Arm64CmtstV,
-        Arm64CntV,
-        Arm64DupSe,
-        Arm64DupVe,
-        Arm64DupGp,
-        Arm64EorV,
-        Arm64ExtV,
-        Arm64FabdS,
-        Arm64FabdV,
-        Arm64FabsV,
-        Arm64FabsS,
-        Arm64FacgeS,
-        Arm64FacgeV,
-        Arm64FacgtS,
-        Arm64FacgtV,
-        Arm64FaddpS,
-        Arm64FaddpV,
-        Arm64FaddV,
-        Arm64FaddS,
-        Arm64FccmpeS,
-        Arm64FccmpS,
-        Arm64FcmeqS,
-        Arm64FcmeqV,
-        Arm64FcmeqSz,
-        Arm64FcmeqVz,
-        Arm64FcmgeS,
-        Arm64FcmgeV,
-        Arm64FcmgeSz,
-        Arm64FcmgeVz,
-        Arm64FcmgtS,
-        Arm64FcmgtV,
-        Arm64FcmgtSz,
-        Arm64FcmgtVz,
-        Arm64FcmleSz,
-        Arm64FcmleVz,
-        Arm64FcmltSz,
-        Arm64FcmltVz,
-        Arm64FcmpeS,
-        Arm64FcmpS,
-        Arm64FcselS,
-        Arm64FcvtasS,
-        Arm64FcvtasV,
-        Arm64FcvtasGp,
-        Arm64FcvtauS,
-        Arm64FcvtauV,
-        Arm64FcvtauGp,
-        Arm64FcvtlV,
-        Arm64FcvtmsS,
-        Arm64FcvtmsV,
-        Arm64FcvtmsGp,
-        Arm64FcvtmuS,
-        Arm64FcvtmuV,
-        Arm64FcvtmuGp,
-        Arm64FcvtnsS,
-        Arm64FcvtnsV,
-        Arm64FcvtnsGp,
-        Arm64FcvtnuS,
-        Arm64FcvtnuV,
-        Arm64FcvtnuGp,
-        Arm64FcvtnV,
-        Arm64FcvtpsS,
-        Arm64FcvtpsV,
-        Arm64FcvtpsGp,
-        Arm64FcvtpuS,
-        Arm64FcvtpuV,
-        Arm64FcvtpuGp,
-        Arm64FcvtxnS,
-        Arm64FcvtxnV,
-        Arm64FcvtzsSFixed,
-        Arm64FcvtzsVFixed,
-        Arm64FcvtzsS,
-        Arm64FcvtzsV,
-        Arm64FcvtzsGpFixed,
-        Arm64FcvtzsGp,
-        Arm64FcvtzuSFixed,
-        Arm64FcvtzuVFixed,
-        Arm64FcvtzuS,
-        Arm64FcvtzuV,
-        Arm64FcvtzuGpFixed,
-        Arm64FcvtzuGp,
-        Arm64FcvtS,
-        Arm64FdivV,
-        Arm64FdivS,
-        Arm64FmaddS,
-        Arm64FmaxnmpS,
-        Arm64FmaxnmpV,
-        Arm64FmaxnmvV,
-        Arm64FmaxnmV,
-        Arm64FmaxnmS,
-        Arm64FmaxpS,
-        Arm64FmaxpV,
-        Arm64FmaxvV,
-        Arm64FmaxV,
-        Arm64FmaxS,
-        Arm64FminnmpS,
-        Arm64FminnmpV,
-        Arm64FminnmvV,
-        Arm64FminnmV,
-        Arm64FminnmS,
-        Arm64FminpS,
-        Arm64FminpV,
-        Arm64FminvV,
-        Arm64FminV,
-        Arm64FminS,
-        Arm64FmlaSe,
-        Arm64FmlaVe,
-        Arm64FmlaV,
-        Arm64FmlsSe,
-        Arm64FmlsVe,
-        Arm64FmlsV,
-        Arm64FmovVi,
-        Arm64FmovS,
-        Arm64FmovGp,
-        Arm64FmovSi,
-        Arm64FmsubS,
-        Arm64FmulxSe,
-        Arm64FmulxVe,
-        Arm64FmulxS,
-        Arm64FmulxV,
-        Arm64FmulSe,
-        Arm64FmulVe,
-        Arm64FmulV,
-        Arm64FmulS,
-        Arm64FnegV,
-        Arm64FnegS,
-        Arm64FnmaddS,
-        Arm64FnmsubS,
-        Arm64FnmulS,
-        Arm64FrecpeS,
-        Arm64FrecpeV,
-        Arm64FrecpsS,
-        Arm64FrecpsV,
-        Arm64FrecpxS,
-        Arm64FrintaV,
-        Arm64FrintaS,
-        Arm64FrintiV,
-        Arm64FrintiS,
-        Arm64FrintmV,
-        Arm64FrintmS,
-        Arm64FrintnV,
-        Arm64FrintnS,
-        Arm64FrintpV,
-        Arm64FrintpS,
-        Arm64FrintxV,
-        Arm64FrintxS,
-        Arm64FrintzV,
-        Arm64FrintzS,
-        Arm64FrsqrteS,
-        Arm64FrsqrteV,
-        Arm64FrsqrtsS,
-        Arm64FrsqrtsV,
-        Arm64FsqrtV,
-        Arm64FsqrtS,
-        Arm64FsubV,
-        Arm64FsubS,
-        Arm64InsVe,
-        Arm64InsGp,
-        Arm64Ld1rV,
-        Arm64Ld1Vms,
-        Arm64Ld1Vss,
-        Arm64Ld2rV,
-        Arm64Ld2Vms,
-        Arm64Ld2Vss,
-        Arm64Ld3rV,
-        Arm64Ld3Vms,
-        Arm64Ld3Vss,
-        Arm64Ld4rV,
-        Arm64Ld4Vms,
-        Arm64Ld4Vss,
-        Arm64MlaVe,
-        Arm64MlaV,
-        Arm64MlsVe,
-        Arm64MlsV,
-        Arm64MoviV,
-        Arm64MrsFpsr,
-        Arm64MsrFpsr,
-        Arm64MulVe,
-        Arm64MulV,
-        Arm64MvniV,
-        Arm64NegS,
-        Arm64NegV,
-        Arm64NotV,
-        Arm64OrnV,
-        Arm64OrrVi,
-        Arm64OrrV,
-        Arm64PmullV,
-        Arm64PmulV,
-        Arm64RaddhnV,
-        Arm64RbitV,
-        Arm64Rev16V,
-        Arm64Rev32V,
-        Arm64Rev64V,
-        Arm64RshrnV,
-        Arm64RsubhnV,
-        Arm64SabalV,
-        Arm64SabaV,
-        Arm64SabdlV,
-        Arm64SabdV,
-        Arm64SadalpV,
-        Arm64SaddlpV,
-        Arm64SaddlvV,
-        Arm64SaddlV,
-        Arm64SaddwV,
-        Arm64ScvtfSFixed,
-        Arm64ScvtfVFixed,
-        Arm64ScvtfS,
-        Arm64ScvtfV,
-        Arm64ScvtfGpFixed,
-        Arm64ScvtfGp,
-        Arm64Sha1cV,
-        Arm64Sha1hV,
-        Arm64Sha1mV,
-        Arm64Sha1pV,
-        Arm64Sha1su0V,
-        Arm64Sha1su1V,
-        Arm64Sha256h2V,
-        Arm64Sha256hV,
-        Arm64Sha256su0V,
-        Arm64Sha256su1V,
-        Arm64ShaddV,
-        Arm64ShllV,
-        Arm64ShlS,
-        Arm64ShlV,
-        Arm64ShrnV,
-        Arm64ShsubV,
-        Arm64SliS,
-        Arm64SliV,
-        Arm64SmaxpV,
-        Arm64SmaxvV,
-        Arm64SmaxV,
-        Arm64SminpV,
-        Arm64SminvV,
-        Arm64SminV,
-        Arm64SmlalVe,
-        Arm64SmlalV,
-        Arm64SmlslVe,
-        Arm64SmlslV,
-        Arm64SmovV,
-        Arm64SmullVe,
-        Arm64SmullV,
-        Arm64SqabsS,
-        Arm64SqabsV,
-        Arm64SqaddS,
-        Arm64SqaddV,
-        Arm64SqdmlalSe,
-        Arm64SqdmlalVe,
-        Arm64SqdmlalS,
-        Arm64SqdmlalV,
-        Arm64SqdmlslSe,
-        Arm64SqdmlslVe,
-        Arm64SqdmlslS,
-        Arm64SqdmlslV,
-        Arm64SqdmulhSe,
-        Arm64SqdmulhVe,
-        Arm64SqdmulhS,
-        Arm64SqdmulhV,
-        Arm64SqdmullSe,
-        Arm64SqdmullVe,
-        Arm64SqdmullS,
-        Arm64SqdmullV,
-        Arm64SqnegS,
-        Arm64SqnegV,
-        Arm64SqrdmulhSe,
-        Arm64SqrdmulhVe,
-        Arm64SqrdmulhS,
-        Arm64SqrdmulhV,
-        Arm64SqrshlS,
-        Arm64SqrshlV,
-        Arm64SqrshrnS,
-        Arm64SqrshrnV,
-        Arm64SqrshrunS,
-        Arm64SqrshrunV,
-        Arm64SqshluS,
-        Arm64SqshluV,
-        Arm64SqshlSi,
-        Arm64SqshlVi,
-        Arm64SqshlS,
-        Arm64SqshlV,
-        Arm64SqshrnS,
-        Arm64SqshrnV,
-        Arm64SqshrunS,
-        Arm64SqshrunV,
-        Arm64SqsubS,
-        Arm64SqsubV,
-        Arm64SqxtnS,
-        Arm64SqxtnV,
-        Arm64SqxtunS,
-        Arm64SqxtunV,
-        Arm64SrhaddV,
-        Arm64SriS,
-        Arm64SriV,
-        Arm64SrshlS,
-        Arm64SrshlV,
-        Arm64SrshrS,
-        Arm64SrshrV,
-        Arm64SrsraS,
-        Arm64SrsraV,
-        Arm64SshllV,
-        Arm64SshlS,
-        Arm64SshlV,
-        Arm64SshrS,
-        Arm64SshrV,
-        Arm64SsraS,
-        Arm64SsraV,
-        Arm64SsublV,
-        Arm64SsubwV,
-        Arm64St1Vms,
-        Arm64St1Vss,
-        Arm64St2Vms,
-        Arm64St2Vss,
-        Arm64St3Vms,
-        Arm64St3Vss,
-        Arm64St4Vms,
-        Arm64St4Vss,
-        Arm64SubhnV,
-        Arm64SubS,
-        Arm64SubV,
-        Arm64SuqaddS,
-        Arm64SuqaddV,
-        Arm64TblV,
-        Arm64TbxV,
-        Arm64Trn1V,
-        Arm64Trn2V,
-        Arm64UabalV,
-        Arm64UabaV,
-        Arm64UabdlV,
-        Arm64UabdV,
-        Arm64UadalpV,
-        Arm64UaddlpV,
-        Arm64UaddlvV,
-        Arm64UaddlV,
-        Arm64UaddwV,
-        Arm64UcvtfSFixed,
-        Arm64UcvtfVFixed,
-        Arm64UcvtfS,
-        Arm64UcvtfV,
-        Arm64UcvtfGpFixed,
-        Arm64UcvtfGp,
-        Arm64UhaddV,
-        Arm64UhsubV,
-        Arm64UmaxpV,
-        Arm64UmaxvV,
-        Arm64UmaxV,
-        Arm64UminpV,
-        Arm64UminvV,
-        Arm64UminV,
-        Arm64UmlalVe,
-        Arm64UmlalV,
-        Arm64UmlslVe,
-        Arm64UmlslV,
-        Arm64UmovV,
-        Arm64UmullVe,
-        Arm64UmullV,
-        Arm64UqaddS,
-        Arm64UqaddV,
-        Arm64UqrshlS,
-        Arm64UqrshlV,
-        Arm64UqrshrnS,
-        Arm64UqrshrnV,
-        Arm64UqshlSi,
-        Arm64UqshlVi,
-        Arm64UqshlS,
-        Arm64UqshlV,
-        Arm64UqshrnS,
-        Arm64UqshrnV,
-        Arm64UqsubS,
-        Arm64UqsubV,
-        Arm64UqxtnS,
-        Arm64UqxtnV,
-        Arm64UrecpeV,
-        Arm64UrhaddV,
-        Arm64UrshlS,
-        Arm64UrshlV,
-        Arm64UrshrS,
-        Arm64UrshrV,
-        Arm64UrsqrteV,
-        Arm64UrsraS,
-        Arm64UrsraV,
-        Arm64UshllV,
-        Arm64UshlS,
-        Arm64UshlV,
-        Arm64UshrS,
-        Arm64UshrV,
-        Arm64UsqaddS,
-        Arm64UsqaddV,
-        Arm64UsraS,
-        Arm64UsraV,
-        Arm64UsublV,
-        Arm64UsubwV,
-        Arm64Uzp1V,
-        Arm64Uzp2V,
-        Arm64XtnV,
-        Arm64Zip1V,
-        Arm64Zip2V,
-
-        Arm64VTypeShift = 13,
-        Arm64VTypeMask = 1 << Arm64VTypeShift,
-        Arm64V64 = 0 << Arm64VTypeShift,
-        Arm64V128 = 1 << Arm64VTypeShift,
-
-        Arm64VSizeShift = 14,
-        Arm64VSizeMask = 3 << Arm64VSizeShift,
-        Arm64VFloat = 0 << Arm64VSizeShift,
-        Arm64VDouble = 1 << Arm64VSizeShift,
-        Arm64VByte = 0 << Arm64VSizeShift,
-        Arm64VHWord = 1 << Arm64VSizeShift,
-        Arm64VWord = 2 << Arm64VSizeShift,
-        Arm64VDWord = 3 << Arm64VSizeShift
-    }
-}

ARMeilleure/Memory/IJitMemoryBlock.cs

@@ -1,14 +0,0 @@
-using System;
-
-namespace ARMeilleure.Memory
-{
-    public interface IJitMemoryBlock : IDisposable
-    {
-        IntPtr Pointer { get; }
-
-        bool Commit(ulong offset, ulong size);
-
-        void MapAsRx(ulong offset, ulong size);
-        void MapAsRwx(ulong offset, ulong size);
-    }
-}

ARMeilleure/Memory/IMemoryManager.cs

@@ -1,76 +0,0 @@
-using System;
-
-namespace ARMeilleure.Memory
-{
-    public interface IMemoryManager
-    {
-        int AddressSpaceBits { get; }
-
-        IntPtr PageTablePointer { get; }
-
-        MemoryManagerType Type { get; }
-
-        event Action<ulong, ulong> UnmapEvent;
-
-        /// <summary>
-        /// Reads data from CPU mapped memory.
-        /// </summary>
-        /// <typeparam name="T">Type of the data being read</typeparam>
-        /// <param name="va">Virtual address of the data in memory</param>
-        /// <returns>The data</returns>
-        T Read<T>(ulong va) where T : unmanaged;
-
-        /// <summary>
-        /// Reads data from CPU mapped memory, with read tracking
-        /// </summary>
-        /// <typeparam name="T">Type of the data being read</typeparam>
-        /// <param name="va">Virtual address of the data in memory</param>
-        /// <returns>The data</returns>
-        T ReadTracked<T>(ulong va) where T : unmanaged;
-
-        /// <summary>
-        /// Writes data to CPU mapped memory.
-        /// </summary>
-        /// <typeparam name="T">Type of the data being written</typeparam>
-        /// <param name="va">Virtual address to write the data into</param>
-        /// <param name="value">Data to be written</param>
-        void Write<T>(ulong va, T value) where T : unmanaged;
-
-        /// <summary>
-        /// Gets a read-only span of data from CPU mapped memory.
-        /// </summary>
-        /// <param name="va">Virtual address of the data</param>
-        /// <param name="size">Size of the data</param>
-        /// <param name="tracked">True if read tracking is triggered on the span</param>
-        /// <returns>A read-only span of the data</returns>
-        ReadOnlySpan<byte> GetSpan(ulong va, int size, bool tracked = false);
-
-        /// <summary>
-        /// Gets a reference for the given type at the specified virtual memory address.
-        /// </summary>
-        /// <remarks>
-        /// The data must be located at a contiguous memory region.
-        /// </remarks>
-        /// <typeparam name="T">Type of the data to get the reference</typeparam>
-        /// <param name="va">Virtual address of the data</param>
-        /// <returns>A reference to the data in memory</returns>
-        ref T GetRef<T>(ulong va) where T : unmanaged;
-
-        /// <summary>
-        /// Checks if the page at a given CPU virtual address is mapped.
-        /// </summary>
-        /// <param name="va">Virtual address to check</param>
-        /// <returns>True if the address is mapped, false otherwise</returns>
-        bool IsMapped(ulong va);
-
-        /// <summary>
-        /// Alerts the memory tracking that a given region has been read from or written to.
-        /// This should be called before read/write is performed.
-        /// </summary>
-        /// <param name="va">Virtual address of the region</param>
-        /// <param name="size">Size of the region</param>
-        /// <param name="write">True if the region was written, false if read</param>
-        /// <param name="precise">True if the access is precise, false otherwise</param>
-        void SignalMemoryTracking(ulong va, ulong size, bool write, bool precise = false);
-    }
-}

ARMeilleure/Optimizations.cs

@@ -1,57 +0,0 @@
-using System.Runtime.Intrinsics.Arm;
-
-namespace ARMeilleure
-{
-    using Arm64HardwareCapabilities = ARMeilleure.CodeGen.Arm64.HardwareCapabilities;
-    using X86HardwareCapabilities = ARMeilleure.CodeGen.X86.HardwareCapabilities;
-
-    public static class Optimizations
-    {
-        public static bool FastFP { get; set; } = true;
-
-        public static bool AllowLcqInFunctionTable  { get; set; } = true;
-        public static bool UseUnmanagedDispatchLoop { get; set; } = true;
-
-        public static bool UseAdvSimdIfAvailable    { get; set; } = true;
-        public static bool UseArm64PmullIfAvailable { get; set; } = true;
-
-        public static bool UseSseIfAvailable       { get; set; } = true;
-        public static bool UseSse2IfAvailable      { get; set; } = true;
-        public static bool UseSse3IfAvailable      { get; set; } = true;
-        public static bool UseSsse3IfAvailable     { get; set; } = true;
-        public static bool UseSse41IfAvailable     { get; set; } = true;
-        public static bool UseSse42IfAvailable     { get; set; } = true;
-        public static bool UsePopCntIfAvailable    { get; set; } = true;
-        public static bool UseAvxIfAvailable       { get; set; } = true;
-        public static bool UseF16cIfAvailable      { get; set; } = true;
-        public static bool UseFmaIfAvailable       { get; set; } = true;
-        public static bool UseAesniIfAvailable     { get; set; } = true;
-        public static bool UsePclmulqdqIfAvailable { get; set; } = true;
-        public static bool UseShaIfAvailable       { get; set; } = true;
-        public static bool UseGfniIfAvailable      { get; set; } = true;
-
-        public static bool ForceLegacySse
-        {
-            get => X86HardwareCapabilities.ForceLegacySse;
-            set => X86HardwareCapabilities.ForceLegacySse = value;
-        }
-
-        internal static bool UseAdvSimd    => UseAdvSimdIfAvailable    && Arm64HardwareCapabilities.SupportsAdvSimd;
-        internal static bool UseArm64Pmull => UseArm64PmullIfAvailable && Arm64HardwareCapabilities.SupportsPmull;
-
-        internal static bool UseSse       => UseSseIfAvailable       && X86HardwareCapabilities.SupportsSse;
-        internal static bool UseSse2      => UseSse2IfAvailable      && X86HardwareCapabilities.SupportsSse2;
-        internal static bool UseSse3      => UseSse3IfAvailable      && X86HardwareCapabilities.SupportsSse3;
-        internal static bool UseSsse3     => UseSsse3IfAvailable     && X86HardwareCapabilities.SupportsSsse3;
-        internal static bool UseSse41     => UseSse41IfAvailable     && X86HardwareCapabilities.SupportsSse41;
-        internal static bool UseSse42     => UseSse42IfAvailable     && X86HardwareCapabilities.SupportsSse42;
-        internal static bool UsePopCnt    => UsePopCntIfAvailable    && X86HardwareCapabilities.SupportsPopcnt;
-        internal static bool UseAvx       => UseAvxIfAvailable       && X86HardwareCapabilities.SupportsAvx && !ForceLegacySse;
-        internal static bool UseF16c      => UseF16cIfAvailable      && X86HardwareCapabilities.SupportsF16c;
-        internal static bool UseFma       => UseFmaIfAvailable       && X86HardwareCapabilities.SupportsFma;
-        internal static bool UseAesni     => UseAesniIfAvailable     && X86HardwareCapabilities.SupportsAesni;
-        internal static bool UsePclmulqdq => UsePclmulqdqIfAvailable && X86HardwareCapabilities.SupportsPclmulqdq;
-        internal static bool UseSha       => UseShaIfAvailable       && X86HardwareCapabilities.SupportsSha;
-        internal static bool UseGfni      => UseGfniIfAvailable      && X86HardwareCapabilities.SupportsGfni;
-    }
-}

ARMeilleure/Signal/NativeSignalHandler.cs

@@ -1,422 +0,0 @@
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Memory;
-using ARMeilleure.Translation;
-using ARMeilleure.Translation.Cache;
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Signal
-{
-    [StructLayout(LayoutKind.Sequential, Pack = 1)]
-    struct SignalHandlerRange
-    {
-        public int IsActive;
-        public nuint RangeAddress;
-        public nuint RangeEndAddress;
-        public IntPtr ActionPointer;
-    }
-
-    [StructLayout(LayoutKind.Sequential, Pack = 1)]
-    struct SignalHandlerConfig
-    {
-        /// <summary>
-        /// The byte offset of the faulting address in the SigInfo or ExceptionRecord struct.
-        /// </summary>
-        public int StructAddressOffset;
-
-        /// <summary>
-        /// The byte offset of the write flag in the SigInfo or ExceptionRecord struct.
-        /// </summary>
-        public int StructWriteOffset;
-
-        /// <summary>
-        /// The sigaction handler that was registered before this one. (unix only)
-        /// </summary>
-        public nuint UnixOldSigaction;
-
-        /// <summary>
-        /// The type of the previous sigaction. True for the 3 argument variant. (unix only)
-        /// </summary>
-        public int UnixOldSigaction3Arg;
-
-        public SignalHandlerRange Range0;
-        public SignalHandlerRange Range1;
-        public SignalHandlerRange Range2;
-        public SignalHandlerRange Range3;
-        public SignalHandlerRange Range4;
-        public SignalHandlerRange Range5;
-        public SignalHandlerRange Range6;
-        public SignalHandlerRange Range7;
-    }
-
-    public static class NativeSignalHandler
-    {
-        private delegate void UnixExceptionHandler(int sig, IntPtr info, IntPtr ucontext);
-        [UnmanagedFunctionPointer(CallingConvention.Winapi)]
-        private delegate int VectoredExceptionHandler(IntPtr exceptionInfo);
-
-        private const int MaxTrackedRanges = 8;
-
-        private const int StructAddressOffset = 0;
-        private const int StructWriteOffset = 4;
-        private const int UnixOldSigaction = 8;
-        private const int UnixOldSigaction3Arg = 16;
-        private const int RangeOffset = 20;
-
-        private const int EXCEPTION_CONTINUE_SEARCH = 0;
-        private const int EXCEPTION_CONTINUE_EXECUTION = -1;
-
-        private const uint EXCEPTION_ACCESS_VIOLATION = 0xc0000005;
-
-        private static ulong _pageSize;
-        private static ulong _pageMask;
-
-        private static IntPtr _handlerConfig;
-        private static IntPtr _signalHandlerPtr;
-        private static IntPtr _signalHandlerHandle;
-
-        private static readonly object _lock = new object();
-        private static bool _initialized;
-
-        static NativeSignalHandler()
-        {
-            _handlerConfig = Marshal.AllocHGlobal(Unsafe.SizeOf<SignalHandlerConfig>());
-            ref SignalHandlerConfig config = ref GetConfigRef();
-
-            config = new SignalHandlerConfig();
-        }
-
-        public static void Initialize(IJitMemoryAllocator allocator)
-        {
-            JitCache.Initialize(allocator);
-        }
-
-        public static void InitializeSignalHandler(ulong pageSize, Func<IntPtr, IntPtr, IntPtr> customSignalHandlerFactory = null)
-        {
-            if (_initialized) return;
-
-            lock (_lock)
-            {
-                if (_initialized) return;
-
-                _pageSize = pageSize;
-                _pageMask = pageSize - 1;
-
-                ref SignalHandlerConfig config = ref GetConfigRef();
-
-                if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
-                {
-                    _signalHandlerPtr = Marshal.GetFunctionPointerForDelegate(GenerateUnixSignalHandler(_handlerConfig));
-
-                    if (customSignalHandlerFactory != null)
-                    {
-                        _signalHandlerPtr = customSignalHandlerFactory(UnixSignalHandlerRegistration.GetSegfaultExceptionHandler().sa_handler, _signalHandlerPtr);
-                    }
-
-                    var old = UnixSignalHandlerRegistration.RegisterExceptionHandler(_signalHandlerPtr);
-
-                    config.UnixOldSigaction = (nuint)(ulong)old.sa_handler;
-                    config.UnixOldSigaction3Arg = old.sa_flags & 4;
-                }
-                else
-                {
-                    config.StructAddressOffset = 40; // ExceptionInformation1
-                    config.StructWriteOffset = 32; // ExceptionInformation0
-
-                    _signalHandlerPtr = Marshal.GetFunctionPointerForDelegate(GenerateWindowsSignalHandler(_handlerConfig));
-
-                    if (customSignalHandlerFactory != null)
-                    {
-                        _signalHandlerPtr = customSignalHandlerFactory(IntPtr.Zero, _signalHandlerPtr);
-                    }
-
-                    _signalHandlerHandle = WindowsSignalHandlerRegistration.RegisterExceptionHandler(_signalHandlerPtr);
-                }
-
-                _initialized = true;
-            }
-        }
-
-        private static unsafe ref SignalHandlerConfig GetConfigRef()
-        {
-            return ref Unsafe.AsRef<SignalHandlerConfig>((void*)_handlerConfig);
-        }
-
-        public static unsafe bool AddTrackedRegion(nuint address, nuint endAddress, IntPtr action)
-        {
-            var ranges = &((SignalHandlerConfig*)_handlerConfig)->Range0;
-
-            for (int i = 0; i < MaxTrackedRanges; i++)
-            {
-                if (ranges[i].IsActive == 0)
-                {
-                    ranges[i].RangeAddress = address;
-                    ranges[i].RangeEndAddress = endAddress;
-                    ranges[i].ActionPointer = action;
-                    ranges[i].IsActive = 1;
-
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        public static unsafe bool RemoveTrackedRegion(nuint address)
-        {
-            var ranges = &((SignalHandlerConfig*)_handlerConfig)->Range0;
-
-            for (int i = 0; i < MaxTrackedRanges; i++)
-            {
-                if (ranges[i].IsActive == 1 && ranges[i].RangeAddress == address)
-                {
-                    ranges[i].IsActive = 0;
-
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        private static Operand EmitGenericRegionCheck(EmitterContext context, IntPtr signalStructPtr, Operand faultAddress, Operand isWrite)
-        {
-            Operand inRegionLocal = context.AllocateLocal(OperandType.I32);
-            context.Copy(inRegionLocal, Const(0));
-
-            Operand endLabel = Label();
-
-            for (int i = 0; i < MaxTrackedRanges; i++)
-            {
-                ulong rangeBaseOffset = (ulong)(RangeOffset + i * Unsafe.SizeOf<SignalHandlerRange>());
-
-                Operand nextLabel = Label();
-
-                Operand isActive = context.Load(OperandType.I32, Const((ulong)signalStructPtr + rangeBaseOffset));
-
-                context.BranchIfFalse(nextLabel, isActive);
-
-                Operand rangeAddress = context.Load(OperandType.I64, Const((ulong)signalStructPtr + rangeBaseOffset + 4));
-                Operand rangeEndAddress = context.Load(OperandType.I64, Const((ulong)signalStructPtr + rangeBaseOffset + 12));
-
-                // Is the fault address within this tracked region?
-                Operand inRange = context.BitwiseAnd(
-                    context.ICompare(faultAddress, rangeAddress, Comparison.GreaterOrEqualUI),
-                    context.ICompare(faultAddress, rangeEndAddress, Comparison.LessUI)
-                    );
-
-                // Only call tracking if in range.
-                context.BranchIfFalse(nextLabel, inRange, BasicBlockFrequency.Cold);
-
-                Operand offset = context.BitwiseAnd(context.Subtract(faultAddress, rangeAddress), Const(~_pageMask));
-
-                // Call the tracking action, with the pointer's relative offset to the base address.
-                Operand trackingActionPtr = context.Load(OperandType.I64, Const((ulong)signalStructPtr + rangeBaseOffset + 20));
-
-                context.Copy(inRegionLocal, Const(0));
-
-                Operand skipActionLabel = Label();
-
-                // Tracking action should be non-null to call it, otherwise assume false return.
-                context.BranchIfFalse(skipActionLabel, trackingActionPtr);
-                Operand result = context.Call(trackingActionPtr, OperandType.I32, offset, Const(_pageSize), isWrite, Const(0));
-                context.Copy(inRegionLocal, result);
-
-                context.MarkLabel(skipActionLabel);
-
-                // If the tracking action returns false or does not exist, it might be an invalid access due to a partial overlap on Windows.
-                if (OperatingSystem.IsWindows())
-                {
-                    context.BranchIfTrue(endLabel, inRegionLocal);
-
-                    context.Copy(inRegionLocal, WindowsPartialUnmapHandler.EmitRetryFromAccessViolation(context));
-                }
-
-                context.Branch(endLabel);
-
-                context.MarkLabel(nextLabel);
-            }
-
-            context.MarkLabel(endLabel);
-
-            return context.Copy(inRegionLocal);
-        }
-
-        private static Operand GenerateUnixFaultAddress(EmitterContext context, Operand sigInfoPtr)
-        {
-            ulong structAddressOffset = OperatingSystem.IsMacOS() ? 24ul : 16ul; // si_addr
-            return context.Load(OperandType.I64, context.Add(sigInfoPtr, Const(structAddressOffset)));
-        }
-
-        private static Operand GenerateUnixWriteFlag(EmitterContext context, Operand ucontextPtr)
-        {
-            if (OperatingSystem.IsMacOS())
-            {
-                const ulong mcontextOffset = 48; // uc_mcontext
-                Operand ctxPtr = context.Load(OperandType.I64, context.Add(ucontextPtr, Const(mcontextOffset)));
-
-                if (RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
-                {
-                    const ulong esrOffset = 8; // __es.__esr
-                    Operand esr = context.Load(OperandType.I64, context.Add(ctxPtr, Const(esrOffset)));
-                    return context.BitwiseAnd(esr, Const(0x40ul));
-                }
-
-                if (RuntimeInformation.ProcessArchitecture == Architecture.X64)
-                {
-                    const ulong errOffset = 4; // __es.__err
-                    Operand err = context.Load(OperandType.I64, context.Add(ctxPtr, Const(errOffset)));
-                    return context.BitwiseAnd(err, Const(2ul));
-                }
-            }
-            else if (OperatingSystem.IsLinux())
-            {
-                if (RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
-                {
-                    Operand auxPtr = context.AllocateLocal(OperandType.I64);
-
-                    Operand loopLabel = Label();
-                    Operand successLabel = Label();
-
-                    const ulong auxOffset = 464; // uc_mcontext.__reserved
-                    const uint esrMagic = 0x45535201;
-
-                    context.Copy(auxPtr,  context.Add(ucontextPtr, Const(auxOffset)));
-
-                    context.MarkLabel(loopLabel);
-
-                    // _aarch64_ctx::magic
-                    Operand magic = context.Load(OperandType.I32, auxPtr);
-                    // _aarch64_ctx::size
-                    Operand size = context.Load(OperandType.I32, context.Add(auxPtr, Const(4ul)));
-
-                    context.BranchIf(successLabel, magic, Const(esrMagic), Comparison.Equal);
-
-                    context.Copy(auxPtr, context.Add(auxPtr, context.ZeroExtend32(OperandType.I64, size)));
-
-                    context.Branch(loopLabel);
-
-                    context.MarkLabel(successLabel);
-
-                    // esr_context::esr
-                    Operand esr = context.Load(OperandType.I64, context.Add(auxPtr, Const(8ul)));
-                    return context.BitwiseAnd(esr, Const(0x40ul));
-                }
-
-                if (RuntimeInformation.ProcessArchitecture == Architecture.X64)
-                {
-                    const int errOffset = 192; // uc_mcontext.gregs[REG_ERR]
-                    Operand err = context.Load(OperandType.I64, context.Add(ucontextPtr, Const(errOffset)));
-                    return context.BitwiseAnd(err, Const(2ul));
-                }
-            }
-
-            throw new PlatformNotSupportedException();
-        }
-
-        private static UnixExceptionHandler GenerateUnixSignalHandler(IntPtr signalStructPtr)
-        {
-            EmitterContext context = new EmitterContext();
-
-            // (int sig, SigInfo* sigInfo, void* ucontext)
-            Operand sigInfoPtr = context.LoadArgument(OperandType.I64, 1);
-            Operand ucontextPtr = context.LoadArgument(OperandType.I64, 2);
-
-            Operand faultAddress = GenerateUnixFaultAddress(context, sigInfoPtr);
-            Operand writeFlag = GenerateUnixWriteFlag(context, ucontextPtr);
-
-            Operand isWrite = context.ICompareNotEqual(writeFlag, Const(0L)); // Normalize to 0/1.
-
-            Operand isInRegion = EmitGenericRegionCheck(context, signalStructPtr, faultAddress, isWrite);
-
-            Operand endLabel = Label();
-
-            context.BranchIfTrue(endLabel, isInRegion);
-
-            Operand unixOldSigaction = context.Load(OperandType.I64, Const((ulong)signalStructPtr + UnixOldSigaction));
-            Operand unixOldSigaction3Arg = context.Load(OperandType.I64, Const((ulong)signalStructPtr + UnixOldSigaction3Arg));
-            Operand threeArgLabel = Label();
-
-            context.BranchIfTrue(threeArgLabel, unixOldSigaction3Arg);
-
-            context.Call(unixOldSigaction, OperandType.None, context.LoadArgument(OperandType.I32, 0));
-            context.Branch(endLabel);
-
-            context.MarkLabel(threeArgLabel);
-
-            context.Call(unixOldSigaction,
-                OperandType.None,
-                context.LoadArgument(OperandType.I32, 0),
-                sigInfoPtr,
-                context.LoadArgument(OperandType.I64, 2)
-                );
-
-            context.MarkLabel(endLabel);
-
-            context.Return();
-
-            ControlFlowGraph cfg = context.GetControlFlowGraph();
-
-            OperandType[] argTypes = new OperandType[] { OperandType.I32, OperandType.I64, OperandType.I64 };
-
-            return Compiler.Compile(cfg, argTypes, OperandType.None, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<UnixExceptionHandler>();
-        }
-
-        private static VectoredExceptionHandler GenerateWindowsSignalHandler(IntPtr signalStructPtr)
-        {
-            EmitterContext context = new EmitterContext();
-
-            // (ExceptionPointers* exceptionInfo)
-            Operand exceptionInfoPtr = context.LoadArgument(OperandType.I64, 0);
-            Operand exceptionRecordPtr = context.Load(OperandType.I64, exceptionInfoPtr);
-
-            // First thing's first - this catches a number of exceptions, but we only want access violations.
-            Operand validExceptionLabel = Label();
-
-            Operand exceptionCode = context.Load(OperandType.I32, exceptionRecordPtr);
-
-            context.BranchIf(validExceptionLabel, exceptionCode, Const(EXCEPTION_ACCESS_VIOLATION), Comparison.Equal);
-
-            context.Return(Const(EXCEPTION_CONTINUE_SEARCH)); // Don't handle this one.
-
-            context.MarkLabel(validExceptionLabel);
-
-            // Next, read the address of the invalid access, and whether it is a write or not.
-
-            Operand structAddressOffset = context.Load(OperandType.I32, Const((ulong)signalStructPtr + StructAddressOffset));
-            Operand structWriteOffset = context.Load(OperandType.I32, Const((ulong)signalStructPtr + StructWriteOffset));
-
-            Operand faultAddress = context.Load(OperandType.I64, context.Add(exceptionRecordPtr, context.ZeroExtend32(OperandType.I64, structAddressOffset)));
-            Operand writeFlag = context.Load(OperandType.I64, context.Add(exceptionRecordPtr, context.ZeroExtend32(OperandType.I64, structWriteOffset)));
-
-            Operand isWrite = context.ICompareNotEqual(writeFlag, Const(0L)); // Normalize to 0/1.
-
-            Operand isInRegion = EmitGenericRegionCheck(context, signalStructPtr, faultAddress, isWrite);
-
-            Operand endLabel = Label();
-
-            // If the region check result is false, then run the next vectored exception handler.
-
-            context.BranchIfTrue(endLabel, isInRegion);
-
-            context.Return(Const(EXCEPTION_CONTINUE_SEARCH));
-
-            context.MarkLabel(endLabel);
-
-            // Otherwise, return to execution.
-
-            context.Return(Const(EXCEPTION_CONTINUE_EXECUTION));
-
-            // Compile and return the function.
-
-            ControlFlowGraph cfg = context.GetControlFlowGraph();
-
-            OperandType[] argTypes = new OperandType[] { OperandType.I64 };
-
-            return Compiler.Compile(cfg, argTypes, OperandType.I32, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<VectoredExceptionHandler>();
-        }
-    }
-}

ARMeilleure/State/ExecutionContext.cs

@@ -1,164 +0,0 @@
-using ARMeilleure.Memory;
-using System;
-
-namespace ARMeilleure.State
-{
-    public class ExecutionContext
-    {
-        private const int MinCountForCheck = 4000;
-
-        private NativeContext _nativeContext;
-
-        internal IntPtr NativeContextPtr => _nativeContext.BasePtr;
-
-        private bool _interrupted;
-
-        private readonly ICounter _counter;
-
-        public ulong Pc => _nativeContext.GetPc();
-
-        public uint CtrEl0 => 0x8444c004;
-        public uint DczidEl0 => 0x00000004;
-
-        public ulong CntfrqEl0 => _counter.Frequency;
-        public ulong CntpctEl0 => _counter.Counter;
-
-        // CNTVCT_EL0 = CNTPCT_EL0 - CNTVOFF_EL2
-        // Since EL2 isn't implemented, CNTVOFF_EL2 = 0
-        public ulong CntvctEl0 => CntpctEl0;
-
-        public long TpidrEl0 { get; set; }
-        public long TpidrroEl0 { get; set; }
-
-        public uint Pstate
-        {
-            get => _nativeContext.GetPstate();
-            set => _nativeContext.SetPstate(value);
-        }
-
-        public FPSR Fpsr
-        {
-            get => (FPSR)_nativeContext.GetFPState((uint)FPSR.Mask);
-            set => _nativeContext.SetFPState((uint)value, (uint)FPSR.Mask);
-        }
-
-        public FPCR Fpcr
-        {
-            get => (FPCR)_nativeContext.GetFPState((uint)FPCR.Mask);
-            set => _nativeContext.SetFPState((uint)value, (uint)FPCR.Mask);
-        }
-        public FPCR StandardFpcrValue => (Fpcr & (FPCR.Ahp)) | FPCR.Dn | FPCR.Fz;
-
-        public FPSCR Fpscr
-        {
-            get => (FPSCR)_nativeContext.GetFPState((uint)FPSCR.Mask);
-            set => _nativeContext.SetFPState((uint)value, (uint)FPSCR.Mask);
-        }
-
-        public bool IsAarch32 { get; set; }
-
-        internal ExecutionMode ExecutionMode
-        {
-            get
-            {
-                if (IsAarch32)
-                {
-                    return GetPstateFlag(PState.TFlag)
-                        ? ExecutionMode.Aarch32Thumb
-                        : ExecutionMode.Aarch32Arm;
-                }
-                else
-                {
-                    return ExecutionMode.Aarch64;
-                }
-            }
-        }
-
-        public bool Running
-        {
-            get => _nativeContext.GetRunning();
-            private set => _nativeContext.SetRunning(value);
-        }
-
-        private readonly ExceptionCallbackNoArgs _interruptCallback;
-        private readonly ExceptionCallback _breakCallback;
-        private readonly ExceptionCallback _supervisorCallback;
-        private readonly ExceptionCallback _undefinedCallback;
-
-        public ExecutionContext(
-            IJitMemoryAllocator allocator,
-            ICounter counter,
-            ExceptionCallbackNoArgs interruptCallback = null,
-            ExceptionCallback breakCallback = null,
-            ExceptionCallback supervisorCallback = null,
-            ExceptionCallback undefinedCallback = null)
-        {
-            _nativeContext = new NativeContext(allocator);
-            _counter = counter;
-            _interruptCallback = interruptCallback;
-            _breakCallback = breakCallback;
-            _supervisorCallback = supervisorCallback;
-            _undefinedCallback = undefinedCallback;
-
-            Running = true;
-
-            _nativeContext.SetCounter(MinCountForCheck);
-        }
-
-        public ulong GetX(int index) => _nativeContext.GetX(index);
-        public void SetX(int index, ulong value) => _nativeContext.SetX(index, value);
-
-        public V128 GetV(int index) => _nativeContext.GetV(index);
-        public void SetV(int index, V128 value) => _nativeContext.SetV(index, value);
-
-        public bool GetPstateFlag(PState flag) => _nativeContext.GetPstateFlag(flag);
-        public void SetPstateFlag(PState flag, bool value) => _nativeContext.SetPstateFlag(flag, value);
-
-        public bool GetFPstateFlag(FPState flag) => _nativeContext.GetFPStateFlag(flag);
-        public void SetFPstateFlag(FPState flag, bool value) => _nativeContext.SetFPStateFlag(flag, value);
-
-        internal void CheckInterrupt()
-        {
-            if (_interrupted)
-            {
-                _interrupted = false;
-
-                _interruptCallback?.Invoke(this);
-            }
-
-            _nativeContext.SetCounter(MinCountForCheck);
-        }
-
-        public void RequestInterrupt()
-        {
-            _interrupted = true;
-        }
-
-        internal void OnBreak(ulong address, int imm)
-        {
-            _breakCallback?.Invoke(this, address, imm);
-        }
-
-        internal void OnSupervisorCall(ulong address, int imm)
-        {
-            _supervisorCallback?.Invoke(this, address, imm);
-        }
-
-        internal void OnUndefined(ulong address, int opCode)
-        {
-            _undefinedCallback?.Invoke(this, address, opCode);
-        }
-
-        public void StopRunning()
-        {
-            Running = false;
-
-            _nativeContext.SetCounter(0);
-        }
-
-        public void Dispose()
-        {
-            _nativeContext.Dispose();
-        }
-    }
-}

ARMeilleure/State/ExecutionMode.cs

@@ -1,9 +0,0 @@
-namespace ARMeilleure.State
-{
-    enum ExecutionMode : int
-    {
-        Aarch32Arm = 0,
-        Aarch32Thumb = 1,
-        Aarch64 = 2
-    }
-}

ARMeilleure/State/NativeContext.cs

@@ -1,251 +0,0 @@
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Memory;
-using System;
-using System.Runtime.CompilerServices;
-
-namespace ARMeilleure.State
-{
-    class NativeContext : IDisposable
-    {
-        private unsafe struct NativeCtxStorage
-        {
-            public fixed ulong X[RegisterConsts.IntRegsCount];
-            public fixed ulong V[RegisterConsts.VecRegsCount * 2];
-            public fixed uint Flags[RegisterConsts.FlagsCount];
-            public fixed uint FpFlags[RegisterConsts.FpFlagsCount];
-            public int Counter;
-            public ulong DispatchAddress;
-            public ulong ExclusiveAddress;
-            public ulong ExclusiveValueLow;
-            public ulong ExclusiveValueHigh;
-            public int Running;
-        }
-
-        private static NativeCtxStorage _dummyStorage = new NativeCtxStorage();
-
-        private readonly IJitMemoryBlock _block;
-
-        public IntPtr BasePtr => _block.Pointer;
-
-        public NativeContext(IJitMemoryAllocator allocator)
-        {
-            _block = allocator.Allocate((ulong)Unsafe.SizeOf<NativeCtxStorage>());
-
-            GetStorage().ExclusiveAddress = ulong.MaxValue;
-        }
-
-        public ulong GetPc()
-        {
-            // TODO: More precise tracking of PC value.
-            return GetStorage().DispatchAddress;
-        }
-
-        public unsafe ulong GetX(int index)
-        {
-            if ((uint)index >= RegisterConsts.IntRegsCount)
-            {
-                throw new ArgumentOutOfRangeException(nameof(index));
-            }
-
-            return GetStorage().X[index];
-        }
-
-        public unsafe void SetX(int index, ulong value)
-        {
-            if ((uint)index >= RegisterConsts.IntRegsCount)
-            {
-                throw new ArgumentOutOfRangeException(nameof(index));
-            }
-
-            GetStorage().X[index] = value;
-        }
-
-        public unsafe V128 GetV(int index)
-        {
-            if ((uint)index >= RegisterConsts.VecRegsCount)
-            {
-                throw new ArgumentOutOfRangeException(nameof(index));
-            }
-
-            return new V128(GetStorage().V[index * 2 + 0], GetStorage().V[index * 2 + 1]);
-        }
-
-        public unsafe void SetV(int index, V128 value)
-        {
-            if ((uint)index >= RegisterConsts.VecRegsCount)
-            {
-                throw new ArgumentOutOfRangeException(nameof(index));
-            }
-
-            GetStorage().V[index * 2 + 0] = value.Extract<ulong>(0);
-            GetStorage().V[index * 2 + 1] = value.Extract<ulong>(1);
-        }
-
-        public unsafe bool GetPstateFlag(PState flag)
-        {
-            if ((uint)flag >= RegisterConsts.FlagsCount)
-            {
-                throw new ArgumentException($"Invalid flag \"{flag}\" specified.");
-            }
-
-            return GetStorage().Flags[(int)flag] != 0;
-        }
-
-        public unsafe void SetPstateFlag(PState flag, bool value)
-        {
-            if ((uint)flag >= RegisterConsts.FlagsCount)
-            {
-                throw new ArgumentException($"Invalid flag \"{flag}\" specified.");
-            }
-
-            GetStorage().Flags[(int)flag] = value ? 1u : 0u;
-        }
-
-        public unsafe uint GetPstate()
-        {
-            uint value = 0;
-            for (int flag = 0; flag < RegisterConsts.FlagsCount; flag++)
-            {
-                value |= GetStorage().Flags[flag] != 0 ? 1u << flag : 0u;
-            }
-            return value;
-        }
-
-        public unsafe void SetPstate(uint value)
-        {
-            for (int flag = 0; flag < RegisterConsts.FlagsCount; flag++)
-            {
-                uint bit = 1u << flag;
-                GetStorage().Flags[flag] = (value & bit) == bit ? 1u : 0u;
-            }
-        }
-
-        public unsafe bool GetFPStateFlag(FPState flag)
-        {
-            if ((uint)flag >= RegisterConsts.FpFlagsCount)
-            {
-                throw new ArgumentException($"Invalid flag \"{flag}\" specified.");
-            }
-
-            return GetStorage().FpFlags[(int)flag] != 0;
-        }
-
-        public unsafe void SetFPStateFlag(FPState flag, bool value)
-        {
-            if ((uint)flag >= RegisterConsts.FpFlagsCount)
-            {
-                throw new ArgumentException($"Invalid flag \"{flag}\" specified.");
-            }
-
-            GetStorage().FpFlags[(int)flag] = value ? 1u : 0u;
-        }
-
-        public unsafe uint GetFPState(uint mask = uint.MaxValue)
-        {
-            uint value = 0;
-            for (int flag = 0; flag < RegisterConsts.FpFlagsCount; flag++)
-            {
-                uint bit = 1u << flag;
-
-                if ((mask & bit) == bit)
-                {
-                    value |= GetStorage().FpFlags[flag] != 0 ? bit : 0u;
-                }
-            }
-            return value;
-        }
-
-        public unsafe void SetFPState(uint value, uint mask = uint.MaxValue)
-        {
-            for (int flag = 0; flag < RegisterConsts.FpFlagsCount; flag++)
-            {
-                uint bit = 1u << flag;
-
-                if ((mask & bit) == bit)
-                {
-                    GetStorage().FpFlags[flag] = (value & bit) == bit ? 1u : 0u;
-                }
-            }
-        }
-
-        public int GetCounter() => GetStorage().Counter;
-        public void SetCounter(int value) => GetStorage().Counter = value;
-
-        public bool GetRunning() => GetStorage().Running != 0;
-        public void SetRunning(bool value) => GetStorage().Running = value ? 1 : 0;
-
-        public unsafe static int GetRegisterOffset(Register reg)
-        {
-            if (reg.Type == RegisterType.Integer)
-            {
-                if ((uint)reg.Index >= RegisterConsts.IntRegsCount)
-                {
-                    throw new ArgumentException("Invalid register.");
-                }
-
-                return StorageOffset(ref _dummyStorage, ref _dummyStorage.X[reg.Index]);
-            }
-            else if (reg.Type == RegisterType.Vector)
-            {
-                if ((uint)reg.Index >= RegisterConsts.VecRegsCount)
-                {
-                    throw new ArgumentException("Invalid register.");
-                }
-
-                return StorageOffset(ref _dummyStorage, ref _dummyStorage.V[reg.Index * 2]);
-            }
-            else if (reg.Type == RegisterType.Flag)
-            {
-                if ((uint)reg.Index >= RegisterConsts.FlagsCount)
-                {
-                    throw new ArgumentException("Invalid register.");
-                }
-
-                return StorageOffset(ref _dummyStorage, ref _dummyStorage.Flags[reg.Index]);
-            }
-            else /* if (reg.Type == RegisterType.FpFlag) */
-            {
-                if ((uint)reg.Index >= RegisterConsts.FpFlagsCount)
-                {
-                    throw new ArgumentException("Invalid register.");
-                }
-
-                return StorageOffset(ref _dummyStorage, ref _dummyStorage.FpFlags[reg.Index]);
-            }
-        }
-
-        public static int GetCounterOffset()
-        {
-            return StorageOffset(ref _dummyStorage, ref _dummyStorage.Counter);
-        }
-
-        public static int GetDispatchAddressOffset()
-        {
-            return StorageOffset(ref _dummyStorage, ref _dummyStorage.DispatchAddress);
-        }
-
-        public static int GetExclusiveAddressOffset()
-        {
-            return StorageOffset(ref _dummyStorage, ref _dummyStorage.ExclusiveAddress);
-        }
-
-        public static int GetExclusiveValueOffset()
-        {
-            return StorageOffset(ref _dummyStorage, ref _dummyStorage.ExclusiveValueLow);
-        }
-
-        public static int GetRunningOffset()
-        {
-            return StorageOffset(ref _dummyStorage, ref _dummyStorage.Running);
-        }
-
-        private static int StorageOffset<T>(ref NativeCtxStorage storage, ref T target)
-        {
-            return (int)Unsafe.ByteOffset(ref Unsafe.As<NativeCtxStorage, T>(ref storage), ref target);
-        }
-
-        private unsafe ref NativeCtxStorage GetStorage() => ref Unsafe.AsRef<NativeCtxStorage>((void*)_block.Pointer);
-
-        public void Dispose() => _block.Dispose();
-    }
-}

ARMeilleure/State/V128.cs

@@ -1,312 +0,0 @@
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace ARMeilleure.State
-{
-    /// <summary>
-    /// Represents a 128-bit vector.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential, Size = 16)]
-    public struct V128 : IEquatable<V128>
-    {
-        // _e0 & _e1 could be marked as readonly, however they are not readonly because we modify them through the Unsafe
-        // APIs. This also means that one should be careful when changing the layout of this struct.
-
-        private ulong _e0;
-        private ulong _e1;
-
-        /// <summary>
-        /// Gets a new <see cref="V128"/> with all bits set to zero.
-        /// </summary>
-        public static V128 Zero => new V128(0, 0);
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="V128"/> struct with the specified <see cref="double"/> value
-        /// as a scalar.
-        /// </summary>
-        /// <param name="value">Scalar value</param>
-        public V128(double value) : this(value, 0) { }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="V128"/> struct with the specified <see cref="double"/> elements.
-        /// </summary>
-        /// <param name="e0">Element 0</param>
-        /// <param name="e1">Element 1</param>
-        public V128(double e0, double e1)
-        {
-            _e0 = (ulong)BitConverter.DoubleToInt64Bits(e0);
-            _e1 = (ulong)BitConverter.DoubleToInt64Bits(e1);
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="V128"/> struct with the specified <see cref="float"/> value as a
-        /// scalar.
-        /// </summary>
-        /// <param name="value">Scalar value</param>
-        public V128(float value) : this(value, 0, 0, 0) { }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="V128"/> struct with the specified <see cref="float"/> elements.
-        /// </summary>
-        /// <param name="e0">Element 0</param>
-        /// <param name="e1">Element 1</param>
-        /// <param name="e2">Element 2</param>
-        /// <param name="e3">Element 3</param>
-        public V128(float e0, float e1, float e2, float e3)
-        {
-            _e0  = (ulong)(uint)BitConverter.SingleToInt32Bits(e0) << 0;
-            _e0 |= (ulong)(uint)BitConverter.SingleToInt32Bits(e1) << 32;
-            _e1  = (ulong)(uint)BitConverter.SingleToInt32Bits(e2) << 0;
-            _e1 |= (ulong)(uint)BitConverter.SingleToInt32Bits(e3) << 32;
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="V128"/> struct with the specified <see cref="ulong"/>
-        /// elements.
-        /// </summary>
-        /// <param name="e0">Element 0</param>
-        /// <param name="e1">Element 1</param>
-        public V128(long e0, long e1) : this((ulong)e0, (ulong)e1) { }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="V128"/> struct with the specified <see cref="long"/> elements.
-        /// </summary>
-        /// <param name="e0">Element 0</param>
-        /// <param name="e1">Element 1</param>
-        public V128(ulong e0, ulong e1)
-        {
-            _e0 = e0;
-            _e1 = e1;
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="V128"/> struct with the specified <see cref="int"/> elements.
-        /// </summary>
-        /// <param name="e0">Element 0</param>
-        /// <param name="e1">Element 1</param>
-        /// <param name="e2">Element 2</param>
-        /// <param name="e3">Element 3</param>
-        public V128(int e0, int e1, int e2, int e3) : this((uint)e0, (uint)e1, (uint)e2, (uint)e3) { }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="V128"/> struct with the specified <see cref="uint"/> elements.
-        /// </summary>
-        /// <param name="e0">Element 0</param>
-        /// <param name="e1">Element 1</param>
-        /// <param name="e2">Element 2</param>
-        /// <param name="e3">Element 3</param>
-        public V128(uint e0, uint e1, uint e2, uint e3)
-        {
-            _e0  = (ulong)e0 << 0;
-            _e0 |= (ulong)e1 << 32;
-            _e1  = (ulong)e2 << 0;
-            _e1 |= (ulong)e3 << 32;
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="V128"/> struct from the specified <see cref="byte"/> array.
-        /// </summary>
-        /// <param name="data"><see cref="byte"/> array to use</param>
-        public V128(byte[] data)
-        {
-            _e0 = (ulong)BitConverter.ToInt64(data, 0);
-            _e1 = (ulong)BitConverter.ToInt64(data, 8);
-        }
-
-        /// <summary>
-        /// Returns the value of the <see cref="V128"/> as a <typeparamref name="T"/> scalar.
-        /// </summary>
-        /// <typeparam name="T">Type of scalar</typeparam>
-        /// <returns>Value of the <see cref="V128"/> as a <typeparamref name="T"/> scalar</returns>
-        /// <exception cref="ArgumentOutOfRangeException">Size of <typeparamref name="T"/> is larger than 16 bytes</exception>
-        public T As<T>() where T : unmanaged
-        {
-            return Extract<T>(0);
-        }
-
-        /// <summary>
-        /// Extracts the element at the specified index as a <typeparamref name="T"/> from the <see cref="V128"/>.
-        /// </summary>
-        /// <typeparam name="T">Element type</typeparam>
-        /// <param name="index">Index of element</param>
-        /// <returns>Element at the specified index as a <typeparamref name="T"/> from the <see cref="V128"/></returns>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// <paramref name="index"/> is out of bound or the size of <typeparamref name="T"/> is larger than 16 bytes
-        /// </exception>
-        public T Extract<T>(int index) where T : unmanaged
-        {
-            if ((uint)index >= GetElementCount<T>())
-                ThrowIndexOutOfRange();
-
-            // Performs:
-            //  return *((*T)this + index);
-            return Unsafe.Add(ref Unsafe.As<V128, T>(ref this), index);
-        }
-
-        /// <summary>
-        /// Inserts the specified value into the element at the specified index in the <see cref="V128"/>.
-        /// </summary>
-        /// <typeparam name="T">Element type</typeparam>
-        /// <param name="index">Index of element</param>
-        /// <param name="value">Value to insert</param>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// <paramref name="index"/> is out of bound or the size of <typeparamref name="T"/> is larger than 16 bytes
-        /// </exception>
-        public void Insert<T>(int index, T value) where T : unmanaged
-        {
-            if ((uint)index >= GetElementCount<T>())
-                ThrowIndexOutOfRange();
-
-            // Performs:
-            //  *((*T)this + index) = value;
-            Unsafe.Add(ref Unsafe.As<V128, T>(ref this), index) = value;
-        }
-
-        /// <summary>
-        /// Returns a new <see cref="byte"/> array which represents the <see cref="V128"/>.
-        /// </summary>
-        /// <returns>A new <see cref="byte"/> array which represents the <see cref="V128"/></returns>
-        public byte[] ToArray()
-        {
-            byte[]     data = new byte[16];
-            Span<byte> span = data;
-
-            BitConverter.TryWriteBytes(span, _e0);
-            BitConverter.TryWriteBytes(span.Slice(8), _e1);
-
-            return data;
-        }
-
-        /// <summary>
-        /// Performs a bitwise logical left shift on the specified <see cref="V128"/> by the specified shift count.
-        /// </summary>
-        /// <param name="x"><see cref="V128"/> instance</param>
-        /// <param name="shift">Number of shifts</param>
-        /// <returns>Result of left shift</returns>
-        /// <remarks>
-        /// This supports shift counts up to 63; anything above may result in unexpected behaviour.
-        /// </remarks>
-        public static V128 operator <<(V128 x, int shift)
-        {
-            if (shift == 0)
-            {
-                return new V128(x._e0, x._e1);
-            }
-
-            ulong shiftOut = x._e0 >> (64 - shift);
-
-            return new V128(x._e0 << shift, (x._e1 << shift) | shiftOut);
-        }
-
-        /// <summary>
-        /// Performs a bitwise logical right shift on the specified <see cref="V128"/> by the specified shift count.
-        /// </summary>
-        /// <param name="x"><see cref="V128"/> instance</param>
-        /// <param name="shift">Number of shifts</param>
-        /// <returns>Result of right shift</returns>
-        /// <remarks>
-        /// This supports shift counts up to 63; anything above may result in unexpected behaviour.
-        /// </remarks>
-        public static V128 operator >>(V128 x, int shift)
-        {
-            if (shift == 0)
-            {
-                return new V128(x._e0, x._e1);
-            }
-
-            ulong shiftOut = x._e1 & ((1UL << shift) - 1);
-
-            return new V128((x._e0 >> shift) | (shiftOut << (64 - shift)), x._e1 >> shift);
-        }
-
-        /// <summary>
-        /// Performs a bitwise not on the specified <see cref="V128"/>.
-        /// </summary>
-        /// <param name="x">Target <see cref="V128"/></param>
-        /// <returns>Result of not operation</returns>
-        public static V128 operator ~(V128 x) => new V128(~x._e0, ~x._e1);
-
-        /// <summary>
-        /// Performs a bitwise and on the specified <see cref="V128"/> instances.
-        /// </summary>
-        /// <param name="x">First instance</param>
-        /// <param name="y">Second instance</param>
-        /// <returns>Result of and operation</returns>
-        public static V128 operator &(V128 x, V128 y) => new V128(x._e0 & y._e0, x._e1 & y._e1);
-
-        /// <summary>
-        /// Performs a bitwise or on the specified <see cref="V128"/> instances.
-        /// </summary>
-        /// <param name="x">First instance</param>
-        /// <param name="y">Second instance</param>
-        /// <returns>Result of or operation</returns>
-        public static V128 operator |(V128 x, V128 y) => new V128(x._e0 | y._e0, x._e1 | y._e1);
-
-        /// <summary>
-        /// Performs a bitwise exlusive or on the specified <see cref="V128"/> instances.
-        /// </summary>
-        /// <param name="x">First instance</param>
-        /// <param name="y">Second instance</param>
-        /// <returns>Result of exclusive or operation</returns>
-        public static V128 operator ^(V128 x, V128 y) => new V128(x._e0 ^ y._e0, x._e1 ^ y._e1);
-
-        /// <summary>
-        /// Determines if the specified <see cref="V128"/> instances are equal.
-        /// </summary>
-        /// <param name="x">First instance</param>
-        /// <param name="y">Second instance</param>
-        /// <returns>true if equal; otherwise false</returns>
-        public static bool operator ==(V128 x, V128 y) => x.Equals(y);
-
-        /// <summary>
-        /// Determines if the specified <see cref="V128"/> instances are not equal.
-        /// </summary>
-        /// <param name="x">First instance</param>
-        /// <param name="y">Second instance</param>
-        /// <returns>true if not equal; otherwise false</returns>
-        public static bool operator !=(V128 x, V128 y) => !x.Equals(y);
-
-        /// <summary>
-        /// Determines if the specified <see cref="V128"/> is equal to this <see cref="V128"/> instance.
-        /// </summary>
-        /// <param name="other">Other <see cref="V128"/> instance</param>
-        /// <returns>true if equal; otherwise false</returns>
-        public bool Equals(V128 other)
-        {
-            return other._e0 == _e0 && other._e1 == _e1;
-        }
-
-        /// <summary>
-        /// Determines if the specified <see cref="object"/> is equal to this <see cref="V128"/> instance.
-        /// </summary>
-        /// <param name="obj">Other <see cref="object"/> instance</param>
-        /// <returns>true if equal; otherwise false</returns>
-        public override bool Equals(object obj)
-        {
-            return obj is V128 vector && Equals(vector);
-        }
-
-        /// <inheritdoc/>
-        public override int GetHashCode()
-        {
-            return HashCode.Combine(_e0, _e1);
-        }
-
-        /// <inheritdoc/>
-        public override string ToString()
-        {
-            return $"0x{_e1:X16}{_e0:X16}";
-        }
-
-        private uint GetElementCount<T>() where T : unmanaged
-        {
-            return (uint)(Unsafe.SizeOf<V128>() / Unsafe.SizeOf<T>());
-        }
-
-        private static void ThrowIndexOutOfRange()
-        {
-            throw new ArgumentOutOfRangeException("index");
-        }
-    }
-}

ARMeilleure/Translation/ArmEmitterContext.cs

@@ -1,267 +0,0 @@
-using ARMeilleure.CodeGen.Linking;
-using ARMeilleure.Common;
-using ARMeilleure.Decoders;
-using ARMeilleure.Diagnostics;
-using ARMeilleure.Instructions;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Memory;
-using ARMeilleure.State;
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Translation
-{
-    class ArmEmitterContext : EmitterContext
-    {
-        private readonly Dictionary<ulong, Operand> _labels;
-
-        private OpCode _optOpLastCompare;
-        private OpCode _optOpLastFlagSet;
-
-        private Operand _optCmpTempN;
-        private Operand _optCmpTempM;
-
-        private Block _currBlock;
-
-        public Block CurrBlock
-        {
-            get
-            {
-                return _currBlock;
-            }
-            set
-            {
-                _currBlock = value;
-
-                ResetBlockState();
-            }
-        }
-
-        private bool _pendingQcFlagSync;
-
-        public OpCode CurrOp { get; set; }
-
-        public IMemoryManager Memory { get; }
-
-        public EntryTable<uint> CountTable { get; }
-        public AddressTable<ulong> FunctionTable { get; }
-        public TranslatorStubs Stubs { get; }
-
-        public ulong EntryAddress { get; }
-        public bool HighCq { get; }
-        public bool HasPtc { get; }
-        public Aarch32Mode Mode { get; }
-
-        private int _ifThenBlockStateIndex = 0;
-        private Condition[] _ifThenBlockState = { };
-        public bool IsInIfThenBlock => _ifThenBlockStateIndex < _ifThenBlockState.Length;
-        public Condition CurrentIfThenBlockCond => _ifThenBlockState[_ifThenBlockStateIndex];
-
-        public ArmEmitterContext(
-            IMemoryManager memory,
-            EntryTable<uint> countTable,
-            AddressTable<ulong> funcTable,
-            TranslatorStubs stubs,
-            ulong entryAddress,
-            bool highCq,
-            bool hasPtc,
-            Aarch32Mode mode)
-        {
-            Memory = memory;
-            CountTable = countTable;
-            FunctionTable = funcTable;
-            Stubs = stubs;
-            EntryAddress = entryAddress;
-            HighCq = highCq;
-            HasPtc = hasPtc;
-            Mode = mode;
-
-            _labels = new Dictionary<ulong, Operand>();
-        }
-
-        public override Operand Call(MethodInfo info, params Operand[] callArgs)
-        {
-            SyncQcFlag();
-
-            if (!HasPtc)
-            {
-                return base.Call(info, callArgs);
-            }
-            else
-            {
-                int index = Delegates.GetDelegateIndex(info);
-                IntPtr funcPtr = Delegates.GetDelegateFuncPtrByIndex(index);
-
-                OperandType returnType = GetOperandType(info.ReturnType);
-
-                Symbol symbol = new Symbol(SymbolType.DelegateTable, (ulong)index);
-
-                Symbols.Add((ulong)funcPtr.ToInt64(), info.Name);
-
-                return Call(Const(funcPtr.ToInt64(), symbol), returnType, callArgs);
-            }
-        }
-
-        public Operand GetLabel(ulong address)
-        {
-            if (!_labels.TryGetValue(address, out Operand label))
-            {
-                label = Label();
-
-                _labels.Add(address, label);
-            }
-
-            return label;
-        }
-
-        public void MarkComparison(Operand n, Operand m)
-        {
-            _optOpLastCompare = CurrOp;
-
-            _optCmpTempN = Copy(n);
-            _optCmpTempM = Copy(m);
-        }
-
-        public void MarkFlagSet(PState stateFlag)
-        {
-            // Set this only if any of the NZCV flag bits were modified.
-            // This is used to ensure that when emiting a direct IL branch
-            // instruction for compare + branch sequences, we're not expecting
-            // to use comparison values from an old instruction, when in fact
-            // the flags were already overwritten by another instruction further along.
-            if (stateFlag >= PState.VFlag)
-            {
-                _optOpLastFlagSet = CurrOp;
-            }
-        }
-
-        private void ResetBlockState()
-        {
-            _optOpLastCompare = null;
-            _optOpLastFlagSet = null;
-        }
-
-        public void SetPendingQcFlagSync()
-        {
-            _pendingQcFlagSync = true;
-        }
-
-        public void SyncQcFlag()
-        {
-            if (_pendingQcFlagSync)
-            {
-                if (Optimizations.UseAdvSimd)
-                {
-                    Operand fpsr = AddIntrinsicInt(Intrinsic.Arm64MrsFpsr);
-
-                    uint qcFlagMask = (uint)FPSR.Qc;
-
-                    Operand qcClearLabel = Label();
-
-                    BranchIfFalse(qcClearLabel, BitwiseAnd(fpsr, Const(qcFlagMask)));
-
-                    AddIntrinsicNoRet(Intrinsic.Arm64MsrFpsr, Const(0));
-                    InstEmitHelper.SetFpFlag(this, FPState.QcFlag, Const(1));
-
-                    MarkLabel(qcClearLabel);
-                }
-
-                _pendingQcFlagSync = false;
-            }
-        }
-
-        public void ClearQcFlag()
-        {
-            if (Optimizations.UseAdvSimd)
-            {
-                AddIntrinsicNoRet(Intrinsic.Arm64MsrFpsr, Const(0));
-            }
-        }
-
-        public void ClearQcFlagIfModified()
-        {
-            if (_pendingQcFlagSync && Optimizations.UseAdvSimd)
-            {
-                AddIntrinsicNoRet(Intrinsic.Arm64MsrFpsr, Const(0));
-            }
-        }
-
-        public Operand TryGetComparisonResult(Condition condition)
-        {
-            if (_optOpLastCompare == null || _optOpLastCompare != _optOpLastFlagSet)
-            {
-                return default;
-            }
-
-            Operand n = _optCmpTempN;
-            Operand m = _optCmpTempM;
-
-            InstName cmpName = _optOpLastCompare.Instruction.Name;
-
-            if (cmpName == InstName.Subs)
-            {
-                switch (condition)
-                {
-                    case Condition.Eq:   return ICompareEqual           (n, m);
-                    case Condition.Ne:   return ICompareNotEqual        (n, m);
-                    case Condition.GeUn: return ICompareGreaterOrEqualUI(n, m);
-                    case Condition.LtUn: return ICompareLessUI          (n, m);
-                    case Condition.GtUn: return ICompareGreaterUI       (n, m);
-                    case Condition.LeUn: return ICompareLessOrEqualUI   (n, m);
-                    case Condition.Ge:   return ICompareGreaterOrEqual  (n, m);
-                    case Condition.Lt:   return ICompareLess            (n, m);
-                    case Condition.Gt:   return ICompareGreater         (n, m);
-                    case Condition.Le:   return ICompareLessOrEqual     (n, m);
-                }
-            }
-            else if (cmpName == InstName.Adds && _optOpLastCompare is IOpCodeAluImm op)
-            {
-                // There are several limitations that needs to be taken into account for CMN comparisons:
-                // - The unsigned comparisons are not valid, as they depend on the
-                // carry flag value, and they will have different values for addition and
-                // subtraction. For addition, it's carry, and for subtraction, it's borrow.
-                // So, we need to make sure we're not doing a unsigned compare for the CMN case.
-                // - We can only do the optimization for the immediate variants,
-                // because when the second operand value is exactly INT_MIN, we can't
-                // negate the value as theres no positive counterpart.
-                // Such invalid values can't be encoded on the immediate encodings.
-                if (op.RegisterSize == RegisterSize.Int32)
-                {
-                    m = Const((int)-op.Immediate);
-                }
-                else
-                {
-                    m = Const(-op.Immediate);
-                }
-
-                switch (condition)
-                {
-                    case Condition.Eq: return ICompareEqual         (n, m);
-                    case Condition.Ne: return ICompareNotEqual      (n, m);
-                    case Condition.Ge: return ICompareGreaterOrEqual(n, m);
-                    case Condition.Lt: return ICompareLess          (n, m);
-                    case Condition.Gt: return ICompareGreater       (n, m);
-                    case Condition.Le: return ICompareLessOrEqual   (n, m);
-                }
-            }
-
-            return default;
-        }
-
-        public void SetIfThenBlockState(Condition[] state)
-        {
-            _ifThenBlockState = state;
-            _ifThenBlockStateIndex = 0;
-        }
-
-        public void AdvanceIfThenBlockState()
-        {
-            if (IsInIfThenBlock)
-            {
-                _ifThenBlockStateIndex++;
-            }
-        }
-    }
-}

ARMeilleure/Translation/Cache/JitCache.cs

@@ -1,198 +0,0 @@
-using ARMeilleure.CodeGen;
-using ARMeilleure.CodeGen.Unwinding;
-using ARMeilleure.Memory;
-using ARMeilleure.Native;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-
-namespace ARMeilleure.Translation.Cache
-{
-    static class JitCache
-    {
-        private const int PageSize = 4 * 1024;
-        private const int PageMask = PageSize - 1;
-
-        private const int CodeAlignment = 4; // Bytes.
-        private const int CacheSize = 2047 * 1024 * 1024;
-
-        private static ReservedRegion _jitRegion;
-        private static JitCacheInvalidation _jitCacheInvalidator;
-
-        private static CacheMemoryAllocator _cacheAllocator;
-
-        private static readonly List<CacheEntry> _cacheEntries = new List<CacheEntry>();
-
-        private static readonly object _lock = new object();
-        private static bool _initialized;
-
-        public static void Initialize(IJitMemoryAllocator allocator)
-        {
-            if (_initialized) return;
-
-            lock (_lock)
-            {
-                if (_initialized) return;
-
-                _jitRegion = new ReservedRegion(allocator, CacheSize);
-                _jitCacheInvalidator = new JitCacheInvalidation(allocator);
-
-                _cacheAllocator = new CacheMemoryAllocator(CacheSize);
-
-                if (OperatingSystem.IsWindows())
-                {
-                    JitUnwindWindows.InstallFunctionTableHandler(_jitRegion.Pointer, CacheSize, _jitRegion.Pointer + Allocate(PageSize));
-                }
-
-                _initialized = true;
-            }
-        }
-
-        public static IntPtr Map(CompiledFunction func)
-        {
-            byte[] code = func.Code;
-
-            lock (_lock)
-            {
-                Debug.Assert(_initialized);
-
-                int funcOffset = Allocate(code.Length);
-
-                IntPtr funcPtr = _jitRegion.Pointer + funcOffset;
-
-                if (OperatingSystem.IsMacOS() && RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
-                {
-                    unsafe
-                    {
-                        fixed (byte *codePtr = code)
-                        {
-                            JitSupportDarwin.Copy(funcPtr, (IntPtr)codePtr, (ulong)code.Length);
-                        }
-                    }
-                }
-                else
-                {
-                    ReprotectAsWritable(funcOffset, code.Length);
-                    Marshal.Copy(code, 0, funcPtr, code.Length);
-                    ReprotectAsExecutable(funcOffset, code.Length);
-
-                    _jitCacheInvalidator.Invalidate(funcPtr, (ulong)code.Length);
-                }
-
-                Add(funcOffset, code.Length, func.UnwindInfo);
-
-                return funcPtr;
-            }
-        }
-
-        public static void Unmap(IntPtr pointer)
-        {
-            lock (_lock)
-            {
-                Debug.Assert(_initialized);
-
-                int funcOffset = (int)(pointer.ToInt64() - _jitRegion.Pointer.ToInt64());
-
-                bool result = TryFind(funcOffset, out CacheEntry entry);
-                Debug.Assert(result);
-
-                _cacheAllocator.Free(funcOffset, AlignCodeSize(entry.Size));
-
-                Remove(funcOffset);
-            }
-        }
-
-        private static void ReprotectAsWritable(int offset, int size)
-        {
-            int endOffs = offset + size;
-
-            int regionStart = offset & ~PageMask;
-            int regionEnd = (endOffs + PageMask) & ~PageMask;
-
-            _jitRegion.Block.MapAsRwx((ulong)regionStart, (ulong)(regionEnd - regionStart));
-        }
-
-        private static void ReprotectAsExecutable(int offset, int size)
-        {
-            int endOffs = offset + size;
-
-            int regionStart = offset & ~PageMask;
-            int regionEnd = (endOffs + PageMask) & ~PageMask;
-
-            _jitRegion.Block.MapAsRx((ulong)regionStart, (ulong)(regionEnd - regionStart));
-        }
-
-        private static int Allocate(int codeSize)
-        {
-            codeSize = AlignCodeSize(codeSize);
-
-            int allocOffset = _cacheAllocator.Allocate(codeSize);
-
-            if (allocOffset < 0)
-            {
-                throw new OutOfMemoryException("JIT Cache exhausted.");
-            }
-
-            _jitRegion.ExpandIfNeeded((ulong)allocOffset + (ulong)codeSize);
-
-            return allocOffset;
-        }
-
-        private static int AlignCodeSize(int codeSize)
-        {
-            return checked(codeSize + (CodeAlignment - 1)) & ~(CodeAlignment - 1);
-        }
-
-        private static void Add(int offset, int size, UnwindInfo unwindInfo)
-        {
-            CacheEntry entry = new CacheEntry(offset, size, unwindInfo);
-
-            int index = _cacheEntries.BinarySearch(entry);
-
-            if (index < 0)
-            {
-                index = ~index;
-            }
-
-            _cacheEntries.Insert(index, entry);
-        }
-
-        private static void Remove(int offset)
-        {
-            int index = _cacheEntries.BinarySearch(new CacheEntry(offset, 0, default));
-
-            if (index < 0)
-            {
-                index = ~index - 1;
-            }
-
-            if (index >= 0)
-            {
-                _cacheEntries.RemoveAt(index);
-            }
-        }
-
-        public static bool TryFind(int offset, out CacheEntry entry)
-        {
-            lock (_lock)
-            {
-                int index = _cacheEntries.BinarySearch(new CacheEntry(offset, 0, default));
-
-                if (index < 0)
-                {
-                    index = ~index - 1;
-                }
-
-                if (index >= 0)
-                {
-                    entry = _cacheEntries[index];
-                    return true;
-                }
-            }
-
-            entry = default;
-            return false;
-        }
-    }
-}

ARMeilleure/Translation/Cache/JitCacheInvalidation.cs

@@ -1,79 +0,0 @@
-using ARMeilleure.Memory;
-using System;
-using System.Runtime.InteropServices;
-
-namespace ARMeilleure.Translation.Cache
-{
-    class JitCacheInvalidation
-    {
-        private static int[] _invalidationCode = new int[]
-        {
-            unchecked((int)0xd53b0022), // mrs  x2, ctr_el0
-            unchecked((int)0xd3504c44), // ubfx x4, x2, #16, #4
-            unchecked((int)0x52800083), // mov  w3, #0x4
-            unchecked((int)0x12000c45), // and  w5, w2, #0xf
-            unchecked((int)0x1ac42064), // lsl  w4, w3, w4
-            unchecked((int)0x51000482), // sub  w2, w4, #0x1
-            unchecked((int)0x8a220002), // bic  x2, x0, x2
-            unchecked((int)0x1ac52063), // lsl  w3, w3, w5
-            unchecked((int)0xeb01005f), // cmp  x2, x1
-            unchecked((int)0x93407c84), // sxtw x4, w4
-            unchecked((int)0x540000a2), // b.cs 3c <do_ic_clear>
-            unchecked((int)0xd50b7b22), // dc   cvau, x2
-            unchecked((int)0x8b040042), // add  x2, x2, x4
-            unchecked((int)0xeb02003f), // cmp  x1, x2
-            unchecked((int)0x54ffffa8), // b.hi 2c <dc_clear_loop>
-            unchecked((int)0xd5033b9f), // dsb  ish
-            unchecked((int)0x51000462), // sub  w2, w3, #0x1
-            unchecked((int)0x93407c63), // sxtw x3, w3
-            unchecked((int)0x8a220000), // bic  x0, x0, x2
-            unchecked((int)0xeb00003f), // cmp  x1, x0
-            unchecked((int)0x540000a9), // b.ls 64 <exit>
-            unchecked((int)0xd50b7520), // ic   ivau, x0
-            unchecked((int)0x8b030000), // add  x0, x0, x3
-            unchecked((int)0xeb00003f), // cmp  x1, x0
-            unchecked((int)0x54ffffa8), // b.hi 54 <ic_clear_loop>
-            unchecked((int)0xd5033b9f), // dsb  ish
-            unchecked((int)0xd5033fdf), // isb
-            unchecked((int)0xd65f03c0), // ret
-        };
-
-        private delegate void InvalidateCache(ulong start, ulong end);
-
-        private InvalidateCache _invalidateCache;
-        private ReservedRegion _invalidateCacheCodeRegion;
-
-        private readonly bool _needsInvalidation;
-
-        public JitCacheInvalidation(IJitMemoryAllocator allocator)
-        {
-            // On macOS, a different path is used to write to the JIT cache, which does the invalidation.
-            if (!OperatingSystem.IsMacOS() && RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
-            {
-                ulong size = (ulong)_invalidationCode.Length * sizeof(int);
-                ulong mask = (ulong)ReservedRegion.DefaultGranularity - 1;
-
-                size = (size + mask) & ~mask;
-
-                _invalidateCacheCodeRegion = new ReservedRegion(allocator, size);
-                _invalidateCacheCodeRegion.ExpandIfNeeded(size);
-
-                Marshal.Copy(_invalidationCode, 0, _invalidateCacheCodeRegion.Pointer, _invalidationCode.Length);
-
-                _invalidateCacheCodeRegion.Block.MapAsRx(0, size);
-
-                _invalidateCache = Marshal.GetDelegateForFunctionPointer<InvalidateCache>(_invalidateCacheCodeRegion.Pointer);
-
-                _needsInvalidation = true;
-            }
-        }
-
-        public void Invalidate(IntPtr basePointer, ulong size)
-        {
-            if (_needsInvalidation)
-            {
-                _invalidateCache((ulong)basePointer, (ulong)basePointer + size);
-            }
-        }
-    }
-}

ARMeilleure/Translation/DelegateHelper.cs

@@ -1,104 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Reflection.Emit;
-
-namespace ARMeilleure.Translation
-{
-    static class DelegateHelper
-    {
-        private const string DelegateTypesAssemblyName = "JitDelegateTypes";
-
-        private static readonly ModuleBuilder _modBuilder;
-
-        private static readonly Dictionary<string, Type> _delegateTypesCache;
-
-        static DelegateHelper()
-        {
-            AssemblyBuilder asmBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(DelegateTypesAssemblyName), AssemblyBuilderAccess.Run);
-
-            _modBuilder = asmBuilder.DefineDynamicModule(DelegateTypesAssemblyName);
-
-            _delegateTypesCache = new Dictionary<string, Type>();
-        }
-
-        public static Delegate GetDelegate(MethodInfo info)
-        {
-            ArgumentNullException.ThrowIfNull(info);
-
-            Type[] parameters = info.GetParameters().Select(pI => pI.ParameterType).ToArray();
-            Type   returnType = info.ReturnType;
-
-            Type delegateType = GetDelegateType(parameters, returnType);
-
-            return Delegate.CreateDelegate(delegateType, info);
-        }
-
-        private static Type GetDelegateType(Type[] parameters, Type returnType)
-        {
-            string key = GetFunctionSignatureKey(parameters, returnType);
-
-            if (!_delegateTypesCache.TryGetValue(key, out Type delegateType))
-            {
-                delegateType = MakeDelegateType(parameters, returnType, key);
-
-                _delegateTypesCache.TryAdd(key, delegateType);
-            }
-
-            return delegateType;
-        }
-
-        private static string GetFunctionSignatureKey(Type[] parameters, Type returnType)
-        {
-            string sig = GetTypeName(returnType);
-
-            foreach (Type type in parameters)
-            {
-                sig += '_' + GetTypeName(type);
-            }
-
-            return sig;
-        }
-
-        private static string GetTypeName(Type type)
-        {
-            return type.FullName.Replace(".", string.Empty);
-        }
-
-        private const MethodAttributes CtorAttributes =
-            MethodAttributes.RTSpecialName |
-            MethodAttributes.HideBySig     |
-            MethodAttributes.Public;
-
-        private const TypeAttributes DelegateTypeAttributes =
-            TypeAttributes.Class     |
-            TypeAttributes.Public    |
-            TypeAttributes.Sealed    |
-            TypeAttributes.AnsiClass |
-            TypeAttributes.AutoClass;
-
-        private const MethodImplAttributes ImplAttributes =
-            MethodImplAttributes.Runtime |
-            MethodImplAttributes.Managed;
-
-        private const MethodAttributes InvokeAttributes =
-            MethodAttributes.Public    |
-            MethodAttributes.HideBySig |
-            MethodAttributes.NewSlot   |
-            MethodAttributes.Virtual;
-
-        private static readonly Type[] _delegateCtorSignature = { typeof(object), typeof(IntPtr) };
-
-        private static Type MakeDelegateType(Type[] parameters, Type returnType, string name)
-        {
-            TypeBuilder builder = _modBuilder.DefineType(name, DelegateTypeAttributes, typeof(MulticastDelegate));
-
-            builder.DefineConstructor(CtorAttributes, CallingConventions.Standard, _delegateCtorSignature).SetImplementationFlags(ImplAttributes);
-
-            builder.DefineMethod("Invoke", InvokeAttributes, returnType, parameters).SetImplementationFlags(ImplAttributes);
-
-            return builder.CreateTypeInfo();
-        }
-    }
-}

ARMeilleure/Translation/Delegates.cs

@@ -1,267 +0,0 @@
-using ARMeilleure.Instructions;
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-
-namespace ARMeilleure.Translation
-{
-    static class Delegates
-    {
-        public static bool TryGetDelegateFuncPtrByIndex(int index, out IntPtr funcPtr)
-        {
-            if (index >= 0 && index < _delegates.Count)
-            {
-                funcPtr = _delegates.Values[index].FuncPtr; // O(1).
-
-                return true;
-            }
-            else
-            {
-                funcPtr = default;
-
-                return false;
-            }
-        }
-
-        public static IntPtr GetDelegateFuncPtrByIndex(int index)
-        {
-            if (index < 0 || index >= _delegates.Count)
-            {
-                throw new ArgumentOutOfRangeException($"({nameof(index)} = {index})");
-            }
-
-            return _delegates.Values[index].FuncPtr; // O(1).
-        }
-
-        public static IntPtr GetDelegateFuncPtr(MethodInfo info)
-        {
-            ArgumentNullException.ThrowIfNull(info);
-
-            string key = GetKey(info);
-
-            if (!_delegates.TryGetValue(key, out DelegateInfo dlgInfo)) // O(log(n)).
-            {
-                throw new KeyNotFoundException($"({nameof(key)} = {key})");
-            }
-
-            return dlgInfo.FuncPtr;
-        }
-
-        public static int GetDelegateIndex(MethodInfo info)
-        {
-            ArgumentNullException.ThrowIfNull(info);
-
-            string key = GetKey(info);
-
-            int index = _delegates.IndexOfKey(key); // O(log(n)).
-
-            if (index == -1)
-            {
-                throw new KeyNotFoundException($"({nameof(key)} = {key})");
-            }
-
-            return index;
-        }
-
-        private static void SetDelegateInfo(MethodInfo info)
-        {
-            string key = GetKey(info);
-
-            Delegate dlg = DelegateHelper.GetDelegate(info);
-
-            _delegates.Add(key, new DelegateInfo(dlg)); // ArgumentException (key).
-        }
-
-        private static string GetKey(MethodInfo info)
-        {
-            return $"{info.DeclaringType.Name}.{info.Name}";
-        }
-
-        private static readonly SortedList<string, DelegateInfo> _delegates;
-
-        static Delegates()
-        {
-            _delegates = new SortedList<string, DelegateInfo>();
-
-            SetDelegateInfo(typeof(Math).GetMethod(nameof(Math.Abs),      new Type[] { typeof(double) }));
-            SetDelegateInfo(typeof(Math).GetMethod(nameof(Math.Ceiling),  new Type[] { typeof(double) }));
-            SetDelegateInfo(typeof(Math).GetMethod(nameof(Math.Floor),    new Type[] { typeof(double) }));
-            SetDelegateInfo(typeof(Math).GetMethod(nameof(Math.Round),    new Type[] { typeof(double), typeof(MidpointRounding) }));
-            SetDelegateInfo(typeof(Math).GetMethod(nameof(Math.Truncate), new Type[] { typeof(double) }));
-
-            SetDelegateInfo(typeof(MathF).GetMethod(nameof(MathF.Abs),      new Type[] { typeof(float) }));
-            SetDelegateInfo(typeof(MathF).GetMethod(nameof(MathF.Ceiling),  new Type[] { typeof(float) }));
-            SetDelegateInfo(typeof(MathF).GetMethod(nameof(MathF.Floor),    new Type[] { typeof(float) }));
-            SetDelegateInfo(typeof(MathF).GetMethod(nameof(MathF.Round),    new Type[] { typeof(float), typeof(MidpointRounding) }));
-            SetDelegateInfo(typeof(MathF).GetMethod(nameof(MathF.Truncate), new Type[] { typeof(float) }));
-
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.Break)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.CheckSynchronization)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.EnqueueForRejit)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntfrqEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntpctEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntvctEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCtrEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetDczidEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetFunctionAddress)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.InvalidateCacheLine)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidrroEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidr32))); // A32 only.
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidrEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidrEl032))); // A32 only.
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadByte)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt16)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt32)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt64)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadVector128)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.SetTpidrEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.SetTpidrEl032))); // A32 only.
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.SignalMemoryTracking)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.SupervisorCall)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ThrowInvalidMemoryAccess)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.Undefined)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteByte)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt16)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt32)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt64)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteVector128)));
-
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.CountLeadingSigns)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.CountLeadingZeros)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32b)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32cb)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32ch)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32cw)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32cx)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32h)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32w)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32x)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Decrypt)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Encrypt)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.FixedRotate)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashChoose)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashLower)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashMajority)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashParity)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashUpper)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.InverseMixColumns)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.MixColumns)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.PolynomialMult64_128)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToS32)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToS64)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToU32)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToU64)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToS32)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToS64)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToU32)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToU64)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Sha1SchedulePart1)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Sha1SchedulePart2)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Sha256SchedulePart1)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Sha256SchedulePart2)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SignedShrImm64)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbl1)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbl2)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbl3)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbl4)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbx1)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbx2)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbx3)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbx4)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.UnsignedShrImm64)));
-
-            SetDelegateInfo(typeof(SoftFloat16_32).GetMethod(nameof(SoftFloat16_32.FPConvert)));
-            SetDelegateInfo(typeof(SoftFloat16_64).GetMethod(nameof(SoftFloat16_64.FPConvert)));
-
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPAdd)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPAddFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompare)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareEQ)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareEQFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGE)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGEFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGT)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGTFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLE)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLEFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLT)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLTFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPDiv)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMax)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxNum)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxNumFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMin)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinNum)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinNumFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMul)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulAdd)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulAddFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulSub)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulSubFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulX)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPNegMulAdd)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPNegMulSub)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipEstimate)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipEstimateFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipStep))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipStepFused)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecpX)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtEstimate)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtEstimateFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtStep))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtStepFused)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPSqrt)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPSub)));
-
-            SetDelegateInfo(typeof(SoftFloat32_16).GetMethod(nameof(SoftFloat32_16.FPConvert)));
-
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPAdd)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPAddFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompare)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareEQ)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareEQFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGE)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGEFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGT)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGTFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLE)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLEFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLT)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLTFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPDiv)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMax)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxNum)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxNumFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMin)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinNum)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinNumFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMul)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulAdd)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulAddFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulSub)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulSubFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulX)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPNegMulAdd)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPNegMulSub)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipEstimate)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipEstimateFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipStep))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipStepFused)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecpX)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtEstimate)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtEstimateFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtStep))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtStepFused)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPSqrt)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPSub)));
-
-            SetDelegateInfo(typeof(SoftFloat64_16).GetMethod(nameof(SoftFloat64_16.FPConvert)));
-        }
-    }
-}

ARMeilleure/Translation/DispatcherFunction.cs

@@ -1,6 +0,0 @@
-using System;
-
-namespace ARMeilleure.Translation
-{
-    delegate void DispatcherFunction(IntPtr nativeContext, ulong startAddress);
-}

ARMeilleure/Translation/PTC/PtcProfiler.cs

@@ -1,420 +0,0 @@
-using ARMeilleure.State;
-using Ryujinx.Common;
-using Ryujinx.Common.Logging;
-using System;
-using System.Buffers.Binary;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.IO.Compression;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-using static ARMeilleure.Translation.PTC.PtcFormatter;
-
-namespace ARMeilleure.Translation.PTC
-{
-    class PtcProfiler
-    {
-        private const string OuterHeaderMagicString = "Pohd\0\0\0\0";
-
-        private const uint InternalVersion = 1866; //! Not to be incremented manually for each change to the ARMeilleure project.
-
-        private const int SaveInterval = 30; // Seconds.
-
-        private const CompressionLevel SaveCompressionLevel = CompressionLevel.Fastest;
-
-        private readonly Ptc _ptc;
-
-        private readonly System.Timers.Timer _timer;
-
-        private readonly ulong _outerHeaderMagic;
-
-        private readonly ManualResetEvent _waitEvent;
-
-        private readonly object _lock;
-
-        private bool _disposed;
-
-        private Hash128 _lastHash;
-
-        public Dictionary<ulong, FuncProfile> ProfiledFuncs { get; private set; }
-
-        public bool Enabled { get; private set; }
-
-        public ulong StaticCodeStart { get; set; }
-        public ulong StaticCodeSize  { get; set; }
-
-        public PtcProfiler(Ptc ptc)
-        {
-            _ptc = ptc;
-
-            _timer = new System.Timers.Timer((double)SaveInterval * 1000d);
-            _timer.Elapsed += PreSave;
-
-            _outerHeaderMagic = BinaryPrimitives.ReadUInt64LittleEndian(EncodingCache.UTF8NoBOM.GetBytes(OuterHeaderMagicString).AsSpan());
-
-            _waitEvent = new ManualResetEvent(true);
-
-            _lock = new object();
-
-            _disposed = false;
-
-            ProfiledFuncs = new Dictionary<ulong, FuncProfile>();
-
-            Enabled = false;
-        }
-
-        public void AddEntry(ulong address, ExecutionMode mode, bool highCq)
-        {
-            if (IsAddressInStaticCodeRange(address))
-            {
-                Debug.Assert(!highCq);
-
-                lock (_lock)
-                {
-                    ProfiledFuncs.TryAdd(address, new FuncProfile(mode, highCq: false));
-                }
-            }
-        }
-
-        public void UpdateEntry(ulong address, ExecutionMode mode, bool highCq)
-        {
-            if (IsAddressInStaticCodeRange(address))
-            {
-                Debug.Assert(highCq);
-
-                lock (_lock)
-                {
-                    Debug.Assert(ProfiledFuncs.ContainsKey(address));
-
-                    ProfiledFuncs[address] = new FuncProfile(mode, highCq: true);
-                }
-            }
-        }
-
-        public bool IsAddressInStaticCodeRange(ulong address)
-        {
-            return address >= StaticCodeStart && address < StaticCodeStart + StaticCodeSize;
-        }
-
-        public ConcurrentQueue<(ulong address, FuncProfile funcProfile)> GetProfiledFuncsToTranslate(TranslatorCache<TranslatedFunction> funcs)
-        {
-            var profiledFuncsToTranslate = new ConcurrentQueue<(ulong address, FuncProfile funcProfile)>();
-
-            foreach (var profiledFunc in ProfiledFuncs)
-            {
-                if (!funcs.ContainsKey(profiledFunc.Key))
-                {
-                    profiledFuncsToTranslate.Enqueue((profiledFunc.Key, profiledFunc.Value));
-                }
-            }
-
-            return profiledFuncsToTranslate;
-        }
-
-        public void ClearEntries()
-        {
-            ProfiledFuncs.Clear();
-            ProfiledFuncs.TrimExcess();
-        }
-
-        public void PreLoad()
-        {
-            _lastHash = default;
-
-            string fileNameActual = $"{_ptc.CachePathActual}.info";
-            string fileNameBackup = $"{_ptc.CachePathBackup}.info";
-
-            FileInfo fileInfoActual = new FileInfo(fileNameActual);
-            FileInfo fileInfoBackup = new FileInfo(fileNameBackup);
-
-            if (fileInfoActual.Exists && fileInfoActual.Length != 0L)
-            {
-                if (!Load(fileNameActual, false))
-                {
-                    if (fileInfoBackup.Exists && fileInfoBackup.Length != 0L)
-                    {
-                        Load(fileNameBackup, true);
-                    }
-                }
-            }
-            else if (fileInfoBackup.Exists && fileInfoBackup.Length != 0L)
-            {
-                Load(fileNameBackup, true);
-            }
-        }
-
-        private bool Load(string fileName, bool isBackup)
-        {
-            using (FileStream compressedStream = new(fileName, FileMode.Open))
-            using (DeflateStream deflateStream = new(compressedStream, CompressionMode.Decompress, true))
-            {
-                OuterHeader outerHeader = DeserializeStructure<OuterHeader>(compressedStream);
-
-                if (!outerHeader.IsHeaderValid())
-                {
-                    InvalidateCompressedStream(compressedStream);
-
-                    return false;
-                }
-
-                if (outerHeader.Magic != _outerHeaderMagic)
-                {
-                    InvalidateCompressedStream(compressedStream);
-
-                    return false;
-                }
-
-                if (outerHeader.InfoFileVersion != InternalVersion)
-                {
-                    InvalidateCompressedStream(compressedStream);
-
-                    return false;
-                }
-
-                if (outerHeader.Endianness != Ptc.GetEndianness())
-                {
-                    InvalidateCompressedStream(compressedStream);
-
-                    return false;
-                }
-
-                using (MemoryStream stream = new MemoryStream())
-                {
-                    Debug.Assert(stream.Seek(0L, SeekOrigin.Begin) == 0L && stream.Length == 0L);
-
-                    try
-                    {
-                        deflateStream.CopyTo(stream);
-                    }
-                    catch
-                    {
-                        InvalidateCompressedStream(compressedStream);
-
-                        return false;
-                    }
-
-                    Debug.Assert(stream.Position == stream.Length);
-
-                    stream.Seek(0L, SeekOrigin.Begin);
-
-                    Hash128 expectedHash = DeserializeStructure<Hash128>(stream);
-
-                    Hash128 actualHash = XXHash128.ComputeHash(GetReadOnlySpan(stream));
-
-                    if (actualHash != expectedHash)
-                    {
-                        InvalidateCompressedStream(compressedStream);
-
-                        return false;
-                    }
-
-                    ProfiledFuncs = Deserialize(stream);
-
-                    Debug.Assert(stream.Position == stream.Length);
-
-                    _lastHash = actualHash;
-                }
-            }
-
-            long fileSize = new FileInfo(fileName).Length;
-
-            Logger.Info?.Print(LogClass.Ptc, $"{(isBackup ? "Loaded Backup Profiling Info" : "Loaded Profiling Info")} (size: {fileSize} bytes, profiled functions: {ProfiledFuncs.Count}).");
-
-            return true;
-        }
-
-        private static Dictionary<ulong, FuncProfile> Deserialize(Stream stream)
-        {
-            return DeserializeDictionary<ulong, FuncProfile>(stream, (stream) => DeserializeStructure<FuncProfile>(stream));
-        }
-
-        private ReadOnlySpan<byte> GetReadOnlySpan(MemoryStream memoryStream)
-        {
-            return new(memoryStream.GetBuffer(), (int)memoryStream.Position, (int)memoryStream.Length - (int)memoryStream.Position);
-        }
-
-        private void InvalidateCompressedStream(FileStream compressedStream)
-        {
-            compressedStream.SetLength(0L);
-        }
-
-        private void PreSave(object source, System.Timers.ElapsedEventArgs e)
-        {
-            _waitEvent.Reset();
-
-            string fileNameActual = $"{_ptc.CachePathActual}.info";
-            string fileNameBackup = $"{_ptc.CachePathBackup}.info";
-
-            FileInfo fileInfoActual = new FileInfo(fileNameActual);
-
-            if (fileInfoActual.Exists && fileInfoActual.Length != 0L)
-            {
-                File.Copy(fileNameActual, fileNameBackup, true);
-            }
-
-            Save(fileNameActual);
-
-            _waitEvent.Set();
-        }
-
-        private void Save(string fileName)
-        {
-            int profiledFuncsCount;
-
-            OuterHeader outerHeader = new OuterHeader();
-
-            outerHeader.Magic = _outerHeaderMagic;
-
-            outerHeader.InfoFileVersion = InternalVersion;
-            outerHeader.Endianness = Ptc.GetEndianness();
-
-            outerHeader.SetHeaderHash();
-
-            using (MemoryStream stream = new MemoryStream())
-            {
-                Debug.Assert(stream.Seek(0L, SeekOrigin.Begin) == 0L && stream.Length == 0L);
-
-                stream.Seek((long)Unsafe.SizeOf<Hash128>(), SeekOrigin.Begin);
-
-                lock (_lock)
-                {
-                    Serialize(stream, ProfiledFuncs);
-
-                    profiledFuncsCount = ProfiledFuncs.Count;
-                }
-
-                Debug.Assert(stream.Position == stream.Length);
-
-                stream.Seek((long)Unsafe.SizeOf<Hash128>(), SeekOrigin.Begin);
-                Hash128 hash = XXHash128.ComputeHash(GetReadOnlySpan(stream));
-
-                stream.Seek(0L, SeekOrigin.Begin);
-                SerializeStructure(stream, hash);
-
-                if (hash == _lastHash)
-                {
-                    return;
-                }
-
-                using (FileStream compressedStream = new(fileName, FileMode.OpenOrCreate))
-                using (DeflateStream deflateStream = new(compressedStream, SaveCompressionLevel, true))
-                {
-                    try
-                    {
-                        SerializeStructure(compressedStream, outerHeader);
-
-                        stream.WriteTo(deflateStream);
-
-                        _lastHash = hash;
-                    }
-                    catch
-                    {
-                        compressedStream.Position = 0L;
-
-                        _lastHash = default;
-                    }
-
-                    if (compressedStream.Position < compressedStream.Length)
-                    {
-                        compressedStream.SetLength(compressedStream.Position);
-                    }
-                }
-            }
-
-            long fileSize = new FileInfo(fileName).Length;
-
-            if (fileSize != 0L)
-            {
-                Logger.Info?.Print(LogClass.Ptc, $"Saved Profiling Info (size: {fileSize} bytes, profiled functions: {profiledFuncsCount}).");
-            }
-        }
-
-        private void Serialize(Stream stream, Dictionary<ulong, FuncProfile> profiledFuncs)
-        {
-            SerializeDictionary(stream, profiledFuncs, (stream, structure) => SerializeStructure(stream, structure));
-        }
-
-        [StructLayout(LayoutKind.Sequential, Pack = 1/*, Size = 29*/)]
-        private struct OuterHeader
-        {
-            public ulong Magic;
-
-            public uint InfoFileVersion;
-
-            public bool Endianness;
-
-            public Hash128 HeaderHash;
-
-            public void SetHeaderHash()
-            {
-                Span<OuterHeader> spanHeader = MemoryMarshal.CreateSpan(ref this, 1);
-
-                HeaderHash = XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader).Slice(0, Unsafe.SizeOf<OuterHeader>() - Unsafe.SizeOf<Hash128>()));
-            }
-
-            public bool IsHeaderValid()
-            {
-                Span<OuterHeader> spanHeader = MemoryMarshal.CreateSpan(ref this, 1);
-
-                return XXHash128.ComputeHash(MemoryMarshal.AsBytes(spanHeader).Slice(0, Unsafe.SizeOf<OuterHeader>() - Unsafe.SizeOf<Hash128>())) == HeaderHash;
-            }
-        }
-
-        [StructLayout(LayoutKind.Sequential, Pack = 1/*, Size = 5*/)]
-        public struct FuncProfile
-        {
-            public ExecutionMode Mode;
-            public bool HighCq;
-
-            public FuncProfile(ExecutionMode mode, bool highCq)
-            {
-                Mode = mode;
-                HighCq = highCq;
-            }
-        }
-
-        public void Start()
-        {
-            if (_ptc.State == PtcState.Enabled ||
-                _ptc.State == PtcState.Continuing)
-            {
-                Enabled = true;
-
-                _timer.Enabled = true;
-            }
-        }
-
-        public void Stop()
-        {
-            Enabled = false;
-
-            if (!_disposed)
-            {
-                _timer.Enabled = false;
-            }
-        }
-
-        public void Wait()
-        {
-            _waitEvent.WaitOne();
-        }
-
-        public void Dispose()
-        {
-            if (!_disposed)
-            {
-                _disposed = true;
-
-                _timer.Elapsed -= PreSave;
-                _timer.Dispose();
-
-                Wait();
-                _waitEvent.Dispose();
-            }
-        }
-    }
-}

ARMeilleure/Translation/TranslatedFunction.cs

@@ -1,29 +0,0 @@
-using ARMeilleure.Common;
-using System;
-
-namespace ARMeilleure.Translation
-{
-    class TranslatedFunction
-    {
-        private readonly GuestFunction _func; // Ensure that this delegate will not be garbage collected.
-
-        public IntPtr FuncPointer { get; }
-        public Counter<uint> CallCounter { get; }
-        public ulong GuestSize { get; }
-        public bool HighCq { get; }
-
-        public TranslatedFunction(GuestFunction func, IntPtr funcPointer, Counter<uint> callCounter, ulong guestSize, bool highCq)
-        {
-            _func = func;
-            FuncPointer = funcPointer;
-            CallCounter = callCounter;
-            GuestSize = guestSize;
-            HighCq = highCq;
-        }
-
-        public ulong Execute(State.ExecutionContext context)
-        {
-            return _func(context.NativeContextPtr);
-        }
-    }
-}

ARMeilleure/Translation/Translator.cs

@@ -1,576 +0,0 @@
-using ARMeilleure.CodeGen;
-using ARMeilleure.Common;
-using ARMeilleure.Decoders;
-using ARMeilleure.Diagnostics;
-using ARMeilleure.Instructions;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Memory;
-using ARMeilleure.Signal;
-using ARMeilleure.State;
-using ARMeilleure.Translation.Cache;
-using ARMeilleure.Translation.PTC;
-using Ryujinx.Common;
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Threading;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Translation
-{
-    public class Translator
-    {
-        private static readonly AddressTable<ulong>.Level[] Levels64Bit =
-            new AddressTable<ulong>.Level[]
-            {
-                new(31, 17),
-                new(23,  8),
-                new(15,  8),
-                new( 7,  8),
-                new( 2,  5)
-            };
-
-        private static readonly AddressTable<ulong>.Level[] Levels32Bit =
-            new AddressTable<ulong>.Level[]
-            {
-                new(31, 17),
-                new(23,  8),
-                new(15,  8),
-                new( 7,  8),
-                new( 1,  6)
-            };
-
-        private readonly IJitMemoryAllocator _allocator;
-        private readonly ConcurrentQueue<KeyValuePair<ulong, TranslatedFunction>> _oldFuncs;
-
-        private readonly Ptc _ptc;
-
-        internal TranslatorCache<TranslatedFunction> Functions { get; }
-        internal AddressTable<ulong> FunctionTable { get; }
-        internal EntryTable<uint> CountTable { get; }
-        internal TranslatorStubs Stubs { get; }
-        internal TranslatorQueue Queue { get; }
-        internal IMemoryManager Memory { get; }
-
-        private volatile int _threadCount;
-
-        // FIXME: Remove this once the init logic of the emulator will be redone.
-        public static readonly ManualResetEvent IsReadyForTranslation = new(false);
-
-        public Translator(IJitMemoryAllocator allocator, IMemoryManager memory, bool for64Bits)
-        {
-            _allocator = allocator;
-            Memory = memory;
-
-            _oldFuncs = new ConcurrentQueue<KeyValuePair<ulong, TranslatedFunction>>();
-
-            _ptc = new Ptc();
-
-            Queue = new TranslatorQueue();
-
-            JitCache.Initialize(allocator);
-
-            CountTable = new EntryTable<uint>();
-            Functions = new TranslatorCache<TranslatedFunction>();
-            FunctionTable = new AddressTable<ulong>(for64Bits ? Levels64Bit : Levels32Bit);
-            Stubs = new TranslatorStubs(this);
-
-            FunctionTable.Fill = (ulong)Stubs.SlowDispatchStub;
-
-            if (memory.Type.IsHostMapped())
-            {
-                NativeSignalHandler.InitializeSignalHandler(allocator.GetPageSize());
-            }
-        }
-
-        public IPtcLoadState LoadDiskCache(string titleIdText, string displayVersion, bool enabled)
-        {
-            _ptc.Initialize(titleIdText, displayVersion, enabled, Memory.Type);
-            return _ptc;
-        }
-
-        public void PrepareCodeRange(ulong address, ulong size)
-        {
-            if (_ptc.Profiler.StaticCodeSize == 0)
-            {
-                _ptc.Profiler.StaticCodeStart = address;
-                _ptc.Profiler.StaticCodeSize = size;
-            }
-        }
-
-        public void Execute(State.ExecutionContext context, ulong address)
-        {
-            if (Interlocked.Increment(ref _threadCount) == 1)
-            {
-                IsReadyForTranslation.WaitOne();
-
-                if (_ptc.State == PtcState.Enabled)
-                {
-                    Debug.Assert(Functions.Count == 0);
-                    _ptc.LoadTranslations(this);
-                    _ptc.MakeAndSaveTranslations(this);
-                }
-
-                _ptc.Profiler.Start();
-
-                _ptc.Disable();
-
-                // Simple heuristic, should be user configurable in future. (1 for 4 core/ht or less, 2 for 6 core + ht
-                // etc). All threads are normal priority except from the last, which just fills as much of the last core
-                // as the os lets it with a low priority. If we only have one rejit thread, it should be normal priority
-                // as highCq code is performance critical.
-                //
-                // TODO: Use physical cores rather than logical. This only really makes sense for processors with
-                // hyperthreading. Requires OS specific code.
-                int unboundedThreadCount = Math.Max(1, (Environment.ProcessorCount - 6) / 3);
-                int threadCount          = Math.Min(4, unboundedThreadCount);
-
-                for (int i = 0; i < threadCount; i++)
-                {
-                    bool last = i != 0 && i == unboundedThreadCount - 1;
-
-                    Thread backgroundTranslatorThread = new Thread(BackgroundTranslate)
-                    {
-                        Name = "CPU.BackgroundTranslatorThread." + i,
-                        Priority = last ? ThreadPriority.Lowest : ThreadPriority.Normal
-                    };
-
-                    backgroundTranslatorThread.Start();
-                }
-            }
-
-            Statistics.InitializeTimer();
-
-            NativeInterface.RegisterThread(context, Memory, this);
-
-            if (Optimizations.UseUnmanagedDispatchLoop)
-            {
-                Stubs.DispatchLoop(context.NativeContextPtr, address);
-            }
-            else
-            {
-                do
-                {
-                    address = ExecuteSingle(context, address);
-                }
-                while (context.Running && address != 0);
-            }
-
-            NativeInterface.UnregisterThread();
-
-            if (Interlocked.Decrement(ref _threadCount) == 0)
-            {
-                ClearJitCache();
-
-                Queue.Dispose();
-                Stubs.Dispose();
-                FunctionTable.Dispose();
-                CountTable.Dispose();
-
-                _ptc.Close();
-                _ptc.Profiler.Stop();
-
-                _ptc.Dispose();
-                _ptc.Profiler.Dispose();
-            }
-        }
-
-        private ulong ExecuteSingle(State.ExecutionContext context, ulong address)
-        {
-            TranslatedFunction func = GetOrTranslate(address, context.ExecutionMode);
-
-            Statistics.StartTimer();
-
-            ulong nextAddr = func.Execute(context);
-
-            Statistics.StopTimer(address);
-
-            return nextAddr;
-        }
-
-        public ulong Step(State.ExecutionContext context, ulong address)
-        {
-            TranslatedFunction func = Translate(address, context.ExecutionMode, highCq: false, singleStep: true);
-
-            address = func.Execute(context);
-
-            EnqueueForDeletion(address, func);
-
-            return address;
-        }
-
-        internal TranslatedFunction GetOrTranslate(ulong address, ExecutionMode mode)
-        {
-            if (!Functions.TryGetValue(address, out TranslatedFunction func))
-            {
-                func = Translate(address, mode, highCq: false);
-
-                TranslatedFunction oldFunc = Functions.GetOrAdd(address, func.GuestSize, func);
-
-                if (oldFunc != func)
-                {
-                    JitCache.Unmap(func.FuncPointer);
-                    func = oldFunc;
-                }
-
-                if (_ptc.Profiler.Enabled)
-                {
-                    _ptc.Profiler.AddEntry(address, mode, highCq: false);
-                }
-
-                RegisterFunction(address, func);
-            }
-
-            return func;
-        }
-
-        internal void RegisterFunction(ulong guestAddress, TranslatedFunction func)
-        {
-            if (FunctionTable.IsValid(guestAddress) && (Optimizations.AllowLcqInFunctionTable || func.HighCq))
-            {
-                Volatile.Write(ref FunctionTable.GetValue(guestAddress), (ulong)func.FuncPointer);
-            }
-        }
-
-        internal TranslatedFunction Translate(ulong address, ExecutionMode mode, bool highCq, bool singleStep = false)
-        {
-            var context = new ArmEmitterContext(
-                Memory,
-                CountTable,
-                FunctionTable,
-                Stubs,
-                address,
-                highCq,
-                _ptc.State != PtcState.Disabled,
-                mode: Aarch32Mode.User);
-
-            Logger.StartPass(PassName.Decoding);
-
-            Block[] blocks = Decoder.Decode(Memory, address, mode, highCq, singleStep ? DecoderMode.SingleInstruction : DecoderMode.MultipleBlocks);
-
-            Logger.EndPass(PassName.Decoding);
-
-            Logger.StartPass(PassName.Translation);
-
-            EmitSynchronization(context);
-
-            if (blocks[0].Address != address)
-            {
-                context.Branch(context.GetLabel(address));
-            }
-
-            ControlFlowGraph cfg = EmitAndGetCFG(context, blocks, out Range funcRange, out Counter<uint> counter);
-
-            ulong funcSize = funcRange.End - funcRange.Start;
-
-            Logger.EndPass(PassName.Translation, cfg);
-
-            Logger.StartPass(PassName.RegisterUsage);
-
-            RegisterUsage.RunPass(cfg, mode);
-
-            Logger.EndPass(PassName.RegisterUsage);
-
-            var retType = OperandType.I64;
-            var argTypes = new OperandType[] { OperandType.I64 };
-
-            var options = highCq ? CompilerOptions.HighCq : CompilerOptions.None;
-
-            if (context.HasPtc && !singleStep)
-            {
-                options |= CompilerOptions.Relocatable;
-            }
-
-            CompiledFunction compiledFunc = Compiler.Compile(cfg, argTypes, retType, options, RuntimeInformation.ProcessArchitecture);
-
-            if (context.HasPtc && !singleStep)
-            {
-                Hash128 hash = Ptc.ComputeHash(Memory, address, funcSize);
-
-                _ptc.WriteCompiledFunction(address, funcSize, hash, highCq, compiledFunc);
-            }
-
-            GuestFunction func = compiledFunc.MapWithPointer<GuestFunction>(out IntPtr funcPointer);
-
-            Allocators.ResetAll();
-
-            return new TranslatedFunction(func, funcPointer, counter, funcSize, highCq);
-        }
-
-        private void BackgroundTranslate()
-        {
-            while (_threadCount != 0 && Queue.TryDequeue(out RejitRequest request))
-            {
-                TranslatedFunction func = Translate(request.Address, request.Mode, highCq: true);
-
-                Functions.AddOrUpdate(request.Address, func.GuestSize, func, (key, oldFunc) =>
-                {
-                    EnqueueForDeletion(key, oldFunc);
-                    return func;
-                });
-
-                if (_ptc.Profiler.Enabled)
-                {
-                    _ptc.Profiler.UpdateEntry(request.Address, request.Mode, highCq: true);
-                }
-
-                RegisterFunction(request.Address, func);
-            }
-        }
-
-        private readonly struct Range
-        {
-            public ulong Start { get; }
-            public ulong End { get; }
-
-            public Range(ulong start, ulong end)
-            {
-                Start = start;
-                End = end;
-            }
-        }
-
-        private static ControlFlowGraph EmitAndGetCFG(
-            ArmEmitterContext context,
-            Block[] blocks,
-            out Range range,
-            out Counter<uint> counter)
-        {
-            counter = null;
-
-            ulong rangeStart = ulong.MaxValue;
-            ulong rangeEnd = 0;
-
-            for (int blkIndex = 0; blkIndex < blocks.Length; blkIndex++)
-            {
-                Block block = blocks[blkIndex];
-
-                if (!block.Exit)
-                {
-                    if (rangeStart > block.Address)
-                    {
-                        rangeStart = block.Address;
-                    }
-
-                    if (rangeEnd < block.EndAddress)
-                    {
-                        rangeEnd = block.EndAddress;
-                    }
-                }
-
-                if (block.Address == context.EntryAddress)
-                {
-                    if (!context.HighCq)
-                    {
-                        EmitRejitCheck(context, out counter);
-                    }
-
-                    context.ClearQcFlag();
-                }
-
-                context.CurrBlock = block;
-
-                context.MarkLabel(context.GetLabel(block.Address));
-
-                if (block.Exit)
-                {
-                    // Left option here as it may be useful if we need to return to managed rather than tail call in
-                    // future. (eg. for debug)
-                    bool useReturns = false;
-
-                    InstEmitFlowHelper.EmitVirtualJump(context, Const(block.Address), isReturn: useReturns);
-                }
-                else
-                {
-                    for (int opcIndex = 0; opcIndex < block.OpCodes.Count; opcIndex++)
-                    {
-                        OpCode opCode = block.OpCodes[opcIndex];
-
-                        context.CurrOp = opCode;
-
-                        bool isLastOp = opcIndex == block.OpCodes.Count - 1;
-
-                        if (isLastOp)
-                        {
-                            context.SyncQcFlag();
-
-                            if (block.Branch != null && !block.Branch.Exit && block.Branch.Address <= block.Address)
-                            {
-                                EmitSynchronization(context);
-                            }
-                        }
-
-                        Operand lblPredicateSkip = default;
-
-                        if (context.IsInIfThenBlock && context.CurrentIfThenBlockCond != Condition.Al)
-                        {
-                            lblPredicateSkip = Label();
-
-                            InstEmitFlowHelper.EmitCondBranch(context, lblPredicateSkip, context.CurrentIfThenBlockCond.Invert());
-                        }
-
-                        if (opCode is OpCode32 op && op.Cond < Condition.Al)
-                        {
-                            lblPredicateSkip = Label();
-
-                            InstEmitFlowHelper.EmitCondBranch(context, lblPredicateSkip, op.Cond.Invert());
-                        }
-
-                        if (opCode.Instruction.Emitter != null)
-                        {
-                            opCode.Instruction.Emitter(context);
-                        }
-                        else
-                        {
-                            throw new InvalidOperationException($"Invalid instruction \"{opCode.Instruction.Name}\".");
-                        }
-
-                        if (lblPredicateSkip != default)
-                        {
-                            context.MarkLabel(lblPredicateSkip);
-                        }
-
-                        if (context.IsInIfThenBlock && opCode.Instruction.Name != InstName.It)
-                        {
-                            context.AdvanceIfThenBlockState();
-                        }
-                    }
-                }
-            }
-
-            range = new Range(rangeStart, rangeEnd);
-
-            return context.GetControlFlowGraph();
-        }
-
-        internal static void EmitRejitCheck(ArmEmitterContext context, out Counter<uint> counter)
-        {
-            const int MinsCallForRejit = 100;
-
-            counter = new Counter<uint>(context.CountTable);
-
-            Operand lblEnd = Label();
-
-            Operand address = !context.HasPtc ?
-                Const(ref counter.Value) :
-                Const(ref counter.Value, Ptc.CountTableSymbol);
-
-            Operand curCount = context.Load(OperandType.I32, address);
-            Operand count = context.Add(curCount, Const(1));
-            context.Store(address, count);
-            context.BranchIf(lblEnd, curCount, Const(MinsCallForRejit), Comparison.NotEqual, BasicBlockFrequency.Cold);
-
-            context.Call(typeof(NativeInterface).GetMethod(nameof(NativeInterface.EnqueueForRejit)), Const(context.EntryAddress));
-
-            context.MarkLabel(lblEnd);
-        }
-
-        internal static void EmitSynchronization(EmitterContext context)
-        {
-            long countOffs = NativeContext.GetCounterOffset();
-
-            Operand lblNonZero = Label();
-            Operand lblExit = Label();
-
-            Operand countAddr = context.Add(context.LoadArgument(OperandType.I64, 0), Const(countOffs));
-            Operand count = context.Load(OperandType.I32, countAddr);
-            context.BranchIfTrue(lblNonZero, count, BasicBlockFrequency.Cold);
-
-            Operand running = context.Call(typeof(NativeInterface).GetMethod(nameof(NativeInterface.CheckSynchronization)));
-            context.BranchIfTrue(lblExit, running, BasicBlockFrequency.Cold);
-
-            context.Return(Const(0L));
-
-            context.MarkLabel(lblNonZero);
-            count = context.Subtract(count, Const(1));
-            context.Store(countAddr, count);
-
-            context.MarkLabel(lblExit);
-        }
-
-        public void InvalidateJitCacheRegion(ulong address, ulong size)
-        {
-            ulong[] overlapAddresses = Array.Empty<ulong>();
-
-            int overlapsCount = Functions.GetOverlaps(address, size, ref overlapAddresses);
-
-            if (overlapsCount != 0)
-            {
-                // If rejit is running, stop it as it may be trying to rejit a function on the invalidated region.
-                ClearRejitQueue(allowRequeue: true);
-            }
-
-            for (int index = 0; index < overlapsCount; index++)
-            {
-                ulong overlapAddress = overlapAddresses[index];
-
-                if (Functions.TryGetValue(overlapAddress, out TranslatedFunction overlap))
-                {
-                    Functions.Remove(overlapAddress);
-                    Volatile.Write(ref FunctionTable.GetValue(overlapAddress), FunctionTable.Fill);
-                    EnqueueForDeletion(overlapAddress, overlap);
-                }
-            }
-
-            // TODO: Remove overlapping functions from the JitCache aswell.
-            // This should be done safely, with a mechanism to ensure the function is not being executed.
-        }
-
-        internal void EnqueueForRejit(ulong guestAddress, ExecutionMode mode)
-        {
-            Queue.Enqueue(guestAddress, mode);
-        }
-
-        private void EnqueueForDeletion(ulong guestAddress, TranslatedFunction func)
-        {
-            _oldFuncs.Enqueue(new(guestAddress, func));
-        }
-
-        private void ClearJitCache()
-        {
-            // Ensure no attempt will be made to compile new functions due to rejit.
-            ClearRejitQueue(allowRequeue: false);
-
-            List<TranslatedFunction> functions = Functions.AsList();
-
-            foreach (var func in functions)
-            {
-                JitCache.Unmap(func.FuncPointer);
-
-                func.CallCounter?.Dispose();
-            }
-
-            Functions.Clear();
-
-            while (_oldFuncs.TryDequeue(out var kv))
-            {
-                JitCache.Unmap(kv.Value.FuncPointer);
-
-                kv.Value.CallCounter?.Dispose();
-            }
-        }
-
-        private void ClearRejitQueue(bool allowRequeue)
-        {
-            if (!allowRequeue)
-            {
-                Queue.Clear();
-
-                return;
-            }
-
-            lock (Queue.Sync)
-            {
-                while (Queue.Count > 0 && Queue.TryDequeue(out RejitRequest request))
-                {
-                    if (Functions.TryGetValue(request.Address, out var func) && func.CallCounter != null)
-                    {
-                        Volatile.Write(ref func.CallCounter.Value, 0);
-                    }
-                }
-            }
-        }
-    }
-}

ARMeilleure/Translation/TranslatorStubs.cs

@@ -1,241 +0,0 @@
-using ARMeilleure.Instructions;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.State;
-using ARMeilleure.Translation.Cache;
-using System;
-using System.Reflection;
-using System.Runtime.InteropServices;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Translation
-{
-    /// <summary>
-    /// Represents a stub manager.
-    /// </summary>
-    class TranslatorStubs : IDisposable
-    {
-        private static readonly Lazy<IntPtr> _slowDispatchStub = new(GenerateSlowDispatchStub, isThreadSafe: true);
-
-        private bool _disposed;
-
-        private readonly Translator _translator;
-        private readonly Lazy<IntPtr> _dispatchStub;
-        private readonly Lazy<DispatcherFunction> _dispatchLoop;
-
-        /// <summary>
-        /// Gets the dispatch stub.
-        /// </summary>
-        /// <exception cref="ObjectDisposedException"><see cref="TranslatorStubs"/> instance was disposed</exception>
-        public IntPtr DispatchStub
-        {
-            get
-            {
-                ObjectDisposedException.ThrowIf(_disposed, this);
-
-                return _dispatchStub.Value;
-            }
-        }
-
-        /// <summary>
-        /// Gets the slow dispatch stub.
-        /// </summary>
-        /// <exception cref="ObjectDisposedException"><see cref="TranslatorStubs"/> instance was disposed</exception>
-        public IntPtr SlowDispatchStub
-        {
-            get
-            {
-                ObjectDisposedException.ThrowIf(_disposed, this);
-
-                return _slowDispatchStub.Value;
-            }
-        }
-
-        /// <summary>
-        /// Gets the dispatch loop function.
-        /// </summary>
-        /// <exception cref="ObjectDisposedException"><see cref="TranslatorStubs"/> instance was disposed</exception>
-        public DispatcherFunction DispatchLoop
-        {
-            get
-            {
-                ObjectDisposedException.ThrowIf(_disposed, this);
-
-                return _dispatchLoop.Value;
-            }
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="TranslatorStubs"/> class with the specified
-        /// <see cref="Translator"/> instance.
-        /// </summary>
-        /// <param name="translator"><see cref="Translator"/> instance to use</param>
-        /// <exception cref="ArgumentNullException"><paramref name="translator"/> is null</exception>
-        public TranslatorStubs(Translator translator)
-        {
-            ArgumentNullException.ThrowIfNull(translator);
-
-            _translator = translator;
-            _dispatchStub = new(GenerateDispatchStub, isThreadSafe: true);
-            _dispatchLoop = new(GenerateDispatchLoop, isThreadSafe: true);
-        }
-
-        /// <summary>
-        /// Releases all resources used by the <see cref="TranslatorStubs"/> instance.
-        /// </summary>
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        /// <summary>
-        /// Releases all unmanaged and optionally managed resources used by the <see cref="TranslatorStubs"/> instance.
-        /// </summary>
-        /// <param name="disposing"><see langword="true"/> to dispose managed resources also; otherwise just unmanaged resouces</param>
-        protected virtual void Dispose(bool disposing)
-        {
-            if (!_disposed)
-            {
-                if (_dispatchStub.IsValueCreated)
-                {
-                    JitCache.Unmap(_dispatchStub.Value);
-                }
-
-                if (_dispatchLoop.IsValueCreated)
-                {
-                    JitCache.Unmap(Marshal.GetFunctionPointerForDelegate(_dispatchLoop.Value));
-                }
-
-                _disposed = true;
-            }
-        }
-
-        /// <summary>
-        /// Frees resources used by the <see cref="TranslatorStubs"/> instance.
-        /// </summary>
-        ~TranslatorStubs()
-        {
-            Dispose(false);
-        }
-
-        /// <summary>
-        /// Generates a <see cref="DispatchStub"/>.
-        /// </summary>
-        /// <returns>Generated <see cref="DispatchStub"/></returns>
-        private IntPtr GenerateDispatchStub()
-        {
-            var context = new EmitterContext();
-
-            Operand lblFallback = Label();
-            Operand lblEnd = Label();
-
-            // Load the target guest address from the native context.
-            Operand nativeContext = context.LoadArgument(OperandType.I64, 0);
-            Operand guestAddress = context.Load(OperandType.I64,
-                context.Add(nativeContext, Const((ulong)NativeContext.GetDispatchAddressOffset())));
-
-            // Check if guest address is within range of the AddressTable.
-            Operand masked = context.BitwiseAnd(guestAddress, Const(~_translator.FunctionTable.Mask));
-            context.BranchIfTrue(lblFallback, masked);
-
-            Operand index = default;
-            Operand page = Const((long)_translator.FunctionTable.Base);
-
-            for (int i = 0; i < _translator.FunctionTable.Levels.Length; i++)
-            {
-                ref var level = ref _translator.FunctionTable.Levels[i];
-
-                // level.Mask is not used directly because it is more often bigger than 32-bits, so it will not
-                // be encoded as an immediate on x86's bitwise and operation.
-                Operand mask = Const(level.Mask >> level.Index);
-
-                index = context.BitwiseAnd(context.ShiftRightUI(guestAddress, Const(level.Index)), mask);
-
-                if (i < _translator.FunctionTable.Levels.Length - 1)
-                {
-                    page = context.Load(OperandType.I64, context.Add(page, context.ShiftLeft(index, Const(3))));
-                    context.BranchIfFalse(lblFallback, page);
-                }
-            }
-
-            Operand hostAddress;
-            Operand hostAddressAddr = context.Add(page, context.ShiftLeft(index, Const(3)));
-            hostAddress = context.Load(OperandType.I64, hostAddressAddr);
-            context.Tailcall(hostAddress, nativeContext);
-
-            context.MarkLabel(lblFallback);
-            hostAddress = context.Call(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetFunctionAddress)), guestAddress);
-            context.Tailcall(hostAddress, nativeContext);
-
-            var cfg = context.GetControlFlowGraph();
-            var retType = OperandType.I64;
-            var argTypes = new[] { OperandType.I64 };
-
-            var func = Compiler.Compile(cfg, argTypes, retType, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<GuestFunction>();
-
-            return Marshal.GetFunctionPointerForDelegate(func);
-        }
-
-        /// <summary>
-        /// Generates a <see cref="SlowDispatchStub"/>.
-        /// </summary>
-        /// <returns>Generated <see cref="SlowDispatchStub"/></returns>
-        private static IntPtr GenerateSlowDispatchStub()
-        {
-            var context = new EmitterContext();
-
-            // Load the target guest address from the native context.
-            Operand nativeContext = context.LoadArgument(OperandType.I64, 0);
-            Operand guestAddress = context.Load(OperandType.I64,
-                context.Add(nativeContext, Const((ulong)NativeContext.GetDispatchAddressOffset())));
-
-            MethodInfo getFuncAddress = typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetFunctionAddress));
-            Operand hostAddress = context.Call(getFuncAddress, guestAddress);
-            context.Tailcall(hostAddress, nativeContext);
-
-            var cfg = context.GetControlFlowGraph();
-            var retType = OperandType.I64;
-            var argTypes = new[] { OperandType.I64 };
-
-            var func = Compiler.Compile(cfg, argTypes, retType, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<GuestFunction>();
-
-            return Marshal.GetFunctionPointerForDelegate(func);
-        }
-
-        /// <summary>
-        /// Generates a <see cref="DispatchLoop"/> function.
-        /// </summary>
-        /// <returns><see cref="DispatchLoop"/> function</returns>
-        private DispatcherFunction GenerateDispatchLoop()
-        {
-            var context = new EmitterContext();
-
-            Operand beginLbl = Label();
-            Operand endLbl = Label();
-
-            Operand nativeContext = context.LoadArgument(OperandType.I64, 0);
-            Operand guestAddress = context.Copy(
-                context.AllocateLocal(OperandType.I64),
-                context.LoadArgument(OperandType.I64, 1));
-
-            Operand runningAddress = context.Add(nativeContext, Const((ulong)NativeContext.GetRunningOffset()));
-            Operand dispatchAddress = context.Add(nativeContext, Const((ulong)NativeContext.GetDispatchAddressOffset()));
-
-            context.MarkLabel(beginLbl);
-            context.Store(dispatchAddress, guestAddress);
-            context.Copy(guestAddress, context.Call(Const((ulong)DispatchStub), OperandType.I64, nativeContext));
-            context.BranchIfFalse(endLbl, guestAddress);
-            context.BranchIfFalse(endLbl, context.Load(OperandType.I32, runningAddress));
-            context.Branch(beginLbl);
-
-            context.MarkLabel(endLbl);
-            context.Return();
-
-            var cfg = context.GetControlFlowGraph();
-            var retType = OperandType.None;
-            var argTypes = new[] { OperandType.I64, OperandType.I64 };
-
-            return Compiler.Compile(cfg, argTypes, retType, CompilerOptions.HighCq, RuntimeInformation.ProcessArchitecture).Map<DispatcherFunction>();
-        }
-    }
-}

Directory.Packages.props

@@ -3,38 +3,38 @@
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
   <ItemGroup>
-    <PackageVersion Include="Avalonia" Version="0.10.18" />
-    <PackageVersion Include="Avalonia.Controls.DataGrid" Version="0.10.18" />
-    <PackageVersion Include="Avalonia.Desktop" Version="0.10.18" />
-    <PackageVersion Include="Avalonia.Diagnostics" Version="0.10.18" />
-    <PackageVersion Include="Avalonia.Markup.Xaml.Loader" Version="0.10.18" />
+    <PackageVersion Include="Avalonia" Version="0.10.21" />
+    <PackageVersion Include="Avalonia.Controls.DataGrid" Version="0.10.21" />
+    <PackageVersion Include="Avalonia.Desktop" Version="0.10.21" />
+    <PackageVersion Include="Avalonia.Diagnostics" Version="0.10.21" />
+    <PackageVersion Include="Avalonia.Markup.Xaml.Loader" Version="0.10.21" />
     <PackageVersion Include="Avalonia.Svg" Version="0.10.18" />
     <PackageVersion Include="Avalonia.Svg.Skia" Version="0.10.18" />
     <PackageVersion Include="CommandLineParser" Version="2.9.1" />
     <PackageVersion Include="Concentus" Version="1.1.7" />
-    <PackageVersion Include="Crc32.NET" Version="1.2.0" />
     <PackageVersion Include="DiscordRichPresence" Version="1.1.3.18" />
-    <PackageVersion Include="DynamicData" Version="7.12.11" />
+    <PackageVersion Include="DynamicData" Version="7.14.2" />
     <PackageVersion Include="FluentAvaloniaUI" Version="1.4.5" />
     <PackageVersion Include="GtkSharp.Dependencies" Version="1.1.1" />
     <PackageVersion Include="GtkSharp.Dependencies.osx" Version="0.0.5" />
     <PackageVersion Include="jp2masa.Avalonia.Flexbox" Version="0.2.0" />
-    <PackageVersion Include="LibHac" Version="0.17.0" />
+    <PackageVersion Include="LibHac" Version="0.18.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.5.0" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.6.2" />
+    <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="2.3.2" />
     <PackageVersion Include="MsgPack.Cli" Version="1.0.1" />
     <PackageVersion Include="NUnit" Version="3.13.3" />
     <PackageVersion Include="NUnit3TestAdapter" Version="4.1.0" />
-    <PackageVersion Include="OpenTK.Core" Version="4.7.5" />
-    <PackageVersion Include="OpenTK.Graphics" Version="4.7.5" />
-    <PackageVersion Include="OpenTK.OpenAL" Version="4.7.5" />
-    <PackageVersion Include="OpenTK.Windowing.GraphicsLibraryFramework" Version="4.7.5" />
+    <PackageVersion Include="OpenTK.Core" Version="4.7.7" />
+    <PackageVersion Include="OpenTK.Graphics" Version="4.7.7" />
+    <PackageVersion Include="OpenTK.OpenAL" Version="4.7.7" />
+    <PackageVersion Include="OpenTK.Windowing.GraphicsLibraryFramework" Version="4.7.7" />
     <PackageVersion Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" />
     <PackageVersion Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build13" />
     <PackageVersion Include="Ryujinx.Graphics.Vulkan.Dependencies.MoltenVK" Version="1.2.0" />
     <PackageVersion Include="Ryujinx.GtkSharp" Version="3.24.24.59-ryujinx" />
-    <PackageVersion Include="Ryujinx.SDL2-CS" Version="2.26.1-build23" />
+    <PackageVersion Include="Ryujinx.SDL2-CS" Version="2.26.3-build25" />
     <PackageVersion Include="shaderc.net" Version="0.1.0" />
     <PackageVersion Include="SharpZipLib" Version="1.4.2" />
     <PackageVersion Include="Silk.NET.Vulkan" Version="2.16.0" />
@@ -44,11 +44,10 @@
     <PackageVersion Include="SixLabors.ImageSharp.Drawing" Version="1.0.0-beta11" />
     <PackageVersion Include="SPB" Version="0.0.4-build28" />
     <PackageVersion Include="System.Drawing.Common" Version="7.0.0" />
-    <PackageVersion Include="System.IdentityModel.Tokens.Jwt" Version="6.26.0" />
-    <PackageVersion Include="System.IO.FileSystem.Primitives" Version="4.3.0" />
-    <PackageVersion Include="System.Management" Version="7.0.0" />
-    <PackageVersion Include="System.Net.NameResolution" Version="4.3.0" />
-    <PackageVersion Include="System.Threading.ThreadPool" Version="4.3.0" />
-    <PackageVersion Include="XamlNameReferenceGenerator" Version="1.5.1" />
+    <PackageVersion Include="System.IdentityModel.Tokens.Jwt" Version="6.31.0" />
+    <PackageVersion Include="System.IO.Hashing" Version="7.0.0" />
+    <PackageVersion Include="System.Management" Version="7.0.2" />
+    <PackageVersion Include="UnicornEngine.Unicorn" Version="2.0.2-rc1-fb78016" />
+    <PackageVersion Include="XamlNameReferenceGenerator" Version="1.6.1" />
   </ItemGroup>
 </Project>

README.md

@@ -40,7 +40,7 @@
 
 ## Compatibility
 
-As of November 2022, Ryujinx has been tested on approximately 3,800 titles; over 3,600 boot past menus and into gameplay, with roughly 3,200 of those being considered playable.
+As of April 2023, Ryujinx has been tested on approximately 4,050 titles; over 4,000 boot past menus and into gameplay, with roughly 3,400 of those being considered playable.
 You can check out the compatibility list [here](https://github.com/Ryujinx/Ryujinx-Games-List/issues). Anyone is free to submit a new game test or update an existing game test entry; simply follow the new issue template and testing guidelines, or post as a reply to the applicable game issue. Use the search function to see if a game has been tested already!
 
 ## Usage
@@ -96,7 +96,7 @@ Ryujinx system files are stored in the `Ryujinx` folder. This folder is located
 
 - **GPU**
 
-  The GPU emulator emulates the Switch's Maxwell GPU using either the OpenGL (version 4.5 minimum), Vulkan, or Metal (via MoltenVK) APIs through a custom build of OpenTK or Silk.NET respectively. There are currently four graphics enhancements available to the end user in Ryujinx: Disk Shader Caching, Resolution Scaling, Aspect Ratio Adjustment, and Anisotropic Filtering. These enhancements can be adjusted or toggled as desired in the GUI.
+  The GPU emulator emulates the Switch's Maxwell GPU using either the OpenGL (version 4.5 minimum), Vulkan, or Metal (via MoltenVK) APIs through a custom build of OpenTK or Silk.NET respectively. There are currently six graphics enhancements available to the end user in Ryujinx: Disk Shader Caching, Resolution Scaling, Anti-Aliasing, Scaling Filters (including FSR), Anisotropic Filtering and Aspect Ratio Adjustment. These enhancements can be adjusted or toggled as desired in the GUI.
 
 - **Input**
 

Ryujinx.Audio.Backends.OpenAL/OpenALHardwareDeviceSession.cs

@@ -1,212 +0,0 @@
-using OpenTK.Audio.OpenAL;
-using Ryujinx.Audio.Backends.Common;
-using Ryujinx.Audio.Common;
-using Ryujinx.Memory;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-
-namespace Ryujinx.Audio.Backends.OpenAL
-{
-    class OpenALHardwareDeviceSession : HardwareDeviceSessionOutputBase
-    {
-        private OpenALHardwareDeviceDriver _driver;
-        private int _sourceId;
-        private ALFormat _targetFormat;
-        private bool _isActive;
-        private Queue<OpenALAudioBuffer> _queuedBuffers;
-        private ulong _playedSampleCount;
-
-        private object _lock = new object();
-
-        public OpenALHardwareDeviceSession(OpenALHardwareDeviceDriver driver, IVirtualMemoryManager memoryManager, SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount, float requestedVolume) : base(memoryManager, requestedSampleFormat, requestedSampleRate, requestedChannelCount)
-        {
-            _driver = driver;
-            _queuedBuffers = new Queue<OpenALAudioBuffer>();
-            _sourceId = AL.GenSource();
-            _targetFormat = GetALFormat();
-            _isActive = false;
-            _playedSampleCount = 0;
-            SetVolume(requestedVolume);
-        }
-
-        private ALFormat GetALFormat()
-        {
-            switch (RequestedSampleFormat)
-            {
-                case SampleFormat.PcmInt16:
-                    switch (RequestedChannelCount)
-                    {
-                        case 1:
-                            return ALFormat.Mono16;
-                        case 2:
-                            return ALFormat.Stereo16;
-                        case 6:
-                            return ALFormat.Multi51Chn16Ext;
-                        default:
-                            throw new NotImplementedException($"Unsupported channel config {RequestedChannelCount}");
-                    }
-                default:
-                    throw new NotImplementedException($"Unsupported sample format {RequestedSampleFormat}");
-            }
-        }
-
-        public override void PrepareToClose() { }
-
-        private void StartIfNotPlaying()
-        {
-            AL.GetSource(_sourceId, ALGetSourcei.SourceState, out int stateInt);
-
-            ALSourceState State = (ALSourceState)stateInt;
-
-            if (State != ALSourceState.Playing)
-            {
-                AL.SourcePlay(_sourceId);
-            }
-        }
-
-        public override void QueueBuffer(AudioBuffer buffer)
-        {
-            lock (_lock)
-            {
-                OpenALAudioBuffer driverBuffer = new OpenALAudioBuffer
-                {
-                    DriverIdentifier = buffer.DataPointer,
-                    BufferId = AL.GenBuffer(),
-                    SampleCount = GetSampleCount(buffer)
-                };
-
-                AL.BufferData(driverBuffer.BufferId, _targetFormat, buffer.Data, (int)RequestedSampleRate);
-
-                _queuedBuffers.Enqueue(driverBuffer);
-
-                AL.SourceQueueBuffer(_sourceId, driverBuffer.BufferId);
-
-                if (_isActive)
-                {
-                    StartIfNotPlaying();
-                }
-            }
-        }
-
-        public override void SetVolume(float volume)
-        {
-            lock (_lock)
-            {
-                AL.Source(_sourceId, ALSourcef.Gain, volume);
-            }
-        }
-
-        public override float GetVolume()
-        {
-            AL.GetSource(_sourceId, ALSourcef.Gain, out float volume);
-
-            return volume;
-        }
-
-        public override void Start()
-        {
-            lock (_lock)
-            {
-                _isActive = true;
-
-                StartIfNotPlaying();
-            }
-        }
-
-        public override void Stop()
-        {
-            lock (_lock)
-            {
-                SetVolume(0.0f);
-
-                AL.SourceStop(_sourceId);
-
-                _isActive = false;
-            }
-        }
-
-        public override void UnregisterBuffer(AudioBuffer buffer) { }
-
-        public override bool WasBufferFullyConsumed(AudioBuffer buffer)
-        {
-            lock (_lock)
-            {
-                if (!_queuedBuffers.TryPeek(out OpenALAudioBuffer driverBuffer))
-                {
-                    return true;
-                }
-
-                return driverBuffer.DriverIdentifier != buffer.DataPointer;
-            }
-        }
-
-        public override ulong GetPlayedSampleCount()
-        {
-            lock (_lock)
-            {
-                return _playedSampleCount;
-            }
-        }
-
-        public bool Update()
-        {
-            lock (_lock)
-            {
-                if (_isActive)
-                {
-                    AL.GetSource(_sourceId, ALGetSourcei.BuffersProcessed, out int releasedCount);
-
-                    if (releasedCount > 0)
-                    {
-                        int[] bufferIds = new int[releasedCount];
-
-                        AL.SourceUnqueueBuffers(_sourceId, releasedCount, bufferIds);
-
-                        int i = 0;
-
-                        while (_queuedBuffers.TryPeek(out OpenALAudioBuffer buffer) && i < bufferIds.Length)
-                        {
-                            if (buffer.BufferId == bufferIds[i])
-                            {
-                                _playedSampleCount += buffer.SampleCount;
-
-                                _queuedBuffers.TryDequeue(out _);
-
-                                i++;
-                            }
-                        }
-
-                        Debug.Assert(i == bufferIds.Length, "Unknown buffer ids found!");
-
-                        AL.DeleteBuffers(bufferIds);
-                    }
-
-                    return releasedCount > 0;
-                }
-
-                return false;
-            }
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing && _driver.Unregister(this))
-            {
-                lock (_lock)
-                {
-                    PrepareToClose();
-                    Stop();
-
-                    AL.DeleteSource(_sourceId);
-                }
-            }
-        }
-
-        public override void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-    }
-}

Ryujinx.Audio.Backends.SDL2/SDL2HardwareDeviceDriver.cs

@@ -1,176 +0,0 @@
-using Ryujinx.Audio.Common;
-using Ryujinx.Audio.Integration;
-using Ryujinx.Common.Logging;
-using Ryujinx.Memory;
-using Ryujinx.SDL2.Common;
-using System;
-using System.Collections.Concurrent;
-using System.Threading;
-
-using static Ryujinx.Audio.Integration.IHardwareDeviceDriver;
-using static SDL2.SDL;
-
-namespace Ryujinx.Audio.Backends.SDL2
-{
-    public class SDL2HardwareDeviceDriver : IHardwareDeviceDriver
-    {
-        private readonly ManualResetEvent _updateRequiredEvent;
-        private readonly ManualResetEvent _pauseEvent;
-        private readonly ConcurrentDictionary<SDL2HardwareDeviceSession, byte> _sessions;
-
-        public SDL2HardwareDeviceDriver()
-        {
-            _updateRequiredEvent = new ManualResetEvent(false);
-            _pauseEvent = new ManualResetEvent(true);
-            _sessions = new ConcurrentDictionary<SDL2HardwareDeviceSession, byte>();
-
-            SDL2Driver.Instance.Initialize();
-        }
-
-        public static bool IsSupported => IsSupportedInternal();
-
-        private static bool IsSupportedInternal()
-        {
-            uint device = OpenStream(SampleFormat.PcmInt16, Constants.TargetSampleRate, Constants.ChannelCountMax, Constants.TargetSampleCount, null);
-
-            if (device != 0)
-            {
-                SDL_CloseAudioDevice(device);
-            }
-
-            return device != 0;
-        }
-
-        public ManualResetEvent GetUpdateRequiredEvent()
-        {
-            return _updateRequiredEvent;
-        }
-
-        public ManualResetEvent GetPauseEvent()
-        {
-            return _pauseEvent;
-        }
-
-        public IHardwareDeviceSession OpenDeviceSession(Direction direction, IVirtualMemoryManager memoryManager, SampleFormat sampleFormat, uint sampleRate, uint channelCount, float volume)
-        {
-            if (channelCount == 0)
-            {
-                channelCount = 2;
-            }
-
-            if (sampleRate == 0)
-            {
-                sampleRate = Constants.TargetSampleRate;
-            }
-
-            if (direction != Direction.Output)
-            {
-                throw new NotImplementedException("Input direction is currently not implemented on SDL2 backend!");
-            }
-
-            SDL2HardwareDeviceSession session = new SDL2HardwareDeviceSession(this, memoryManager, sampleFormat, sampleRate, channelCount, volume);
-
-            _sessions.TryAdd(session, 0);
-
-            return session;
-        }
-
-        internal bool Unregister(SDL2HardwareDeviceSession session)
-        {
-            return _sessions.TryRemove(session, out _);
-        }
-
-        private static SDL_AudioSpec GetSDL2Spec(SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount, uint sampleCount)
-        {
-            return new SDL_AudioSpec
-            {
-                channels = (byte)requestedChannelCount,
-                format = GetSDL2Format(requestedSampleFormat),
-                freq = (int)requestedSampleRate,
-                samples = (ushort)sampleCount
-            };
-        }
-
-        internal static ushort GetSDL2Format(SampleFormat format)
-        {
-            return format switch
-            {
-                SampleFormat.PcmInt8 => AUDIO_S8,
-                SampleFormat.PcmInt16 => AUDIO_S16,
-                SampleFormat.PcmInt32 => AUDIO_S32,
-                SampleFormat.PcmFloat => AUDIO_F32,
-                _ => throw new ArgumentException($"Unsupported sample format {format}"),
-            };
-        }
-
-        internal static uint OpenStream(SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount, uint sampleCount, SDL_AudioCallback callback)
-        {
-            SDL_AudioSpec desired = GetSDL2Spec(requestedSampleFormat, requestedSampleRate, requestedChannelCount, sampleCount);
-
-            desired.callback = callback;
-
-            uint device = SDL_OpenAudioDevice(IntPtr.Zero, 0, ref desired, out SDL_AudioSpec got, 0);
-
-            if (device == 0)
-            {
-                Logger.Error?.Print(LogClass.Application, 
-                    $"SDL2 open audio device initialization failed with error \"{SDL_GetError()}\"");
-
-                return 0;
-            }
-
-            bool isValid = got.format == desired.format && got.freq == desired.freq && got.channels == desired.channels;
-
-            if (!isValid)
-            {
-                Logger.Error?.Print(LogClass.Application, "SDL2 open audio device is not valid");
-                SDL_CloseAudioDevice(device);
-
-                return 0;
-            }
-
-            return device;
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                foreach (SDL2HardwareDeviceSession session in _sessions.Keys)
-                {
-                    session.Dispose();
-                }
-
-                SDL2Driver.Instance.Dispose();
-
-                _pauseEvent.Dispose();
-            }
-        }
-
-        public bool SupportsSampleRate(uint sampleRate)
-        {
-            return true;
-        }
-
-        public bool SupportsSampleFormat(SampleFormat sampleFormat)
-        {
-            return sampleFormat != SampleFormat.PcmInt24;
-        }
-
-        public bool SupportsChannelCount(uint channelCount)
-        {
-            return true;
-        }
-
-        public bool SupportsDirection(Direction direction)
-        {
-            // TODO: add direction input when supported.
-            return direction == Direction.Output;
-        }
-    }
-}

Ryujinx.Audio.Backends.SDL2/SDL2HardwareDeviceSession.cs

@@ -1,223 +0,0 @@
-using Ryujinx.Audio.Backends.Common;
-using Ryujinx.Audio.Common;
-using Ryujinx.Common.Logging;
-using Ryujinx.Memory;
-using System;
-using System.Collections.Concurrent;
-using System.Threading;
-
-using static SDL2.SDL;
-
-namespace Ryujinx.Audio.Backends.SDL2
-{
-    class SDL2HardwareDeviceSession : HardwareDeviceSessionOutputBase
-    {
-        private SDL2HardwareDeviceDriver _driver;
-        private ConcurrentQueue<SDL2AudioBuffer> _queuedBuffers;
-        private DynamicRingBuffer _ringBuffer;
-        private ulong _playedSampleCount;
-        private ManualResetEvent _updateRequiredEvent;
-        private uint _outputStream;
-        private SDL_AudioCallback _callbackDelegate;
-        private int _bytesPerFrame;
-        private uint _sampleCount;
-        private bool _started;
-        private float _volume;
-        private ushort _nativeSampleFormat;
-
-        public SDL2HardwareDeviceSession(SDL2HardwareDeviceDriver driver, IVirtualMemoryManager memoryManager, SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount, float requestedVolume) : base(memoryManager, requestedSampleFormat, requestedSampleRate, requestedChannelCount)
-        {
-            _driver = driver;
-            _updateRequiredEvent = _driver.GetUpdateRequiredEvent();
-            _queuedBuffers = new ConcurrentQueue<SDL2AudioBuffer>();
-            _ringBuffer = new DynamicRingBuffer();
-            _callbackDelegate = Update;
-            _bytesPerFrame = BackendHelper.GetSampleSize(RequestedSampleFormat) * (int)RequestedChannelCount;
-            _nativeSampleFormat = SDL2HardwareDeviceDriver.GetSDL2Format(RequestedSampleFormat);
-            _sampleCount = uint.MaxValue;
-            _started = false;
-            _volume = requestedVolume;
-        }
-
-        private void EnsureAudioStreamSetup(AudioBuffer buffer)
-        {
-            uint bufferSampleCount = (uint)GetSampleCount(buffer);
-            bool needAudioSetup = _outputStream == 0 ||
-                (bufferSampleCount >= Constants.TargetSampleCount && bufferSampleCount < _sampleCount);
-
-            if (needAudioSetup)
-            {
-                _sampleCount = Math.Max(Constants.TargetSampleCount, bufferSampleCount);
-
-                uint newOutputStream = SDL2HardwareDeviceDriver.OpenStream(RequestedSampleFormat, RequestedSampleRate, RequestedChannelCount, _sampleCount, _callbackDelegate);
-
-                if (newOutputStream == 0)
-                {
-                    // No stream in place, this is unexpected.
-                    throw new InvalidOperationException($"OpenStream failed with error: \"{SDL_GetError()}\"");
-                }
-                else
-                {
-                    if (_outputStream != 0)
-                    {
-                        SDL_CloseAudioDevice(_outputStream);
-                    }
-
-                    _outputStream = newOutputStream;
-
-                    SDL_PauseAudioDevice(_outputStream, _started ? 0 : 1);
-
-                    Logger.Info?.Print(LogClass.Audio, $"New audio stream setup with a target sample count of {_sampleCount}");
-                }
-            }
-        }
-
-        private unsafe void Update(IntPtr userdata, IntPtr stream, int streamLength)
-        {
-            Span<byte> streamSpan = new Span<byte>((void*)stream, streamLength);
-
-            int maxFrameCount = (int)GetSampleCount(streamLength);
-            int bufferedFrames = _ringBuffer.Length / _bytesPerFrame;
-
-            int frameCount = Math.Min(bufferedFrames, maxFrameCount);
-
-            if (frameCount == 0)
-            {
-                // SDL2 left the responsibility to the user to clear the buffer.
-                streamSpan.Fill(0);
-
-                return;
-            }
-
-            byte[] samples = new byte[frameCount * _bytesPerFrame];
-
-            _ringBuffer.Read(samples, 0, samples.Length);
-
-            fixed (byte* p = samples)
-            {
-                IntPtr pStreamSrc = (IntPtr)p;
-
-                // Zero the dest buffer
-                streamSpan.Fill(0);
-
-                // Apply volume to written data
-                SDL_MixAudioFormat(stream, pStreamSrc, _nativeSampleFormat, (uint)samples.Length, (int)(_volume * SDL_MIX_MAXVOLUME));
-            }
-
-            ulong sampleCount = GetSampleCount(samples.Length);
-
-            ulong availaibleSampleCount = sampleCount;
-
-            bool needUpdate = false;
-
-            while (availaibleSampleCount > 0 && _queuedBuffers.TryPeek(out SDL2AudioBuffer driverBuffer))
-            {
-                ulong sampleStillNeeded = driverBuffer.SampleCount - Interlocked.Read(ref driverBuffer.SamplePlayed);
-                ulong playedAudioBufferSampleCount = Math.Min(sampleStillNeeded, availaibleSampleCount);
-
-                ulong currentSamplePlayed = Interlocked.Add(ref driverBuffer.SamplePlayed, playedAudioBufferSampleCount);
-                availaibleSampleCount -= playedAudioBufferSampleCount;
-
-                if (currentSamplePlayed == driverBuffer.SampleCount)
-                {
-                    _queuedBuffers.TryDequeue(out _);
-
-                    needUpdate = true;
-                }
-
-                Interlocked.Add(ref _playedSampleCount, playedAudioBufferSampleCount);
-            }
-
-            // Notify the output if needed.
-            if (needUpdate)
-            {
-                _updateRequiredEvent.Set();
-            }
-        }
-
-        public override ulong GetPlayedSampleCount()
-        {
-            return Interlocked.Read(ref _playedSampleCount);
-        }
-
-        public override float GetVolume()
-        {
-            return _volume;
-        }
-
-        public override void PrepareToClose() { }
-
-        public override void QueueBuffer(AudioBuffer buffer)
-        {
-            EnsureAudioStreamSetup(buffer);
-
-            SDL2AudioBuffer driverBuffer = new SDL2AudioBuffer(buffer.DataPointer, GetSampleCount(buffer));
-
-            _ringBuffer.Write(buffer.Data, 0, buffer.Data.Length);
-
-            _queuedBuffers.Enqueue(driverBuffer);
-        }
-
-        public override void SetVolume(float volume)
-        {
-            _volume = volume;
-        }
-
-        public override void Start()
-        {
-            if (!_started)
-            {
-                if (_outputStream != 0)
-                {
-                    SDL_PauseAudioDevice(_outputStream, 0);
-                }
-
-                _started = true;
-            }
-        }
-
-        public override void Stop()
-        {
-            if (_started)
-            {
-                if (_outputStream != 0)
-                {
-                    SDL_PauseAudioDevice(_outputStream, 1);
-                }
-
-                _started = false;
-            }
-        }
-
-        public override void UnregisterBuffer(AudioBuffer buffer) { }
-
-        public override bool WasBufferFullyConsumed(AudioBuffer buffer)
-        {
-            if (!_queuedBuffers.TryPeek(out SDL2AudioBuffer driverBuffer))
-            {
-                return true;
-            }
-
-            return driverBuffer.DriverIdentifier != buffer.DataPointer;
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing && _driver.Unregister(this))
-            {
-                PrepareToClose();
-                Stop();
-
-                if (_outputStream != 0)
-                {
-                    SDL_CloseAudioDevice(_outputStream);
-                }
-            }
-        }
-
-        public override void Dispose()
-        {
-            Dispose(true);
-        }
-    }
-}

Ryujinx.Audio.Backends.SoundIo/Native/SoundIoBackend.cs

@@ -1,13 +0,0 @@
-namespace Ryujinx.Audio.Backends.SoundIo.Native
-{
-    public enum SoundIoBackend : int
-    {
-        None = 0,
-        Jack = 1,
-        PulseAudio = 2,
-        Alsa = 3,
-        CoreAudio = 4,
-        Wasapi = 5,
-        Dummy = 6
-    }
-}

Ryujinx.Audio.Backends.SoundIo/SoundIoHardwareDeviceDriver.cs

@@ -1,248 +0,0 @@
-using Ryujinx.Audio.Backends.SoundIo.Native;
-using Ryujinx.Audio.Common;
-using Ryujinx.Audio.Integration;
-using Ryujinx.Memory;
-using System;
-using System.Collections.Concurrent;
-using System.Threading;
-
-using static Ryujinx.Audio.Integration.IHardwareDeviceDriver;
-using static Ryujinx.Audio.Backends.SoundIo.Native.SoundIo;
-
-namespace Ryujinx.Audio.Backends.SoundIo
-{
-    public class SoundIoHardwareDeviceDriver : IHardwareDeviceDriver
-    {
-        private readonly SoundIoContext _audioContext;
-        private readonly SoundIoDeviceContext _audioDevice;
-        private readonly ManualResetEvent _updateRequiredEvent;
-        private readonly ManualResetEvent _pauseEvent;
-        private readonly ConcurrentDictionary<SoundIoHardwareDeviceSession, byte> _sessions;
-        private int _disposeState;
-
-        public SoundIoHardwareDeviceDriver()
-        {
-            _audioContext = SoundIoContext.Create();
-            _updateRequiredEvent = new ManualResetEvent(false);
-            _pauseEvent = new ManualResetEvent(true);
-            _sessions = new ConcurrentDictionary<SoundIoHardwareDeviceSession, byte>();
-
-            _audioContext.Connect();
-            _audioContext.FlushEvents();
-
-            _audioDevice = FindValidAudioDevice(_audioContext, true);
-        }
-
-        public static bool IsSupported => IsSupportedInternal();
-
-        private static bool IsSupportedInternal()
-        {
-            SoundIoContext context = null;
-            SoundIoDeviceContext device = null;
-            SoundIoOutStreamContext stream = null;
-
-            bool backendDisconnected = false;
-
-            try
-            {
-                context = SoundIoContext.Create();
-                context.OnBackendDisconnect = err =>
-                {
-                    backendDisconnected = true;
-                };
-
-                context.Connect();
-                context.FlushEvents();
-
-                if (backendDisconnected)
-                {
-                    return false;
-                }
-
-                if (context.OutputDeviceCount == 0)
-                {
-                    return false;
-                }
-
-                device = FindValidAudioDevice(context);
-
-                if (device == null || backendDisconnected)
-                {
-                    return false;
-                }
-
-                stream = device.CreateOutStream();
-
-                if (stream == null || backendDisconnected)
-                {
-                    return false;
-                }
-
-                return true;
-            }
-            catch
-            {
-                return false;
-            }
-            finally
-            {
-                stream?.Dispose();
-                context?.Dispose();
-            }
-        }
-
-        private static SoundIoDeviceContext FindValidAudioDevice(SoundIoContext audioContext, bool fallback = false)
-        {
-            SoundIoDeviceContext defaultAudioDevice = audioContext.GetOutputDevice(audioContext.DefaultOutputDeviceIndex);
-
-            if (!defaultAudioDevice.IsRaw)
-            {
-                return defaultAudioDevice;
-            }
-
-            for (int i = 0; i < audioContext.OutputDeviceCount; i++)
-            {
-                SoundIoDeviceContext audioDevice = audioContext.GetOutputDevice(i);
-
-                if (audioDevice.Id == defaultAudioDevice.Id && !audioDevice.IsRaw)
-                {
-                    return audioDevice;
-                }
-            }
-
-            return fallback ? defaultAudioDevice : null;
-        }
-
-        public ManualResetEvent GetUpdateRequiredEvent()
-        {
-            return _updateRequiredEvent;
-        }
-
-        public ManualResetEvent GetPauseEvent()
-        {
-            return _pauseEvent;
-        }
-
-        public IHardwareDeviceSession OpenDeviceSession(Direction direction, IVirtualMemoryManager memoryManager, SampleFormat sampleFormat, uint sampleRate, uint channelCount, float volume)
-        {
-            if (channelCount == 0)
-            {
-                channelCount = 2;
-            }
-
-            if (sampleRate == 0)
-            {
-                sampleRate = Constants.TargetSampleRate;
-            }
-
-            volume = Math.Clamp(volume, 0, 1);
-
-            if (direction != Direction.Output)
-            {
-                throw new NotImplementedException("Input direction is currently not implemented on SoundIO backend!");
-            }
-
-            SoundIoHardwareDeviceSession session = new SoundIoHardwareDeviceSession(this, memoryManager, sampleFormat, sampleRate, channelCount, volume);
-
-            _sessions.TryAdd(session, 0);
-
-            return session;
-        }
-
-        internal bool Unregister(SoundIoHardwareDeviceSession session)
-        {
-            return _sessions.TryRemove(session, out _);
-        }
-
-        public static SoundIoFormat GetSoundIoFormat(SampleFormat format)
-        {
-            return format switch
-            {
-                SampleFormat.PcmInt8 => SoundIoFormat.S8,
-                SampleFormat.PcmInt16 => SoundIoFormat.S16LE,
-                SampleFormat.PcmInt24 => SoundIoFormat.S24LE,
-                SampleFormat.PcmInt32 => SoundIoFormat.S32LE,
-                SampleFormat.PcmFloat => SoundIoFormat.Float32LE,
-                _ => throw new ArgumentException ($"Unsupported sample format {format}"),
-            };
-        }
-
-        internal SoundIoOutStreamContext OpenStream(SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount)
-        {
-            SoundIoFormat driverSampleFormat = GetSoundIoFormat(requestedSampleFormat);
-
-            if (!_audioDevice.SupportsSampleRate((int)requestedSampleRate))
-            {
-                throw new ArgumentException($"This sound device does not support a sample rate of {requestedSampleRate}Hz");
-            }
-
-            if (!_audioDevice.SupportsFormat(driverSampleFormat))
-            {
-                throw new ArgumentException($"This sound device does not support {requestedSampleFormat}");
-            }
-
-            if (!_audioDevice.SupportsChannelCount((int)requestedChannelCount))
-            {
-                throw new ArgumentException($"This sound device does not support channel count {requestedChannelCount}");
-            }
-
-            SoundIoOutStreamContext result = _audioDevice.CreateOutStream();
-
-            result.Name = "Ryujinx";
-            result.Layout = SoundIoChannelLayout.GetDefaultValue((int)requestedChannelCount);
-            result.Format = driverSampleFormat;
-            result.SampleRate = (int)requestedSampleRate;
-
-            return result;
-        }
-
-        internal void FlushContextEvents()
-        {
-            _audioContext.FlushEvents();
-        }
-
-        public void Dispose()
-        {
-            if (Interlocked.CompareExchange(ref _disposeState, 1, 0) == 0)
-            {
-                Dispose(true);
-            }
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                foreach (SoundIoHardwareDeviceSession session in _sessions.Keys)
-                {
-                    session.Dispose();
-                }
-
-                _audioContext.Disconnect();
-                _audioContext.Dispose();
-                _pauseEvent.Dispose();
-            }
-        }
-
-        public bool SupportsSampleRate(uint sampleRate)
-        {
-            return _audioDevice.SupportsSampleRate((int)sampleRate);
-        }
-
-        public bool SupportsSampleFormat(SampleFormat sampleFormat)
-        {
-            return _audioDevice.SupportsFormat(GetSoundIoFormat(sampleFormat));
-        }
-
-        public bool SupportsChannelCount(uint channelCount)
-        {
-            return _audioDevice.SupportsChannelCount((int)channelCount);
-        }
-
-        public bool SupportsDirection(Direction direction)
-        {
-            // TODO: add direction input when supported.
-            return direction == Direction.Output;
-        }
-    }
-}

Ryujinx.Audio/AudioManager.cs

@@ -1,132 +0,0 @@
-using System;
-using System.Threading;
-
-namespace Ryujinx.Audio
-{
-    /// <summary>
-    /// Manage audio input and output system.
-    /// </summary>
-    public class AudioManager : IDisposable
-    {
-        /// <summary>
-        /// Lock used to control the waiters registration.
-        /// </summary>
-        private object _lock = new object();
-
-        /// <summary>
-        /// Events signaled when the driver played audio buffers.
-        /// </summary>
-        private ManualResetEvent[] _updateRequiredEvents;
-
-        /// <summary>
-        /// Action to execute when the driver played audio buffers.
-        /// </summary>
-        private Action[] _actions;
-
-        /// <summary>
-        /// The worker thread in charge of handling sessions update.
-        /// </summary>
-        private Thread _workerThread;
-
-        private bool _isRunning;
-
-        /// <summary>
-        /// Create a new <see cref="AudioManager"/>.
-        /// </summary>
-        public AudioManager()
-        {
-            _updateRequiredEvents = new ManualResetEvent[2];
-            _actions = new Action[2];
-            _isRunning = false;
-
-            // Termination event.
-            _updateRequiredEvents[1] = new ManualResetEvent(false);
-
-            _workerThread = new Thread(Update)
-            {
-                Name = "AudioManager.Worker"
-            };
-        }
-
-        /// <summary>
-        /// Start the <see cref="AudioManager"/>.
-        /// </summary>
-        public void Start()
-        {
-            if (_workerThread.IsAlive)
-            {
-                throw new InvalidOperationException();
-            }
-
-            _isRunning = true;
-            _workerThread.Start();
-        }
-
-        /// <summary>
-        /// Initialize update handlers.
-        /// </summary>
-        /// <param name="updatedRequiredEvent ">The driver event that will get signaled by the device driver when an audio buffer finished playing/being captured</param>
-        /// <param name="outputCallback">The callback to call when an audio buffer finished playing</param>
-        /// <param name="inputCallback">The callback to call when an audio buffer was captured</param>
-        public void Initialize(ManualResetEvent updatedRequiredEvent, Action outputCallback, Action inputCallback)
-        {
-            lock (_lock)
-            {
-                _updateRequiredEvents[0] = updatedRequiredEvent;
-                _actions[0] = outputCallback;
-                _actions[1] = inputCallback;
-            }
-        }
-
-        /// <summary>
-        /// Entrypoint of the <see cref="_workerThread"/> in charge of updating the <see cref="AudioManager"/>.
-        /// </summary>
-        private void Update()
-        {
-            while (_isRunning)
-            {
-                int index = WaitHandle.WaitAny(_updateRequiredEvents);
-
-                // Last index is here to indicate thread termination.
-                if (index + 1 == _updateRequiredEvents.Length)
-                {
-                    break;
-                }
-
-                lock (_lock)
-                {
-                    foreach (Action action in _actions)
-                    {
-                        action?.Invoke();
-                    }
-
-                    _updateRequiredEvents[0].Reset();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Stop updating the <see cref="AudioManager"/> without stopping the worker thread.
-        /// </summary>
-        public void StopUpdates()
-        {
-            _isRunning = false;
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                _updateRequiredEvents[1].Set();
-                _workerThread.Join();
-
-                _updateRequiredEvents[1].Dispose();
-            }
-        }
-    }
-}

Ryujinx.Audio/Backends/Common/DynamicRingBuffer.cs

@@ -1,166 +0,0 @@
-using Ryujinx.Common;
-using System;
-
-namespace Ryujinx.Audio.Backends.Common
-{
-    /// <summary>
-    /// A ring buffer that grow if data written to it is too big to fit.
-    /// </summary>
-    public class DynamicRingBuffer
-    {
-        private const int RingBufferAlignment = 2048;
-
-        private object _lock = new object();
-
-        private byte[] _buffer;
-        private int _size;
-        private int _headOffset;
-        private int _tailOffset;
-
-        public int Length => _size;
-
-        public DynamicRingBuffer(int initialCapacity = RingBufferAlignment)
-        {
-            _buffer = new byte[initialCapacity];
-        }
-
-        public void Clear()
-        {
-            _size = 0;
-            _headOffset = 0;
-            _tailOffset = 0;
-        }
-
-        public void Clear(int size)
-        {
-            lock (_lock)
-            {
-                if (size > _size)
-                {
-                    size = _size;
-                }
-
-                if (size == 0)
-                {
-                    return;
-                }
-
-                _headOffset = (_headOffset + size) % _buffer.Length;
-                _size -= size;
-
-                if (_size == 0)
-                {
-                    _headOffset = 0;
-                    _tailOffset = 0;
-                }
-            }
-        }
-
-        private void SetCapacityLocked(int capacity)
-        {
-            byte[] buffer = new byte[capacity];
-
-            if (_size > 0)
-            {
-                if (_headOffset < _tailOffset)
-                {
-                    Buffer.BlockCopy(_buffer, _headOffset, buffer, 0, _size);
-                }
-                else
-                {
-                    Buffer.BlockCopy(_buffer, _headOffset, buffer, 0, _buffer.Length - _headOffset);
-                    Buffer.BlockCopy(_buffer, 0, buffer, _buffer.Length - _headOffset, _tailOffset);
-                }
-            }
-
-            _buffer = buffer;
-            _headOffset = 0;
-            _tailOffset = _size;
-        }
-
-
-        public void Write<T>(T[] buffer, int index, int count)
-        {
-            if (count == 0)
-            {
-                return;
-            }
-
-            lock (_lock)
-            {
-                if ((_size + count) > _buffer.Length)
-                {
-                    SetCapacityLocked(BitUtils.AlignUp(_size + count, RingBufferAlignment));
-                }
-
-                if (_headOffset < _tailOffset)
-                {
-                    int tailLength = _buffer.Length - _tailOffset;
-
-                    if (tailLength >= count)
-                    {
-                        Buffer.BlockCopy(buffer, index, _buffer, _tailOffset, count);
-                    }
-                    else
-                    {
-                        Buffer.BlockCopy(buffer, index, _buffer, _tailOffset, tailLength);
-                        Buffer.BlockCopy(buffer, index + tailLength, _buffer, 0, count - tailLength);
-                    }
-                }
-                else
-                {
-                    Buffer.BlockCopy(buffer, index, _buffer, _tailOffset, count);
-                }
-
-                _size += count;
-                _tailOffset = (_tailOffset + count) % _buffer.Length;
-            }
-        }
-
-        public int Read<T>(T[] buffer, int index, int count)
-        {
-            lock (_lock)
-            {
-                if (count > _size)
-                {
-                    count = _size;
-                }
-
-                if (count == 0)
-                {
-                    return 0;
-                }
-
-                if (_headOffset < _tailOffset)
-                {
-                    Buffer.BlockCopy(_buffer, _headOffset, buffer, index, count);
-                }
-                else
-                {
-                    int tailLength = _buffer.Length - _headOffset;
-
-                    if (tailLength >= count)
-                    {
-                        Buffer.BlockCopy(_buffer, _headOffset, buffer, index, count);
-                    }
-                    else
-                    {
-                        Buffer.BlockCopy(_buffer, _headOffset, buffer, index, tailLength);
-                        Buffer.BlockCopy(_buffer, 0, buffer, index + tailLength, count - tailLength);
-                    }
-                }
-
-                _size -= count;
-                _headOffset = (_headOffset + count) % _buffer.Length;
-
-                if (_size == 0)
-                {
-                    _headOffset = 0;
-                    _tailOffset = 0;
-                }
-
-                return count;
-            }
-        }
-    }
-}

Ryujinx.Audio/Common/AudioDeviceSession.cs

@@ -1,516 +0,0 @@
-using Ryujinx.Audio.Integration;
-using Ryujinx.Common;
-using System;
-using System.Diagnostics;
-
-namespace Ryujinx.Audio.Common
-{
-    /// <summary>
-    /// An audio device session.
-    /// </summary>
-    class AudioDeviceSession : IDisposable
-    {
-        /// <summary>
-        /// The volume of the <see cref="AudioDeviceSession"/>.
-        /// </summary>
-        private float _volume;
-
-        /// <summary>
-        /// The state of the <see cref="AudioDeviceSession"/>.
-        /// </summary>
-        private AudioDeviceState _state;
-
-        /// <summary>
-        /// Array of all buffers currently used or released.
-        /// </summary>
-        private AudioBuffer[] _buffers;
-
-        /// <summary>
-        /// The server index inside <see cref="_buffers"/> (appended but not queued to device driver).
-        /// </summary>
-        private uint _serverBufferIndex;
-
-        /// <summary>
-        /// The hardware index inside <see cref="_buffers"/> (queued to device driver).
-        /// </summary>
-        private uint _hardwareBufferIndex;
-
-        /// <summary>
-        /// The released index inside <see cref="_buffers"/> (released by the device driver).
-        /// </summary>
-        private uint _releasedBufferIndex;
-
-        /// <summary>
-        /// The count of buffer appended (server side).
-        /// </summary>
-        private uint _bufferAppendedCount;
-
-        /// <summary>
-        /// The count of buffer registered (driver side).
-        /// </summary>
-        private uint _bufferRegisteredCount;
-
-        /// <summary>
-        /// The count of buffer released (released by the driver side).
-        /// </summary>
-        private uint _bufferReleasedCount;
-
-        /// <summary>
-        /// The released buffer event.
-        /// </summary>
-        private IWritableEvent _bufferEvent;
-
-        /// <summary>
-        /// The session on the device driver.
-        /// </summary>
-        private IHardwareDeviceSession _hardwareDeviceSession;
-
-        /// <summary>
-        /// Max number of buffers that can be registered to the device driver at a time.
-        /// </summary>
-        private uint _bufferRegisteredLimit;
-
-        /// <summary>
-        /// Create a new <see cref="AudioDeviceSession"/>.
-        /// </summary>
-        /// <param name="deviceSession">The device driver session associated</param>
-        /// <param name="bufferEvent">The release buffer event</param>
-        /// <param name="bufferRegisteredLimit">The max number of buffers that can be registered to the device driver at a time</param>
-        public AudioDeviceSession(IHardwareDeviceSession deviceSession, IWritableEvent bufferEvent, uint bufferRegisteredLimit = 4)
-        {
-            _bufferEvent = bufferEvent;
-            _hardwareDeviceSession = deviceSession;
-            _bufferRegisteredLimit = bufferRegisteredLimit;
-
-            _buffers = new AudioBuffer[Constants.AudioDeviceBufferCountMax];
-            _serverBufferIndex = 0;
-            _hardwareBufferIndex = 0;
-            _releasedBufferIndex = 0;
-
-            _bufferAppendedCount = 0;
-            _bufferRegisteredCount = 0;
-            _bufferReleasedCount = 0;
-            _volume = deviceSession.GetVolume();
-            _state = AudioDeviceState.Stopped;
-        }
-
-        /// <summary>
-        /// Get the released buffer event.
-        /// </summary>
-        /// <returns>The released buffer event</returns>
-        public IWritableEvent GetBufferEvent()
-        {
-            return _bufferEvent;
-        }
-
-        /// <summary>
-        /// Get the state of the session.
-        /// </summary>
-        /// <returns>The state of the session</returns>
-        public AudioDeviceState GetState()
-        {
-            Debug.Assert(_state == AudioDeviceState.Started || _state == AudioDeviceState.Stopped);
-
-            return _state;
-        }
-
-        /// <summary>
-        /// Get the total buffer count (server + driver + released).
-        /// </summary>
-        /// <returns>Return the total buffer count</returns>
-        private uint GetTotalBufferCount()
-        {
-            uint bufferCount = _bufferAppendedCount + _bufferRegisteredCount + _bufferReleasedCount;
-
-            Debug.Assert(bufferCount <= Constants.AudioDeviceBufferCountMax);
-
-            return bufferCount;
-        }
-
-        /// <summary>
-        /// Register a new <see cref="AudioBuffer"/> on the server side.
-        /// </summary>
-        /// <param name="buffer">The <see cref="AudioBuffer"/> to register</param>
-        /// <returns>True if the operation succeeded</returns>
-        private bool RegisterBuffer(AudioBuffer buffer)
-        {
-            if (GetTotalBufferCount() == Constants.AudioDeviceBufferCountMax)
-            {
-                return false;
-            }
-
-            _buffers[_serverBufferIndex] = buffer;
-            _serverBufferIndex = (_serverBufferIndex + 1) % Constants.AudioDeviceBufferCountMax;
-            _bufferAppendedCount++;
-
-            return true;
-        }
-
-        /// <summary>
-        /// Flush server buffers to hardware.
-        /// </summary>
-        private void FlushToHardware()
-        {
-            uint bufferToFlushCount = Math.Min(Math.Min(_bufferAppendedCount, 4), _bufferRegisteredLimit - _bufferRegisteredCount);
-
-            AudioBuffer[] buffersToFlush = new AudioBuffer[bufferToFlushCount];
-
-            uint hardwareBufferIndex = _hardwareBufferIndex;
-
-            for (int i = 0; i < buffersToFlush.Length; i++)
-            {
-                buffersToFlush[i] = _buffers[hardwareBufferIndex];
-
-                _bufferAppendedCount--;
-                _bufferRegisteredCount++;
-
-                hardwareBufferIndex = (hardwareBufferIndex + 1) % Constants.AudioDeviceBufferCountMax;
-            }
-
-            _hardwareBufferIndex = hardwareBufferIndex;
-
-            for (int i = 0; i < buffersToFlush.Length; i++)
-            {
-                _hardwareDeviceSession.QueueBuffer(buffersToFlush[i]);
-            }
-        }
-
-        /// <summary>
-        /// Get the current index of the <see cref="AudioBuffer"/> playing on the driver side.
-        /// </summary>
-        /// <param name="playingIndex">The output index of the <see cref="AudioBuffer"/> playing on the driver side</param>
-        /// <returns>True if any buffer is playing</returns>
-        private bool TryGetPlayingBufferIndex(out uint playingIndex)
-        {
-            if (_bufferRegisteredCount > 0)
-            {
-                playingIndex = (_hardwareBufferIndex - _bufferRegisteredCount) % Constants.AudioDeviceBufferCountMax;
-
-                return true;
-            }
-
-            playingIndex = 0;
-
-            return false;
-        }
-
-        /// <summary>
-        /// Try to pop the <see cref="AudioBuffer"/> playing on the driver side.
-        /// </summary>
-        /// <param name="buffer">The output <see cref="AudioBuffer"/> playing on the driver side</param>
-        /// <returns>True if any buffer is playing</returns>
-        private bool TryPopPlayingBuffer(out AudioBuffer buffer)
-        {
-            if (_bufferRegisteredCount > 0)
-            {
-                uint bufferIndex = (_hardwareBufferIndex - _bufferRegisteredCount) % Constants.AudioDeviceBufferCountMax;
-
-                buffer = _buffers[bufferIndex];
-
-                _buffers[bufferIndex] = null;
-
-                _bufferRegisteredCount--;
-
-                return true;
-            }
-
-            buffer = null;
-
-            return false;
-        }
-
-        /// <summary>
-        /// Try to pop a <see cref="AudioBuffer"/> released by the driver side.
-        /// </summary>
-        /// <param name="buffer">The output <see cref="AudioBuffer"/> released by the driver side</param>
-        /// <returns>True if any buffer has been released</returns>
-        public bool TryPopReleasedBuffer(out AudioBuffer buffer)
-        {
-            if (_bufferReleasedCount > 0)
-            {
-                uint bufferIndex = (_releasedBufferIndex - _bufferReleasedCount) % Constants.AudioDeviceBufferCountMax;
-
-                buffer = _buffers[bufferIndex];
-
-                _buffers[bufferIndex] = null;
-
-                _bufferReleasedCount--;
-
-                return true;
-            }
-
-            buffer = null;
-
-            return false;
-        }
-
-        /// <summary>
-        /// Release a <see cref="AudioBuffer"/>.
-        /// </summary>
-        /// <param name="buffer">The <see cref="AudioBuffer"/> to release</param>
-        private void ReleaseBuffer(AudioBuffer buffer)
-        {
-            buffer.PlayedTimestamp = (ulong)PerformanceCounter.ElapsedNanoseconds;
-
-            _bufferRegisteredCount--;
-            _bufferReleasedCount++;
-
-            _releasedBufferIndex = (_releasedBufferIndex + 1) % Constants.AudioDeviceBufferCountMax;
-        }
-
-        /// <summary>
-        /// Update the released buffers.
-        /// </summary>
-        /// <param name="updateForStop">True if the session is currently stopping</param>
-        private void UpdateReleaseBuffers(bool updateForStop = false)
-        {
-            bool wasAnyBuffersReleased = false;
-
-            while (TryGetPlayingBufferIndex(out uint playingIndex))
-            {
-                if (!updateForStop && !_hardwareDeviceSession.WasBufferFullyConsumed(_buffers[playingIndex]))
-                {
-                    break;
-                }
-
-                if (updateForStop)
-                {
-                    _hardwareDeviceSession.UnregisterBuffer(_buffers[playingIndex]);
-                }
-
-                ReleaseBuffer(_buffers[playingIndex]);
-
-                wasAnyBuffersReleased = true;
-            }
-
-            if (wasAnyBuffersReleased)
-            {
-                _bufferEvent.Signal();
-            }
-        }
-
-        /// <summary>
-        /// Append a new <see cref="AudioBuffer"/>.
-        /// </summary>
-        /// <param name="buffer">The <see cref="AudioBuffer"/> to append</param>
-        /// <returns>True if the buffer was appended</returns>
-        public bool AppendBuffer(AudioBuffer buffer)
-        {
-            if (_hardwareDeviceSession.RegisterBuffer(buffer))
-            {
-                if (RegisterBuffer(buffer))
-                {
-                    FlushToHardware();
-
-                    return true;
-                }
-
-                _hardwareDeviceSession.UnregisterBuffer(buffer);
-            }
-
-            return false;
-        }
-
-        public bool AppendUacBuffer(AudioBuffer buffer, uint handle)
-        {
-            // NOTE: On hardware, there is another RegisterBuffer method taking an handle.
-            // This variant of the call always return false (stubbed?) as a result this logic will never succeed.
-
-            return false;
-        }
-
-        /// <summary>
-        /// Start the audio session.
-        /// </summary>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success</returns>
-        public ResultCode Start()
-        {
-            if (_state == AudioDeviceState.Started)
-            {
-                return ResultCode.OperationFailed;
-            }
-
-            _hardwareDeviceSession.Start();
-
-            _state = AudioDeviceState.Started;
-
-            FlushToHardware();
-
-            _hardwareDeviceSession.SetVolume(_volume);
-
-            return ResultCode.Success;
-        }
-
-        /// <summary>
-        /// Stop the audio session.
-        /// </summary>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success</returns>
-        public ResultCode Stop()
-        {
-            if (_state == AudioDeviceState.Started)
-            {
-                _hardwareDeviceSession.Stop();
-
-                UpdateReleaseBuffers(true);
-
-                _state = AudioDeviceState.Stopped;
-            }
-
-            return ResultCode.Success;
-        }
-
-        /// <summary>
-        /// Get the volume of the session.
-        /// </summary>
-        /// <returns>The volume of the session</returns>
-        public float GetVolume()
-        {
-            return _hardwareDeviceSession.GetVolume();
-        }
-
-        /// <summary>
-        /// Set the volume of the session.
-        /// </summary>
-        /// <param name="volume">The new volume to set</param>
-        public void SetVolume(float volume)
-        {
-            _volume = volume;
-
-            if (_state == AudioDeviceState.Started)
-            {
-                _hardwareDeviceSession.SetVolume(volume);
-            }
-        }
-
-        /// <summary>
-        /// Get the count of buffer currently in use (server + driver side).
-        /// </summary>
-        /// <returns>The count of buffer currently in use</returns>
-        public uint GetBufferCount()
-        {
-            return _bufferAppendedCount + _bufferRegisteredCount;
-        }
-
-        /// <summary>
-        /// Check if a buffer is present.
-        /// </summary>
-        /// <param name="bufferTag">The unique tag of the buffer</param>
-        /// <returns>Return true if a buffer is present</returns>
-        public bool ContainsBuffer(ulong bufferTag)
-        {
-            uint bufferIndex = (_releasedBufferIndex - _bufferReleasedCount) % Constants.AudioDeviceBufferCountMax;
-
-            for (int i = 0; i < GetTotalBufferCount(); i++)
-            {
-                if (_buffers[bufferIndex].BufferTag == bufferTag)
-                {
-                    return true;
-                }
-
-                bufferIndex = (bufferIndex + 1) % Constants.AudioDeviceBufferCountMax;
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Get the count of sample played in this session.
-        /// </summary>
-        /// <returns>The count of sample played in this session</returns>
-        public ulong GetPlayedSampleCount()
-        {
-            if (_state == AudioDeviceState.Stopped)
-            {
-                return 0;
-            }
-            else
-            {
-                return _hardwareDeviceSession.GetPlayedSampleCount();
-            }
-        }
-
-        /// <summary>
-        /// Flush all buffers to the initial state.
-        /// </summary>
-        /// <returns>True if any buffer was flushed</returns>
-        public bool FlushBuffers()
-        {
-            if (_state == AudioDeviceState.Stopped)
-            {
-                return false;
-            }
-
-            uint bufferCount = GetBufferCount();
-
-            while (TryPopReleasedBuffer(out AudioBuffer buffer))
-            {
-                _hardwareDeviceSession.UnregisterBuffer(buffer);
-            }
-
-            while (TryPopPlayingBuffer(out AudioBuffer buffer))
-            {
-                _hardwareDeviceSession.UnregisterBuffer(buffer);
-            }
-
-            if (_bufferRegisteredCount == 0 || (_bufferReleasedCount + _bufferAppendedCount) > Constants.AudioDeviceBufferCountMax)
-            {
-                return false;
-            }
-
-            _bufferReleasedCount += _bufferAppendedCount;
-            _releasedBufferIndex = (_releasedBufferIndex + _bufferAppendedCount) % Constants.AudioDeviceBufferCountMax;
-            _bufferAppendedCount = 0;
-            _hardwareBufferIndex = _serverBufferIndex;
-
-            if (bufferCount > 0)
-            {
-                _bufferEvent.Signal();
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Update the session.
-        /// </summary>
-        public void Update()
-        {
-            if (_state == AudioDeviceState.Started)
-            {
-                UpdateReleaseBuffers();
-                FlushToHardware();
-            }
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                // Tell the hardware session that we are ending.
-                _hardwareDeviceSession.PrepareToClose();
-
-                // Unregister all buffers
-
-                while (TryPopReleasedBuffer(out AudioBuffer buffer))
-                {
-                    _hardwareDeviceSession.UnregisterBuffer(buffer);
-                }
-
-                while (TryPopPlayingBuffer(out AudioBuffer buffer))
-                {
-                    _hardwareDeviceSession.UnregisterBuffer(buffer);
-                }
-
-                // Finally dispose hardware session.
-                _hardwareDeviceSession.Dispose();
-
-                _bufferEvent.Signal();
-            }
-        }
-    }
-}

Ryujinx.Audio/Input/AudioInputManager.cs

@@ -1,266 +0,0 @@
-using Ryujinx.Audio.Common;
-using Ryujinx.Audio.Integration;
-using Ryujinx.Common.Logging;
-using Ryujinx.Memory;
-using System;
-using System.Diagnostics;
-using System.Linq;
-using System.Threading;
-
-namespace Ryujinx.Audio.Input
-{
-    /// <summary>
-    /// The audio input manager.
-    /// </summary>
-    public class AudioInputManager : IDisposable
-    {
-        private object _lock = new object();
-
-        /// <summary>
-        /// Lock used for session allocation.
-        /// </summary>
-        private object _sessionLock = new object();
-
-        /// <summary>
-        /// The session ids allocation table.
-        /// </summary>
-        private int[] _sessionIds;
-
-        /// <summary>
-        /// The device driver.
-        /// </summary>
-        private IHardwareDeviceDriver _deviceDriver;
-
-        /// <summary>
-        /// The events linked to each session.
-        /// </summary>
-        private IWritableEvent[] _sessionsBufferEvents;
-
-        /// <summary>
-        /// The <see cref="AudioInputSystem"/> session instances.
-        /// </summary>
-        private AudioInputSystem[] _sessions;
-
-        /// <summary>
-        /// The count of active sessions.
-        /// </summary>
-        private int _activeSessionCount;
-
-        /// <summary>
-        /// The dispose state.
-        /// </summary>
-        private int _disposeState;
-
-        /// <summary>
-        /// Create a new <see cref="AudioInputManager"/>.
-        /// </summary>
-        public AudioInputManager()
-        {
-            _sessionIds = new int[Constants.AudioInSessionCountMax];
-            _sessions = new AudioInputSystem[Constants.AudioInSessionCountMax];
-            _activeSessionCount = 0;
-
-            for (int i = 0; i < _sessionIds.Length; i++)
-            {
-                _sessionIds[i] = i;
-            }
-        }
-
-        /// <summary>
-        /// Initialize the <see cref="AudioInputManager"/>.
-        /// </summary>
-        /// <param name="deviceDriver">The device driver.</param>
-        /// <param name="sessionRegisterEvents">The events associated to each session.</param>
-        public void Initialize(IHardwareDeviceDriver deviceDriver, IWritableEvent[] sessionRegisterEvents)
-        {
-            _deviceDriver = deviceDriver;
-            _sessionsBufferEvents = sessionRegisterEvents;
-        }
-
-        /// <summary>
-        /// Acquire a new session id.
-        /// </summary>
-        /// <returns>A new session id.</returns>
-        private int AcquireSessionId()
-        {
-            lock (_sessionLock)
-            {
-                int index = _activeSessionCount;
-
-                Debug.Assert(index < _sessionIds.Length);
-
-                int sessionId = _sessionIds[index];
-
-                _sessionIds[index] = -1;
-
-                _activeSessionCount++;
-
-                Logger.Info?.Print(LogClass.AudioRenderer, $"Registered new input ({sessionId})");
-
-                return sessionId;
-            }
-        }
-
-        /// <summary>
-        /// Release a given <paramref name="sessionId"/>.
-        /// </summary>
-        /// <param name="sessionId">The session id to release.</param>
-        private void ReleaseSessionId(int sessionId)
-        {
-            lock (_sessionLock)
-            {
-                Debug.Assert(_activeSessionCount > 0);
-
-                int newIndex = --_activeSessionCount;
-
-                _sessionIds[newIndex] = sessionId;
-            }
-
-            Logger.Info?.Print(LogClass.AudioRenderer, $"Unregistered input ({sessionId})");
-        }
-
-        /// <summary>
-        /// Used to update audio input system.
-        /// </summary>
-        public void Update()
-        {
-            lock (_sessionLock)
-            {
-                foreach (AudioInputSystem input in _sessions)
-                {
-                    input?.Update();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Register a new <see cref="AudioInputSystem"/>.
-        /// </summary>
-        /// <param name="input">The <see cref="AudioInputSystem"/> to register.</param>
-        private void Register(AudioInputSystem input)
-        {
-            lock (_sessionLock)
-            {
-                _sessions[input.GetSessionId()] = input;
-            }
-        }
-
-        /// <summary>
-        /// Unregister a new <see cref="AudioInputSystem"/>.
-        /// </summary>
-        /// <param name="input">The <see cref="AudioInputSystem"/> to unregister.</param>
-        internal void Unregister(AudioInputSystem input)
-        {
-            lock (_sessionLock)
-            {
-                int sessionId = input.GetSessionId();
-
-                _sessions[input.GetSessionId()] = null;
-
-                ReleaseSessionId(sessionId);
-            }
-        }
-
-        /// <summary>
-        /// Get the list of all audio inputs names.
-        /// </summary>
-        /// <param name="filtered">If true, filter disconnected devices</param>
-        /// <returns>The list of all audio inputs name</returns>
-        public string[] ListAudioIns(bool filtered)
-        {
-            if (filtered)
-            {
-                // TODO: Detect if the driver supports audio input
-            }
-
-            return new string[] { Constants.DefaultDeviceInputName };
-        }
-
-        /// <summary>
-        /// Open a new <see cref="AudioInputSystem"/>.
-        /// </summary>
-        /// <param name="outputDeviceName">The output device name selected by the <see cref="AudioInputSystem"/></param>
-        /// <param name="outputConfiguration">The output audio configuration selected by the <see cref="AudioInputSystem"/></param>
-        /// <param name="obj">The new <see cref="AudioInputSystem"/></param>
-        /// <param name="memoryManager">The memory manager that will be used for all guest memory operations</param>
-        /// <param name="inputDeviceName">The input device name wanted by the user</param>
-        /// <param name="sampleFormat">The sample format to use</param>
-        /// <param name="parameter">The user configuration</param>
-        /// <param name="appletResourceUserId">The applet resource user id of the application</param>
-        /// <param name="processHandle">The process handle of the application</param>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success</returns>
-        public ResultCode OpenAudioIn(out string outputDeviceName,
-                                      out AudioOutputConfiguration outputConfiguration,
-                                      out AudioInputSystem obj,
-                                      IVirtualMemoryManager memoryManager,
-                                      string inputDeviceName,
-                                      SampleFormat sampleFormat,
-                                      ref AudioInputConfiguration parameter,
-                                      ulong appletResourceUserId,
-                                      uint processHandle)
-        {
-            int sessionId = AcquireSessionId();
-
-            _sessionsBufferEvents[sessionId].Clear();
-
-            IHardwareDeviceSession deviceSession = _deviceDriver.OpenDeviceSession(IHardwareDeviceDriver.Direction.Input, memoryManager, sampleFormat, parameter.SampleRate, parameter.ChannelCount);
-
-            AudioInputSystem audioIn = new AudioInputSystem(this, _lock, deviceSession, _sessionsBufferEvents[sessionId]);
-
-            ResultCode result = audioIn.Initialize(inputDeviceName, sampleFormat, ref parameter, sessionId);
-
-            if (result == ResultCode.Success)
-            {
-                outputDeviceName = audioIn.DeviceName;
-                outputConfiguration = new AudioOutputConfiguration
-                {
-                    ChannelCount = audioIn.ChannelCount,
-                    SampleFormat = audioIn.SampleFormat,
-                    SampleRate = audioIn.SampleRate,
-                    AudioOutState = audioIn.GetState(),
-                };
-
-                obj = audioIn;
-
-                Register(audioIn);
-            }
-            else
-            {
-                ReleaseSessionId(sessionId);
-
-                obj = null;
-                outputDeviceName = null;
-                outputConfiguration = default;
-            }
-
-            return result;
-        }
-
-        public void Dispose()
-        {
-            if (Interlocked.CompareExchange(ref _disposeState, 1, 0) == 0)
-            {
-                Dispose(true);
-            }
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                // Clone the sessions array to dispose them outside the lock.
-                AudioInputSystem[] sessions;
-
-                lock (_sessionLock)
-                {
-                    sessions = _sessions.ToArray();
-                }
-
-                foreach (AudioInputSystem input in sessions)
-                {
-                    input?.Dispose();
-                }
-            }
-        }
-    }
-}

Ryujinx.Audio/Input/AudioInputSystem.cs

@@ -1,392 +0,0 @@
-using Ryujinx.Audio.Common;
-using Ryujinx.Audio.Integration;
-using System;
-using System.Threading;
-
-namespace Ryujinx.Audio.Input
-{
-    /// <summary>
-    /// Audio input system.
-    /// </summary>
-    public class AudioInputSystem : IDisposable
-    {
-        /// <summary>
-        /// The session id associated to the <see cref="AudioInputSystem"/>.
-        /// </summary>
-        private int _sessionId;
-
-        /// <summary>
-        /// The session the <see cref="AudioInputSystem"/>.
-        /// </summary>
-        private AudioDeviceSession _session;
-
-        /// <summary>
-        /// The target device name of the <see cref="AudioInputSystem"/>.
-        /// </summary>
-        public string DeviceName { get; private set; }
-
-        /// <summary>
-        /// The target sample rate of the <see cref="AudioInputSystem"/>.
-        /// </summary>
-        public uint SampleRate { get; private set; }
-
-        /// <summary>
-        /// The target channel count of the <see cref="AudioInputSystem"/>.
-        /// </summary>
-        public uint ChannelCount { get; private set; }
-
-        /// <summary>
-        /// The target sample format of the <see cref="AudioInputSystem"/>.
-        /// </summary>
-        public SampleFormat SampleFormat { get; private set; }
-
-        /// <summary>
-        /// The <see cref="AudioInputManager"/> owning this.
-        /// </summary>
-        private AudioInputManager _manager;
-
-        /// <summary>
-        /// The lock of the parent.
-        /// </summary>
-        private object _parentLock;
-
-        /// <summary>
-        /// The dispose state.
-        /// </summary>
-        private int _disposeState;
-
-        /// <summary>
-        /// Create a new <see cref="AudioInputSystem"/>.
-        /// </summary>
-        /// <param name="manager">The manager instance</param>
-        /// <param name="parentLock">The lock of the manager</param>
-        /// <param name="deviceSession">The hardware device session</param>
-        /// <param name="bufferEvent">The buffer release event of the audio input</param>
-        public AudioInputSystem(AudioInputManager manager, object parentLock, IHardwareDeviceSession deviceSession, IWritableEvent bufferEvent)
-        {
-            _manager = manager;
-            _parentLock = parentLock;
-            _session = new AudioDeviceSession(deviceSession, bufferEvent);
-        }
-
-        /// <summary>
-        /// Get the default device name on the system.
-        /// </summary>
-        /// <returns>The default device name on the system.</returns>
-        private static string GetDeviceDefaultName()
-        {
-            return Constants.DefaultDeviceInputName;
-        }
-
-        /// <summary>
-        /// Check if a given configuration and device name is valid on the system.
-        /// </summary>
-        /// <param name="configuration">The configuration to check.</param>
-        /// <param name="deviceName">The device name to check.</param>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success.</returns>
-        private static ResultCode IsConfigurationValid(ref AudioInputConfiguration configuration, string deviceName)
-        {
-            if (deviceName.Length != 0 && !deviceName.Equals(GetDeviceDefaultName()))
-            {
-                return ResultCode.DeviceNotFound;
-            }
-            else if (configuration.SampleRate != 0 && configuration.SampleRate != Constants.TargetSampleRate)
-            {
-                return ResultCode.UnsupportedSampleRate;
-            }
-            else if (configuration.ChannelCount != 0 && configuration.ChannelCount != 1 && configuration.ChannelCount != 2 && configuration.ChannelCount != 6)
-            {
-                return ResultCode.UnsupportedChannelConfiguration;
-            }
-
-            return ResultCode.Success;
-        }
-
-        /// <summary>
-        /// Get the released buffer event.
-        /// </summary>
-        /// <returns>The released buffer event</returns>
-        public IWritableEvent RegisterBufferEvent()
-        {
-            lock (_parentLock)
-            {
-                return _session.GetBufferEvent();
-            }
-        }
-
-        /// <summary>
-        /// Update the <see cref="AudioInputSystem"/>.
-        /// </summary>
-        public void Update()
-        {
-            lock (_parentLock)
-            {
-                _session.Update();
-            }
-        }
-
-        /// <summary>
-        /// Get the id of this session.
-        /// </summary>
-        /// <returns>The id of this session</returns>
-        public int GetSessionId()
-        {
-            return _sessionId;
-        }
-
-        /// <summary>
-        /// Initialize the <see cref="AudioInputSystem"/>.
-        /// </summary>
-        /// <param name="inputDeviceName">The input device name wanted by the user</param>
-        /// <param name="sampleFormat">The sample format to use</param>
-        /// <param name="parameter">The user configuration</param>
-        /// <param name="sessionId">The session id associated to this <see cref="AudioInputSystem"/></param>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success.</returns>
-        public ResultCode Initialize(string inputDeviceName, SampleFormat sampleFormat, ref AudioInputConfiguration parameter, int sessionId)
-        {
-            _sessionId = sessionId;
-
-            ResultCode result = IsConfigurationValid(ref parameter, inputDeviceName);
-
-            if (result == ResultCode.Success)
-            {
-                if (inputDeviceName.Length == 0)
-                {
-                    DeviceName = GetDeviceDefaultName();
-                }
-                else
-                {
-                    DeviceName = inputDeviceName;
-                }
-
-                if (parameter.ChannelCount == 6)
-                {
-                    ChannelCount = 6;
-                }
-                else
-                {
-                    ChannelCount = 2;
-                }
-
-                SampleFormat = sampleFormat;
-                SampleRate = Constants.TargetSampleRate;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Append a new audio buffer to the audio input.
-        /// </summary>
-        /// <param name="bufferTag">The unique tag of this buffer.</param>
-        /// <param name="userBuffer">The buffer informations.</param>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success.</returns>
-        public ResultCode AppendBuffer(ulong bufferTag, ref AudioUserBuffer userBuffer)
-        {
-            lock (_parentLock)
-            {
-                AudioBuffer buffer = new AudioBuffer
-                {
-                    BufferTag = bufferTag,
-                    DataPointer = userBuffer.Data,
-                    DataSize = userBuffer.DataSize
-                };
-
-                if (_session.AppendBuffer(buffer))
-                {
-                    return ResultCode.Success;
-                }
-
-                return ResultCode.BufferRingFull;
-            }
-        }
-
-        /// <summary>
-        /// Append a new audio buffer to the audio input.
-        /// </summary>
-        /// <remarks>This is broken by design, only added for completness.</remarks>
-        /// <param name="bufferTag">The unique tag of this buffer.</param>
-        /// <param name="userBuffer">The buffer informations.</param>
-        /// <param name="handle">Some unknown handle.</param>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success.</returns>
-        public ResultCode AppendUacBuffer(ulong bufferTag, ref AudioUserBuffer userBuffer, uint handle)
-        {
-            lock (_parentLock)
-            {
-                AudioBuffer buffer = new AudioBuffer
-                {
-                    BufferTag = bufferTag,
-                    DataPointer = userBuffer.Data,
-                    DataSize = userBuffer.DataSize
-                };
-
-                if (_session.AppendUacBuffer(buffer, handle))
-                {
-                    return ResultCode.Success;
-                }
-
-                return ResultCode.BufferRingFull;
-            }
-        }
-
-        /// <summary>
-        /// Get the release buffers.
-        /// </summary>
-        /// <param name="releasedBuffers">The buffer to write the release buffers</param>
-        /// <param name="releasedCount">The count of released buffers</param>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success.</returns>
-        public ResultCode GetReleasedBuffers(Span<ulong> releasedBuffers, out uint releasedCount)
-        {
-            releasedCount = 0;
-
-            // Ensure that the first entry is set to zero if no entries are returned.
-            if (releasedBuffers.Length > 0)
-            {
-                releasedBuffers[0] = 0;
-            }
-
-            lock (_parentLock)
-            {
-                for (int i = 0; i < releasedBuffers.Length; i++)
-                {
-                    if (!_session.TryPopReleasedBuffer(out AudioBuffer buffer))
-                    {
-                        break;
-                    }
-
-                    releasedBuffers[i] = buffer.BufferTag;
-                    releasedCount++;
-                }
-            }
-
-            return ResultCode.Success;
-        }
-
-        /// <summary>
-        /// Get the current state of the <see cref="AudioInputSystem"/>.
-        /// </summary>
-        /// <returns>Return the curent sta\te of the <see cref="AudioInputSystem"/></returns>
-        public AudioDeviceState GetState()
-        {
-            lock (_parentLock)
-            {
-                return _session.GetState();
-            }
-        }
-
-        /// <summary>
-        /// Start the audio session.
-        /// </summary>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success</returns>
-        public ResultCode Start()
-        {
-            lock (_parentLock)
-            {
-                return _session.Start();
-            }
-        }
-
-        /// <summary>
-        /// Stop the audio session.
-        /// </summary>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success</returns>
-        public ResultCode Stop()
-        {
-            lock (_parentLock)
-            {
-                return _session.Stop();
-            }
-        }
-
-        /// <summary>
-        /// Get the volume of the session.
-        /// </summary>
-        /// <returns>The volume of the session</returns>
-        public float GetVolume()
-        {
-            lock (_parentLock)
-            {
-                return _session.GetVolume();
-            }
-        }
-
-        /// <summary>
-        /// Set the volume of the session.
-        /// </summary>
-        /// <param name="volume">The new volume to set</param>
-        public void SetVolume(float volume)
-        {
-            lock (_parentLock)
-            {
-                _session.SetVolume(volume);
-            }
-        }
-
-        /// <summary>
-        /// Get the count of buffer currently in use (server + driver side).
-        /// </summary>
-        /// <returns>The count of buffer currently in use</returns>
-        public uint GetBufferCount()
-        {
-            lock (_parentLock)
-            {
-                return _session.GetBufferCount();
-            }
-        }
-
-        /// <summary>
-        /// Check if a buffer is present.
-        /// </summary>
-        /// <param name="bufferTag">The unique tag of the buffer</param>
-        /// <returns>Return true if a buffer is present</returns>
-        public bool ContainsBuffer(ulong bufferTag)
-        {
-            lock (_parentLock)
-            {
-                return _session.ContainsBuffer(bufferTag);
-            }
-        }
-
-        /// <summary>
-        /// Get the count of sample played in this session.
-        /// </summary>
-        /// <returns>The count of sample played in this session</returns>
-        public ulong GetPlayedSampleCount()
-        {
-            lock (_parentLock)
-            {
-                return _session.GetPlayedSampleCount();
-            }
-        }
-
-        /// <summary>
-        /// Flush all buffers to the initial state.
-        /// </summary>
-        /// <returns>True if any buffers was flushed</returns>
-        public bool FlushBuffers()
-        {
-            lock (_parentLock)
-            {
-                return _session.FlushBuffers();
-            }
-        }
-
-        public void Dispose()
-        {
-            if (Interlocked.CompareExchange(ref _disposeState, 1, 0) == 0)
-            {
-                Dispose(true);
-            }
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                _session.Dispose();
-
-                _manager.Unregister(this);
-            }
-        }
-    }
-}

Ryujinx.Audio/Output/AudioOutputManager.cs

@@ -1,296 +0,0 @@
-using Ryujinx.Audio.Common;
-using Ryujinx.Audio.Integration;
-using Ryujinx.Common.Logging;
-using Ryujinx.Memory;
-using System;
-using System.Diagnostics;
-using System.Linq;
-using System.Threading;
-
-namespace Ryujinx.Audio.Output
-{
-    /// <summary>
-    /// The audio output manager.
-    /// </summary>
-    public class AudioOutputManager : IDisposable
-    {
-        private object _lock = new object();
-
-        /// <summary>
-        /// Lock used for session allocation.
-        /// </summary>
-        private object _sessionLock = new object();
-
-        /// <summary>
-        /// The session ids allocation table.
-        /// </summary>
-        private int[] _sessionIds;
-
-        /// <summary>
-        /// The device driver.
-        /// </summary>
-        private IHardwareDeviceDriver _deviceDriver;
-
-        /// <summary>
-        /// The events linked to each session.
-        /// </summary>
-        private IWritableEvent[] _sessionsBufferEvents;
-
-        /// <summary>
-        /// The <see cref="AudioOutputSystem"/> session instances.
-        /// </summary>
-        private AudioOutputSystem[] _sessions;
-
-        /// <summary>
-        /// The count of active sessions.
-        /// </summary>
-        private int _activeSessionCount;
-
-        /// <summary>
-        /// The dispose state.
-        /// </summary>
-        private int _disposeState;
-
-        /// <summary>
-        /// Create a new <see cref="AudioOutputManager"/>.
-        /// </summary>
-        public AudioOutputManager()
-        {
-            _sessionIds = new int[Constants.AudioOutSessionCountMax];
-            _sessions = new AudioOutputSystem[Constants.AudioOutSessionCountMax];
-            _activeSessionCount = 0;
-
-            for (int i = 0; i < _sessionIds.Length; i++)
-            {
-                _sessionIds[i] = i;
-            }
-        }
-
-        /// <summary>
-        /// Initialize the <see cref="AudioOutputManager"/>.
-        /// </summary>
-        /// <param name="deviceDriver">The device driver.</param>
-        /// <param name="sessionRegisterEvents">The events associated to each session.</param>
-        public void Initialize(IHardwareDeviceDriver deviceDriver, IWritableEvent[] sessionRegisterEvents)
-        {
-            _deviceDriver = deviceDriver;
-            _sessionsBufferEvents = sessionRegisterEvents;
-        }
-
-        /// <summary>
-        /// Acquire a new session id.
-        /// </summary>
-        /// <returns>A new session id.</returns>
-        private int AcquireSessionId()
-        {
-            lock (_sessionLock)
-            {
-                int index = _activeSessionCount;
-
-                Debug.Assert(index < _sessionIds.Length);
-
-                int sessionId = _sessionIds[index];
-
-                _sessionIds[index] = -1;
-
-                _activeSessionCount++;
-
-                Logger.Info?.Print(LogClass.AudioRenderer, $"Registered new output ({sessionId})");
-
-                return sessionId;
-            }
-        }
-
-        /// <summary>
-        /// Release a given <paramref name="sessionId"/>.
-        /// </summary>
-        /// <param name="sessionId">The session id to release.</param>
-        private void ReleaseSessionId(int sessionId)
-        {
-            lock (_sessionLock)
-            {
-                Debug.Assert(_activeSessionCount > 0);
-
-                int newIndex = --_activeSessionCount;
-
-                _sessionIds[newIndex] = sessionId;
-            }
-
-            Logger.Info?.Print(LogClass.AudioRenderer, $"Unregistered output ({sessionId})");
-        }
-
-        /// <summary>
-        /// Used to update audio output system.
-        /// </summary>
-        public void Update()
-        {
-            lock (_sessionLock)
-            {
-                foreach (AudioOutputSystem output in _sessions)
-                {
-                    output?.Update();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Register a new <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        /// <param name="output">The <see cref="AudioOutputSystem"/> to register.</param>
-        private void Register(AudioOutputSystem output)
-        {
-            lock (_sessionLock)
-            {
-                _sessions[output.GetSessionId()] = output;
-            }
-        }
-
-        /// <summary>
-        /// Unregister a new <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        /// <param name="output">The <see cref="AudioOutputSystem"/> to unregister.</param>
-        internal void Unregister(AudioOutputSystem output)
-        {
-            lock (_sessionLock)
-            {
-                int sessionId = output.GetSessionId();
-
-                _sessions[output.GetSessionId()] = null;
-
-                ReleaseSessionId(sessionId);
-            }
-        }
-
-        /// <summary>
-        /// Get the list of all audio outputs name.
-        /// </summary>
-        /// <returns>The list of all audio outputs name</returns>
-        public string[] ListAudioOuts()
-        {
-            return new string[] { Constants.DefaultDeviceOutputName };
-        }
-
-        /// <summary>
-        /// Open a new <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        /// <param name="outputDeviceName">The output device name selected by the <see cref="AudioOutputSystem"/></param>
-        /// <param name="outputConfiguration">The output audio configuration selected by the <see cref="AudioOutputSystem"/></param>
-        /// <param name="obj">The new <see cref="AudioOutputSystem"/></param>
-        /// <param name="memoryManager">The memory manager that will be used for all guest memory operations</param>
-        /// <param name="inputDeviceName">The input device name wanted by the user</param>
-        /// <param name="sampleFormat">The sample format to use</param>
-        /// <param name="parameter">The user configuration</param>
-        /// <param name="appletResourceUserId">The applet resource user id of the application</param>
-        /// <param name="processHandle">The process handle of the application</param>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success</returns>
-        public ResultCode OpenAudioOut(out string outputDeviceName,
-                                       out AudioOutputConfiguration outputConfiguration,
-                                       out AudioOutputSystem obj,
-                                       IVirtualMemoryManager memoryManager,
-                                       string inputDeviceName,
-                                       SampleFormat sampleFormat,
-                                       ref AudioInputConfiguration parameter,
-                                       ulong appletResourceUserId,
-                                       uint processHandle,
-                                       float volume)
-        {
-            int sessionId = AcquireSessionId();
-
-            _sessionsBufferEvents[sessionId].Clear();
-
-            IHardwareDeviceSession deviceSession = _deviceDriver.OpenDeviceSession(IHardwareDeviceDriver.Direction.Output, memoryManager, sampleFormat, parameter.SampleRate, parameter.ChannelCount, volume);
-
-            AudioOutputSystem audioOut = new AudioOutputSystem(this, _lock, deviceSession, _sessionsBufferEvents[sessionId]);
-
-            ResultCode result = audioOut.Initialize(inputDeviceName, sampleFormat, ref parameter, sessionId);
-
-            if (result == ResultCode.Success)
-            {
-                outputDeviceName = audioOut.DeviceName;
-                outputConfiguration = new AudioOutputConfiguration
-                {
-                    ChannelCount = audioOut.ChannelCount,
-                    SampleFormat = audioOut.SampleFormat,
-                    SampleRate = audioOut.SampleRate,
-                    AudioOutState = audioOut.GetState(),
-                };
-
-                obj = audioOut;
-
-                Register(audioOut);
-            }
-            else
-            {
-                ReleaseSessionId(sessionId);
-
-                obj = null;
-                outputDeviceName = null;
-                outputConfiguration = default;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Sets the volume for all output devices.
-        /// </summary>
-        /// <param name="volume">The volume to set.</param>
-        public void SetVolume(float volume)
-        {
-            if (_sessions != null)
-            {
-                foreach (AudioOutputSystem session in _sessions)
-                {
-                    session?.SetVolume(volume);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Gets the volume for all output devices.
-        /// </summary>
-        /// <returns>A float indicating the volume level.</returns>
-        public float GetVolume()
-        {
-            if (_sessions != null)
-            {
-                foreach (AudioOutputSystem session in _sessions)
-                {
-                    if (session != null)
-                    {
-                        return session.GetVolume();
-                    }
-                }
-            }
-
-            return 0.0f;
-        }
-
-        public void Dispose()
-        {
-            if (Interlocked.CompareExchange(ref _disposeState, 1, 0) == 0)
-            {
-                Dispose(true);
-            }
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                // Clone the sessions array to dispose them outside the lock.
-                AudioOutputSystem[] sessions;
-
-                lock (_sessionLock)
-                {
-                    sessions = _sessions.ToArray();
-                }
-
-                foreach (AudioOutputSystem output in sessions)
-                {
-                    output?.Dispose();
-                }
-            }
-        }
-    }
-}

Ryujinx.Audio/Output/AudioOutputSystem.cs

@@ -1,365 +0,0 @@
-using Ryujinx.Audio.Common;
-using Ryujinx.Audio.Integration;
-using System;
-using System.Threading;
-
-namespace Ryujinx.Audio.Output
-{
-    /// <summary>
-    /// Audio output system.
-    /// </summary>
-    public class AudioOutputSystem : IDisposable
-    {
-        /// <summary>
-        /// The session id associated to the <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        private int _sessionId;
-
-        /// <summary>
-        /// The session the <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        private AudioDeviceSession _session;
-
-        /// <summary>
-        /// The target device name of the <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        public string DeviceName { get; private set; }
-
-        /// <summary>
-        /// The target sample rate of the <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        public uint SampleRate { get; private set; }
-
-        /// <summary>
-        /// The target channel count of the <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        public uint ChannelCount { get; private set; }
-
-        /// <summary>
-        /// The target sample format of the <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        public SampleFormat SampleFormat { get; private set; }
-
-        /// <summary>
-        /// The <see cref="AudioOutputManager"/> owning this.
-        /// </summary>
-        private AudioOutputManager _manager;
-
-        /// <summary>
-        /// THe lock of the parent.
-        /// </summary>
-        private object _parentLock;
-
-        /// <summary>
-        /// The dispose state.
-        /// </summary>
-        private int _disposeState;
-
-        /// <summary>
-        /// Create a new <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        /// <param name="manager">The manager instance</param>
-        /// <param name="parentLock">The lock of the manager</param>
-        /// <param name="deviceSession">The hardware device session</param>
-        /// <param name="bufferEvent">The buffer release event of the audio output</param>
-        public AudioOutputSystem(AudioOutputManager manager, object parentLock, IHardwareDeviceSession deviceSession, IWritableEvent bufferEvent)
-        {
-            _manager = manager;
-            _parentLock = parentLock;
-            _session = new AudioDeviceSession(deviceSession, bufferEvent);
-        }
-
-        /// <summary>
-        /// Get the default device name on the system.
-        /// </summary>
-        /// <returns>The default device name on the system.</returns>
-        private static string GetDeviceDefaultName()
-        {
-            return Constants.DefaultDeviceOutputName;
-        }
-
-        /// <summary>
-        /// Check if a given configuration and device name is valid on the system.
-        /// </summary>
-        /// <param name="configuration">The configuration to check.</param>
-        /// <param name="deviceName">The device name to check.</param>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success.</returns>
-        private static ResultCode IsConfigurationValid(ref AudioInputConfiguration configuration, string deviceName)
-        {
-            if (deviceName.Length != 0 && !deviceName.Equals(GetDeviceDefaultName()))
-            {
-                return ResultCode.DeviceNotFound;
-            }
-            else if (configuration.SampleRate != 0 && configuration.SampleRate != Constants.TargetSampleRate)
-            {
-                return ResultCode.UnsupportedSampleRate;
-            }
-            else if (configuration.ChannelCount != 0 && configuration.ChannelCount != 1 && configuration.ChannelCount != 2 && configuration.ChannelCount != 6)
-            {
-                return ResultCode.UnsupportedChannelConfiguration;
-            }
-
-            return ResultCode.Success;
-        }
-
-        /// <summary>
-        /// Get the released buffer event.
-        /// </summary>
-        /// <returns>The released buffer event</returns>
-        public IWritableEvent RegisterBufferEvent()
-        {
-            lock (_parentLock)
-            {
-                return _session.GetBufferEvent();
-            }
-        }
-
-        /// <summary>
-        /// Update the <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        public void Update()
-        {
-            lock (_parentLock)
-            {
-                _session.Update();
-            }
-        }
-
-        /// <summary>
-        /// Get the id of this session.
-        /// </summary>
-        /// <returns>The id of this session</returns>
-        public int GetSessionId()
-        {
-            return _sessionId;
-        }
-
-        /// <summary>
-        /// Initialize the <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        /// <param name="inputDeviceName">The input device name wanted by the user</param>
-        /// <param name="sampleFormat">The sample format to use</param>
-        /// <param name="parameter">The user configuration</param>
-        /// <param name="sessionId">The session id associated to this <see cref="AudioOutputSystem"/></param>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success.</returns>
-        public ResultCode Initialize(string inputDeviceName, SampleFormat sampleFormat, ref AudioInputConfiguration parameter, int sessionId)
-        {
-            _sessionId = sessionId;
-
-            ResultCode result = IsConfigurationValid(ref parameter, inputDeviceName);
-
-            if (result == ResultCode.Success)
-            {
-                if (inputDeviceName.Length == 0)
-                {
-                    DeviceName = GetDeviceDefaultName();
-                }
-                else
-                {
-                    DeviceName = inputDeviceName;
-                }
-
-                if (parameter.ChannelCount == 6)
-                {
-                    ChannelCount = 6;
-                }
-                else
-                {
-                    ChannelCount = 2;
-                }
-
-                SampleFormat = sampleFormat;
-                SampleRate = Constants.TargetSampleRate;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Append a new audio buffer to the audio output.
-        /// </summary>
-        /// <param name="bufferTag">The unique tag of this buffer.</param>
-        /// <param name="userBuffer">The buffer informations.</param>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success.</returns>
-        public ResultCode AppendBuffer(ulong bufferTag, ref AudioUserBuffer userBuffer)
-        {
-            lock (_parentLock)
-            {
-                AudioBuffer buffer = new AudioBuffer
-                {
-                    BufferTag = bufferTag,
-                    DataPointer = userBuffer.Data,
-                    DataSize = userBuffer.DataSize
-                };
-
-                if (_session.AppendBuffer(buffer))
-                {
-                    return ResultCode.Success;
-                }
-
-                return ResultCode.BufferRingFull;
-            }
-        }
-
-        /// <summary>
-        /// Get the release buffers.
-        /// </summary>
-        /// <param name="releasedBuffers">The buffer to write the release buffers</param>
-        /// <param name="releasedCount">The count of released buffers</param>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success.</returns>
-        public ResultCode GetReleasedBuffer(Span<ulong> releasedBuffers, out uint releasedCount)
-        {
-            releasedCount = 0;
-
-            // Ensure that the first entry is set to zero if no entries are returned.
-            if (releasedBuffers.Length > 0)
-            {
-                releasedBuffers[0] = 0;
-            }
-
-            lock (_parentLock)
-            {
-                for (int i = 0; i < releasedBuffers.Length; i++)
-                {
-                    if (!_session.TryPopReleasedBuffer(out AudioBuffer buffer))
-                    {
-                        break;
-                    }
-
-                    releasedBuffers[i] = buffer.BufferTag;
-                    releasedCount++;
-                }
-            }
-
-            return ResultCode.Success;
-        }
-
-        /// <summary>
-        /// Get the current state of the <see cref="AudioOutputSystem"/>.
-        /// </summary>
-        /// <returns>Return the curent sta\te of the <see cref="AudioOutputSystem"/></returns>
-        /// <returns></returns>
-        public AudioDeviceState GetState()
-        {
-            lock (_parentLock)
-            {
-                return _session.GetState();
-            }
-        }
-
-        /// <summary>
-        /// Start the audio session.
-        /// </summary>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success</returns>
-        public ResultCode Start()
-        {
-            lock (_parentLock)
-            {
-                return _session.Start();
-            }
-        }
-
-        /// <summary>
-        /// Stop the audio session.
-        /// </summary>
-        /// <returns>A <see cref="ResultCode"/> reporting an error or a success</returns>
-        public ResultCode Stop()
-        {
-            lock (_parentLock)
-            {
-                return _session.Stop();
-            }
-        }
-
-        /// <summary>
-        /// Get the volume of the session.
-        /// </summary>
-        /// <returns>The volume of the session</returns>
-        public float GetVolume()
-        {
-            lock (_parentLock)
-            {
-                return _session.GetVolume();
-            }
-        }
-
-        /// <summary>
-        /// Set the volume of the session.
-        /// </summary>
-        /// <param name="volume">The new volume to set</param>
-        public void SetVolume(float volume)
-        {
-            lock (_parentLock)
-            {
-                _session.SetVolume(volume);
-            }
-        }
-
-        /// <summary>
-        /// Get the count of buffer currently in use (server + driver side).
-        /// </summary>
-        /// <returns>The count of buffer currently in use</returns>
-        public uint GetBufferCount()
-        {
-            lock (_parentLock)
-            {
-                return _session.GetBufferCount();
-            }
-        }
-
-        /// <summary>
-        /// Check if a buffer is present.
-        /// </summary>
-        /// <param name="bufferTag">The unique tag of the buffer</param>
-        /// <returns>Return true if a buffer is present</returns>
-        public bool ContainsBuffer(ulong bufferTag)
-        {
-            lock (_parentLock)
-            {
-                return _session.ContainsBuffer(bufferTag);
-            }
-        }
-
-        /// <summary>
-        /// Get the count of sample played in this session.
-        /// </summary>
-        /// <returns>The count of sample played in this session</returns>
-        public ulong GetPlayedSampleCount()
-        {
-            lock (_parentLock)
-            {
-                return _session.GetPlayedSampleCount();
-            }
-        }
-
-        /// <summary>
-        /// Flush all buffers to the initial state.
-        /// </summary>
-        /// <returns>True if any buffers was flushed</returns>
-        public bool FlushBuffers()
-        {
-            lock (_parentLock)
-            {
-                return _session.FlushBuffers();
-            }
-        }
-
-        public void Dispose()
-        {
-            if (Interlocked.CompareExchange(ref _disposeState, 1, 0) == 0)
-            {
-                Dispose(true);
-            }
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                _session.Dispose();
-
-                _manager.Unregister(this);
-            }
-        }
-    }
-}

Ryujinx.Audio/Renderer/Device/VirtualDevice.cs

@@ -1,89 +0,0 @@
-using System.Diagnostics;
-
-namespace Ryujinx.Audio.Renderer.Device
-{
-    /// <summary>
-    /// Represents a virtual device used by IAudioDevice.
-    /// </summary>
-    public class VirtualDevice
-    {
-        /// <summary>
-        /// All the defined virtual devices.
-        /// </summary>
-        public static readonly VirtualDevice[] Devices = new VirtualDevice[5]
-        {
-            new VirtualDevice("AudioStereoJackOutput", 2, true),
-            new VirtualDevice("AudioBuiltInSpeakerOutput", 2, false),
-            new VirtualDevice("AudioTvOutput", 6, false),
-            new VirtualDevice("AudioUsbDeviceOutput", 2, true),
-            new VirtualDevice("AudioExternalOutput", 6, true),
-        };
-
-        /// <summary>
-        /// The name of the <see cref="VirtualDevice"/>.
-        /// </summary>
-        public string Name { get; }
-
-        /// <summary>
-        /// The count of channels supported by the <see cref="VirtualDevice"/>.
-        /// </summary>
-        public uint ChannelCount { get; }
-
-        /// <summary>
-        /// The system master volume of the <see cref="VirtualDevice"/>.
-        /// </summary>
-        public float MasterVolume { get; private set; }
-
-        /// <summary>
-        /// Define if the <see cref="VirtualDevice"/> is provided by an external interface.
-        /// </summary>
-        public bool IsExternalOutput { get; }
-
-        /// <summary>
-        /// Create a new <see cref="VirtualDevice"/> instance.
-        /// </summary>
-        /// <param name="name">The name of the <see cref="VirtualDevice"/>.</param>
-        /// <param name="channelCount">The count of channels supported by the <see cref="VirtualDevice"/>.</param>
-        /// <param name="isExternalOutput">Indicate if the <see cref="VirtualDevice"/> is provided by an external interface.</param>
-        private VirtualDevice(string name, uint channelCount, bool isExternalOutput)
-        {
-            Name = name;
-            ChannelCount = channelCount;
-            IsExternalOutput = isExternalOutput;
-        }
-
-        /// <summary>
-        /// Update the master volume of the <see cref="VirtualDevice"/>.
-        /// </summary>
-        /// <param name="volume">The new master volume.</param>
-        public void UpdateMasterVolume(float volume)
-        {
-            Debug.Assert(volume >= 0.0f && volume <= 1.0f);
-
-            MasterVolume = volume;
-        }
-
-        /// <summary>
-        /// Check if the <see cref="VirtualDevice"/> is a usb device.
-        /// </summary>
-        /// <returns>Returns true if the <see cref="VirtualDevice"/> is a usb device.</returns>
-        public bool IsUsbDevice()
-        {
-            return Name.Equals("AudioUsbDeviceOutput");
-        }
-
-        /// <summary>
-        /// Get the output device name of the <see cref="VirtualDevice"/>.
-        /// </summary>
-        /// <returns>The output device name of the <see cref="VirtualDevice"/>.</returns>
-        public string GetOutputDeviceName()
-        {
-            if (IsExternalOutput)
-            {
-                return "AudioExternalOutput";
-            }
-
-            return Name;
-        }
-    }
-}

Ryujinx.Audio/Renderer/Device/VirtualDeviceSessionRegistry.cs

@@ -1,62 +0,0 @@
-using System.Collections.Generic;
-
-namespace Ryujinx.Audio.Renderer.Device
-{
-    /// <summary>
-    /// Represent an instance containing a registry of <see cref="VirtualDeviceSession"/>.
-    /// </summary>
-    public class VirtualDeviceSessionRegistry
-    {
-        /// <summary>
-        /// The session registry, used to store the sessions of a given AppletResourceId.
-        /// </summary>
-        private Dictionary<ulong, VirtualDeviceSession[]> _sessionsRegistry = new Dictionary<ulong, VirtualDeviceSession[]>();
-
-        /// <summary>
-        /// The default <see cref="VirtualDevice"/>.
-        /// </summary>
-        /// <remarks>This is used when the USB device is the default one on older revision.</remarks>
-        public VirtualDevice DefaultDevice => VirtualDevice.Devices[0];
-
-        /// <summary>
-        /// The current active <see cref="VirtualDevice"/>.
-        /// </summary>
-        // TODO: make this configurable
-        public VirtualDevice ActiveDevice = VirtualDevice.Devices[2];
-
-        /// <summary>
-        /// Get the associated <see cref="T:VirtualDeviceSession[]"/> from an AppletResourceId.
-        /// </summary>
-        /// <param name="resourceAppletId">The AppletResourceId used.</param>
-        /// <returns>The associated <see cref="T:VirtualDeviceSession[]"/> from an AppletResourceId.</returns>
-        public VirtualDeviceSession[] GetSessionByAppletResourceId(ulong resourceAppletId)
-        {
-            if (_sessionsRegistry.TryGetValue(resourceAppletId, out VirtualDeviceSession[] result))
-            {
-                return result;
-            }
-
-            result = CreateSessionsFromBehaviourContext();
-
-            _sessionsRegistry.Add(resourceAppletId, result);
-
-            return result;
-        }
-
-        /// <summary>
-        /// Create a new array of sessions for each <see cref="VirtualDevice"/>.
-        /// </summary>
-        /// <returns>A new array of sessions for each <see cref="VirtualDevice"/>.</returns>
-        private static VirtualDeviceSession[] CreateSessionsFromBehaviourContext()
-        {
-            VirtualDeviceSession[] virtualDeviceSession = new VirtualDeviceSession[VirtualDevice.Devices.Length];
-
-            for (int i = 0; i < virtualDeviceSession.Length; i++)
-            {
-                virtualDeviceSession[i] = new VirtualDeviceSession(VirtualDevice.Devices[i]);
-            }
-
-            return virtualDeviceSession;
-        }
-    }
-}

Ryujinx.Audio/Renderer/Dsp/AudioProcessor.cs

@@ -1,276 +0,0 @@
-using Ryujinx.Audio.Integration;
-using Ryujinx.Audio.Renderer.Dsp.Command;
-using Ryujinx.Audio.Renderer.Utils;
-using Ryujinx.Common;
-using Ryujinx.Common.Logging;
-using System;
-using System.Threading;
-
-namespace Ryujinx.Audio.Renderer.Dsp
-{
-    public class AudioProcessor : IDisposable
-    {
-        private const int MaxBufferedFrames = 5;
-        private const int TargetBufferedFrames = 3;
-
-        private enum MailboxMessage : uint
-        {
-            Start,
-            Stop,
-            RenderStart,
-            RenderEnd
-        }
-
-        private class RendererSession
-        {
-            public CommandList CommandList;
-            public int RenderingLimit;
-            public ulong AppletResourceId;
-        }
-
-        private Mailbox<MailboxMessage> _mailbox;
-        private RendererSession[] _sessionCommandList;
-        private Thread _workerThread;
-
-        public IHardwareDevice[] OutputDevices { get; private set; }
-
-        private long _lastTime;
-        private long _playbackEnds;
-        private ManualResetEvent _event;
-
-        private ManualResetEvent _pauseEvent;
-
-        public AudioProcessor()
-        {
-            _event = new ManualResetEvent(false);
-        }
-
-        private static uint GetHardwareChannelCount(IHardwareDeviceDriver deviceDriver)
-        {
-            // Get the real device driver (In case the compat layer is on top of it).
-            deviceDriver = deviceDriver.GetRealDeviceDriver();
-
-            if (deviceDriver.SupportsChannelCount(6))
-            {
-                return 6;
-            }
-            else
-            {
-                // NOTE: We default to stereo as this will get downmixed to mono by the compat layer if it's not compatible.
-                return 2;
-            }
-        }
-
-        public void Start(IHardwareDeviceDriver deviceDriver, float volume)
-        {
-            OutputDevices = new IHardwareDevice[Constants.AudioRendererSessionCountMax];
-
-            // TODO: Before enabling this, we need up-mixing from stereo to 5.1.
-            // uint channelCount = GetHardwareChannelCount(deviceDriver);
-            uint channelCount = 2;
-
-            for (int i = 0; i < OutputDevices.Length; i++)
-            {
-                // TODO: Don't hardcode sample rate.
-                OutputDevices[i] = new HardwareDeviceImpl(deviceDriver, channelCount, Constants.TargetSampleRate, volume);
-            }
-
-            _mailbox = new Mailbox<MailboxMessage>();
-            _sessionCommandList = new RendererSession[Constants.AudioRendererSessionCountMax];
-            _event.Reset();
-            _lastTime = PerformanceCounter.ElapsedNanoseconds;
-            _pauseEvent = deviceDriver.GetPauseEvent();
-
-            StartThread();
-
-            _mailbox.SendMessage(MailboxMessage.Start);
-
-            if (_mailbox.ReceiveResponse() != MailboxMessage.Start)
-            {
-                throw new InvalidOperationException("Audio Processor Start response was invalid!");
-            }
-        }
-
-        public void Stop()
-        {
-            _mailbox.SendMessage(MailboxMessage.Stop);
-
-            if (_mailbox.ReceiveResponse() != MailboxMessage.Stop)
-            {
-                throw new InvalidOperationException("Audio Processor Stop response was invalid!");
-            }
-
-            foreach (IHardwareDevice device in OutputDevices)
-            {
-                device.Dispose();
-            }
-        }
-
-        public void Send(int sessionId, CommandList commands, int renderingLimit, ulong appletResourceId)
-        {
-            _sessionCommandList[sessionId] = new RendererSession
-            {
-                CommandList = commands,
-                RenderingLimit = renderingLimit,
-                AppletResourceId = appletResourceId
-            };
-        }
-
-        public bool HasRemainingCommands(int sessionId)
-        {
-            return _sessionCommandList[sessionId] != null;
-        }
-
-        public void Signal()
-        {
-            _mailbox.SendMessage(MailboxMessage.RenderStart);
-        }
-
-        public void Wait()
-        {
-            if (_mailbox.ReceiveResponse() != MailboxMessage.RenderEnd)
-            {
-                throw new InvalidOperationException("Audio Processor Wait response was invalid!");
-            }
-
-            long increment = Constants.AudioProcessorMaxUpdateTimeTarget;
-
-            long timeNow = PerformanceCounter.ElapsedNanoseconds;
-
-            if (timeNow > _playbackEnds)
-            {
-                // Playback has restarted.
-                _playbackEnds = timeNow;
-            }
-
-            _playbackEnds += increment;
-
-            // The number of frames we are behind where the timer says we should be.
-            long framesBehind = (timeNow - _lastTime) / increment;
-
-            // The number of frames yet to play on the backend.
-            long bufferedFrames = (_playbackEnds - timeNow) / increment + framesBehind;
-
-            // If we've entered a situation where a lot of buffers will be queued on the backend,
-            // Skip some audio frames so that playback can catch up.
-            if (bufferedFrames > MaxBufferedFrames)
-            {
-                // Skip a few frames so that we're not too far behind. (the target number of frames)
-                _lastTime += increment * (bufferedFrames - TargetBufferedFrames);
-            }
-
-            while (timeNow < _lastTime + increment)
-            {
-                _event.WaitOne(1);
-
-                timeNow = PerformanceCounter.ElapsedNanoseconds;
-            }
-
-            _lastTime += increment;
-        }
-
-        private void StartThread()
-        {
-            _workerThread = new Thread(Work)
-            {
-                Name = "AudioProcessor.Worker"
-            };
-
-            _workerThread.Start();
-        }
-
-        private void Work()
-        {
-            if (_mailbox.ReceiveMessage() != MailboxMessage.Start)
-            {
-                throw new InvalidOperationException("Audio Processor Start message was invalid!");
-            }
-
-            _mailbox.SendResponse(MailboxMessage.Start);
-            _mailbox.SendResponse(MailboxMessage.RenderEnd);
-
-            Logger.Info?.Print(LogClass.AudioRenderer, "Starting audio processor");
-
-            while (true)
-            {
-                _pauseEvent?.WaitOne();
-
-                MailboxMessage message = _mailbox.ReceiveMessage();
-
-                if (message == MailboxMessage.Stop)
-                {
-                    break;
-                }
-
-                if (message == MailboxMessage.RenderStart)
-                {
-                    long startTicks = PerformanceCounter.ElapsedNanoseconds;
-
-                    for (int i = 0; i < _sessionCommandList.Length; i++)
-                    {
-                        if (_sessionCommandList[i] != null)
-                        {
-                            _sessionCommandList[i].CommandList.Process(OutputDevices[i]);
-                            _sessionCommandList[i].CommandList.Dispose();
-                            _sessionCommandList[i] = null;
-                        }
-                    }
-
-                    long endTicks = PerformanceCounter.ElapsedNanoseconds;
-
-                    long elapsedTime = endTicks - startTicks;
-
-                    if (Constants.AudioProcessorMaxUpdateTime < elapsedTime)
-                    {
-                        Logger.Debug?.Print(LogClass.AudioRenderer, $"DSP too slow (exceeded by {elapsedTime - Constants.AudioProcessorMaxUpdateTime}ns)");
-                    }
-
-                    _mailbox.SendResponse(MailboxMessage.RenderEnd);
-                }
-            }
-
-            Logger.Info?.Print(LogClass.AudioRenderer, "Stopping audio processor");
-            _mailbox.SendResponse(MailboxMessage.Stop);
-        }
-
-        public float GetVolume()
-        {
-            if (OutputDevices != null)
-            {
-                foreach (IHardwareDevice outputDevice in OutputDevices)
-                {
-                    if (outputDevice != null)
-                    {
-                        return outputDevice.GetVolume();
-                    }
-                }
-            }
-
-            return 0f;
-        }
-
-        public void SetVolume(float volume)
-        {
-            if (OutputDevices != null)
-            {
-                foreach (IHardwareDevice outputDevice in OutputDevices)
-                {
-                    outputDevice?.SetVolume(volume);
-                }
-            }
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                _event.Dispose();
-            }
-        }
-    }
-}

Ryujinx.Audio/Renderer/Dsp/Command/CompressorCommand.cs

@@ -1,173 +0,0 @@
-using System;
-using System.Diagnostics;
-using Ryujinx.Audio.Renderer.Dsp.Effect;
-using Ryujinx.Audio.Renderer.Dsp.State;
-using Ryujinx.Audio.Renderer.Parameter.Effect;
-
-namespace Ryujinx.Audio.Renderer.Dsp.Command
-{
-    public class CompressorCommand : ICommand
-    {
-        private const int FixedPointPrecision = 15;
-
-        public bool Enabled { get; set; }
-
-        public int NodeId { get; }
-
-        public CommandType CommandType => CommandType.Compressor;
-
-        public uint EstimatedProcessingTime { get; set; }
-
-        public CompressorParameter Parameter => _parameter;
-        public Memory<CompressorState> State { get; }
-        public ushort[] OutputBufferIndices { get; }
-        public ushort[] InputBufferIndices { get; }
-        public bool IsEffectEnabled { get; }
-
-        private CompressorParameter _parameter;
-
-        public CompressorCommand(uint bufferOffset, CompressorParameter parameter, Memory<CompressorState> state, bool isEnabled, int nodeId)
-        {
-            Enabled = true;
-            NodeId = nodeId;
-            _parameter = parameter;
-            State = state;
-
-            IsEffectEnabled = isEnabled;
-
-            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-
-            for (int i = 0; i < _parameter.ChannelCount; i++)
-            {
-                InputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Input[i]);
-                OutputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Output[i]);
-            }
-        }
-
-        public void Process(CommandList context)
-        {
-            ref CompressorState state = ref State.Span[0];
-
-            if (IsEffectEnabled)
-            {
-                if (_parameter.Status == Server.Effect.UsageState.Invalid)
-                {
-                    state = new CompressorState(ref _parameter);
-                }
-                else if (_parameter.Status == Server.Effect.UsageState.New)
-                {
-                    state.UpdateParameter(ref _parameter);
-                }
-            }
-
-            ProcessCompressor(context, ref state);
-        }
-
-        private unsafe void ProcessCompressor(CommandList context, ref CompressorState state)
-        {
-            Debug.Assert(_parameter.IsChannelCountValid());
-
-            if (IsEffectEnabled && _parameter.IsChannelCountValid())
-            {
-                Span<IntPtr> inputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
-                Span<IntPtr> outputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
-                Span<float> channelInput = stackalloc float[Parameter.ChannelCount];
-                ExponentialMovingAverage inputMovingAverage = state.InputMovingAverage;
-                float unknown4 = state.Unknown4;
-                ExponentialMovingAverage compressionGainAverage = state.CompressionGainAverage;
-                float previousCompressionEmaAlpha = state.PreviousCompressionEmaAlpha;
-
-                for (int i = 0; i < _parameter.ChannelCount; i++)
-                {
-                    inputBuffers[i] = context.GetBufferPointer(InputBufferIndices[i]);
-                    outputBuffers[i] = context.GetBufferPointer(OutputBufferIndices[i]);
-                }
-
-                for (int sampleIndex = 0; sampleIndex < context.SampleCount; sampleIndex++)
-                {
-                    for (int channelIndex = 0; channelIndex < _parameter.ChannelCount; channelIndex++)
-                    {
-                        channelInput[channelIndex] = *((float*)inputBuffers[channelIndex] + sampleIndex);
-                    }
-
-                    float newMean = inputMovingAverage.Update(FloatingPointHelper.MeanSquare(channelInput), _parameter.InputGain);
-                    float y = FloatingPointHelper.Log10(newMean) * 10.0f;
-                    float z = 0.0f;
-
-                    bool unknown10OutOfRange = false;
-
-                    if (newMean < 1.0e-10f)
-                    {
-                        z = 1.0f;
-
-                        unknown10OutOfRange = state.Unknown10 < -100.0f;
-                    }
-
-                    if (y >= state.Unknown10 || unknown10OutOfRange)
-                    {
-                        float tmpGain;
-
-                        if (y >= state.Unknown14)
-                        {
-                            tmpGain = ((1.0f / Parameter.Ratio) - 1.0f) * (y - Parameter.Threshold);
-                        }
-                        else
-                        {
-                            tmpGain = (y - state.Unknown10) * ((y - state.Unknown10) * -state.CompressorGainReduction);
-                        }
-
-                        z = FloatingPointHelper.DecibelToLinearExtended(tmpGain);
-                    }
-
-                    float unknown4New = z;
-                    float compressionEmaAlpha;
-
-                    if ((unknown4 - z) <= 0.08f)
-                    {
-                        compressionEmaAlpha = Parameter.ReleaseCoefficient;
-
-                        if ((unknown4 - z) >= -0.08f)
-                        {
-                            if (MathF.Abs(compressionGainAverage.Read() - z) >= 0.001f)
-                            {
-                                unknown4New = unknown4;
-                            }
-
-                            compressionEmaAlpha = previousCompressionEmaAlpha;
-                        }
-                    }
-                    else
-                    {
-                        compressionEmaAlpha = Parameter.AttackCoefficient;
-                    }
-
-                    float compressionGain = compressionGainAverage.Update(z, compressionEmaAlpha);
-
-                    for (int channelIndex = 0; channelIndex < Parameter.ChannelCount; channelIndex++)
-                    {
-                        *((float*)outputBuffers[channelIndex] + sampleIndex) = channelInput[channelIndex] * compressionGain * state.OutputGain;
-                    }
-
-                    unknown4 = unknown4New;
-                    previousCompressionEmaAlpha = compressionEmaAlpha;
-                }
-
-                state.InputMovingAverage = inputMovingAverage;
-                state.Unknown4 = unknown4;
-                state.CompressionGainAverage = compressionGainAverage;
-                state.PreviousCompressionEmaAlpha = previousCompressionEmaAlpha;
-            }
-            else
-            {
-                for (int i = 0; i < Parameter.ChannelCount; i++)
-                {
-                    if (InputBufferIndices[i] != OutputBufferIndices[i])
-                    {
-                        context.CopyBuffer(OutputBufferIndices[i], InputBufferIndices[i]);
-                    }
-                }
-            }
-        }
-    }
-}

Ryujinx.Audio/Renderer/Dsp/Command/DelayCommand.cs

@@ -1,280 +0,0 @@
-using Ryujinx.Audio.Renderer.Dsp.State;
-using Ryujinx.Audio.Renderer.Parameter.Effect;
-using Ryujinx.Audio.Renderer.Server.Effect;
-using Ryujinx.Audio.Renderer.Utils.Math;
-using System;
-using System.Diagnostics;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-namespace Ryujinx.Audio.Renderer.Dsp.Command
-{
-    public class DelayCommand : ICommand
-    {
-        public bool Enabled { get; set; }
-
-        public int NodeId { get; }
-
-        public CommandType CommandType => CommandType.Delay;
-
-        public uint EstimatedProcessingTime { get; set; }
-
-        public DelayParameter Parameter => _parameter;
-        public Memory<DelayState> State { get; }
-        public ulong WorkBuffer { get; }
-        public ushort[] OutputBufferIndices { get; }
-        public ushort[] InputBufferIndices { get; }
-        public bool IsEffectEnabled { get; }
-
-        private DelayParameter _parameter;
-
-        private const int FixedPointPrecision = 14;
-
-        public DelayCommand(uint bufferOffset, DelayParameter parameter, Memory<DelayState> state, bool isEnabled, ulong workBuffer, int nodeId, bool newEffectChannelMappingSupported)
-        {
-            Enabled = true;
-            NodeId = nodeId;
-            _parameter = parameter;
-            State = state;
-            WorkBuffer = workBuffer;
-
-            IsEffectEnabled = isEnabled;
-
-            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-
-            for (int i = 0; i < Parameter.ChannelCount; i++)
-            {
-                InputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Input[i]);
-                OutputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Output[i]);
-            }
-
-            DataSourceHelper.RemapLegacyChannelEffectMappingToChannelResourceMapping(newEffectChannelMappingSupported, InputBufferIndices);
-            DataSourceHelper.RemapLegacyChannelEffectMappingToChannelResourceMapping(newEffectChannelMappingSupported, OutputBufferIndices);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-        private unsafe void ProcessDelayMono(ref DelayState state, float* outputBuffer, float* inputBuffer, uint sampleCount)
-        {
-            const ushort channelCount = 1;
-
-            float feedbackGain = FixedPointHelper.ToFloat(Parameter.FeedbackGain, FixedPointPrecision);
-            float inGain = FixedPointHelper.ToFloat(Parameter.InGain, FixedPointPrecision);
-            float dryGain = FixedPointHelper.ToFloat(Parameter.DryGain, FixedPointPrecision);
-            float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);
-
-            for (int i = 0; i < sampleCount; i++)
-            {
-                float input = inputBuffer[i] * 64;
-                float delayLineValue = state.DelayLines[0].Read();
-
-                float temp = input * inGain + delayLineValue * feedbackGain;
-
-                state.UpdateLowPassFilter(ref temp, channelCount);
-
-                outputBuffer[i] = (input * dryGain + delayLineValue * outGain) / 64;
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-        private unsafe void ProcessDelayStereo(ref DelayState state, Span<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
-        {
-            const ushort channelCount = 2;
-
-            float delayFeedbackBaseGain = state.DelayFeedbackBaseGain;
-            float delayFeedbackCrossGain = state.DelayFeedbackCrossGain;
-            float inGain = FixedPointHelper.ToFloat(Parameter.InGain, FixedPointPrecision);
-            float dryGain = FixedPointHelper.ToFloat(Parameter.DryGain, FixedPointPrecision);
-            float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);
-
-            Matrix2x2 delayFeedback = new Matrix2x2(delayFeedbackBaseGain, delayFeedbackCrossGain,
-                                                    delayFeedbackCrossGain, delayFeedbackBaseGain);
-
-            for (int i = 0; i < sampleCount; i++)
-            {
-                Vector2 channelInput = new Vector2
-                {
-                    X = *((float*)inputBuffers[0] + i) * 64,
-                    Y = *((float*)inputBuffers[1] + i) * 64,
-                };
-
-                Vector2 delayLineValues = new Vector2()
-                {
-                    X = state.DelayLines[0].Read(),
-                    Y = state.DelayLines[1].Read(),
-                };
-
-                Vector2 temp = MatrixHelper.Transform(ref delayLineValues, ref delayFeedback) + channelInput * inGain;
-
-                state.UpdateLowPassFilter(ref Unsafe.As<Vector2, float>(ref temp), channelCount);
-
-                *((float*)outputBuffers[0] + i) = (channelInput.X * dryGain + delayLineValues.X * outGain) / 64;
-                *((float*)outputBuffers[1] + i) = (channelInput.Y * dryGain + delayLineValues.Y * outGain) / 64;
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-        private unsafe void ProcessDelayQuadraphonic(ref DelayState state, Span<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
-        {
-            const ushort channelCount = 4;
-
-            float delayFeedbackBaseGain = state.DelayFeedbackBaseGain;
-            float delayFeedbackCrossGain = state.DelayFeedbackCrossGain;
-            float inGain = FixedPointHelper.ToFloat(Parameter.InGain, FixedPointPrecision);
-            float dryGain = FixedPointHelper.ToFloat(Parameter.DryGain, FixedPointPrecision);
-            float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);
-
-            Matrix4x4 delayFeedback = new Matrix4x4(delayFeedbackBaseGain, delayFeedbackCrossGain, delayFeedbackCrossGain, 0.0f,
-                                                    delayFeedbackCrossGain, delayFeedbackBaseGain, 0.0f, delayFeedbackCrossGain,
-                                                    delayFeedbackCrossGain, 0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain,
-                                                    0.0f, delayFeedbackCrossGain, delayFeedbackCrossGain, delayFeedbackBaseGain);
-
-
-            for (int i = 0; i < sampleCount; i++)
-            {
-                Vector4 channelInput = new Vector4
-                {
-                    X = *((float*)inputBuffers[0] + i) * 64,
-                    Y = *((float*)inputBuffers[1] + i) * 64,
-                    Z = *((float*)inputBuffers[2] + i) * 64,
-                    W = *((float*)inputBuffers[3] + i) * 64
-                };
-
-                Vector4 delayLineValues = new Vector4()
-                {
-                    X = state.DelayLines[0].Read(),
-                    Y = state.DelayLines[1].Read(),
-                    Z = state.DelayLines[2].Read(),
-                    W = state.DelayLines[3].Read()
-                };
-
-                Vector4 temp = MatrixHelper.Transform(ref delayLineValues, ref delayFeedback) + channelInput * inGain;
-
-                state.UpdateLowPassFilter(ref Unsafe.As<Vector4, float>(ref temp), channelCount);
-
-                *((float*)outputBuffers[0] + i) = (channelInput.X * dryGain + delayLineValues.X * outGain) / 64;
-                *((float*)outputBuffers[1] + i) = (channelInput.Y * dryGain + delayLineValues.Y * outGain) / 64;
-                *((float*)outputBuffers[2] + i) = (channelInput.Z * dryGain + delayLineValues.Z * outGain) / 64;
-                *((float*)outputBuffers[3] + i) = (channelInput.W * dryGain + delayLineValues.W * outGain) / 64;
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-        private unsafe void ProcessDelaySurround(ref DelayState state, Span<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
-        {
-            const ushort channelCount = 6;
-
-            float feedbackGain = FixedPointHelper.ToFloat(Parameter.FeedbackGain, FixedPointPrecision);
-            float delayFeedbackBaseGain = state.DelayFeedbackBaseGain;
-            float delayFeedbackCrossGain = state.DelayFeedbackCrossGain;
-            float inGain = FixedPointHelper.ToFloat(Parameter.InGain, FixedPointPrecision);
-            float dryGain = FixedPointHelper.ToFloat(Parameter.DryGain, FixedPointPrecision);
-            float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);
-
-            Matrix6x6 delayFeedback = new Matrix6x6(delayFeedbackBaseGain, 0.0f, delayFeedbackCrossGain, 0.0f, delayFeedbackCrossGain, 0.0f,
-                                                    0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain, 0.0f, 0.0f, delayFeedbackCrossGain,
-                                                    delayFeedbackCrossGain, delayFeedbackCrossGain, delayFeedbackBaseGain, 0.0f, 0.0f, 0.0f,
-                                                    0.0f, 0.0f, 0.0f, feedbackGain, 0.0f, 0.0f,
-                                                    delayFeedbackCrossGain, 0.0f, 0.0f, 0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain,
-                                                    0.0f, delayFeedbackCrossGain, 0.0f, 0.0f, delayFeedbackCrossGain, delayFeedbackBaseGain);
-
-            for (int i = 0; i < sampleCount; i++)
-            {
-                Vector6 channelInput = new Vector6
-                {
-                    X = *((float*)inputBuffers[0] + i) * 64,
-                    Y = *((float*)inputBuffers[1] + i) * 64,
-                    Z = *((float*)inputBuffers[2] + i) * 64,
-                    W = *((float*)inputBuffers[3] + i) * 64,
-                    V = *((float*)inputBuffers[4] + i) * 64,
-                    U = *((float*)inputBuffers[5] + i) * 64
-                };
-
-                Vector6 delayLineValues = new Vector6
-                {
-                    X = state.DelayLines[0].Read(),
-                    Y = state.DelayLines[1].Read(),
-                    Z = state.DelayLines[2].Read(),
-                    W = state.DelayLines[3].Read(),
-                    V = state.DelayLines[4].Read(),
-                    U = state.DelayLines[5].Read()
-                };
-
-                Vector6 temp = MatrixHelper.Transform(ref delayLineValues, ref delayFeedback) + channelInput * inGain;
-
-                state.UpdateLowPassFilter(ref Unsafe.As<Vector6, float>(ref temp), channelCount);
-
-                *((float*)outputBuffers[0] + i) = (channelInput.X * dryGain + delayLineValues.X * outGain) / 64;
-                *((float*)outputBuffers[1] + i) = (channelInput.Y * dryGain + delayLineValues.Y * outGain) / 64;
-                *((float*)outputBuffers[2] + i) = (channelInput.Z * dryGain + delayLineValues.Z * outGain) / 64;
-                *((float*)outputBuffers[3] + i) = (channelInput.W * dryGain + delayLineValues.W * outGain) / 64;
-                *((float*)outputBuffers[4] + i) = (channelInput.V * dryGain + delayLineValues.V * outGain) / 64;
-                *((float*)outputBuffers[5] + i) = (channelInput.U * dryGain + delayLineValues.U * outGain) / 64;
-            }
-        }
-
-        private unsafe void ProcessDelay(CommandList context, ref DelayState state)
-        {
-            Debug.Assert(Parameter.IsChannelCountValid());
-
-            if (IsEffectEnabled && Parameter.IsChannelCountValid())
-            {
-                Span<IntPtr> inputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
-                Span<IntPtr> outputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
-
-                for (int i = 0; i < Parameter.ChannelCount; i++)
-                {
-                    inputBuffers[i] = context.GetBufferPointer(InputBufferIndices[i]);
-                    outputBuffers[i] = context.GetBufferPointer(OutputBufferIndices[i]);
-                }
-
-                switch (Parameter.ChannelCount)
-                {
-                    case 1:
-                        ProcessDelayMono(ref state, (float*)outputBuffers[0], (float*)inputBuffers[0], context.SampleCount);
-                        break;
-                    case 2:
-                        ProcessDelayStereo(ref state, outputBuffers, inputBuffers, context.SampleCount);
-                        break;
-                    case 4:
-                        ProcessDelayQuadraphonic(ref state, outputBuffers, inputBuffers, context.SampleCount);
-                        break;
-                    case 6:
-                        ProcessDelaySurround(ref state, outputBuffers, inputBuffers, context.SampleCount);
-                        break;
-                    default:
-                        throw new NotImplementedException(Parameter.ChannelCount.ToString());
-                }
-            }
-            else
-            {
-                for (int i = 0; i < Parameter.ChannelCount; i++)
-                {
-                    if (InputBufferIndices[i] != OutputBufferIndices[i])
-                    {
-                        context.CopyBuffer(OutputBufferIndices[i], InputBufferIndices[i]);
-                    }
-                }
-            }
-        }
-
-        public void Process(CommandList context)
-        {
-            ref DelayState state = ref State.Span[0];
-
-            if (IsEffectEnabled)
-            {
-                if (Parameter.Status == UsageState.Invalid)
-                {
-                    state = new DelayState(ref _parameter, WorkBuffer);
-                }
-                else if (Parameter.Status == UsageState.New)
-                {
-                    state.UpdateParameter(ref _parameter);
-                }
-            }
-
-            ProcessDelay(context, ref state);
-        }
-    }
-}

Ryujinx.Audio/Renderer/Dsp/Command/DeviceSinkCommand.cs

@@ -1,91 +0,0 @@
-using Ryujinx.Audio.Integration;
-using Ryujinx.Audio.Renderer.Server.Sink;
-using System;
-using System.Runtime.CompilerServices;
-using System.Text;
-
-namespace Ryujinx.Audio.Renderer.Dsp.Command
-{
-    public class DeviceSinkCommand : ICommand
-    {
-        public bool Enabled { get; set; }
-
-        public int NodeId { get; }
-
-        public CommandType CommandType => CommandType.DeviceSink;
-
-        public uint EstimatedProcessingTime { get; set; }
-
-        public string DeviceName { get; }
-
-        public int SessionId { get; }
-
-        public uint InputCount { get; }
-        public ushort[] InputBufferIndices { get; }
-
-        public Memory<float> Buffers { get; }
-
-        public DeviceSinkCommand(uint bufferOffset, DeviceSink sink, int sessionId, Memory<float> buffers, int nodeId)
-        {
-            Enabled = true;
-            NodeId = nodeId;
-
-            DeviceName = Encoding.ASCII.GetString(sink.Parameter.DeviceName).TrimEnd('\0');
-            SessionId = sessionId;
-            InputCount = sink.Parameter.InputCount;
-            InputBufferIndices = new ushort[InputCount];
-
-            for (int i = 0; i < Math.Min(InputCount, Constants.ChannelCountMax); i++)
-            {
-                InputBufferIndices[i] = (ushort)(bufferOffset + sink.Parameter.Input[i]);
-            }
-
-            if (sink.UpsamplerState != null)
-            {
-                Buffers = sink.UpsamplerState.OutputBuffer;
-            }
-            else
-            {
-                Buffers = buffers;
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private Span<float> GetBuffer(int index, int sampleCount)
-        {
-            return Buffers.Span.Slice(index * sampleCount, sampleCount);
-        }
-
-        public void Process(CommandList context)
-        {
-            IHardwareDevice device = context.OutputDevice;
-
-            if (device.GetSampleRate() == Constants.TargetSampleRate)
-            {
-                int channelCount = (int)device.GetChannelCount();
-                uint bufferCount = Math.Min(device.GetChannelCount(), InputCount);
-
-                const int sampleCount = Constants.TargetSampleCount;
-
-                short[] outputBuffer = new short[bufferCount * sampleCount];
-
-                for (int i = 0; i < bufferCount; i++)
-                {
-                    ReadOnlySpan<float> inputBuffer = GetBuffer(InputBufferIndices[i], sampleCount);
-
-                    for (int j = 0; j < sampleCount; j++)
-                    {
-                        outputBuffer[i + j * channelCount] = PcmHelper.Saturate(inputBuffer[j]);
-                    }
-                }
-
-                device.AppendBuffer(outputBuffer, InputCount);
-            }
-            else
-            {
-                // TODO: support resampling for device only supporting something different
-                throw new NotImplementedException();
-            }
-        }
-    }
-}

Ryujinx.Audio/Renderer/Dsp/Command/Reverb3dCommand.cs

@@ -1,254 +0,0 @@
-using Ryujinx.Audio.Renderer.Dsp.State;
-using Ryujinx.Audio.Renderer.Parameter.Effect;
-using Ryujinx.Audio.Renderer.Server.Effect;
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace Ryujinx.Audio.Renderer.Dsp.Command
-{
-    public class Reverb3dCommand : ICommand
-    {
-        private static readonly int[] OutputEarlyIndicesTableMono = new int[20] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-        private static readonly int[] TargetEarlyDelayLineIndicesTableMono = new int[20] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
-        private static readonly int[] TargetOutputFeedbackIndicesTableMono = new int[1] { 0 };
-
-        private static readonly int[] OutputEarlyIndicesTableStereo = new int[20] { 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 };
-        private static readonly int[] TargetEarlyDelayLineIndicesTableStereo = new int[20] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
-        private static readonly int[] TargetOutputFeedbackIndicesTableStereo = new int[2] { 0, 1 };
-
-        private static readonly int[] OutputEarlyIndicesTableQuadraphonic = new int[20] { 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 3, 3, 3 };
-        private static readonly int[] TargetEarlyDelayLineIndicesTableQuadraphonic = new int[20] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
-        private static readonly int[] TargetOutputFeedbackIndicesTableQuadraphonic = new int[4] { 0, 1, 2, 3 };
-
-        private static readonly int[] OutputEarlyIndicesTableSurround = new int[40] { 4, 5, 0, 5, 0, 5, 1, 5, 1, 5, 1, 5, 1, 5, 2, 5, 2, 5, 2, 5, 1, 5, 1, 5, 1, 5, 0, 5, 0, 5, 0, 5, 0, 5, 3, 5, 3, 5, 3, 5 };
-        private static readonly int[] TargetEarlyDelayLineIndicesTableSurround = new int[40] { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19 };
-        private static readonly int[] TargetOutputFeedbackIndicesTableSurround = new int[6] { 0, 1, 2, 3, -1, 3 };
-
-        public bool Enabled { get; set; }
-
-        public int NodeId { get; }
-
-        public CommandType CommandType => CommandType.Reverb3d;
-
-        public uint EstimatedProcessingTime { get; set; }
-
-        public ushort InputBufferIndex { get; }
-        public ushort OutputBufferIndex { get; }
-
-        public Reverb3dParameter Parameter => _parameter;
-        public Memory<Reverb3dState> State { get; }
-        public ulong WorkBuffer { get; }
-        public ushort[] OutputBufferIndices { get; }
-        public ushort[] InputBufferIndices { get; }
-
-        public bool IsEffectEnabled { get; }
-
-        private Reverb3dParameter _parameter;
-
-        public Reverb3dCommand(uint bufferOffset, Reverb3dParameter parameter, Memory<Reverb3dState> state, bool isEnabled, ulong workBuffer, int nodeId, bool newEffectChannelMappingSupported)
-        {
-            Enabled = true;
-            IsEffectEnabled = isEnabled;
-            NodeId = nodeId;
-            _parameter = parameter;
-            State = state;
-            WorkBuffer = workBuffer;
-
-            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-
-            for (int i = 0; i < Parameter.ChannelCount; i++)
-            {
-                InputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Input[i]);
-                OutputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Output[i]);
-            }
-
-            // NOTE: We do the opposite as Nintendo here for now to restore previous behaviour
-            // TODO: Update reverb 3d processing and remove this to use RemapLegacyChannelEffectMappingToChannelResourceMapping.
-            DataSourceHelper.RemapChannelResourceMappingToLegacy(newEffectChannelMappingSupported, InputBufferIndices);
-            DataSourceHelper.RemapChannelResourceMappingToLegacy(newEffectChannelMappingSupported, OutputBufferIndices);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ProcessReverb3dMono(ref Reverb3dState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
-        {
-            ProcessReverb3dGeneric(ref state, outputBuffers, inputBuffers, sampleCount, OutputEarlyIndicesTableMono, TargetEarlyDelayLineIndicesTableMono, TargetOutputFeedbackIndicesTableMono);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ProcessReverb3dStereo(ref Reverb3dState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
-        {
-            ProcessReverb3dGeneric(ref state, outputBuffers, inputBuffers, sampleCount, OutputEarlyIndicesTableStereo, TargetEarlyDelayLineIndicesTableStereo, TargetOutputFeedbackIndicesTableStereo);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ProcessReverb3dQuadraphonic(ref Reverb3dState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
-        {
-            ProcessReverb3dGeneric(ref state, outputBuffers, inputBuffers, sampleCount, OutputEarlyIndicesTableQuadraphonic, TargetEarlyDelayLineIndicesTableQuadraphonic, TargetOutputFeedbackIndicesTableQuadraphonic);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ProcessReverb3dSurround(ref Reverb3dState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
-        {
-            ProcessReverb3dGeneric(ref state, outputBuffers, inputBuffers, sampleCount, OutputEarlyIndicesTableSurround, TargetEarlyDelayLineIndicesTableSurround, TargetOutputFeedbackIndicesTableSurround);
-        }
-
-        private unsafe void ProcessReverb3dGeneric(ref Reverb3dState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount, ReadOnlySpan<int> outputEarlyIndicesTable, ReadOnlySpan<int> targetEarlyDelayLineIndicesTable, ReadOnlySpan<int> targetOutputFeedbackIndicesTable)
-        {
-            const int delayLineSampleIndexOffset = 1;
-
-            bool isMono = Parameter.ChannelCount == 1;
-            bool isSurround = Parameter.ChannelCount == 6;
-
-            Span<float> outputValues = stackalloc float[Constants.ChannelCountMax];
-            Span<float> channelInput = stackalloc float[Parameter.ChannelCount];
-            Span<float> feedbackValues = stackalloc float[4];
-            Span<float> feedbackOutputValues = stackalloc float[4];
-            Span<float> values = stackalloc float[4];
-
-            for (int sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++)
-            {
-                outputValues.Fill(0);
-
-                float tapOut = state.PreDelayLine.TapUnsafe(state.ReflectionDelayTime, delayLineSampleIndexOffset);
-
-                for (int i = 0; i < targetEarlyDelayLineIndicesTable.Length; i++)
-                {
-                    int earlyDelayIndex = targetEarlyDelayLineIndicesTable[i];
-                    int outputIndex = outputEarlyIndicesTable[i];
-
-                    float tempTapOut = state.PreDelayLine.TapUnsafe(state.EarlyDelayTime[earlyDelayIndex], delayLineSampleIndexOffset);
-
-                    outputValues[outputIndex] += tempTapOut * state.EarlyGain[earlyDelayIndex];
-                }
-
-                float targetPreDelayValue = 0;
-
-                for (int channelIndex = 0; channelIndex < Parameter.ChannelCount; channelIndex++)
-                {
-                    channelInput[channelIndex] = *((float*)inputBuffers[channelIndex] + sampleIndex);
-                    targetPreDelayValue += channelInput[channelIndex];
-                }
-
-                for (int i = 0; i < Parameter.ChannelCount; i++)
-                {
-                    outputValues[i] *= state.EarlyReflectionsGain;
-                }
-
-                state.PreviousPreDelayValue = (targetPreDelayValue * state.TargetPreDelayGain) + (state.PreviousPreDelayValue * state.PreviousPreDelayGain);
-
-                state.PreDelayLine.Update(state.PreviousPreDelayValue);
-
-                for (int i = 0; i < state.FdnDelayLines.Length; i++)
-                {
-                    float fdnValue = state.FdnDelayLines[i].Read();
-
-                    float feedbackOutputValue = fdnValue * state.DecayDirectFdnGain[i] + state.PreviousFeedbackOutputDecayed[i];
-
-                    state.PreviousFeedbackOutputDecayed[i] = (fdnValue * state.DecayCurrentFdnGain[i]) + (feedbackOutputValue * state.DecayCurrentOutputGain[i]);
-
-                    feedbackOutputValues[i] = feedbackOutputValue;
-                }
-
-                feedbackValues[0] = feedbackOutputValues[2] + feedbackOutputValues[1];
-                feedbackValues[1] = -feedbackOutputValues[0] - feedbackOutputValues[3];
-                feedbackValues[2] = feedbackOutputValues[0] - feedbackOutputValues[3];
-                feedbackValues[3] = feedbackOutputValues[1] - feedbackOutputValues[2];
-
-                for (int i = 0; i < state.DecayDelays1.Length; i++)
-                {
-                    float temp = state.DecayDelays1[i].Update(tapOut * state.LateReverbGain + feedbackValues[i]);
-
-                    values[i] = state.DecayDelays2[i].Update(temp);
-
-                    state.FdnDelayLines[i].Update(values[i]);
-                }
-
-                for (int channelIndex = 0; channelIndex < targetOutputFeedbackIndicesTable.Length; channelIndex++)
-                {
-                    int targetOutputFeedbackIndex = targetOutputFeedbackIndicesTable[channelIndex];
-
-                    if (targetOutputFeedbackIndex >= 0)
-                    {
-                        *((float*)outputBuffers[channelIndex] + sampleIndex) = (outputValues[channelIndex] + values[targetOutputFeedbackIndex] + channelInput[channelIndex] * state.DryGain);
-                    }
-                }
-
-                if (isMono)
-                {
-                    *((float*)outputBuffers[0] + sampleIndex) += values[1];
-                }
-
-                if (isSurround)
-                {
-                    *((float*)outputBuffers[4] + sampleIndex) += (outputValues[4] + state.FrontCenterDelayLine.Update((values[2] - values[3]) * 0.5f) + channelInput[4] * state.DryGain);
-                }
-            }
-        }
-
-        public void ProcessReverb3d(CommandList context, ref Reverb3dState state)
-        {
-            Debug.Assert(Parameter.IsChannelCountValid());
-
-            if (IsEffectEnabled && Parameter.IsChannelCountValid())
-            {
-                Span<IntPtr> inputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
-                Span<IntPtr> outputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
-
-                for (int i = 0; i < Parameter.ChannelCount; i++)
-                {
-                    inputBuffers[i] = context.GetBufferPointer(InputBufferIndices[i]);
-                    outputBuffers[i] = context.GetBufferPointer(OutputBufferIndices[i]);
-                }
-
-                switch (Parameter.ChannelCount)
-                {
-                    case 1:
-                        ProcessReverb3dMono(ref state, outputBuffers, inputBuffers, context.SampleCount);
-                        break;
-                    case 2:
-                        ProcessReverb3dStereo(ref state, outputBuffers, inputBuffers, context.SampleCount);
-                        break;
-                    case 4:
-                        ProcessReverb3dQuadraphonic(ref state, outputBuffers, inputBuffers, context.SampleCount);
-                        break;
-                    case 6:
-                        ProcessReverb3dSurround(ref state, outputBuffers, inputBuffers, context.SampleCount);
-                        break;
-                    default:
-                        throw new NotImplementedException(Parameter.ChannelCount.ToString());
-                }
-            }
-            else
-            {
-                for (int i = 0; i < Parameter.ChannelCount; i++)
-                {
-                    if (InputBufferIndices[i] != OutputBufferIndices[i])
-                    {
-                        context.CopyBuffer(OutputBufferIndices[i], InputBufferIndices[i]);
-                    }
-                }
-            }
-        }
-
-        public void Process(CommandList context)
-        {
-            ref Reverb3dState state = ref State.Span[0];
-
-            if (IsEffectEnabled)
-            {
-                if (Parameter.ParameterStatus == UsageState.Invalid)
-                {
-                    state = new Reverb3dState(ref _parameter, WorkBuffer);
-                }
-                else if (Parameter.ParameterStatus == UsageState.New)
-                {
-                    state.UpdateParameter(ref _parameter);
-                }
-            }
-
-            ProcessReverb3d(context, ref state);
-        }
-    }
-}

Ryujinx.Audio/Renderer/Dsp/Command/ReverbCommand.cs

@@ -1,279 +0,0 @@
-using Ryujinx.Audio.Renderer.Dsp.State;
-using Ryujinx.Audio.Renderer.Parameter.Effect;
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace Ryujinx.Audio.Renderer.Dsp.Command
-{
-    public class ReverbCommand : ICommand
-    {
-        private static readonly int[] OutputEarlyIndicesTableMono = new int[10] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-        private static readonly int[] TargetEarlyDelayLineIndicesTableMono = new int[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-        private static readonly int[] OutputIndicesTableMono = new int[4] { 0, 0, 0, 0 };
-        private static readonly int[] TargetOutputFeedbackIndicesTableMono = new int[4] { 0, 1, 2, 3 };
-
-        private static readonly int[] OutputEarlyIndicesTableStereo = new int[10] { 0, 0, 1, 1, 0, 1, 0, 0, 1, 1 };
-        private static readonly int[] TargetEarlyDelayLineIndicesTableStereo = new int[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-        private static readonly int[] OutputIndicesTableStereo = new int[4] { 0, 0, 1, 1 };
-        private static readonly int[] TargetOutputFeedbackIndicesTableStereo = new int[4] { 2, 0, 3, 1 };
-
-        private static readonly int[] OutputEarlyIndicesTableQuadraphonic = new int[10] { 0, 0, 1, 1, 0, 1, 2, 2, 3, 3 };
-        private static readonly int[] TargetEarlyDelayLineIndicesTableQuadraphonic = new int[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-        private static readonly int[] OutputIndicesTableQuadraphonic = new int[4] { 0, 1, 2, 3 };
-        private static readonly int[] TargetOutputFeedbackIndicesTableQuadraphonic = new int[4] { 0, 1, 2, 3 };
-
-        private static readonly int[] OutputEarlyIndicesTableSurround = new int[20] { 0, 5, 0, 5, 1, 5, 1, 5, 4, 5, 4, 5, 2, 5, 2, 5, 3, 5, 3, 5 };
-        private static readonly int[] TargetEarlyDelayLineIndicesTableSurround = new int[20] { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9 };
-        private static readonly int[] OutputIndicesTableSurround = new int[Constants.ChannelCountMax] { 0, 1, 2, 3, 4, 5 };
-        private static readonly int[] TargetOutputFeedbackIndicesTableSurround = new int[Constants.ChannelCountMax] { 0, 1, 2, 3, -1, 3 };
-
-        public bool Enabled { get; set; }
-
-        public int NodeId { get; }
-
-        public CommandType CommandType => CommandType.Reverb;
-
-        public uint EstimatedProcessingTime { get; set; }
-
-        public ReverbParameter Parameter => _parameter;
-        public Memory<ReverbState> State { get; }
-        public ulong WorkBuffer { get; }
-        public ushort[] OutputBufferIndices { get; }
-        public ushort[] InputBufferIndices { get; }
-        public bool IsLongSizePreDelaySupported { get; }
-
-        public bool IsEffectEnabled { get; }
-
-        private ReverbParameter _parameter;
-
-        private const int FixedPointPrecision = 14;
-
-        public ReverbCommand(uint bufferOffset, ReverbParameter parameter, Memory<ReverbState> state, bool isEnabled, ulong workBuffer, int nodeId, bool isLongSizePreDelaySupported, bool newEffectChannelMappingSupported)
-        {
-            Enabled = true;
-            IsEffectEnabled = isEnabled;
-            NodeId = nodeId;
-            _parameter = parameter;
-            State = state;
-            WorkBuffer = workBuffer;
-
-            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
-
-            for (int i = 0; i < Parameter.ChannelCount; i++)
-            {
-                InputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Input[i]);
-                OutputBufferIndices[i] = (ushort)(bufferOffset + Parameter.Output[i]);
-            }
-
-            IsLongSizePreDelaySupported = isLongSizePreDelaySupported;
-
-            // NOTE: We do the opposite as Nintendo here for now to restore previous behaviour
-            // TODO: Update reverb processing and remove this to use RemapLegacyChannelEffectMappingToChannelResourceMapping.
-            DataSourceHelper.RemapChannelResourceMappingToLegacy(newEffectChannelMappingSupported, InputBufferIndices);
-            DataSourceHelper.RemapChannelResourceMappingToLegacy(newEffectChannelMappingSupported, OutputBufferIndices);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ProcessReverbMono(ref ReverbState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
-        {
-            ProcessReverbGeneric(ref state,
-                     outputBuffers,
-                     inputBuffers,
-                     sampleCount,
-                     OutputEarlyIndicesTableMono,
-                     TargetEarlyDelayLineIndicesTableMono,
-                     TargetOutputFeedbackIndicesTableMono,
-                     OutputIndicesTableMono);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ProcessReverbStereo(ref ReverbState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
-        {
-            ProcessReverbGeneric(ref state,
-                     outputBuffers,
-                     inputBuffers,
-                     sampleCount,
-                     OutputEarlyIndicesTableStereo,
-                     TargetEarlyDelayLineIndicesTableStereo,
-                     TargetOutputFeedbackIndicesTableStereo,
-                     OutputIndicesTableStereo);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ProcessReverbQuadraphonic(ref ReverbState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
-        {
-            ProcessReverbGeneric(ref state,
-                     outputBuffers,
-                     inputBuffers,
-                     sampleCount,
-                     OutputEarlyIndicesTableQuadraphonic,
-                     TargetEarlyDelayLineIndicesTableQuadraphonic,
-                     TargetOutputFeedbackIndicesTableQuadraphonic,
-                     OutputIndicesTableQuadraphonic);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ProcessReverbSurround(ref ReverbState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
-        {
-            ProcessReverbGeneric(ref state,
-                     outputBuffers,
-                     inputBuffers,
-                     sampleCount,
-                     OutputEarlyIndicesTableSurround,
-                     TargetEarlyDelayLineIndicesTableSurround,
-                     TargetOutputFeedbackIndicesTableSurround,
-                     OutputIndicesTableSurround);
-        }
-
-        private unsafe void ProcessReverbGeneric(ref ReverbState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount, ReadOnlySpan<int> outputEarlyIndicesTable, ReadOnlySpan<int> targetEarlyDelayLineIndicesTable, ReadOnlySpan<int> targetOutputFeedbackIndicesTable, ReadOnlySpan<int> outputIndicesTable)
-        {
-            bool isSurround = Parameter.ChannelCount == 6;
-
-            float reverbGain = FixedPointHelper.ToFloat(Parameter.ReverbGain, FixedPointPrecision);
-            float lateGain = FixedPointHelper.ToFloat(Parameter.LateGain, FixedPointPrecision);
-            float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);
-            float dryGain = FixedPointHelper.ToFloat(Parameter.DryGain, FixedPointPrecision);
-
-            Span<float> outputValues = stackalloc float[Constants.ChannelCountMax];
-            Span<float> feedbackValues = stackalloc float[4];
-            Span<float> feedbackOutputValues = stackalloc float[4];
-            Span<float> channelInput = stackalloc float[Parameter.ChannelCount];
-
-            for (int sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++)
-            {
-                outputValues.Fill(0);
-
-                for (int i = 0; i < targetEarlyDelayLineIndicesTable.Length; i++)
-                {
-                    int earlyDelayIndex = targetEarlyDelayLineIndicesTable[i];
-                    int outputIndex = outputEarlyIndicesTable[i];
-
-                    float tapOutput = state.PreDelayLine.TapUnsafe(state.EarlyDelayTime[earlyDelayIndex], 0);
-
-                    outputValues[outputIndex] += tapOutput * state.EarlyGain[earlyDelayIndex];
-                }
-
-                if (isSurround)
-                {
-                    outputValues[5] *= 0.2f;
-                }
-
-                float targetPreDelayValue = 0;
-
-                for (int channelIndex = 0; channelIndex < Parameter.ChannelCount; channelIndex++)
-                {
-                    channelInput[channelIndex] = *((float*)inputBuffers[channelIndex] + sampleIndex) * 64;
-                    targetPreDelayValue += channelInput[channelIndex] * reverbGain;
-                }
-
-                state.PreDelayLine.Update(targetPreDelayValue);
-
-                float lateValue = state.PreDelayLine.Tap(state.PreDelayLineDelayTime) * lateGain;
-
-                for (int i = 0; i < state.FdnDelayLines.Length; i++)
-                {
-                    feedbackOutputValues[i] = state.FdnDelayLines[i].Read() * state.HighFrequencyDecayDirectGain[i] + state.PreviousFeedbackOutput[i] * state.HighFrequencyDecayPreviousGain[i];
-                    state.PreviousFeedbackOutput[i] = feedbackOutputValues[i];
-                }
-
-                feedbackValues[0] = feedbackOutputValues[2] + feedbackOutputValues[1];
-                feedbackValues[1] = -feedbackOutputValues[0] - feedbackOutputValues[3];
-                feedbackValues[2] = feedbackOutputValues[0] - feedbackOutputValues[3];
-                feedbackValues[3] = feedbackOutputValues[1] - feedbackOutputValues[2];
-
-                for (int i = 0; i < state.FdnDelayLines.Length; i++)
-                {
-                    feedbackOutputValues[i] = state.DecayDelays[i].Update(feedbackValues[i] + lateValue);
-                    state.FdnDelayLines[i].Update(feedbackOutputValues[i]);
-                }
-
-                for (int i = 0; i < targetOutputFeedbackIndicesTable.Length; i++)
-                {
-                    int targetOutputFeedbackIndex = targetOutputFeedbackIndicesTable[i];
-                    int outputIndex = outputIndicesTable[i];
-
-                    if (targetOutputFeedbackIndex >= 0)
-                    {
-                        outputValues[outputIndex] += feedbackOutputValues[targetOutputFeedbackIndex];
-                    }
-                }
-
-                if (isSurround)
-                {
-                    outputValues[4] += state.FrontCenterDelayLine.Update((feedbackOutputValues[2] - feedbackOutputValues[3]) * 0.5f);
-                }
-
-                for (int channelIndex = 0; channelIndex < Parameter.ChannelCount; channelIndex++)
-                {
-                    *((float*)outputBuffers[channelIndex] + sampleIndex) = (outputValues[channelIndex] * outGain + channelInput[channelIndex] * dryGain) / 64;
-                }
-            }
-        }
-
-        private void ProcessReverb(CommandList context, ref ReverbState state)
-        {
-            Debug.Assert(Parameter.IsChannelCountValid());
-
-            if (IsEffectEnabled && Parameter.IsChannelCountValid())
-            {
-                Span<IntPtr> inputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
-                Span<IntPtr> outputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
-
-                for (int i = 0; i < Parameter.ChannelCount; i++)
-                {
-                    inputBuffers[i] = context.GetBufferPointer(InputBufferIndices[i]);
-                    outputBuffers[i] = context.GetBufferPointer(OutputBufferIndices[i]);
-                }
-
-                switch (Parameter.ChannelCount)
-                {
-                    case 1:
-                        ProcessReverbMono(ref state, outputBuffers, inputBuffers, context.SampleCount);
-                        break;
-                    case 2:
-                        ProcessReverbStereo(ref state, outputBuffers, inputBuffers, context.SampleCount);
-                        break;
-                    case 4:
-                        ProcessReverbQuadraphonic(ref state, outputBuffers, inputBuffers, context.SampleCount);
-                        break;
-                    case 6:
-                        ProcessReverbSurround(ref state, outputBuffers, inputBuffers, context.SampleCount);
-                        break;
-                    default:
-                        throw new NotImplementedException(Parameter.ChannelCount.ToString());
-                }
-            }
-            else
-            {
-                for (int i = 0; i < Parameter.ChannelCount; i++)
-                {
-                    if (InputBufferIndices[i] != OutputBufferIndices[i])
-                    {
-                        context.CopyBuffer(OutputBufferIndices[i], InputBufferIndices[i]);
-                    }
-                }
-            }
-        }
-
-        public void Process(CommandList context)
-        {
-            ref ReverbState state = ref State.Span[0];
-
-            if (IsEffectEnabled)
-            {
-                if (Parameter.Status == Server.Effect.UsageState.Invalid)
-                {
-                    state = new ReverbState(ref _parameter, WorkBuffer, IsLongSizePreDelaySupported);
-                }
-                else if (Parameter.Status == Server.Effect.UsageState.New)
-                {
-                    state.UpdateParameter(ref _parameter);
-                }
-            }
-
-            ProcessReverb(context, ref state);
-        }
-    }
-}

Ryujinx.Audio/Renderer/Dsp/DataSourceHelper.cs

@@ -1,466 +0,0 @@
-using Ryujinx.Audio.Common;
-using Ryujinx.Audio.Renderer.Common;
-using Ryujinx.Audio.Renderer.Dsp.State;
-using Ryujinx.Common.Logging;
-using Ryujinx.Memory;
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.Arm;
-using System.Runtime.Intrinsics.X86;
-using static Ryujinx.Audio.Renderer.Parameter.VoiceInParameter;
-
-namespace Ryujinx.Audio.Renderer.Dsp
-{
-    public static class DataSourceHelper
-    {
-        private const int FixedPointPrecision = 15;
-
-        public struct WaveBufferInformation
-        {
-            public uint SourceSampleRate;
-            public float Pitch;
-            public ulong ExtraParameter;
-            public ulong ExtraParameterSize;
-            public int ChannelIndex;
-            public int ChannelCount;
-            public DecodingBehaviour DecodingBehaviour;
-            public SampleRateConversionQuality SrcQuality;
-            public SampleFormat SampleFormat;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int GetPitchLimitBySrcQuality(SampleRateConversionQuality quality)
-        {
-            return quality switch
-            {
-                SampleRateConversionQuality.Default or SampleRateConversionQuality.Low => 4,
-                SampleRateConversionQuality.High => 8,
-                _ => throw new ArgumentException(quality.ToString()),
-            };
-        }
-
-        public static void ProcessWaveBuffers(IVirtualMemoryManager memoryManager, Span<float> outputBuffer, ref WaveBufferInformation info, Span<WaveBuffer> wavebuffers, ref VoiceUpdateState voiceState, uint targetSampleRate, int sampleCount)
-        {
-            const int tempBufferSize = 0x3F00;
-
-            Span<short> tempBuffer = stackalloc short[tempBufferSize];
-
-            float sampleRateRatio = (float)info.SourceSampleRate / targetSampleRate * info.Pitch;
-
-            float fraction = voiceState.Fraction;
-            int waveBufferIndex = (int)voiceState.WaveBufferIndex;
-            ulong playedSampleCount = voiceState.PlayedSampleCount;
-            int offset = voiceState.Offset;
-            uint waveBufferConsumed = voiceState.WaveBufferConsumed;
-
-            int pitchMaxLength = GetPitchLimitBySrcQuality(info.SrcQuality);
-
-            int totalNeededSize = (int)MathF.Truncate(fraction + sampleRateRatio * sampleCount);
-
-            if (totalNeededSize + pitchMaxLength <= tempBufferSize && totalNeededSize >= 0)
-            {
-                int sourceSampleCountToProcess = sampleCount;
-
-                int maxSampleCountPerIteration = Math.Min((int)MathF.Truncate((tempBufferSize - fraction) / sampleRateRatio), sampleCount);
-
-                bool isStarving = false;
-
-                int i = 0;
-
-                while (i < sourceSampleCountToProcess)
-                {
-                    int tempBufferIndex = 0;
-
-                    if (!info.DecodingBehaviour.HasFlag(DecodingBehaviour.SkipPitchAndSampleRateConversion))
-                    {
-                        voiceState.Pitch.AsSpan().Slice(0, pitchMaxLength).CopyTo(tempBuffer);
-                        tempBufferIndex += pitchMaxLength;
-                    }
-
-                    int sampleCountToProcess = Math.Min(sourceSampleCountToProcess, maxSampleCountPerIteration);
-
-                    int y = 0;
-
-                    int sampleCountToDecode = (int)MathF.Truncate(fraction + sampleRateRatio * sampleCountToProcess);
-
-                    while (y < sampleCountToDecode)
-                    {
-                        if (waveBufferIndex >= Constants.VoiceWaveBufferCount)
-                        {
-                            waveBufferIndex = 0;
-                            playedSampleCount = 0;
-                        }
-
-                        if (!voiceState.IsWaveBufferValid[waveBufferIndex])
-                        {
-                            isStarving = true;
-                            break;
-                        }
-
-                        ref WaveBuffer waveBuffer = ref wavebuffers[waveBufferIndex];
-
-                        if (offset == 0 && info.SampleFormat == SampleFormat.Adpcm && waveBuffer.Context != 0)
-                        {
-                            voiceState.LoopContext = memoryManager.Read<AdpcmLoopContext>(waveBuffer.Context);
-                        }
-
-                        Span<short> tempSpan = tempBuffer.Slice(tempBufferIndex + y);
-
-                        int decodedSampleCount = -1;
-
-                        int targetSampleStartOffset;
-                        int targetSampleEndOffset;
-
-                        if (voiceState.LoopCount > 0 && waveBuffer.LoopStartSampleOffset != 0 && waveBuffer.LoopEndSampleOffset != 0 && waveBuffer.LoopStartSampleOffset <= waveBuffer.LoopEndSampleOffset)
-                        {
-                            targetSampleStartOffset = (int)waveBuffer.LoopStartSampleOffset;
-                            targetSampleEndOffset = (int)waveBuffer.LoopEndSampleOffset;
-                        }
-                        else
-                        {
-                            targetSampleStartOffset = (int)waveBuffer.StartSampleOffset;
-                            targetSampleEndOffset = (int)waveBuffer.EndSampleOffset;
-                        }
-
-                        int targetWaveBufferSampleCount = targetSampleEndOffset - targetSampleStartOffset;
-
-                        switch (info.SampleFormat)
-                        {
-                            case SampleFormat.Adpcm:
-                                ReadOnlySpan<byte> waveBufferAdpcm = ReadOnlySpan<byte>.Empty;
-
-                                if (waveBuffer.Buffer != 0 && waveBuffer.BufferSize != 0)
-                                {
-                                    // TODO: we are possibly copying a lot of unneeded data here, we should only take what we need.
-                                    waveBufferAdpcm = memoryManager.GetSpan(waveBuffer.Buffer, (int)waveBuffer.BufferSize);
-                                }
-
-                                ReadOnlySpan<short> coefficients = MemoryMarshal.Cast<byte, short>(memoryManager.GetSpan(info.ExtraParameter, (int)info.ExtraParameterSize));
-                                decodedSampleCount = AdpcmHelper.Decode(tempSpan, waveBufferAdpcm, targetSampleStartOffset, targetSampleEndOffset, offset, sampleCountToDecode - y, coefficients, ref voiceState.LoopContext);
-                                break;
-                            case SampleFormat.PcmInt16:
-                                ReadOnlySpan<short> waveBufferPcm16 = ReadOnlySpan<short>.Empty;
-
-                                if (waveBuffer.Buffer != 0 && waveBuffer.BufferSize != 0)
-                                {
-                                    ulong bufferOffset = waveBuffer.Buffer + PcmHelper.GetBufferOffset<short>(targetSampleStartOffset, offset, info.ChannelCount);
-                                    int bufferSize = PcmHelper.GetBufferSize<short>(targetSampleStartOffset, targetSampleEndOffset, offset, sampleCountToDecode - y) * info.ChannelCount;
-
-                                    waveBufferPcm16 = MemoryMarshal.Cast<byte, short>(memoryManager.GetSpan(bufferOffset, bufferSize));
-                                }
-
-                                decodedSampleCount = PcmHelper.Decode(tempSpan, waveBufferPcm16, targetSampleStartOffset, targetSampleEndOffset, info.ChannelIndex, info.ChannelCount);
-                                break;
-                            case SampleFormat.PcmFloat:
-                                ReadOnlySpan<float> waveBufferPcmFloat = ReadOnlySpan<float>.Empty;
-
-                                if (waveBuffer.Buffer != 0 && waveBuffer.BufferSize != 0)
-                                {
-                                    ulong bufferOffset = waveBuffer.Buffer + PcmHelper.GetBufferOffset<float>(targetSampleStartOffset, offset, info.ChannelCount);
-                                    int bufferSize = PcmHelper.GetBufferSize<float>(targetSampleStartOffset, targetSampleEndOffset, offset, sampleCountToDecode - y) * info.ChannelCount;
-
-                                    waveBufferPcmFloat = MemoryMarshal.Cast<byte, float>(memoryManager.GetSpan(bufferOffset, bufferSize));
-                                }
-
-                                decodedSampleCount = PcmHelper.Decode(tempSpan, waveBufferPcmFloat, targetSampleStartOffset, targetSampleEndOffset, info.ChannelIndex, info.ChannelCount);
-                                break;
-                            default:
-                                Logger.Error?.Print(LogClass.AudioRenderer, $"Unsupported sample format " + info.SampleFormat);
-                                break;
-                        }
-
-                        Debug.Assert(decodedSampleCount <= sampleCountToDecode);
-
-                        if (decodedSampleCount < 0)
-                        {
-                            Logger.Warning?.Print(LogClass.AudioRenderer, "Decoding failed, skipping WaveBuffer");
-
-                            voiceState.MarkEndOfBufferWaveBufferProcessing(ref waveBuffer, ref waveBufferIndex, ref waveBufferConsumed, ref playedSampleCount);
-                            decodedSampleCount = 0;
-                        }
-
-                        y += decodedSampleCount;
-                        offset += decodedSampleCount;
-                        playedSampleCount += (uint)decodedSampleCount;
-
-                        if (offset >= targetWaveBufferSampleCount || decodedSampleCount == 0)
-                        {
-                            offset = 0;
-
-                            if (waveBuffer.Looping)
-                            {
-                                voiceState.LoopCount++;
-
-                                if (waveBuffer.LoopCount >= 0)
-                                {
-                                    if (decodedSampleCount == 0 || voiceState.LoopCount > waveBuffer.LoopCount)
-                                    {
-                                        voiceState.MarkEndOfBufferWaveBufferProcessing(ref waveBuffer, ref waveBufferIndex, ref waveBufferConsumed, ref playedSampleCount);
-                                    }
-                                }
-
-                                if (decodedSampleCount == 0)
-                                {
-                                    isStarving = true;
-                                    break;
-                                }
-
-                                if (info.DecodingBehaviour.HasFlag(DecodingBehaviour.PlayedSampleCountResetWhenLooping))
-                                {
-                                    playedSampleCount = 0;
-                                }
-                            }
-                            else
-                            {
-                                voiceState.MarkEndOfBufferWaveBufferProcessing(ref waveBuffer, ref waveBufferIndex, ref waveBufferConsumed, ref playedSampleCount);
-                            }
-                        }
-                    }
-
-                    Span<int> outputSpanInt = MemoryMarshal.Cast<float, int>(outputBuffer.Slice(i));
-
-                    if (info.DecodingBehaviour.HasFlag(DecodingBehaviour.SkipPitchAndSampleRateConversion))
-                    {
-                        for (int j = 0; j < y; j++)
-                        {
-                            outputBuffer[j] = tempBuffer[j];
-                        }
-                    }
-                    else
-                    {
-                        Span<short> tempSpan = tempBuffer.Slice(tempBufferIndex + y);
-
-                        tempSpan.Slice(0, sampleCountToDecode - y).Fill(0);
-
-                        ToFloat(outputBuffer, outputSpanInt, sampleCountToProcess);
-
-                        ResamplerHelper.Resample(outputBuffer, tempBuffer, sampleRateRatio, ref fraction, sampleCountToProcess, info.SrcQuality, y != sourceSampleCountToProcess || info.Pitch != 1.0f);
-
-                        tempBuffer.Slice(sampleCountToDecode, pitchMaxLength).CopyTo(voiceState.Pitch.AsSpan());
-                    }
-
-                    i += sampleCountToProcess;
-                }
-
-                Debug.Assert(sourceSampleCountToProcess == i || !isStarving);
-
-                voiceState.WaveBufferConsumed = waveBufferConsumed;
-                voiceState.Offset = offset;
-                voiceState.PlayedSampleCount = playedSampleCount;
-                voiceState.WaveBufferIndex = (uint)waveBufferIndex;
-                voiceState.Fraction = fraction;
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void ToFloatAvx(Span<float> output, ReadOnlySpan<int> input, int sampleCount)
-        {
-            ReadOnlySpan<Vector256<int>> inputVec = MemoryMarshal.Cast<int, Vector256<int>>(input);
-            Span<Vector256<float>> outputVec = MemoryMarshal.Cast<float, Vector256<float>>(output);
-
-            int sisdStart = inputVec.Length * 8;
-
-            for (int i = 0; i < inputVec.Length; i++)
-            {
-                outputVec[i] = Avx.ConvertToVector256Single(inputVec[i]);
-            }
-
-            for (int i = sisdStart; i < sampleCount; i++)
-            {
-                output[i] = input[i];
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void ToFloatSse2(Span<float> output, ReadOnlySpan<int> input, int sampleCount)
-        {
-            ReadOnlySpan<Vector128<int>> inputVec = MemoryMarshal.Cast<int, Vector128<int>>(input);
-            Span<Vector128<float>> outputVec = MemoryMarshal.Cast<float, Vector128<float>>(output);
-
-            int sisdStart = inputVec.Length * 4;
-
-            for (int i = 0; i < inputVec.Length; i++)
-            {
-                outputVec[i] = Sse2.ConvertToVector128Single(inputVec[i]);
-            }
-
-            for (int i = sisdStart; i < sampleCount; i++)
-            {
-                output[i] = input[i];
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void ToFloatAdvSimd(Span<float> output, ReadOnlySpan<int> input, int sampleCount)
-        {
-            ReadOnlySpan<Vector128<int>> inputVec = MemoryMarshal.Cast<int, Vector128<int>>(input);
-            Span<Vector128<float>> outputVec = MemoryMarshal.Cast<float, Vector128<float>>(output);
-
-            int sisdStart = inputVec.Length * 4;
-
-            for (int i = 0; i < inputVec.Length; i++)
-            {
-                outputVec[i] = AdvSimd.ConvertToSingle(inputVec[i]);
-            }
-
-            for (int i = sisdStart; i < sampleCount; i++)
-            {
-                output[i] = input[i];
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ToFloatSlow(Span<float> output, ReadOnlySpan<int> input, int sampleCount)
-        {
-            for (int i = 0; i < sampleCount; i++)
-            {
-                output[i] = input[i];
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ToFloat(Span<float> output, ReadOnlySpan<int> input, int sampleCount)
-        {
-            if (Avx.IsSupported)
-            {
-                ToFloatAvx(output, input, sampleCount);
-            }
-            else if (Sse2.IsSupported)
-            {
-                ToFloatSse2(output, input, sampleCount);
-            }
-            else if (AdvSimd.IsSupported)
-            {
-                ToFloatAdvSimd(output, input, sampleCount);
-            }
-            else
-            {
-                ToFloatSlow(output, input, sampleCount);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ToIntAvx(Span<int> output, ReadOnlySpan<float> input, int sampleCount)
-        {
-            ReadOnlySpan<Vector256<float>> inputVec = MemoryMarshal.Cast<float, Vector256<float>>(input);
-            Span<Vector256<int>> outputVec = MemoryMarshal.Cast<int, Vector256<int>>(output);
-
-            int sisdStart = inputVec.Length * 8;
-
-            for (int i = 0; i < inputVec.Length; i++)
-            {
-                outputVec[i] = Avx.ConvertToVector256Int32(inputVec[i]);
-            }
-
-            for (int i = sisdStart; i < sampleCount; i++)
-            {
-                output[i] = (int)input[i];
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ToIntSse2(Span<int> output, ReadOnlySpan<float> input, int sampleCount)
-        {
-            ReadOnlySpan<Vector128<float>> inputVec = MemoryMarshal.Cast<float, Vector128<float>>(input);
-            Span<Vector128<int>> outputVec = MemoryMarshal.Cast<int, Vector128<int>>(output);
-
-            int sisdStart = inputVec.Length * 4;
-
-            for (int i = 0; i < inputVec.Length; i++)
-            {
-                outputVec[i] = Sse2.ConvertToVector128Int32(inputVec[i]);
-            }
-
-            for (int i = sisdStart; i < sampleCount; i++)
-            {
-                output[i] = (int)input[i];
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ToIntAdvSimd(Span<int> output, ReadOnlySpan<float> input, int sampleCount)
-        {
-            ReadOnlySpan<Vector128<float>> inputVec = MemoryMarshal.Cast<float, Vector128<float>>(input);
-            Span<Vector128<int>> outputVec = MemoryMarshal.Cast<int, Vector128<int>>(output);
-
-            int sisdStart = inputVec.Length * 4;
-
-            for (int i = 0; i < inputVec.Length; i++)
-            {
-                outputVec[i] = AdvSimd.ConvertToInt32RoundToZero(inputVec[i]);
-            }
-
-            for (int i = sisdStart; i < sampleCount; i++)
-            {
-                output[i] = (int)input[i];
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ToIntSlow(Span<int> output, ReadOnlySpan<float> input, int sampleCount)
-        {
-            for (int i = 0; i < sampleCount; i++)
-            {
-                output[i] = (int)input[i];
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ToInt(Span<int> output, ReadOnlySpan<float> input, int sampleCount)
-        {
-            if (Avx.IsSupported)
-            {
-                ToIntAvx(output, input, sampleCount);
-            }
-            else if (Sse2.IsSupported)
-            {
-                ToIntSse2(output, input, sampleCount);
-            }
-            else if (AdvSimd.IsSupported)
-            {
-                ToIntAdvSimd(output, input, sampleCount);
-            }
-            else
-            {
-                ToIntSlow(output, input, sampleCount);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void RemapLegacyChannelEffectMappingToChannelResourceMapping(bool isSupported, Span<ushort> bufferIndices)
-        {
-            if (!isSupported && bufferIndices.Length == 6)
-            {
-                ushort backLeft = bufferIndices[2];
-                ushort backRight = bufferIndices[3];
-                ushort frontCenter = bufferIndices[4];
-                ushort lowFrequency = bufferIndices[5];
-
-                bufferIndices[2] = frontCenter;
-                bufferIndices[3] = lowFrequency;
-                bufferIndices[4] = backLeft;
-                bufferIndices[5] = backRight;
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void RemapChannelResourceMappingToLegacy(bool isSupported, Span<ushort> bufferIndices)
-        {
-            if (isSupported && bufferIndices.Length == 6)
-            {
-                ushort frontCenter = bufferIndices[2];
-                ushort lowFrequency = bufferIndices[3];
-                ushort backLeft = bufferIndices[4];
-                ushort backRight = bufferIndices[5];
-
-                bufferIndices[2] = backLeft;
-                bufferIndices[3] = backRight;
-                bufferIndices[4] = frontCenter;
-                bufferIndices[5] = lowFrequency;
-            }
-        }
-    }
-}

Ryujinx.Audio/Renderer/Dsp/ResamplerHelper.cs

@@ -1,583 +0,0 @@
-using System;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-using static Ryujinx.Audio.Renderer.Parameter.VoiceInParameter;
-
-namespace Ryujinx.Audio.Renderer.Dsp
-{
-    public static class ResamplerHelper
-    {
-        #region "Default Quality Lookup Tables"
-        private static short[] _normalCurveLut0 = new short[]
-        {
-            6600,  19426, 6722,  3,     6479,  19424, 6845,  9,     6359,  19419, 6968,  15,    6239,  19412, 7093,  22,
-            6121,  19403, 7219,  28,    6004,  19391, 7345,  34,    5888,  19377, 7472,  41,    5773,  19361, 7600,  48,
-            5659,  19342, 7728,  55,    5546,  19321, 7857,  62,    5434,  19298, 7987,  69,    5323,  19273, 8118,  77,
-            5213,  19245, 8249,  84,    5104,  19215, 8381,  92,    4997,  19183, 8513,  101,   4890,  19148, 8646,  109,
-            4785,  19112, 8780,  118,   4681,  19073, 8914,  127,   4579,  19031, 9048,  137,   4477,  18988, 9183,  147,
-            4377,  18942, 9318,  157,   4277,  18895, 9454,  168,   4179,  18845, 9590,  179,   4083,  18793, 9726,  190,
-            3987,  18738, 9863,  202,   3893,  18682, 10000, 215,   3800,  18624, 10137, 228,   3709,  18563, 10274, 241,
-            3618,  18500, 10411, 255,   3529,  18436, 10549, 270,   3441,  18369, 10687, 285,   3355,  18300, 10824, 300,
-            3269,  18230, 10962, 317,   3186,  18157, 11100, 334,   3103,  18082, 11238, 351,   3022,  18006, 11375, 369,
-            2942,  17927, 11513, 388,   2863,  17847, 11650, 408,   2785,  17765, 11788, 428,   2709,  17681, 11925, 449,
-            2635,  17595, 12062, 471,   2561,  17507, 12198, 494,   2489,  17418, 12334, 517,   2418,  17327, 12470, 541,
-            2348,  17234, 12606, 566,   2280,  17140, 12741, 592,   2213,  17044, 12876, 619,   2147,  16946, 13010, 647,
-            2083,  16846, 13144, 675,   2020,  16745, 13277, 704,   1958,  16643, 13409, 735,   1897,  16539, 13541, 766,
-            1838,  16434, 13673, 798,   1780,  16327, 13803, 832,   1723,  16218, 13933, 866,   1667,  16109, 14062, 901,
-            1613,  15998, 14191, 937,   1560,  15885, 14318, 975,   1508,  15772, 14445, 1013,  1457,  15657, 14571, 1052,
-            1407,  15540, 14695, 1093,  1359,  15423, 14819, 1134,  1312,  15304, 14942, 1177,  1266,  15185, 15064, 1221,
-            1221,  15064, 15185, 1266,  1177,  14942, 15304, 1312,  1134,  14819, 15423, 1359,  1093,  14695, 15540, 1407,
-            1052,  14571, 15657, 1457,  1013,  14445, 15772, 1508,  975,   14318, 15885, 1560,  937,   14191, 15998, 1613,
-            901,   14062, 16109, 1667,  866,   13933, 16218, 1723,  832,   13803, 16327, 1780,  798,   13673, 16434, 1838,
-            766,   13541, 16539, 1897,  735,   13409, 16643, 1958,  704,   13277, 16745, 2020,  675,   13144, 16846, 2083,
-            647,   13010, 16946, 2147,  619,   12876, 17044, 2213,  592,   12741, 17140, 2280,  566,   12606, 17234, 2348,
-            541,   12470, 17327, 2418,  517,   12334, 17418, 2489,  494,   12198, 17507, 2561,  471,   12062, 17595, 2635,
-            449,   11925, 17681, 2709,  428,   11788, 17765, 2785,  408,   11650, 17847, 2863,  388,   11513, 17927, 2942,
-            369,   11375, 18006, 3022,  351,   11238, 18082, 3103,  334,   11100, 18157, 3186,  317,   10962, 18230, 3269,
-            300,   10824, 18300, 3355,  285,   10687, 18369, 3441,  270,   10549, 18436, 3529,  255,   10411, 18500, 3618,
-            241,   10274, 18563, 3709,  228,   10137, 18624, 3800,  215,   10000, 18682, 3893,  202,   9863,  18738, 3987,
-            190,   9726,  18793, 4083,  179,   9590,  18845, 4179,  168,   9454,  18895, 4277,  157,   9318,  18942, 4377,
-            147,   9183,  18988, 4477,  137,   9048,  19031, 4579,  127,   8914,  19073, 4681,  118,   8780,  19112, 4785,
-            109,   8646,  19148, 4890,  101,   8513,  19183, 4997,  92,    8381,  19215, 5104,  84,    8249,  19245, 5213,
-            77,    8118,  19273, 5323,  69,    7987,  19298, 5434,  62,    7857,  19321, 5546,  55,    7728,  19342, 5659,
-            48,    7600,  19361, 5773,  41,    7472,  19377, 5888,  34,    7345,  19391, 6004,  28,    7219,  19403, 6121,
-            22,    7093,  19412, 6239,  15,    6968,  19419, 6359,  9,     6845,  19424, 6479,  3,     6722,  19426, 6600
-        };
-
-        private static short[] _normalCurveLut1 = new short[]
-        {
-            -68,   32639, 69,    -5,    -200,  32630, 212,   -15,   -328,  32613, 359,   -26,   -450,  32586, 512,   -36,
-            -568,  32551, 669,   -47,   -680,  32507, 832,   -58,   -788,  32454, 1000,  -69,   -891,  32393, 1174,  -80,
-            -990,  32323, 1352,  -92,   -1084, 32244, 1536,  -103,  -1173, 32157, 1724,  -115,  -1258, 32061, 1919,  -128,
-            -1338, 31956, 2118,  -140,  -1414, 31844, 2322,  -153,  -1486, 31723, 2532,  -167,  -1554, 31593, 2747,  -180,
-            -1617, 31456, 2967,  -194,  -1676, 31310, 3192,  -209,  -1732, 31157, 3422,  -224,  -1783, 30995, 3657,  -240,
-            -1830, 30826, 3897,  -256,  -1874, 30649, 4143,  -272,  -1914, 30464, 4393,  -289,  -1951, 30272, 4648,  -307,
-            -1984, 30072, 4908,  -325,  -2014, 29866, 5172,  -343,  -2040, 29652, 5442,  -362,  -2063, 29431, 5716,  -382,
-            -2083, 29203, 5994,  -403,  -2100, 28968, 6277,  -424,  -2114, 28727, 6565,  -445,  -2125, 28480, 6857,  -468,
-            -2133, 28226, 7153,  -490,  -2139, 27966, 7453,  -514,  -2142, 27700, 7758,  -538,  -2142, 27428, 8066,  -563,
-            -2141, 27151, 8378,  -588,  -2136, 26867, 8694,  -614,  -2130, 26579, 9013,  -641,  -2121, 26285, 9336,  -668,
-            -2111, 25987, 9663,  -696,  -2098, 25683, 9993,  -724,  -2084, 25375, 10326, -753,  -2067, 25063, 10662, -783,
-            -2049, 24746, 11000, -813,  -2030, 24425, 11342, -844,  -2009, 24100, 11686, -875,  -1986, 23771, 12033, -907,
-            -1962, 23438, 12382, -939,  -1937, 23103, 12733, -972,  -1911, 22764, 13086, -1005, -1883, 22422, 13441, -1039,
-            -1855, 22077, 13798, -1072, -1825, 21729, 14156, -1107, -1795, 21380, 14516, -1141, -1764, 21027, 14877, -1176,
-            -1732, 20673, 15239, -1211, -1700, 20317, 15602, -1246, -1667, 19959, 15965, -1282, -1633, 19600, 16329, -1317,
-            -1599, 19239, 16694, -1353, -1564, 18878, 17058, -1388, -1530, 18515, 17423, -1424, -1495, 18151, 17787, -1459,
-            -1459, 17787, 18151, -1495, -1424, 17423, 18515, -1530, -1388, 17058, 18878, -1564, -1353, 16694, 19239, -1599,
-            -1317, 16329, 19600, -1633, -1282, 15965, 19959, -1667, -1246, 15602, 20317, -1700, -1211, 15239, 20673, -1732,
-            -1176, 14877, 21027, -1764, -1141, 14516, 21380, -1795, -1107, 14156, 21729, -1825, -1072, 13798, 22077, -1855,
-            -1039, 13441, 22422, -1883, -1005, 13086, 22764, -1911, -972,  12733, 23103, -1937, -939,  12382, 23438, -1962,
-            -907,  12033, 23771, -1986, -875,  11686, 24100, -2009, -844,  11342, 24425, -2030, -813,  11000, 24746, -2049,
-            -783,  10662, 25063, -2067, -753,  10326, 25375, -2084, -724,  9993,  25683, -2098, -696,  9663,  25987, -2111,
-            -668,  9336,  26285, -2121, -641,  9013,  26579, -2130, -614,  8694,  26867, -2136, -588,  8378,  27151, -2141,
-            -563,  8066,  27428, -2142, -538,  7758,  27700, -2142, -514,  7453,  27966, -2139, -490,  7153,  28226, -2133,
-            -468,  6857,  28480, -2125, -445,  6565,  28727, -2114, -424,  6277,  28968, -2100, -403,  5994,  29203, -2083,
-            -382,  5716,  29431, -2063, -362,  5442,  29652, -2040, -343,  5172,  29866, -2014, -325,  4908,  30072, -1984,
-            -307,  4648,  30272, -1951, -289,  4393,  30464, -1914, -272,  4143,  30649, -1874, -256,  3897,  30826, -1830,
-            -240,  3657,  30995, -1783, -224,  3422,  31157, -1732, -209,  3192,  31310, -1676, -194,  2967,  31456, -1617,
-            -180,  2747,  31593, -1554, -167,  2532,  31723, -1486, -153,  2322,  31844, -1414, -140,  2118,  31956, -1338,
-            -128,  1919,  32061, -1258, -115,  1724,  32157, -1173, -103,  1536,  32244, -1084, -92,   1352,  32323, -990,
-            -80,   1174,  32393, -891,  -69,   1000,  32454, -788,  -58,   832,   32507, -680,  -47,   669,   32551, -568,
-            -36,   512,   32586, -450,  -26,   359,   32613, -328,  -15,   212,   32630, -200,  -5,    69,    32639, -68
-        };
-
-        private static short[] _normalCurveLut2 = new short[]
-        {
-            3195,  26287, 3329,  -32,   3064,  26281, 3467,  -34,   2936,  26270, 3608,  -38,   2811,  26253, 3751,  -42,
-            2688,  26230, 3897,  -46,   2568,  26202, 4046,  -50,   2451,  26169, 4199,  -54,   2338,  26130, 4354,  -58,
-            2227,  26085, 4512,  -63,   2120,  26035, 4673,  -67,   2015,  25980, 4837,  -72,   1912,  25919, 5004,  -76,
-            1813,  25852, 5174,  -81,   1716,  25780, 5347,  -87,   1622,  25704, 5522,  -92,   1531,  25621, 5701,  -98,
-            1442,  25533, 5882,  -103,  1357,  25440, 6066,  -109,  1274,  25342, 6253,  -115,  1193,  25239, 6442,  -121,
-            1115,  25131, 6635,  -127,  1040,  25018, 6830,  -133,  967,   24899, 7027,  -140,  897,   24776, 7227,  -146,
-            829,   24648, 7430,  -153,  764,   24516, 7635,  -159,  701,   24379, 7842,  -166,  641,   24237, 8052,  -174,
-            583,   24091, 8264,  -181,  526,   23940, 8478,  -187,  472,   23785, 8695,  -194,  420,   23626, 8914,  -202,
-            371,   23462, 9135,  -209,  324,   23295, 9358,  -215,  279,   23123, 9583,  -222,  236,   22948, 9809,  -230,
-            194,   22769, 10038, -237,  154,   22586, 10269, -243,  117,   22399, 10501, -250,  81,    22208, 10735, -258,
-            47,    22015, 10970, -265,  15,    21818, 11206, -271,  -16,   21618, 11444, -277,  -44,   21415, 11684, -283,
-            -71,   21208, 11924, -290,  -97,   20999, 12166, -296,  -121,  20786, 12409, -302,  -143,  20571, 12653, -306,
-            -163,  20354, 12898, -311,  -183,  20134, 13143, -316,  -201,  19911, 13389, -321,  -218,  19686, 13635, -325,
-            -234,  19459, 13882, -328,  -248,  19230, 14130, -332,  -261,  18998, 14377, -335,  -273,  18765, 14625, -337,
-            -284,  18531, 14873, -339,  -294,  18295, 15121, -341,  -302,  18057, 15369, -341,  -310,  17817, 15617, -341,
-            -317,  17577, 15864, -340,  -323,  17335, 16111, -340,  -328,  17092, 16357, -338,  -332,  16848, 16603, -336,
-            -336,  16603, 16848, -332,  -338,  16357, 17092, -328,  -340,  16111, 17335, -323,  -340,  15864, 17577, -317,
-            -341,  15617, 17817, -310,  -341,  15369, 18057, -302,  -341,  15121, 18295, -294,  -339,  14873, 18531, -284,
-            -337,  14625, 18765, -273,  -335,  14377, 18998, -261,  -332,  14130, 19230, -248,  -328,  13882, 19459, -234,
-            -325,  13635, 19686, -218,  -321,  13389, 19911, -201,  -316,  13143, 20134, -183,  -311,  12898, 20354, -163,
-            -306,  12653, 20571, -143,  -302,  12409, 20786, -121,  -296,  12166, 20999, -97,   -290,  11924, 21208, -71,
-            -283,  11684, 21415, -44,   -277,  11444, 21618, -16,   -271,  11206, 21818, 15,    -265,  10970, 22015, 47,
-            -258,  10735, 22208, 81,    -250,  10501, 22399, 117,   -243,  10269, 22586, 154,   -237,  10038, 22769, 194,
-            -230,  9809,  22948, 236,   -222,  9583,  23123, 279,   -215,  9358,  23295, 324,   -209,  9135,  23462, 371,
-            -202,  8914,  23626, 420,   -194,  8695,  23785, 472,   -187,  8478,  23940, 526,   -181,  8264,  24091, 583,
-            -174,  8052,  24237, 641,   -166,  7842,  24379, 701,   -159,  7635,  24516, 764,   -153,  7430,  24648, 829,
-            -146,  7227,  24776, 897,   -140,  7027,  24899, 967,   -133,  6830,  25018, 1040,  -127,  6635,  25131, 1115,
-            -121,  6442,  25239, 1193,  -115,  6253,  25342, 1274,  -109,  6066,  25440, 1357,  -103,  5882,  25533, 1442,
-            -98,   5701,  25621, 1531,  -92,   5522,  25704, 1622,  -87,   5347,  25780, 1716,  -81,   5174,  25852, 1813,
-            -76,   5004,  25919, 1912,  -72,   4837,  25980, 2015,  -67,   4673,  26035, 2120,  -63,   4512,  26085, 2227,
-            -58,   4354,  26130, 2338,  -54,   4199,  26169, 2451,  -50,   4046,  26202, 2568,  -46,   3897,  26230, 2688,
-            -42,   3751,  26253, 2811,  -38,   3608,  26270, 2936,  -34,   3467,  26281, 3064,  -32,   3329,  26287, 3195
-        };
-        #endregion
-
-        #region "High Quality Lookup Tables"
-        private static short[] _highCurveLut0 = new short[]
-        {
-            -582, -23,  8740, 16386, 8833,  8,    -590,  0,    -573, -54,  8647, 16385, 8925,  40,   -598, -1,
-            -565, -84,  8555, 16383, 9018,  72,   -606,  -1,   -557, -113, 8462, 16379, 9110,  105,  -614, -2,
-            -549, -142, 8370, 16375, 9203,  139,  -622,  -2,   -541, -170, 8277, 16369, 9295,  173,  -630, -3,
-            -533, -198, 8185, 16362, 9387,  208,  -638,  -4,   -525, -225, 8093, 16354, 9480,  244,  -646, -5,
-            -516, -251, 8000, 16344, 9572,  280,  -654,  -5,   -508, -277, 7908, 16334, 9664,  317,  -662, -6,
-            -500, -302, 7816, 16322, 9756,  355,  -670,  -7,   -492, -327, 7724, 16310, 9847,  393,  -678, -8,
-            -484, -351, 7632, 16296, 9939,  432,  -686,  -9,   -476, -374, 7540, 16281, 10030, 471,  -694, -10,
-            -468, -397, 7449, 16265, 10121, 511,  -702,  -11,  -460, -419, 7357, 16247, 10212, 552,  -709, -13,
-            -452, -441, 7266, 16229, 10303, 593,  -717,  -14,  -445, -462, 7175, 16209, 10394, 635,  -724, -15,
-            -437, -483, 7084, 16189, 10484, 678,  -732,  -16,  -429, -503, 6994, 16167, 10574, 722,  -739, -18,
-            -421, -523, 6903, 16144, 10664, 766,  -747,  -19,  -414, -542, 6813, 16120, 10754, 810,  -754, -21,
-            -406, -560, 6723, 16095, 10843, 856,  -761,  -22,  -398, -578, 6633, 16068, 10932, 902,  -768, -24,
-            -391, -596, 6544, 16041, 11021, 949,  -775,  -26,  -383, -612, 6454, 16012, 11109, 996,  -782, -27,
-            -376, -629, 6366, 15983, 11197, 1044, -789,  -29,  -368, -645, 6277, 15952, 11285, 1093, -796, -31,
-            -361, -660, 6189, 15920, 11372, 1142, -802,  -33,  -354, -675, 6100, 15887, 11459, 1192, -809, -35,
-            -347, -689, 6013, 15853, 11546, 1243, -815,  -37,  -339, -703, 5925, 15818, 11632, 1294, -821, -39,
-            -332, -717, 5838, 15782, 11718, 1346, -827,  -41,  -325, -730, 5751, 15745, 11803, 1399, -833, -43,
-            -318, -742, 5665, 15707, 11888, 1452, -839,  -46,  -312, -754, 5579, 15668, 11973, 1506, -845, -48,
-            -305, -766, 5493, 15627, 12057, 1561, -850,  -50,  -298, -777, 5408, 15586, 12140, 1616, -855, -53,
-            -291, -787, 5323, 15544, 12224, 1672, -861,  -56,  -285, -798, 5239, 15500, 12306, 1729, -866, -58,
-            -278, -807, 5155, 15456, 12388, 1786, -871,  -61,  -272, -817, 5071, 15410, 12470, 1844, -875, -64,
-            -265, -826, 4988, 15364, 12551, 1902, -880,  -67,  -259, -834, 4905, 15317, 12631, 1962, -884, -70,
-            -253, -842, 4823, 15268, 12711, 2022, -888,  -73,  -247, -850, 4741, 15219, 12790, 2082, -892, -76,
-            -241, -857, 4659, 15168, 12869, 2143, -896,  -79,  -235, -864, 4578, 15117, 12947, 2205, -899, -82,
-            -229, -870, 4498, 15065, 13025, 2267, -903,  -85,  -223, -876, 4417, 15012, 13102, 2331, -906, -89,
-            -217, -882, 4338, 14958, 13178, 2394, -909,  -92,  -211, -887, 4259, 14903, 13254, 2459, -911, -96,
-            -206, -892, 4180, 14847, 13329, 2523, -914,  -100, -200, -896, 4102, 14790, 13403, 2589, -916, -103,
-            -195, -900, 4024, 14732, 13477, 2655, -918,  -107, -190, -904, 3947, 14673, 13550, 2722, -919, -111,
-            -184, -908, 3871, 14614, 13622, 2789, -921,  -115, -179, -911, 3795, 14553, 13693, 2857, -922, -119,
-            -174, -913, 3719, 14492, 13764, 2926, -923,  -123, -169, -916, 3644, 14430, 13834, 2995, -923, -127,
-            -164, -918, 3570, 14367, 13904, 3065, -924,  -132, -159, -920, 3496, 14303, 13972, 3136, -924, -136,
-            -154, -921, 3423, 14239, 14040, 3207, -924,  -140, -150, -922, 3350, 14173, 14107, 3278, -923, -145,
-            -145, -923, 3278, 14107, 14173, 3350, -922,  -150, -140, -924, 3207, 14040, 14239, 3423, -921, -154,
-            -136, -924, 3136, 13972, 14303, 3496, -920,  -159, -132, -924, 3065, 13904, 14367, 3570, -918, -164,
-            -127, -923, 2995, 13834, 14430, 3644, -916,  -169, -123, -923, 2926, 13764, 14492, 3719, -913, -174,
-            -119, -922, 2857, 13693, 14553, 3795, -911,  -179, -115, -921, 2789, 13622, 14614, 3871, -908, -184,
-            -111, -919, 2722, 13550, 14673, 3947, -904,  -190, -107, -918, 2655, 13477, 14732, 4024, -900, -195,
-            -103, -916, 2589, 13403, 14790, 4102, -896,  -200, -100, -914, 2523, 13329, 14847, 4180, -892, -206,
-            -96,  -911, 2459, 13254, 14903, 4259, -887,  -211, -92,  -909, 2394, 13178, 14958, 4338, -882, -217,
-            -89,  -906, 2331, 13102, 15012, 4417, -876,  -223, -85,  -903, 2267, 13025, 15065, 4498, -870, -229,
-            -82,  -899, 2205, 12947, 15117, 4578, -864,  -235, -79,  -896, 2143, 12869, 15168, 4659, -857, -241,
-            -76,  -892, 2082, 12790, 15219, 4741, -850,  -247, -73,  -888, 2022, 12711, 15268, 4823, -842, -253,
-            -70,  -884, 1962, 12631, 15317, 4905, -834,  -259, -67,  -880, 1902, 12551, 15364, 4988, -826, -265,
-            -64,  -875, 1844, 12470, 15410, 5071, -817,  -272, -61,  -871, 1786, 12388, 15456, 5155, -807, -278,
-            -58,  -866, 1729, 12306, 15500, 5239, -798,  -285, -56,  -861, 1672, 12224, 15544, 5323, -787, -291,
-            -53,  -855, 1616, 12140, 15586, 5408, -777,  -298, -50,  -850, 1561, 12057, 15627, 5493, -766, -305,
-            -48,  -845, 1506, 11973, 15668, 5579, -754,  -312, -46,  -839, 1452, 11888, 15707, 5665, -742, -318,
-            -43,  -833, 1399, 11803, 15745, 5751, -730,  -325, -41,  -827, 1346, 11718, 15782, 5838, -717, -332,
-            -39,  -821, 1294, 11632, 15818, 5925, -703,  -339, -37,  -815, 1243, 11546, 15853, 6013, -689, -347,
-            -35,  -809, 1192, 11459, 15887, 6100, -675,  -354, -33,  -802, 1142, 11372, 15920, 6189, -660, -361,
-            -31,  -796, 1093, 11285, 15952, 6277, -645,  -368, -29,  -789, 1044, 11197, 15983, 6366, -629, -376,
-            -27,  -782, 996,  11109, 16012, 6454, -612,  -383, -26,  -775, 949,  11021, 16041, 6544, -596, -391,
-            -24,  -768, 902,  10932, 16068, 6633, -578,  -398, -22,  -761, 856,  10843, 16095, 6723, -560, -406,
-            -21,  -754, 810,  10754, 16120, 6813, -542,  -414, -19,  -747, 766,  10664, 16144, 6903, -523, -421,
-            -18,  -739, 722,  10574, 16167, 6994, -503,  -429, -16,  -732, 678,  10484, 16189, 7084, -483, -437,
-            -15,  -724, 635,  10394, 16209, 7175, -462,  -445, -14,  -717, 593,  10303, 16229, 7266, -441, -452,
-            -13,  -709, 552,  10212, 16247, 7357, -419,  -460, -11,  -702, 511,  10121, 16265, 7449, -397, -468,
-            -10,  -694, 471,  10030, 16281, 7540, -374,  -476, -9,   -686, 432,  9939,  16296, 7632, -351, -484,
-            -8,   -678, 393,  9847,  16310, 7724, -327,  -492, -7,   -670, 355,  9756,  16322, 7816, -302, -500,
-            -6,   -662, 317,  9664,  16334, 7908, -277,  -508, -5,   -654, 280,  9572,  16344, 8000, -251, -516,
-            -5,   -646, 244,  9480,  16354, 8093, -225,  -525, -4,   -638, 208,  9387,  16362, 8185, -198, -533,
-            -3,   -630, 173,  9295,  16369, 8277, -170,  -541, -2,   -622, 139,  9203,  16375, 8370, -142, -549,
-            -2,   -614, 105,  9110,  16379, 8462, -113,  -557, -1,   -606, 72,   9018,  16383, 8555, -84,  -565,
-            -1,   -598, 40,   8925,  16385, 8647, -54,   -573, 0,    -590, 8,    8833,  16386, 8740, -23,  -582,
-        };
-
-        private static short[] _highCurveLut1 = new short[]
-        {
-            -12,  47,   -134,  32767, 81,     -16,   2,     0,    -26,  108,  -345,   32760, 301,   -79,   17,   -1,
-            -40,  168,  -552,  32745, 526,    -144,  32,    -2,   -53,  226,  -753,   32723, 755,   -210,  47,   -3,
-            -66,  284,  -950,  32694, 989,    -277,  63,    -5,   -78,  340,  -1143,  32658, 1226,  -346,  79,   -6,
-            -90,  394,  -1331, 32615, 1469,   -415,  96,    -8,   -101, 447,  -1514,  32564, 1715,  -486,  113,  -9,
-            -112, 499,  -1692, 32506, 1966,   -557,  130,   -11,  -123, 550,  -1865,  32441, 2221,  -630,  148,  -13,
-            -133, 599,  -2034, 32369, 2480,   -703,  166,   -14,  -143, 646,  -2198,  32290, 2743,  -778,  185,  -16,
-            -152, 693,  -2357, 32204, 3010,   -853,  204,   -18,  -162, 738,  -2512,  32110, 3281,  -929,  223,  -20,
-            -170, 781,  -2662, 32010, 3555,   -1007, 242,   -23,  -178, 823,  -2807,  31903, 3834,  -1084, 262,  -25,
-            -186, 864,  -2947, 31789, 4116,   -1163, 282,   -27,  -194, 903,  -3082,  31668, 4403,  -1242, 303,  -30,
-            -201, 940,  -3213, 31540, 4692,   -1322, 323,   -32,  -207, 977,  -3339,  31406, 4985,  -1403, 344,  -35,
-            -214, 1011, -3460, 31265, 5282,   -1484, 365,   -37,  -220, 1045, -3577,  31117, 5582,  -1566, 387,  -40,
-            -225, 1077, -3688, 30963, 5885,   -1648, 409,   -43,  -230, 1107, -3796,  30802, 6191,  -1730, 431,  -46,
-            -235, 1136, -3898, 30635, 6501,   -1813, 453,   -49,  -240, 1164, -3996,  30462, 6813,  -1896, 475,  -52,
-            -244, 1190, -4089, 30282, 7128,   -1980, 498,   -55,  -247, 1215, -4178,  30097, 7446,  -2064, 520,  -58,
-            -251, 1239, -4262, 29905, 7767,   -2148, 543,   -62,  -254, 1261, -4342,  29707, 8091,  -2231, 566,  -65,
-            -257, 1281, -4417, 29503, 8416,   -2315, 589,   -69,  -259, 1301, -4488,  29293, 8745,  -2399, 613,  -72,
-            -261, 1319, -4555, 29078, 9075,   -2483, 636,   -76,  -263, 1336, -4617,  28857, 9408,  -2567, 659,  -80,
-            -265, 1351, -4674, 28631, 9743,   -2651, 683,   -83,  -266, 1365, -4728,  28399, 10080, -2734, 706,  -87,
-            -267, 1378, -4777, 28161, 10418,  -2817, 730,   -91,  -267, 1389, -4822,  27919, 10759, -2899, 753,  -95,
-            -268, 1400, -4863, 27671, 11100,  -2981, 777,   -99,  -268, 1409, -4900,  27418, 11444, -3063, 800,  -103,
-            -268, 1416, -4933, 27161, 11789,  -3144, 824,   -107, -267, 1423, -4962,  26898, 12135, -3224, 847,  -112,
-            -267, 1428, -4987, 26631, 12482,  -3303, 870,   -116, -266, 1433, -5008,  26359, 12830, -3382, 893,  -120,
-            -265, 1436, -5026, 26083, 13179,  -3460, 916,   -125, -264, 1438, -5039,  25802, 13529, -3537, 939,  -129,
-            -262, 1438, -5049, 25517, 13880,  -3613, 962,   -133, -260, 1438, -5055,  25228, 14231, -3687, 984,  -138,
-            -258, 1437, -5058, 24935, 14582,  -3761, 1006,  -142, -256, 1435, -5058,  24639, 14934, -3833, 1028, -147,
-            -254, 1431, -5053, 24338, 15286,  -3904, 1049,  -151, -252, 1427, -5046,  24034, 15638, -3974, 1071, -155,
-            -249, 1422, -5035, 23726, 15989,  -4042, 1091,  -160, -246, 1416, -5021,  23415, 16341, -4109, 1112, -164,
-            -243, 1408, -5004, 23101, 16691,  -4174, 1132,  -169, -240, 1400, -4984,  22783, 17042, -4237, 1152, -173,
-            -237, 1392, -4960, 22463, 17392,  -4299, 1171,  -178, -234, 1382, -4934,  22140, 17740, -4358, 1190, -182,
-            -230, 1371, -4905, 21814, 18088,  -4416, 1209,  -186, -227, 1360, -4873,  21485, 18435, -4472, 1226, -191,
-            -223, 1348, -4839, 21154, 18781,  -4526, 1244,  -195, -219, 1335, -4801,  20821, 19125, -4578, 1260, -199,
-            -215, 1321, -4761, 20486, 19468,  -4627, 1277,  -203, -211, 1307, -4719,  20148, 19809, -4674, 1292, -207,
-            -207, 1292, -4674, 19809, 20148,  -4719, 1307,  -211, -203, 1277, -4627,  19468, 20486, -4761, 1321, -215,
-            -199, 1260, -4578, 19125, 20821,  -4801, 1335,  -219, -195, 1244, -4526,  18781, 21154, -4839, 1348, -223,
-            -191, 1226, -4472, 18435, 21485,  -4873, 1360,  -227, -186, 1209, -4416,  18088, 21814, -4905, 1371, -230,
-            -182, 1190, -4358, 17740, 22140,  -4934, 1382,  -234, -178, 1171, -4299,  17392, 22463, -4960, 1392, -237,
-            -173, 1152, -4237, 17042, 22783,  -4984, 1400,  -240, -169, 1132, -4174,  16691, 23101, -5004, 1408, -243,
-            -164, 1112, -4109, 16341, 23415,  -5021, 1416,  -246, -160, 1091, -4042,  15989, 23726, -5035, 1422, -249,
-            -155, 1071, -3974, 15638, 24034,  -5046, 1427,  -252, -151, 1049, -3904,  15286, 24338, -5053, 1431, -254,
-            -147, 1028, -3833, 14934, 24639,  -5058, 1435,  -256, -142, 1006, -3761,  14582, 24935, -5058, 1437, -258,
-            -138, 984,  -3687, 14231, 25228,  -5055, 1438,  -260, -133, 962,  -3613,  13880, 25517, -5049, 1438, -262,
-            -129, 939,  -3537, 13529, 25802,  -5039, 1438,  -264, -125, 916,  -3460,  13179, 26083, -5026, 1436, -265,
-            -120, 893,  -3382, 12830, 26359,  -5008, 1433,  -266, -116, 870,  -3303,  12482, 26631, -4987, 1428, -267,
-            -112, 847,  -3224, 12135, 26898,  -4962, 1423,  -267, -107, 824,  -3144,  11789, 27161, -4933, 1416, -268,
-            -103, 800,  -3063, 11444, 27418,  -4900, 1409,  -268, -99,  777,  -2981,  11100, 27671, -4863, 1400, -268,
-            -95,  753,  -2899, 10759, 27919,  -4822, 1389,  -267, -91,  730,  -2817,  10418, 28161, -4777, 1378, -267,
-            -87,  706,  -2734, 10080, 28399,  -4728, 1365,  -266, -83,  683,  -2651,  9743,  28631, -4674, 1351, -265,
-            -80,  659,  -2567, 9408,  28857,  -4617, 1336,  -263, -76,  636,  -2483,  9075,  29078, -4555, 1319, -261,
-            -72,  613,  -2399, 8745,  29293,  -4488, 1301,  -259, -69,  589,  -2315,  8416,  29503, -4417, 1281, -257,
-            -65,  566,  -2231, 8091,  29707,  -4342, 1261,  -254, -62,  543,  -2148,  7767,  29905, -4262, 1239, -251,
-            -58,  520,  -2064, 7446,  30097,  -4178, 1215,  -247, -55,  498,  -1980,  7128,  30282, -4089, 1190, -244,
-            -52,  475,  -1896, 6813,  30462,  -3996, 1164,  -240, -49,  453,  -1813,  6501,  30635, -3898, 1136, -235,
-            -46,  431,  -1730, 6191,  30802,  -3796, 1107,  -230, -43,  409,  -1648,  5885,  30963, -3688, 1077, -225,
-            -40,  387,  -1566, 5582,  31117,  -3577, 1045,  -220, -37,  365,  -1484,  5282,  31265, -3460, 1011, -214,
-            -35,  344,  -1403, 4985,  31406,  -3339, 977,   -207, -32,  323,  -1322,  4692,  31540, -3213, 940,  -201,
-            -30,  303,  -1242, 4403,  31668,  -3082, 903,   -194, -27,  282,  -1163,  4116,  31789, -2947, 864,  -186,
-            -25,  262,  -1084, 3834,  31903,  -2807, 823,   -178, -23,  242,  -1007,  3555,  32010, -2662, 781,  -170,
-            -20,  223,  -929,  3281,  32110,  -2512, 738,   -162, -18,  204,  -853,   3010,  32204, -2357, 693,  -152,
-            -16,  185,  -778,  2743,  32290,  -2198, 646,   -143, -14,  166,  -703,   2480,  32369, -2034, 599,  -133,
-            -13,  148,  -630,  2221,  32441,  -1865, 550,   -123, -11,  130,  -557,   1966,  32506, -1692, 499,  -112,
-            -9,   113,  -486,  1715,  32564,  -1514, 447,   -101, -8,   96,   -415,   1469,  32615, -1331, 394,  -90,
-            -6,   79,   -346,  1226,  32658,  -1143, 340,   -78,  -5,   63,   -277,   989,   32694, -950,  284,  -66,
-            -3,   47,   -210,  755,   32723,  -753,  226,   -53,  -2,   32,   -144,   526,   32745, -552,  168,  -40,
-            -1,   17,   -79,   301,   32760,  -345,  108,   -26,  0,    2,    -16,    81,    32767, -134,  47,   -12,
-        };
-
-        private static short[] _highCurveLut2 = new short[]
-        {
-            418, -2538, 6118,  24615, 6298,  -2563, 417,   0,   420, -2512, 5939,  24611, 6479,  -2588, 415,   1,
-            421, -2485, 5761,  24605, 6662,  -2612, 412,   2,   422, -2458, 5585,  24595, 6846,  -2635, 409,   3,
-            423, -2430, 5410,  24582, 7030,  -2658, 406,   4,   423, -2402, 5236,  24565, 7216,  -2680, 403,   5,
-            423, -2373, 5064,  24546, 7403,  -2701, 399,   6,   423, -2343, 4893,  24523, 7591,  -2721, 395,   7,
-            423, -2313, 4724,  24496, 7780,  -2741, 391,   8,   422, -2283, 4556,  24467, 7970,  -2759, 386,   9,
-            421, -2252, 4390,  24434, 8161,  -2777, 381,   11,  420, -2221, 4225,  24398, 8353,  -2794, 376,   12,
-            419, -2190, 4062,  24359, 8545,  -2810, 370,   14,  418, -2158, 3900,  24316, 8739,  -2825, 364,   15,
-            416, -2126, 3740,  24271, 8933,  -2839, 358,   17,  414, -2093, 3582,  24222, 9127,  -2851, 351,   19,
-            412, -2060, 3425,  24170, 9323,  -2863, 344,   21,  410, -2027, 3270,  24115, 9519,  -2874, 336,   22,
-            407, -1993, 3117,  24056, 9715,  -2884, 328,   24,  404, -1960, 2966,  23995, 9912,  -2893, 319,   26,
-            402, -1926, 2816,  23930, 10110, -2900, 311,   29,  398, -1892, 2668,  23863, 10308, -2907, 301,   31,
-            395, -1858, 2522,  23792, 10506, -2912, 292,   33,  392, -1823, 2378,  23718, 10705, -2916, 282,   35,
-            389, -1789, 2235,  23641, 10904, -2919, 271,   38,  385, -1754, 2095,  23561, 11103, -2920, 261,   40,
-            381, -1719, 1956,  23478, 11303, -2921, 249,   43,  377, -1684, 1819,  23393, 11502, -2920, 238,   45,
-            373, -1649, 1684,  23304, 11702, -2917, 225,   48,  369, -1615, 1551,  23212, 11902, -2914, 213,   51,
-            365, -1580, 1420,  23118, 12102, -2909, 200,   54,  361, -1545, 1291,  23020, 12302, -2902, 186,   57,
-            356, -1510, 1163,  22920, 12502, -2895, 173,   60,  352, -1475, 1038,  22817, 12702, -2885, 158,   63,
-            347, -1440, 915,   22711, 12901, -2875, 143,   66,  342, -1405, 793,   22602, 13101, -2863, 128,   69,
-            338, -1370, 674,   22491, 13300, -2849, 113,   73,  333, -1335, 557,   22377, 13499, -2834, 97,    76,
-            328, -1301, 441,   22260, 13698, -2817, 80,    80,  323, -1266, 328,   22141, 13896, -2799, 63,    83,
-            318, -1232, 217,   22019, 14094, -2779, 46,    87,  313, -1197, 107,   21894, 14291, -2758, 28,    91,
-            307, -1163, 0,     21767, 14488, -2735, 9,     95,  302, -1129, -105,  21637, 14684, -2710, -9,    98,
-            297, -1096, -208,  21506, 14879, -2684, -29,   102, 292, -1062, -310,  21371, 15074, -2656, -48,   106,
-            286, -1029, -409,  21234, 15268, -2626, -69,   111, 281, -996,  -506,  21095, 15461, -2595, -89,   115,
-            276, -963,  -601,  20954, 15654, -2562, -110,  119, 270, -930,  -694,  20810, 15846, -2527, -132,  123,
-            265, -898,  -785,  20664, 16036, -2490, -154,  128, 260, -866,  -874,  20516, 16226, -2452, -176,  132,
-            254, -834,  -961,  20366, 16415, -2411, -199,  137, 249, -803,  -1046, 20213, 16602, -2369, -222,  141,
-            243, -771,  -1129, 20059, 16789, -2326, -246,  146, 238, -740,  -1209, 19902, 16974, -2280, -270,  151,
-            233, -710,  -1288, 19744, 17158, -2232, -294,  156, 227, -680,  -1365, 19583, 17341, -2183, -319,  160,
-            222, -650,  -1440, 19421, 17523, -2132, -345,  165, 217, -620,  -1513, 19257, 17703, -2079, -370,  170,
-            211, -591,  -1583, 19091, 17882, -2023, -396,  175, 206, -562,  -1652, 18923, 18059, -1966, -423,  180,
-            201, -533,  -1719, 18754, 18235, -1907, -450,  185, 196, -505,  -1784, 18582, 18410, -1847, -477,  191,
-            191, -477,  -1847, 18410, 18582, -1784, -505,  196, 185, -450,  -1907, 18235, 18754, -1719, -533,  201,
-            180, -423,  -1966, 18059, 18923, -1652, -562,  206, 175, -396,  -2023, 17882, 19091, -1583, -591,  211,
-            170, -370,  -2079, 17703, 19257, -1513, -620,  217, 165, -345,  -2132, 17523, 19421, -1440, -650,  222,
-            160, -319,  -2183, 17341, 19583, -1365, -680,  227, 156, -294,  -2232, 17158, 19744, -1288, -710,  233,
-            151, -270,  -2280, 16974, 19902, -1209, -740,  238, 146, -246,  -2326, 16789, 20059, -1129, -771,  243,
-            141, -222,  -2369, 16602, 20213, -1046, -803,  249, 137, -199,  -2411, 16415, 20366, -961,  -834,  254,
-            132, -176,  -2452, 16226, 20516, -874,  -866,  260, 128, -154,  -2490, 16036, 20664, -785,  -898,  265,
-            123, -132,  -2527, 15846, 20810, -694,  -930,  270, 119, -110,  -2562, 15654, 20954, -601,  -963,  276,
-            115, -89,   -2595, 15461, 21095, -506,  -996,  281, 111, -69,   -2626, 15268, 21234, -409,  -1029, 286,
-            106, -48,   -2656, 15074, 21371, -310,  -1062, 292, 102, -29,   -2684, 14879, 21506, -208,  -1096, 297,
-            98,  -9,    -2710, 14684, 21637, -105,  -1129, 302, 95,  9,     -2735, 14488, 21767, 0,     -1163, 307,
-            91,  28,    -2758, 14291, 21894, 107,   -1197, 313, 87,  46,    -2779, 14094, 22019, 217,   -1232, 318,
-            83,  63,    -2799, 13896, 22141, 328,   -1266, 323, 80,  80,    -2817, 13698, 22260, 441,   -1301, 328,
-            76,  97,    -2834, 13499, 22377, 557,   -1335, 333, 73,  113,   -2849, 13300, 22491, 674,   -1370, 338,
-            69,  128,   -2863, 13101, 22602, 793,   -1405, 342, 66,  143,   -2875, 12901, 22711, 915,   -1440, 347,
-            63,  158,   -2885, 12702, 22817, 1038,  -1475, 352, 60,  173,   -2895, 12502, 22920, 1163,  -1510, 356,
-            57,  186,   -2902, 12302, 23020, 1291,  -1545, 361, 54,  200,   -2909, 12102, 23118, 1420,  -1580, 365,
-            51,  213,   -2914, 11902, 23212, 1551,  -1615, 369, 48,  225,   -2917, 11702, 23304, 1684,  -1649, 373,
-            45,  238,   -2920, 11502, 23393, 1819,  -1684, 377, 43,  249,   -2921, 11303, 23478, 1956,  -1719, 381,
-            40,  261,   -2920, 11103, 23561, 2095,  -1754, 385, 38,  271,   -2919, 10904, 23641, 2235,  -1789, 389,
-            35,  282,   -2916, 10705, 23718, 2378,  -1823, 392, 33,  292,   -2912, 10506, 23792, 2522,  -1858, 395,
-            31,  301,   -2907, 10308, 23863, 2668,  -1892, 398, 29,  311,   -2900, 10110, 23930, 2816,  -1926, 402,
-            26,  319,   -2893, 9912,  23995, 2966,  -1960, 404, 24,  328,   -2884, 9715,  24056, 3117,  -1993, 407,
-            22,  336,   -2874, 9519,  24115, 3270,  -2027, 410, 21,  344,   -2863, 9323,  24170, 3425,  -2060, 412,
-            19,  351,   -2851, 9127,  24222, 3582,  -2093, 414, 17,  358,   -2839, 8933,  24271, 3740,  -2126, 416,
-            15,  364,   -2825, 8739,  24316, 3900,  -2158, 418, 14,  370,   -2810, 8545,  24359, 4062,  -2190, 419,
-            12,  376,   -2794, 8353,  24398, 4225,  -2221, 420, 11,  381,   -2777, 8161,  24434, 4390,  -2252, 421,
-            9,   386,   -2759, 7970,  24467, 4556,  -2283, 422, 8,   391,   -2741, 7780,  24496, 4724,  -2313, 423,
-            7,   395,   -2721, 7591,  24523, 4893,  -2343, 423, 6,   399,   -2701, 7403,  24546, 5064,  -2373, 423,
-            5,   403,   -2680, 7216,  24565, 5236,  -2402, 423, 4,   406,   -2658, 7030,  24582, 5410,  -2430, 423,
-            3,   409,   -2635, 6846,  24595, 5585,  -2458, 422, 2,   412,   -2612, 6662,  24605, 5761,  -2485, 421,
-            1,   415,   -2588, 6479,  24611, 5939,  -2512, 420, 0,   417,   -2563, 6298,  24615, 6118,  -2538, 418,
-        };
-        #endregion
-
-        private static float[] _normalCurveLut0F;
-        private static float[] _normalCurveLut1F;
-        private static float[] _normalCurveLut2F;
-
-        private static float[] _highCurveLut0F;
-        private static float[] _highCurveLut1F;
-        private static float[] _highCurveLut2F;
-
-        static ResamplerHelper()
-        {
-            _normalCurveLut0F = _normalCurveLut0.Select(x => x / 32768f).ToArray();
-            _normalCurveLut1F = _normalCurveLut1.Select(x => x / 32768f).ToArray();
-            _normalCurveLut2F = _normalCurveLut2.Select(x => x / 32768f).ToArray();
-
-            _highCurveLut0F = _highCurveLut0.Select(x => x / 32768f).ToArray();
-            _highCurveLut1F = _highCurveLut1.Select(x => x / 32768f).ToArray();
-            _highCurveLut2F = _highCurveLut2.Select(x => x / 32768f).ToArray();
-        }
-
-        private const int FixedPointPrecision = 15;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void Resample(Span<float> outputBuffer, ReadOnlySpan<short> inputBuffer, float ratio, ref float fraction, int sampleCount, SampleRateConversionQuality srcQuality, bool needPitch)
-        {
-            switch (srcQuality)
-            {
-                case SampleRateConversionQuality.Default:
-                    ResampleDefaultQuality(outputBuffer, inputBuffer, ratio, ref fraction, sampleCount, needPitch);
-                    break;
-                case SampleRateConversionQuality.Low:
-                    ResampleLowQuality(outputBuffer, inputBuffer, ratio, ref fraction, sampleCount);
-                    break;
-                case SampleRateConversionQuality.High:
-                    ResampleHighQuality(outputBuffer, inputBuffer, ratio, ref fraction, sampleCount);
-                    break;
-                default:
-                    throw new NotImplementedException($"{srcQuality}");
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static ReadOnlySpan<float> GetDefaultParameter(float ratio)
-        {
-            if (ratio <= 1.0f)
-            {
-                return _normalCurveLut1F;
-            }
-            else if (ratio > 1.333313f)
-            {
-                return _normalCurveLut0F;
-            }
-
-            return _normalCurveLut2F;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private unsafe static void ResampleDefaultQuality(Span<float> outputBuffer, ReadOnlySpan<short> inputBuffer, float ratio, ref float fraction, int sampleCount, bool needPitch)
-        {
-            ReadOnlySpan<float> parameters = GetDefaultParameter(ratio);
-
-            int inputBufferIndex = 0, i = 0;
-
-            // TODO: REV8 fast path (when needPitch == false the input index progression is constant + we need SIMD)
-
-            if (Sse41.IsSupported)
-            {
-                if (ratio == 1f)
-                {
-                    fixed (short* pInput = inputBuffer)
-                    {
-                        fixed (float* pOutput = outputBuffer, pParameters = parameters)
-                        {
-                            Vector128<float> parameter = Sse.LoadVector128(pParameters);
-
-                            for (; i < (sampleCount & ~3); i += 4)
-                            {
-                                Vector128<int> intInput0 = Sse41.ConvertToVector128Int32(pInput + (uint)i);
-                                Vector128<int> intInput1 = Sse41.ConvertToVector128Int32(pInput + (uint)i + 1);
-                                Vector128<int> intInput2 = Sse41.ConvertToVector128Int32(pInput + (uint)i + 2);
-                                Vector128<int> intInput3 = Sse41.ConvertToVector128Int32(pInput + (uint)i + 3);
-
-                                Vector128<float> input0 = Sse2.ConvertToVector128Single(intInput0);
-                                Vector128<float> input1 = Sse2.ConvertToVector128Single(intInput1);
-                                Vector128<float> input2 = Sse2.ConvertToVector128Single(intInput2);
-                                Vector128<float> input3 = Sse2.ConvertToVector128Single(intInput3);
-
-                                Vector128<float> mix0 = Sse.Multiply(input0, parameter);
-                                Vector128<float> mix1 = Sse.Multiply(input1, parameter);
-                                Vector128<float> mix2 = Sse.Multiply(input2, parameter);
-                                Vector128<float> mix3 = Sse.Multiply(input3, parameter);
-
-                                Vector128<float> mix01 = Sse3.HorizontalAdd(mix0, mix1);
-                                Vector128<float> mix23 = Sse3.HorizontalAdd(mix2, mix3);
-
-                                Vector128<float> mix0123 = Sse3.HorizontalAdd(mix01, mix23);
-
-                                Sse.Store(pOutput + (uint)i, Sse41.RoundToNearestInteger(mix0123));
-                            }
-                        }
-                    }
-
-                    inputBufferIndex = i;
-                }
-                else
-                {
-                    fixed (short* pInput = inputBuffer)
-                    {
-                        fixed (float* pOutput = outputBuffer, pParameters = parameters)
-                        {
-                            for (; i < (sampleCount & ~3); i += 4)
-                            {
-                                uint baseIndex0 = (uint)(fraction * 128) * 4;
-                                uint inputIndex0 = (uint)inputBufferIndex;
-
-                                fraction += ratio;
-
-                                uint baseIndex1 = ((uint)(fraction * 128) & 127) * 4;
-                                uint inputIndex1 = (uint)inputBufferIndex + (uint)fraction;
-
-                                fraction += ratio;
-
-                                uint baseIndex2 = ((uint)(fraction * 128) & 127) * 4;
-                                uint inputIndex2 = (uint)inputBufferIndex + (uint)fraction;
-
-                                fraction += ratio;
-
-                                uint baseIndex3 = ((uint)(fraction * 128) & 127) * 4;
-                                uint inputIndex3 = (uint)inputBufferIndex + (uint)fraction;
-
-                                fraction += ratio;
-                                inputBufferIndex += (int)fraction;
-
-                                // Only keep lower part (safe as fraction isn't supposed to be negative)
-                                fraction -= (int)fraction;
-
-                                Vector128<float> parameter0 = Sse.LoadVector128(pParameters + baseIndex0);
-                                Vector128<float> parameter1 = Sse.LoadVector128(pParameters + baseIndex1);
-                                Vector128<float> parameter2 = Sse.LoadVector128(pParameters + baseIndex2);
-                                Vector128<float> parameter3 = Sse.LoadVector128(pParameters + baseIndex3);
-
-                                Vector128<int> intInput0 = Sse41.ConvertToVector128Int32(pInput + inputIndex0);
-                                Vector128<int> intInput1 = Sse41.ConvertToVector128Int32(pInput + inputIndex1);
-                                Vector128<int> intInput2 = Sse41.ConvertToVector128Int32(pInput + inputIndex2);
-                                Vector128<int> intInput3 = Sse41.ConvertToVector128Int32(pInput + inputIndex3);
-
-                                Vector128<float> input0 = Sse2.ConvertToVector128Single(intInput0);
-                                Vector128<float> input1 = Sse2.ConvertToVector128Single(intInput1);
-                                Vector128<float> input2 = Sse2.ConvertToVector128Single(intInput2);
-                                Vector128<float> input3 = Sse2.ConvertToVector128Single(intInput3);
-
-                                Vector128<float> mix0 = Sse.Multiply(input0, parameter0);
-                                Vector128<float> mix1 = Sse.Multiply(input1, parameter1);
-                                Vector128<float> mix2 = Sse.Multiply(input2, parameter2);
-                                Vector128<float> mix3 = Sse.Multiply(input3, parameter3);
-
-                                Vector128<float> mix01 = Sse3.HorizontalAdd(mix0, mix1);
-                                Vector128<float> mix23 = Sse3.HorizontalAdd(mix2, mix3);
-
-                                Vector128<float> mix0123 = Sse3.HorizontalAdd(mix01, mix23);
-
-                                Sse.Store(pOutput + (uint)i, Sse41.RoundToNearestInteger(mix0123));
-                            }
-                        }
-                    }
-                }
-            }
-
-            for (; i < sampleCount; i++)
-            {
-                int baseIndex = (int)(fraction * 128) * 4;
-                ReadOnlySpan<float> parameter = parameters.Slice(baseIndex, 4);
-                ReadOnlySpan<short> currentInput = inputBuffer.Slice(inputBufferIndex, 4);
-
-                outputBuffer[i] = (float)Math.Round(currentInput[0] * parameter[0] +
-                                                    currentInput[1] * parameter[1] +
-                                                    currentInput[2] * parameter[2] +
-                                                    currentInput[3] * parameter[3]);
-
-                fraction += ratio;
-                inputBufferIndex += (int)fraction;
-
-                // Only keep lower part (safe as fraction isn't supposed to be negative)
-                fraction -= (int)fraction;
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static ReadOnlySpan<float> GetHighParameter(float ratio)
-        {
-            if (ratio <= 1.0f)
-            {
-                return _highCurveLut1F;
-            }
-            else if (ratio > 1.333313f)
-            {
-                return _highCurveLut0F;
-            }
-
-            return _highCurveLut2F;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void ResampleHighQuality(Span<float> outputBuffer, ReadOnlySpan<short> inputBuffer, float ratio, ref float fraction, int sampleCount)
-        {
-            ReadOnlySpan<float> parameters = GetHighParameter(ratio);
-
-            int inputBufferIndex = 0;
-
-            // TODO: fast path
-
-            for (int i = 0; i < sampleCount; i++)
-            {
-                int baseIndex = (int)(fraction * 128) * 8;
-                ReadOnlySpan<float> parameter = parameters.Slice(baseIndex, 8);
-                ReadOnlySpan<short> currentInput = inputBuffer.Slice(inputBufferIndex, 8);
-
-                outputBuffer[i] = (float)Math.Round(currentInput[0] * parameter[0] +
-                                                    currentInput[1] * parameter[1] +
-                                                    currentInput[2] * parameter[2] +
-                                                    currentInput[3] * parameter[3] +
-                                                    currentInput[4] * parameter[4] +
-                                                    currentInput[5] * parameter[5] +
-                                                    currentInput[6] * parameter[6] +
-                                                    currentInput[7] * parameter[7]);
-
-                fraction += ratio;
-                inputBufferIndex += (int)MathF.Truncate(fraction);
-
-                fraction -= (int)fraction;
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ResampleLowQuality(Span<float> outputBuffer, ReadOnlySpan<short> inputBuffer, float ratio, ref float fraction, int sampleCount)
-        {
-            int inputBufferIndex = 0;
-
-            for (int i = 0; i < sampleCount; i++)
-            {
-                int outputData = inputBuffer[inputBufferIndex];
-
-                if (fraction > 1.0f)
-                {
-                    outputData = inputBuffer[inputBufferIndex + 1];
-                }
-
-                outputBuffer[i] = outputData;
-
-                fraction += ratio;
-                inputBufferIndex += (int)MathF.Truncate(fraction);
-
-                fraction -= (int)fraction;
-            }
-        }
-    }
-}

Ryujinx.Audio/Renderer/Dsp/UpsamplerHelper.cs

@@ -1,175 +0,0 @@
-using Ryujinx.Audio.Renderer.Server.Upsampler;
-using Ryujinx.Common.Memory;
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace Ryujinx.Audio.Renderer.Dsp
-{
-    public class UpsamplerHelper
-    {
-        private const int HistoryLength = UpsamplerBufferState.HistoryLength;
-        private const int FilterBankLength = 20;
-        // Bank0 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-        private const int Bank0CenterIndex = 9;
-        private static readonly Array20<float> Bank1 = PrecomputeFilterBank(1.0f / 6.0f);
-        private static readonly Array20<float> Bank2 = PrecomputeFilterBank(2.0f / 6.0f);
-        private static readonly Array20<float> Bank3 = PrecomputeFilterBank(3.0f / 6.0f);
-        private static readonly Array20<float> Bank4 = PrecomputeFilterBank(4.0f / 6.0f);
-        private static readonly Array20<float> Bank5 = PrecomputeFilterBank(5.0f / 6.0f);
-
-        private static Array20<float> PrecomputeFilterBank(float offset)
-        {
-            float Sinc(float x)
-            {
-                if (x == 0)
-                {
-                    return 1.0f;
-                }
-                return (MathF.Sin(MathF.PI * x) / (MathF.PI * x));
-            }
-
-            float BlackmanWindow(float x)
-            {
-                const float a = 0.18f;
-                const float a0 = 0.5f - 0.5f * a;
-                const float a1 = -0.5f;
-                const float a2 = 0.5f * a;
-                return a0 + a1 * MathF.Cos(2 * MathF.PI * x) + a2 * MathF.Cos(4 * MathF.PI * x);
-            }
-            
-            Array20<float> result = new Array20<float>();
-
-            for (int i = 0; i < FilterBankLength; i++)
-            {
-                float x = (Bank0CenterIndex - i) + offset;
-                result[i] = Sinc(x) * BlackmanWindow(x / FilterBankLength + 0.5f);
-            }
-
-            return result;
-        }
-
-        // Polyphase upsampling algorithm
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void Upsample(Span<float> outputBuffer, ReadOnlySpan<float> inputBuffer, int outputSampleCount, int inputSampleCount, ref UpsamplerBufferState state)
-        {
-            if (!state.Initialized)
-            {
-                state.Scale = inputSampleCount switch
-                {
-                    40  => 6.0f,
-                    80  => 3.0f,
-                    160 => 1.5f,
-                    _   => throw new ArgumentOutOfRangeException()
-                };
-                state.Initialized = true;
-            }
-
-            if (outputSampleCount == 0)
-            {
-                return;
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            float DoFilterBank(ref UpsamplerBufferState state, in Array20<float> bank)
-            {
-                float result = 0.0f;
-
-                Debug.Assert(state.History.Length == HistoryLength);
-                Debug.Assert(bank.Length == FilterBankLength);
-                for (int j = 0; j < FilterBankLength; j++)
-                {
-                    result += bank[j] * state.History[j];
-                }
-
-                return result;
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            void NextInput(ref UpsamplerBufferState state, float input)
-            {
-                state.History.AsSpan().Slice(1).CopyTo(state.History.AsSpan());
-                state.History[HistoryLength - 1] = input;
-            }
-
-            int inputBufferIndex = 0;
-
-            switch (state.Scale)
-            { 
-                case 6.0f:
-                    for (int i = 0; i < outputSampleCount; i++)
-                    {
-                        switch (state.Phase)
-                        {
-                            case 0:
-                                NextInput(ref state, inputBuffer[inputBufferIndex++]);
-                                outputBuffer[i] = state.History[Bank0CenterIndex];
-                                break;
-                            case 1:
-                                outputBuffer[i] = DoFilterBank(ref state, Bank1);
-                                break;
-                            case 2:
-                                outputBuffer[i] = DoFilterBank(ref state, Bank2);
-                                break;
-                            case 3:
-                                outputBuffer[i] = DoFilterBank(ref state, Bank3);
-                                break;
-                            case 4:
-                                outputBuffer[i] = DoFilterBank(ref state, Bank4);
-                                break;
-                            case 5:
-                                outputBuffer[i] = DoFilterBank(ref state, Bank5);
-                                break;
-                        }
-
-                        state.Phase = (state.Phase + 1) % 6;
-                    }
-                    break;
-                case 3.0f:
-                    for (int i = 0; i < outputSampleCount; i++)
-                    {
-                        switch (state.Phase)
-                        {
-                            case 0:
-                                NextInput(ref state, inputBuffer[inputBufferIndex++]);
-                                outputBuffer[i] = state.History[Bank0CenterIndex];
-                                break;
-                            case 1:
-                                outputBuffer[i] = DoFilterBank(ref state, Bank2);
-                                break;
-                            case 2:
-                                outputBuffer[i] = DoFilterBank(ref state, Bank4);
-                                break;
-                        }
-
-                        state.Phase = (state.Phase + 1) % 3;
-                    }
-                    break;
-                case 1.5f:
-                    // Upsample by 3 then decimate by 2.
-                    for (int i = 0; i < outputSampleCount; i++)
-                    {
-                        switch (state.Phase)
-                        {
-                            case 0:
-                                NextInput(ref state, inputBuffer[inputBufferIndex++]);
-                                outputBuffer[i] = state.History[Bank0CenterIndex];
-                                break;
-                            case 1:
-                                outputBuffer[i] = DoFilterBank(ref state, Bank4);
-                                break;
-                            case 2:
-                                NextInput(ref state, inputBuffer[inputBufferIndex++]);
-                                outputBuffer[i] = DoFilterBank(ref state, Bank2);
-                                break;
-                        }
-
-                        state.Phase = (state.Phase + 1) % 3;
-                    }
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
-        }
-    }
-}

Ryujinx.Audio/Renderer/Server/AudioRenderSystem.cs

@@ -1,893 +0,0 @@
-using Ryujinx.Audio.Integration;
-using Ryujinx.Audio.Renderer.Common;
-using Ryujinx.Audio.Renderer.Dsp.Command;
-using Ryujinx.Audio.Renderer.Parameter;
-using Ryujinx.Audio.Renderer.Server.Effect;
-using Ryujinx.Audio.Renderer.Server.MemoryPool;
-using Ryujinx.Audio.Renderer.Server.Mix;
-using Ryujinx.Audio.Renderer.Server.Performance;
-using Ryujinx.Audio.Renderer.Server.Sink;
-using Ryujinx.Audio.Renderer.Server.Splitter;
-using Ryujinx.Audio.Renderer.Server.Types;
-using Ryujinx.Audio.Renderer.Server.Upsampler;
-using Ryujinx.Audio.Renderer.Server.Voice;
-using Ryujinx.Audio.Renderer.Utils;
-using Ryujinx.Common;
-using Ryujinx.Common.Logging;
-using Ryujinx.Memory;
-using System;
-using System.Buffers;
-using System.Diagnostics;
-using System.Threading;
-
-using CpuAddress = System.UInt64;
-
-namespace Ryujinx.Audio.Renderer.Server
-{
-    public class AudioRenderSystem : IDisposable
-    {
-        private object _lock = new object();
-
-        private AudioRendererRenderingDevice _renderingDevice;
-        private AudioRendererExecutionMode _executionMode;
-        private IWritableEvent _systemEvent;
-        private ManualResetEvent _terminationEvent;
-        private MemoryPoolState _dspMemoryPoolState;
-        private VoiceContext _voiceContext;
-        private MixContext _mixContext;
-        private SinkContext _sinkContext;
-        private SplitterContext _splitterContext;
-        private EffectContext _effectContext;
-        private PerformanceManager _performanceManager;
-        private UpsamplerManager _upsamplerManager;
-        private bool _isActive;
-        private BehaviourContext _behaviourContext;
-        private ulong _totalElapsedTicksUpdating;
-        private ulong _totalElapsedTicks;
-        private int _sessionId;
-        private Memory<MemoryPoolState> _memoryPools;
-
-        private uint _sampleRate;
-        private uint _sampleCount;
-        private uint _mixBufferCount;
-        private uint _voiceChannelCountMax;
-        private uint _upsamplerCount;
-        private uint _memoryPoolCount;
-        private uint _processHandle;
-        private ulong _appletResourceId;
-
-        private MemoryHandle _workBufferMemoryPin;
-
-        private Memory<float> _mixBuffer;
-        private Memory<float> _depopBuffer;
-
-        private uint _renderingTimeLimitPercent;
-        private bool _voiceDropEnabled;
-        private uint _voiceDropCount;
-        private float _voiceDropParameter;
-        private bool _isDspRunningBehind;
-
-        private ICommandProcessingTimeEstimator _commandProcessingTimeEstimator;
-
-        private Memory<byte> _performanceBuffer;
-
-        public IVirtualMemoryManager MemoryManager { get; private set; }
-
-        private ulong _elapsedFrameCount;
-        private ulong _renderingStartTick;
-
-        private AudioRendererManager _manager;
-
-        private int _disposeState;
-
-        public AudioRenderSystem(AudioRendererManager manager, IWritableEvent systemEvent)
-        {
-            _manager = manager;
-            _terminationEvent = new ManualResetEvent(false);
-            _dspMemoryPoolState = MemoryPoolState.Create(MemoryPoolState.LocationType.Dsp);
-            _voiceContext = new VoiceContext();
-            _mixContext = new MixContext();
-            _sinkContext = new SinkContext();
-            _splitterContext = new SplitterContext();
-            _effectContext = new EffectContext();
-
-            _commandProcessingTimeEstimator = null;
-            _systemEvent = systemEvent;
-            _behaviourContext = new BehaviourContext();
-
-            _totalElapsedTicksUpdating = 0;
-            _sessionId = 0;
-            _voiceDropParameter = 1.0f;
-        }
-
-        public ResultCode Initialize(
-            ref AudioRendererConfiguration parameter,
-            uint processHandle,
-            Memory<byte> workBufferMemory,
-            CpuAddress workBuffer,
-            ulong workBufferSize,
-            int sessionId,
-            ulong appletResourceId,
-            IVirtualMemoryManager memoryManager)
-        {
-            if (!BehaviourContext.CheckValidRevision(parameter.Revision))
-            {
-                return ResultCode.OperationFailed;
-            }
-
-            if (GetWorkBufferSize(ref parameter) > workBufferSize)
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            Debug.Assert(parameter.RenderingDevice == AudioRendererRenderingDevice.Dsp && parameter.ExecutionMode == AudioRendererExecutionMode.Auto);
-
-            Logger.Info?.Print(LogClass.AudioRenderer, $"Initializing with REV{BehaviourContext.GetRevisionNumber(parameter.Revision)}");
-
-            _behaviourContext.SetUserRevision(parameter.Revision);
-
-            _sampleRate = parameter.SampleRate;
-            _sampleCount = parameter.SampleCount;
-            _mixBufferCount = parameter.MixBufferCount;
-            _voiceChannelCountMax = Constants.VoiceChannelCountMax;
-            _upsamplerCount = parameter.SinkCount + parameter.SubMixBufferCount;
-            _appletResourceId = appletResourceId;
-            _memoryPoolCount = parameter.EffectCount + parameter.VoiceCount * Constants.VoiceWaveBufferCount;
-            _renderingDevice = parameter.RenderingDevice;
-            _executionMode = parameter.ExecutionMode;
-            _sessionId = sessionId;
-            MemoryManager = memoryManager;
-
-            if (memoryManager is IRefCounted rc)
-            {
-                rc.IncrementReferenceCount();
-            }
-
-            WorkBufferAllocator workBufferAllocator;
-
-            workBufferMemory.Span.Fill(0);
-            _workBufferMemoryPin = workBufferMemory.Pin();
-
-            workBufferAllocator = new WorkBufferAllocator(workBufferMemory);
-
-            PoolMapper poolMapper = new PoolMapper(processHandle, false);
-            poolMapper.InitializeSystemPool(ref _dspMemoryPoolState, workBuffer, workBufferSize);
-
-            _mixBuffer = workBufferAllocator.Allocate<float>(_sampleCount * (_voiceChannelCountMax + _mixBufferCount), 0x10);
-
-            if (_mixBuffer.IsEmpty)
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            Memory<float> upSamplerWorkBuffer = workBufferAllocator.Allocate<float>(Constants.TargetSampleCount * (_voiceChannelCountMax + _mixBufferCount) * _upsamplerCount, 0x10);
-
-            if (upSamplerWorkBuffer.IsEmpty)
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            _depopBuffer = workBufferAllocator.Allocate<float>(BitUtils.AlignUp<ulong>(parameter.MixBufferCount, Constants.BufferAlignment), Constants.BufferAlignment);
-
-            if (_depopBuffer.IsEmpty)
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            // Invalidate DSP cache on what was currently allocated with workBuffer.
-            AudioProcessorMemoryManager.InvalidateDspCache(_dspMemoryPoolState.Translate(workBuffer, workBufferAllocator.Offset), workBufferAllocator.Offset);
-
-            Debug.Assert((workBufferAllocator.Offset % Constants.BufferAlignment) == 0);
-
-            Memory<VoiceState> voices = workBufferAllocator.Allocate<VoiceState>(parameter.VoiceCount, VoiceState.Alignment);
-
-            if (voices.IsEmpty)
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            foreach (ref VoiceState voice in voices.Span)
-            {
-                voice.Initialize();
-            }
-
-            // A pain to handle as we can't have VoiceState*, use indices to be a bit more safe
-            Memory<int> sortedVoices = workBufferAllocator.Allocate<int>(parameter.VoiceCount, 0x10);
-
-            if (sortedVoices.IsEmpty)
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            // Clear memory (use -1 as it's an invalid index)
-            sortedVoices.Span.Fill(-1);
-
-            Memory<VoiceChannelResource> voiceChannelResources = workBufferAllocator.Allocate<VoiceChannelResource>(parameter.VoiceCount, VoiceChannelResource.Alignment);
-
-            if (voiceChannelResources.IsEmpty)
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            for (uint id = 0; id < voiceChannelResources.Length; id++)
-            {
-                ref VoiceChannelResource voiceChannelResource = ref voiceChannelResources.Span[(int)id];
-
-                voiceChannelResource.Id = id;
-                voiceChannelResource.IsUsed = false;
-            }
-
-            Memory<VoiceUpdateState> voiceUpdateStates = workBufferAllocator.Allocate<VoiceUpdateState>(parameter.VoiceCount, VoiceUpdateState.Align);
-
-            if (voiceUpdateStates.IsEmpty)
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            uint mixesCount = parameter.SubMixBufferCount + 1;
-
-            Memory<MixState> mixes = workBufferAllocator.Allocate<MixState>(mixesCount, MixState.Alignment);
-
-            if (mixes.IsEmpty)
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            if (parameter.EffectCount == 0)
-            {
-                foreach (ref MixState mix in mixes.Span)
-                {
-                    mix = new MixState(Memory<int>.Empty, ref _behaviourContext);
-                }
-            }
-            else
-            {
-                Memory<int> effectProcessingOrderArray = workBufferAllocator.Allocate<int>(parameter.EffectCount * mixesCount, 0x10);
-
-                foreach (ref MixState mix in mixes.Span)
-                {
-                    mix = new MixState(effectProcessingOrderArray.Slice(0, (int)parameter.EffectCount), ref _behaviourContext);
-
-                    effectProcessingOrderArray = effectProcessingOrderArray.Slice((int)parameter.EffectCount);
-                }
-            }
-
-            // Initialize the final mix id
-            mixes.Span[0].MixId = Constants.FinalMixId;
-
-            Memory<int> sortedMixesState = workBufferAllocator.Allocate<int>(mixesCount, 0x10);
-
-            if (sortedMixesState.IsEmpty)
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            // Clear memory (use -1 as it's an invalid index)
-            sortedMixesState.Span.Fill(-1);
-
-            Memory<byte> nodeStatesWorkBuffer = Memory<byte>.Empty;
-            Memory<byte> edgeMatrixWorkBuffer = Memory<byte>.Empty;
-
-            if (_behaviourContext.IsSplitterSupported())
-            {
-                nodeStatesWorkBuffer = workBufferAllocator.Allocate((uint)NodeStates.GetWorkBufferSize((int)mixesCount), 1);
-                edgeMatrixWorkBuffer = workBufferAllocator.Allocate((uint)EdgeMatrix.GetWorkBufferSize((int)mixesCount), 1);
-
-                if (nodeStatesWorkBuffer.IsEmpty || edgeMatrixWorkBuffer.IsEmpty)
-                {
-                    return ResultCode.WorkBufferTooSmall;
-                }
-            }
-
-            _mixContext.Initialize(sortedMixesState, mixes, nodeStatesWorkBuffer, edgeMatrixWorkBuffer);
-
-            _memoryPools = workBufferAllocator.Allocate<MemoryPoolState>(_memoryPoolCount, MemoryPoolState.Alignment);
-
-            if (_memoryPools.IsEmpty)
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            foreach (ref MemoryPoolState state in _memoryPools.Span)
-            {
-                state = MemoryPoolState.Create(MemoryPoolState.LocationType.Cpu);
-            }
-
-            if (!_splitterContext.Initialize(ref _behaviourContext, ref parameter, workBufferAllocator))
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            _processHandle = processHandle;
-
-            _upsamplerManager = new UpsamplerManager(upSamplerWorkBuffer, _upsamplerCount);
-
-            _effectContext.Initialize(parameter.EffectCount, _behaviourContext.IsEffectInfoVersion2Supported() ? parameter.EffectCount : 0);
-            _sinkContext.Initialize(parameter.SinkCount);
-
-            Memory<VoiceUpdateState> voiceUpdateStatesDsp = workBufferAllocator.Allocate<VoiceUpdateState>(parameter.VoiceCount, VoiceUpdateState.Align);
-
-            if (voiceUpdateStatesDsp.IsEmpty)
-            {
-                return ResultCode.WorkBufferTooSmall;
-            }
-
-            _voiceContext.Initialize(sortedVoices, voices, voiceChannelResources, voiceUpdateStates, voiceUpdateStatesDsp, parameter.VoiceCount);
-
-            if (parameter.PerformanceMetricFramesCount > 0)
-            {
-                ulong performanceBufferSize = PerformanceManager.GetRequiredBufferSizeForPerformanceMetricsPerFrame(ref parameter, ref _behaviourContext) * (parameter.PerformanceMetricFramesCount + 1) + 0xC;
-
-                _performanceBuffer = workBufferAllocator.Allocate(performanceBufferSize, Constants.BufferAlignment);
-
-                if (_performanceBuffer.IsEmpty)
-                {
-                    return ResultCode.WorkBufferTooSmall;
-                }
-
-                _performanceManager = PerformanceManager.Create(_performanceBuffer, ref parameter, _behaviourContext);
-            }
-            else
-            {
-                _performanceManager = null;
-            }
-
-            _totalElapsedTicksUpdating = 0;
-            _totalElapsedTicks = 0;
-            _renderingTimeLimitPercent = 100;
-            _voiceDropEnabled = parameter.VoiceDropEnabled && _executionMode == AudioRendererExecutionMode.Auto;
-
-            AudioProcessorMemoryManager.InvalidateDataCache(workBuffer, workBufferSize);
-
-            _processHandle = processHandle;
-            _elapsedFrameCount = 0;
-            _voiceDropParameter = 1.0f;
-
-            switch (_behaviourContext.GetCommandProcessingTimeEstimatorVersion())
-            {
-                case 1:
-                    _commandProcessingTimeEstimator = new CommandProcessingTimeEstimatorVersion1(_sampleCount, _mixBufferCount);
-                    break;
-                case 2:
-                    _commandProcessingTimeEstimator = new CommandProcessingTimeEstimatorVersion2(_sampleCount, _mixBufferCount);
-                    break;
-                case 3:
-                    _commandProcessingTimeEstimator = new CommandProcessingTimeEstimatorVersion3(_sampleCount, _mixBufferCount);
-                    break;
-                case 4:
-                    _commandProcessingTimeEstimator = new CommandProcessingTimeEstimatorVersion4(_sampleCount, _mixBufferCount);
-                    break;
-                case 5:
-                    _commandProcessingTimeEstimator = new CommandProcessingTimeEstimatorVersion5(_sampleCount, _mixBufferCount);
-                    break;
-                default:
-                    throw new NotImplementedException($"Unsupported processing time estimator version {_behaviourContext.GetCommandProcessingTimeEstimatorVersion()}.");
-            }
-
-            return ResultCode.Success;
-        }
-
-        public void Start()
-        {
-            Logger.Info?.Print(LogClass.AudioRenderer, $"Starting renderer id {_sessionId}");
-
-            lock (_lock)
-            {
-                _elapsedFrameCount = 0;
-                _isActive = true;
-            }
-        }
-
-        public void Stop()
-        {
-            Logger.Info?.Print(LogClass.AudioRenderer, $"Stopping renderer id {_sessionId}");
-
-            lock (_lock)
-            {
-                _isActive = false;
-            }
-
-            if (_executionMode == AudioRendererExecutionMode.Auto)
-            {
-                _terminationEvent.WaitOne();
-            }
-
-            Logger.Info?.Print(LogClass.AudioRenderer, $"Stopped renderer id {_sessionId}");
-        }
-
-        public void Disable()
-        {
-            lock (_lock)
-            {
-                _isActive = false;
-            }
-        }
-
-        public ResultCode Update(Memory<byte> output, Memory<byte> performanceOutput, ReadOnlyMemory<byte> input)
-        {
-            lock (_lock)
-            {
-                ulong updateStartTicks = GetSystemTicks();
-
-                output.Span.Fill(0);
-
-                StateUpdater stateUpdater = new StateUpdater(input, output, _processHandle, _behaviourContext);
-
-                ResultCode result;
-
-                result = stateUpdater.UpdateBehaviourContext();
-
-                if (result != ResultCode.Success)
-                {
-                    return result;
-                }
-
-                result = stateUpdater.UpdateMemoryPools(_memoryPools.Span);
-
-                if (result != ResultCode.Success)
-                {
-                    return result;
-                }
-
-                result = stateUpdater.UpdateVoiceChannelResources(_voiceContext);
-
-                if (result != ResultCode.Success)
-                {
-                    return result;
-                }
-
-                result = stateUpdater.UpdateVoices(_voiceContext, _memoryPools);
-
-                if (result != ResultCode.Success)
-                {
-                    return result;
-                }
-
-                result = stateUpdater.UpdateEffects(_effectContext, _isActive, _memoryPools);
-
-                if (result != ResultCode.Success)
-                {
-                    return result;
-                }
-
-                if (_behaviourContext.IsSplitterSupported())
-                {
-                    result = stateUpdater.UpdateSplitter(_splitterContext);
-
-                    if (result != ResultCode.Success)
-                    {
-                        return result;
-                    }
-                }
-
-                result = stateUpdater.UpdateMixes(_mixContext, GetMixBufferCount(), _effectContext, _splitterContext);
-
-                if (result != ResultCode.Success)
-                {
-                    return result;
-                }
-
-                result = stateUpdater.UpdateSinks(_sinkContext, _memoryPools);
-
-                if (result != ResultCode.Success)
-                {
-                    return result;
-                }
-
-                result = stateUpdater.UpdatePerformanceBuffer(_performanceManager, performanceOutput.Span);
-
-                if (result != ResultCode.Success)
-                {
-                    return result;
-                }
-
-                result = stateUpdater.UpdateErrorInfo();
-
-                if (result != ResultCode.Success)
-                {
-                    return result;
-                }
-
-                if (_behaviourContext.IsElapsedFrameCountSupported())
-                {
-                    result = stateUpdater.UpdateRendererInfo(_elapsedFrameCount);
-
-                    if (result != ResultCode.Success)
-                    {
-                        return result;
-                    }
-                }
-
-                result = stateUpdater.CheckConsumedSize();
-
-                if (result != ResultCode.Success)
-                {
-                    return result;
-                }
-
-                _systemEvent.Clear();
-
-                ulong updateEndTicks = GetSystemTicks();
-
-                _totalElapsedTicksUpdating += (updateEndTicks - updateStartTicks);
-
-                return result;
-            }
-        }
-
-        private ulong GetSystemTicks()
-        {
-            return (ulong)(_manager.TickSource.ElapsedSeconds * Constants.TargetTimerFrequency);
-        }
-
-        private uint ComputeVoiceDrop(CommandBuffer commandBuffer, uint voicesEstimatedTime, long deltaTimeDsp)
-        {
-            int i;
-
-            for (i = 0; i < commandBuffer.CommandList.Commands.Count; i++)
-            {
-                ICommand command = commandBuffer.CommandList.Commands[i];
-
-                CommandType commandType = command.CommandType;
-
-                if (commandType == CommandType.AdpcmDataSourceVersion1 ||
-                    commandType == CommandType.AdpcmDataSourceVersion2 ||
-                    commandType == CommandType.PcmInt16DataSourceVersion1 ||
-                    commandType == CommandType.PcmInt16DataSourceVersion2 ||
-                    commandType == CommandType.PcmFloatDataSourceVersion1 ||
-                    commandType == CommandType.PcmFloatDataSourceVersion2 ||
-                    commandType == CommandType.Performance)
-                {
-                    break;
-                }
-            }
-
-            uint voiceDropped = 0;
-
-            for (; i < commandBuffer.CommandList.Commands.Count; i++)
-            {
-                ICommand targetCommand = commandBuffer.CommandList.Commands[i];
-
-                int targetNodeId = targetCommand.NodeId;
-
-                if (voicesEstimatedTime <= deltaTimeDsp || NodeIdHelper.GetType(targetNodeId) != NodeIdType.Voice)
-                {
-                    break;
-                }
-
-                ref VoiceState voice = ref _voiceContext.GetState(NodeIdHelper.GetBase(targetNodeId));
-
-                if (voice.Priority == Constants.VoiceHighestPriority)
-                {
-                    break;
-                }
-
-                // We can safely drop this voice, disable all associated commands while activating depop preparation commands.
-                voiceDropped++;
-                voice.VoiceDropFlag = true;
-
-                Logger.Warning?.Print(LogClass.AudioRenderer, $"Dropping voice {voice.NodeId}");
-
-                for (; i < commandBuffer.CommandList.Commands.Count; i++)
-                {
-                    ICommand command = commandBuffer.CommandList.Commands[i];
-
-                    if (command.NodeId != targetNodeId)
-                    {
-                        break;
-                    }
-
-                    if (command.CommandType == CommandType.DepopPrepare)
-                    {
-                        command.Enabled = true;
-                    }
-                    else if (command.CommandType == CommandType.Performance || !command.Enabled)
-                    {
-                        continue;
-                    }
-                    else
-                    {
-                        command.Enabled = false;
-
-                        voicesEstimatedTime -= (uint)(_voiceDropParameter * command.EstimatedProcessingTime);
-                    }
-                }
-            }
-
-            return voiceDropped;
-        }
-
-        private void GenerateCommandList(out CommandList commandList)
-        {
-            Debug.Assert(_executionMode == AudioRendererExecutionMode.Auto);
-
-            PoolMapper.ClearUsageState(_memoryPools);
-
-            ulong startTicks = GetSystemTicks();
-
-            commandList = new CommandList(this);
-
-            if (_performanceManager != null)
-            {
-                _performanceManager.TapFrame(_isDspRunningBehind, _voiceDropCount, _renderingStartTick);
-
-                _isDspRunningBehind = false;
-                _voiceDropCount = 0;
-                _renderingStartTick = 0;
-            }
-
-            CommandBuffer commandBuffer = new CommandBuffer(commandList, _commandProcessingTimeEstimator);
-
-            CommandGenerator commandGenerator = new CommandGenerator(commandBuffer, GetContext(), _voiceContext, _mixContext, _effectContext, _sinkContext, _splitterContext, _performanceManager);
-
-            _voiceContext.Sort();
-            commandGenerator.GenerateVoices();
-
-            uint voicesEstimatedTime = (uint)(_voiceDropParameter * commandBuffer.EstimatedProcessingTime);
-
-            commandGenerator.GenerateSubMixes();
-            commandGenerator.GenerateFinalMixes();
-            commandGenerator.GenerateSinks();
-
-            uint totalEstimatedTime = (uint)(_voiceDropParameter * commandBuffer.EstimatedProcessingTime);
-
-            if (_voiceDropEnabled)
-            {
-                long maxDspTime = GetMaxAllocatedTimeForDsp();
-
-                long restEstimateTime = totalEstimatedTime - voicesEstimatedTime;
-
-                long deltaTimeDsp = Math.Max(maxDspTime - restEstimateTime, 0);
-
-                _voiceDropCount = ComputeVoiceDrop(commandBuffer, voicesEstimatedTime, deltaTimeDsp);
-            }
-
-            _voiceContext.UpdateForCommandGeneration();
-
-            if (_behaviourContext.IsEffectInfoVersion2Supported())
-            {
-                _effectContext.UpdateResultStateForCommandGeneration();
-            }
-
-            ulong endTicks = GetSystemTicks();
-
-            _totalElapsedTicks = endTicks - startTicks;
-
-            _renderingStartTick = GetSystemTicks();
-            _elapsedFrameCount++;
-        }
-
-        private int GetMaxAllocatedTimeForDsp()
-        {
-            return (int)(Constants.AudioProcessorMaxUpdateTimePerSessions * _behaviourContext.GetAudioRendererProcessingTimeLimit() * (GetRenderingTimeLimit() / 100.0f));
-        }
-
-        public void SendCommands()
-        {
-            lock (_lock)
-            {
-                if (_isActive)
-                {
-                    _terminationEvent.Reset();
-
-                    if (!_manager.Processor.HasRemainingCommands(_sessionId))
-                    {
-                        GenerateCommandList(out CommandList commands);
-
-                        _manager.Processor.Send(_sessionId,
-                                                commands,
-                                                GetMaxAllocatedTimeForDsp(),
-                                                _appletResourceId);
-
-                        _systemEvent.Signal();
-                    }
-                    else
-                    {
-                        _isDspRunningBehind = true;
-                    }
-                }
-                else
-                {
-                    _terminationEvent.Set();
-                }
-            }
-        }
-
-        public uint GetMixBufferCount()
-        {
-            return _mixBufferCount;
-        }
-
-        public void SetRenderingTimeLimitPercent(uint percent)
-        {
-            Debug.Assert(percent <= 100);
-
-            _renderingTimeLimitPercent = percent;
-        }
-
-        public uint GetRenderingTimeLimit()
-        {
-            return _renderingTimeLimitPercent;
-        }
-
-        public Memory<float> GetMixBuffer()
-        {
-            return _mixBuffer;
-        }
-
-        public uint GetSampleCount()
-        {
-            return _sampleCount;
-        }
-
-        public uint GetSampleRate()
-        {
-            return _sampleRate;
-        }
-
-        public uint GetVoiceChannelCountMax()
-        {
-            return _voiceChannelCountMax;
-        }
-
-        public bool IsActive()
-        {
-            return _isActive;
-        }
-
-        private RendererSystemContext GetContext()
-        {
-            return new RendererSystemContext
-            {
-                ChannelCount = _manager.Processor.OutputDevices[_sessionId].GetChannelCount(),
-                BehaviourContext = _behaviourContext,
-                DepopBuffer = _depopBuffer,
-                MixBufferCount = GetMixBufferCount(),
-                SessionId = _sessionId,
-                UpsamplerManager = _upsamplerManager
-            };
-        }
-
-        public int GetSessionId()
-        {
-            return _sessionId;
-        }
-
-        public static ulong GetWorkBufferSize(ref AudioRendererConfiguration parameter)
-        {
-            BehaviourContext behaviourContext = new BehaviourContext();
-
-            behaviourContext.SetUserRevision(parameter.Revision);
-
-            uint mixesCount = parameter.SubMixBufferCount + 1;
-
-            uint memoryPoolCount = parameter.EffectCount + parameter.VoiceCount * Constants.VoiceWaveBufferCount;
-
-            ulong size = 0;
-
-            // Mix Buffers
-            size = WorkBufferAllocator.GetTargetSize<float>(size, parameter.SampleCount * (Constants.VoiceChannelCountMax + parameter.MixBufferCount), 0x10);
-
-            // Upsampler workbuffer
-            size = WorkBufferAllocator.GetTargetSize<float>(size, Constants.TargetSampleCount * (Constants.VoiceChannelCountMax + parameter.MixBufferCount) * (parameter.SinkCount + parameter.SubMixBufferCount), 0x10);
-
-            // Depop buffer
-            size = WorkBufferAllocator.GetTargetSize<float>(size, BitUtils.AlignUp<ulong>(parameter.MixBufferCount, Constants.BufferAlignment), Constants.BufferAlignment);
-
-            // Voice
-            size = WorkBufferAllocator.GetTargetSize<VoiceState>(size, parameter.VoiceCount, VoiceState.Alignment);
-            size = WorkBufferAllocator.GetTargetSize<int>(size, parameter.VoiceCount, 0x10);
-            size = WorkBufferAllocator.GetTargetSize<VoiceChannelResource>(size, parameter.VoiceCount, VoiceChannelResource.Alignment);
-            size = WorkBufferAllocator.GetTargetSize<VoiceUpdateState>(size, parameter.VoiceCount, VoiceUpdateState.Align);
-
-            // Mix
-            size = WorkBufferAllocator.GetTargetSize<MixState>(size, mixesCount, MixState.Alignment);
-            size = WorkBufferAllocator.GetTargetSize<int>(size, parameter.EffectCount * mixesCount, 0x10);
-            size = WorkBufferAllocator.GetTargetSize<int>(size, mixesCount, 0x10);
-
-            if (behaviourContext.IsSplitterSupported())
-            {
-                size += (ulong)BitUtils.AlignUp(NodeStates.GetWorkBufferSize((int)mixesCount) + EdgeMatrix.GetWorkBufferSize((int)mixesCount), 0x10);
-            }
-
-            // Memory Pool
-            size = WorkBufferAllocator.GetTargetSize<MemoryPoolState>(size, memoryPoolCount, MemoryPoolState.Alignment);
-
-            // Splitter
-            size = SplitterContext.GetWorkBufferSize(size, ref behaviourContext, ref parameter);
-
-            // DSP Voice
-            size = WorkBufferAllocator.GetTargetSize<VoiceUpdateState>(size, parameter.VoiceCount, VoiceUpdateState.Align);
-
-            // Performance
-            if (parameter.PerformanceMetricFramesCount > 0)
-            {
-                ulong performanceMetricsPerFramesSize = PerformanceManager.GetRequiredBufferSizeForPerformanceMetricsPerFrame(ref parameter, ref behaviourContext) * (parameter.PerformanceMetricFramesCount + 1) + 0xC;
-
-                size += BitUtils.AlignUp<ulong>(performanceMetricsPerFramesSize, Constants.PerformanceMetricsPerFramesSizeAlignment);
-            }
-
-            return BitUtils.AlignUp<ulong>(size, Constants.WorkBufferAlignment);
-        }
-
-        public ResultCode QuerySystemEvent(out IWritableEvent systemEvent)
-        {
-            systemEvent = default;
-
-            if (_executionMode == AudioRendererExecutionMode.Manual)
-            {
-                return ResultCode.UnsupportedOperation;
-            }
-
-            systemEvent = _systemEvent;
-
-            return ResultCode.Success;
-        }
-
-        public void Dispose()
-        {
-            if (Interlocked.CompareExchange(ref _disposeState, 1, 0) == 0)
-            {
-                Dispose(true);
-            }
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                if (_isActive)
-                {
-                    Stop();
-                }
-
-                PoolMapper mapper = new PoolMapper(_processHandle, false);
-                mapper.Unmap(ref _dspMemoryPoolState);
-
-                PoolMapper.ClearUsageState(_memoryPools);
-
-                for (int i = 0; i < _memoryPoolCount; i++)
-                {
-                    ref MemoryPoolState memoryPool = ref _memoryPools.Span[i];
-
-                    if (memoryPool.IsMapped())
-                    {
-                        mapper.Unmap(ref memoryPool);
-                    }
-                }
-
-                _manager.Unregister(this);
-                _terminationEvent.Dispose();
-                _workBufferMemoryPin.Dispose();
-
-                if (MemoryManager is IRefCounted rc)
-                {
-                    rc.DecrementReferenceCount();
-
-                    MemoryManager = null;
-                }
-            }
-        }
-
-        public void SetVoiceDropParameter(float voiceDropParameter)
-        {
-            _voiceDropParameter = Math.Clamp(voiceDropParameter, 0.0f, 2.0f);
-        }
-
-        public float GetVoiceDropParameter()
-        {
-            return _voiceDropParameter;
-        }
-
-        public ResultCode ExecuteAudioRendererRendering()
-        {
-            if (_executionMode == AudioRendererExecutionMode.Manual && _renderingDevice == AudioRendererRenderingDevice.Cpu)
-            {
-                // NOTE: Here Nintendo aborts with this error code, we don't want that.
-                return ResultCode.InvalidExecutionContextOperation;
-            }
-
-            return ResultCode.UnsupportedOperation;
-        }
-    }
-}