Fix exception when trying to read output pointer buffer size (#6221)

* Fix exception when trying to read output pointer buffer size

* Better name

.editorconfig

@@ -1,19 +1,31 @@
 # Remove the line below if you want to inherit .editorconfig settings from higher directories
 root = true
 
-# C# files
-[*.cs]
+[*]
 
 #### Core EditorConfig Options ####
 
+# Set default charset
+charset = utf-8
+
 # Indentation and spacing
 indent_size = 4
 indent_style = space
 tab_width = 4
 
 # New line preferences
-end_of_line = crlf
-insert_final_newline = false
+end_of_line = lf
+insert_final_newline = true
+
+# Markdown, JSON, YAML, props and csproj files
+[*.{md,json,yml,props,csproj}]
+
+# Indentation and spacing
+indent_size = 2
+tab_width = 2
+
+# C# files
+[*.cs]
 
 #### .NET Coding Conventions ####
 
@@ -59,10 +71,14 @@ dotnet_style_prefer_simplified_interpolation = true:suggestion
 dotnet_style_readonly_field = true:suggestion
 
 # Parameter preferences
-dotnet_code_quality_unused_parameters = all:suggestion
+dotnet_code_quality_unused_parameters = all:silent
 
 #### 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
@@ -81,7 +97,7 @@ csharp_style_expression_bodied_properties = true:silent
 # Pattern matching preferences
 csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
 csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
-csharp_style_prefer_switch_expression = true:suggestion
+csharp_style_prefer_switch_expression = false:silent
 
 # Null-checking preferences
 csharp_style_conditional_delegate_call = true:suggestion
@@ -90,6 +106,7 @@ csharp_style_conditional_delegate_call = true:suggestion
 csharp_prefer_static_local_function = true:suggestion
 csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:silent
 csharp_style_prefer_readonly_struct = true
+csharp_style_prefer_method_group_conversion = true
 
 # Code-block preferences
 csharp_prefer_braces = true:silent
@@ -105,6 +122,7 @@ csharp_style_prefer_range_operator = true:suggestion
 csharp_style_throw_expression = true:suggestion
 csharp_style_unused_value_assignment_preference = discard_variable:suggestion
 csharp_style_unused_value_expression_statement_preference = discard_variable:silent
+csharp_style_implicit_object_creation_when_type_is_apparent = true
 
 # 'using' directive preferences
 csharp_using_directive_placement = outside_namespace:silent
@@ -136,7 +154,6 @@ csharp_space_after_dot = false
 csharp_space_after_keywords_in_control_flow_statements = true
 csharp_space_after_semicolon_in_for_statement = true
 csharp_space_around_binary_operators = before_and_after
-csharp_space_around_declaration_statements = false
 csharp_space_before_colon_in_inheritance_clause = true
 csharp_space_before_comma = false
 csharp_space_before_dot = false
@@ -154,23 +171,31 @@ csharp_space_between_square_brackets = false
 
 # Wrapping preferences
 csharp_preserve_single_line_blocks = true
-csharp_preserve_single_line_statements = true
+csharp_preserve_single_line_statements = false
 
 #### Naming styles ####
 
 # Naming rules
 
-dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion
-dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
-dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
+dotnet_naming_rule.interfaces_should_be_prefixed_with_I.severity = suggestion
+dotnet_naming_rule.interfaces_should_be_prefixed_with_I.symbols = interface
+dotnet_naming_rule.interfaces_should_be_prefixed_with_I.style = IPascalCase
 
 dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion
 dotnet_naming_rule.types_should_be_pascal_case.symbols = types
-dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
+dotnet_naming_rule.types_should_be_pascal_case.style = PascalCase
 
 dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion
 dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
-dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
+dotnet_naming_rule.non_field_members_should_be_pascal_case.style = PascalCase
+
+dotnet_naming_rule.private_static_readonly_fields_should_be_camel_case_and_prefixed_with__.symbols = private_static_readonly_fields
+dotnet_naming_rule.private_static_readonly_fields_should_be_camel_case_and_prefixed_with__.severity = suggestion
+dotnet_naming_rule.private_static_readonly_fields_should_be_camel_case_and_prefixed_with__.style = _camelCase
+
+dotnet_naming_rule.local_constants_should_be_pascal_case.symbols = local_constants
+dotnet_naming_rule.local_constants_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.local_constants_should_be_pascal_case.style = PascalCase
 
 # Symbol specifications
 
@@ -186,14 +211,62 @@ dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, meth
 dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
 dotnet_naming_symbols.non_field_members.required_modifiers =
 
+dotnet_naming_symbols.private_static_readonly_fields.applicable_kinds = field
+dotnet_naming_symbols.private_static_readonly_fields.applicable_accessibilities = private
+dotnet_naming_symbols.private_static_readonly_fields.required_modifiers = static, readonly
+
+dotnet_naming_symbols.local_constants.applicable_kinds = local
+dotnet_naming_symbols.local_constants.applicable_accessibilities = local
+dotnet_naming_symbols.local_constants.required_modifiers = const
+
 # Naming styles
 
-dotnet_naming_style.pascal_case.required_prefix =
-dotnet_naming_style.pascal_case.required_suffix =
-dotnet_naming_style.pascal_case.word_separator =
-dotnet_naming_style.pascal_case.capitalization = pascal_case
+dotnet_naming_style._camelCase.required_prefix = _
+dotnet_naming_style._camelCase.required_suffix =
+dotnet_naming_style._camelCase.word_separator =
+dotnet_naming_style._camelCase.capitalization = camel_case
 
-dotnet_naming_style.begins_with_i.required_prefix = I
-dotnet_naming_style.begins_with_i.required_suffix =
-dotnet_naming_style.begins_with_i.word_separator =
-dotnet_naming_style.begins_with_i.capitalization = pascal_case
+dotnet_naming_style.PascalCase.required_prefix =
+dotnet_naming_style.PascalCase.required_suffix =
+dotnet_naming_style.PascalCase.word_separator =
+dotnet_naming_style.PascalCase.capitalization = pascal_case
+
+dotnet_naming_style.IPascalCase.required_prefix = I
+dotnet_naming_style.IPascalCase.required_suffix =
+dotnet_naming_style.IPascalCase.word_separator =
+dotnet_naming_style.IPascalCase.capitalization = pascal_case
+
+# TODO:
+# .NET 8 migration (new warnings are caused by the NET 8 C# compiler and analyzer)
+# The following info messages might need to be fixed in the source code instead of hiding the actual message
+# Without the following lines, dotnet format would fail
+# Disable "Collection initialization can be simplified"
+dotnet_diagnostic.IDE0028.severity = none
+dotnet_diagnostic.IDE0300.severity = none
+dotnet_diagnostic.IDE0301.severity = none
+dotnet_diagnostic.IDE0302.severity = none
+dotnet_diagnostic.IDE0305.severity = none
+# Disable "'new' expression can be simplified"
+dotnet_diagnostic.IDE0090.severity = none
+# Disable "Use primary constructor"
+dotnet_diagnostic.IDE0290.severity = none
+# Disable "Member '' does not access instance data and can be marked as static"
+dotnet_diagnostic.CA1822.severity = none
+# Disable "Change type of field '' from '' to '' for improved performance"
+dotnet_diagnostic.CA1859.severity = none
+# Disable "Prefer 'static readonly' fields over constant array arguments if the called method is called repeatedly and is not mutating the passed array"
+dotnet_diagnostic.CA1861.severity = none
+# Disable "Prefer using 'string.Equals(string, StringComparison)' to perform a case-insensitive comparison, but keep in mind that this might cause subtle changes in behavior, so make sure to conduct thorough testing after applying the suggestion, or if culturally sensitive comparison is not required, consider using 'StringComparison.OrdinalIgnoreCase'"
+dotnet_diagnostic.CA1862.severity = none
+
+[src/Ryujinx.HLE/HOS/Services/**.cs]
+# Disable "mark members as static" rule for services
+dotnet_diagnostic.CA1822.severity = none
+
+[src/Ryujinx.Ava/UI/ViewModels/**.cs]
+# Disable "mark members as static" rule for ViewModels
+dotnet_diagnostic.CA1822.severity = none
+
+[src/Ryujinx.Tests/Cpu/*.cs]
+# Disable naming rules for CPU tests
+dotnet_diagnostic.IDE1006.severity = none

.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/csc.json

@@ -0,0 +1,18 @@
+{
+    "problemMatcher": [
+        {
+            "owner": "csc",
+            "pattern": [
+                {
+                    "regexp": "^((?:\\\\|/)(?:[^\\\\/:]+(?:\\\\|/))+[^\\\\/]+)\\((\\d+),(\\d+)\\):\\s+([a-zA-Z]+)\\s+([^:]+):\\s+([^[]+)\\s+\\[",
+                    "file": 1,
+                    "line": 2,
+                    "column": 3,
+                    "severity": 4,
+                    "code": 5,
+                    "message": 6
+                }
+            ]
+        }
+    ]
+}

.github/dependabot.yml

@@ -13,7 +13,7 @@ updates:
 
   - package-ecosystem: nuget
     directory: /
-    open-pull-requests-limit: 5
+    open-pull-requests-limit: 10
     schedule:
       interval: daily
     labels:
@@ -22,3 +22,19 @@ updates:
       - marysaka
     commit-message:
       prefix: nuget
+    groups:
+      Avalonia:
+        patterns:
+          - "*Avalonia*"
+      Silk.NET:
+        patterns:
+          - "Silk.NET*"
+      OpenTK:
+        patterns:
+          - "OpenTK*"
+      SixLabors:
+        patterns:
+          - "SixLabors*"
+      NUnit:
+        patterns:
+          - "NUnit*"

.github/labeler.yml

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

.github/reviewers.yml

@@ -0,0 +1,32 @@
+audio:
+  - marysaka
+
+cpu:
+  - gdkchan
+  - riperiperi
+  - marysaka
+  - LDj3SNuD
+
+gpu:
+  - gdkchan
+  - riperiperi
+  - marysaka
+
+gui:
+  - Ack77
+  - emmauss
+  - TSRBerry
+  - marysaka
+
+horizon:
+  - gdkchan
+  - Ack77
+  - marysaka
+  - TSRBerry
+
+infra:
+  - marysaka
+  - TSRBerry
+
+default:
+  - '@developers'

.github/workflows/build.yml

@@ -1,27 +1,18 @@
 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/**'
-      - '*.yml'
-      - 'README.md'
+  workflow_call:
+
+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,57 +24,150 @@ 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
 
         - os: windows-latest
           OS_NAME: Windows x64
-          DOTNET_RUNTIME_IDENTIFIER: win10-x64
+          DOTNET_RUNTIME_IDENTIFIER: win-x64
           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
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 7.0.x
+          global-json-file: global.json
+
+      - name: Overwrite csc problem matcher
+        run: echo "::add-matcher::.github/csc.json"
+
       - name: Get git short hash
         id: git_short_hash
         run: echo "result=$(git rev-parse --short "${{ github.sha }}")" >> $GITHUB_OUTPUT
         shell: bash
+
+      - name: Change config filename
+        run: sed -r --in-place 's/\%\%RYUJINX_CONFIG_FILE_NAME\%\%/PRConfig\.json/g;' src/Ryujinx.Common/ReleaseInformation.cs
+        shell: bash
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
+      - name: Change config filename for macOS
+        run: sed -r -i '' 's/\%\%RYUJINX_CONFIG_FILE_NAME\%\%/PRConfig\.json/g;' src/Ryujinx.Common/ReleaseInformation.cs
+        shell: bash
+        if: github.event_name == 'pull_request' && matrix.os == 'macOS-latest'
+
       - 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 }}"
+        uses: TSRBerry/unstable-commands@v1
+        with:
+          commands: dotnet test --no-build -c "${{ matrix.configuration }}"
+          timeout-minutes: 10
+          retry-codes: 139
+
       - 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
+        uses: actions/upload-artifact@v4
         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
+        uses: actions/upload-artifact@v4
         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
+        uses: actions/upload-artifact@v4
         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' && 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@v4
+
+      - uses: actions/setup-dotnet@v4
+        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: Change config filename
+        run: sed -r --in-place 's/\%\%RYUJINX_CONFIG_FILE_NAME\%\%/PRConfig\.json/g;' src/Ryujinx.Common/ReleaseInformation.cs
+        shell: bash
+        if: github.event_name == 'pull_request'
+
+      - name: Publish macOS Ryujinx.Ava
+        run: |
+          ./distribution/macos/create_macos_build_ava.sh . publish_tmp_ava publish_ava ./distribution/macos/entitlements.xml "${{ env.RYUJINX_BASE_VERSION }}" "${{ steps.git_short_hash.outputs.result }}" "${{ matrix.configuration }}" "-p:ExtraDefineConstants=DISABLE_UPDATER"
+
+      - name: Publish macOS Ryujinx.Headless.SDL2
+        run: |
+          ./distribution/macos/create_macos_build_headless.sh . publish_tmp_headless publish_headless ./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@v4
+        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'
+
+      - name: Upload Ryujinx.Headless.SDL2 artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: sdl2-ryujinx-headless-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-macos_universal
+          path: "publish_headless/*.tar.gz"
         if: github.event_name == 'pull_request'

.github/workflows/checks.yml

@@ -0,0 +1,74 @@
+name: Perform checks
+
+on:
+  pull_request:
+    branches: [ master ]
+    paths:
+      - '**'
+      - '!.github/**'
+      - '!*.yml'
+      - '!*.config'
+      - '!*.md'
+      - '.github/workflows/*.yml'
+
+permissions:
+  pull-requests: write
+  checks: write
+
+concurrency:
+  group: pr-checks-${{ github.event.number }}
+  cancel-in-progress: true
+
+jobs:
+  format:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-dotnet@v4
+        with:
+          global-json-file: global.json
+
+      - name: Overwrite csc problem matcher
+        run: echo "::add-matcher::.github/csc.json"
+
+      - run: dotnet restore
+
+      - name: Print dotnet format version
+        run: dotnet format --version
+
+      - name: Run dotnet format whitespace
+        run: |
+          dotnet format whitespace --verify-no-changes --report ./whitespace-report.json -v d
+
+      # For some unknown reason this step sometimes fails with exit code 139 (segfault?),
+      # so in that case we'll try again (3 tries max).
+      - name: Run dotnet format style
+        uses: TSRBerry/unstable-commands@v1
+        with:
+          commands: dotnet format style --severity info --verify-no-changes --report ./style-report.json -v d
+          timeout-minutes: 5
+          retry-codes: 139
+
+      # For some unknown reason this step sometimes fails with exit code 139 (segfault?),
+      # so in that case we'll try again (3 tries max).
+      - name: Run dotnet format analyzers
+        uses: TSRBerry/unstable-commands@v1
+        with:
+          commands: dotnet format analyzers --severity info --verify-no-changes --report ./analyzers-report.json -v d
+          timeout-minutes: 5
+          retry-codes: 139
+
+      - name: Upload report
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: dotnet-format
+          path: ./*-report.json
+
+  pr_build:
+    uses: ./.github/workflows/build.yml
+    needs: format
+    secrets: inherit

.github/workflows/flatpak.yml

@@ -12,22 +12,23 @@ 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: "Ryujinx/Ryujinx.csproj"
+      RYUJINX_PROJECT_FILE: "src/Ryujinx/Ryujinx.csproj"
       NUGET_SOURCES_DESTDIR: "nuget-sources"
       RYUJINX_VERSION: "${{ inputs.ryujinx_version }}"
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           path: Ryujinx
 
-      - uses: actions/setup-dotnet@v3
+      - uses: actions/setup-dotnet@v4
         with:
           global-json-file: Ryujinx/global.json
 
@@ -37,7 +38,7 @@ jobs:
         run: |
           echo "git_hash=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           repository: flathub/org.ryujinx.Ryujinx
           token: ${{ secrets.RYUJINX_BOT_PAT }}
@@ -48,7 +49,9 @@ jobs:
         run: python -m pip install PyYAML lxml
 
       - name: Restore Nuget packages
-        run: dotnet restore Ryujinx/${{ env.RYUJINX_PROJECT_FILE }}
+        # With .NET 8.0.100, Microsoft.NET.ILLink.Tasks isn't restored by default and only seems to appears when publishing.
+        # So we just publish to grab the dependencies
+        run: dotnet publish -c Release -r linux-x64 Ryujinx/${{ env.RYUJINX_PROJECT_FILE }} --self-contained
 
       - name: Generate nuget_sources.json
         shell: python
@@ -168,4 +171,4 @@ jobs:
           git config user.email "${{ env.GIT_COMMITTER_EMAIL }}"
           git add .
           git commit -m "$COMMIT_MESSAGE"
-          git push origin master
+          git push origin master

.github/workflows/mako.yml

@@ -0,0 +1,41 @@
+name: Mako
+on:
+  discussion:
+    types: [created, edited, answered, unanswered, category_changed]
+  discussion_comment:
+    types: [created, edited]
+  gollum:
+  issue_comment:
+    types: [created, edited]
+  issues:
+    types: [opened, edited, reopened, pinned, milestoned, demilestoned, assigned, unassigned, labeled, unlabeled]
+  pull_request_target:
+    types: [opened, edited, reopened, synchronize, ready_for_review, assigned, unassigned]
+
+jobs:
+  tasks:
+    name: Run Ryujinx tasks
+    permissions:
+      actions: read
+      contents: read
+      discussions: write
+      issues: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        if: github.event_name == 'pull_request_target'
+        with:
+          # Ensure we pin the source origin as pull_request_target run under forks.
+          fetch-depth: 0
+          repository: Ryujinx/Ryujinx
+          ref: master
+
+      - name: Run Mako command
+        uses: Ryujinx/Ryujinx-Mako@master
+        with:
+          command: exec-ryujinx-tasks
+          args: --event-name "${{ github.event_name }}" --event-path "${{ github.event_path }}" -w "${{ github.workspace }}" "${{ github.repository }}" "${{ github.run_id }}"
+          app_id: ${{ secrets.MAKO_APP_ID }}
+          private_key: ${{ secrets.MAKO_PRIVATE_KEY }}
+          installation_id: ${{ secrets.MAKO_INSTALLATION_ID }}

.github/workflows/nightly_pr_comment.yml

@@ -1,12 +1,15 @@
 name: Comment PR artifacts links
+
 on:
   workflow_run:
-    workflows: ['Build job']
+    workflows: ['Perform checks']
     types: [completed]
+
 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 +68,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,28 @@
+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:
+      # Grab sources to get latest labeler.yml
+      - name: Fetch sources
+        uses: actions/checkout@v4
+        with:
+           # Ensure we pin the source origin as pull_request_target run under forks.
+           fetch-depth: 0
+           repository: Ryujinx/Ryujinx
+           ref: master
+
+      - name: Update labels based on changes
+        uses: actions/labeler@v5
+        with:
+          sync-labels: true
+          dot: true

.github/workflows/release.yml

@@ -6,10 +6,11 @@ on:
   push:
     branches: [ master ]
     paths-ignore:
-      - '.github/*'
-      - '.github/ISSUE_TEMPLATE/**'
+      - '.github/**'
       - '*.yml'
-      - 'README.md'
+      - '*.json'
+      - '*.config'
+      - '*.md'
 
 concurrency: release
 
@@ -22,79 +23,112 @@ env:
   RYUJINX_TARGET_RELEASE_CHANNEL_REPO: "release-channel-master"
 
 jobs:
-  release:
-    runs-on: windows-latest
+  tag:
+    name: Create tag
+    runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-dotnet@v3
+      - 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:
+    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: win-x64
+            RELEASE_ZIP_OS_NAME: win_x64
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-dotnet@v4
         with:
           global-json-file: global.json
+          
+      - name: Overwrite csc problem matcher
+        run: echo "::add-matcher::.github/csc.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
+          sed -r --in-place 's/\%\%RYUJINX_CONFIG_FILE_NAME\%\%/Config\.json/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
 
@@ -104,9 +138,75 @@ 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
+          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@v4
+
+      - uses: actions/setup-dotnet@v4
+        with:
+          global-json-file: global.json
+
+      - name: Setup LLVM 15
+        run: |
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 15
+
+      - 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
+          sed -r --in-place 's/\%\%RYUJINX_CONFIG_FILE_NAME\%\%/Config\.json/g;' src/Ryujinx.Common/ReleaseInformation.cs
+        shell: bash
+
+      - name: Publish macOS Ryujinx.Ava
+        run: |
+          ./distribution/macos/create_macos_build_ava.sh . publish_tmp_ava publish_ava ./distribution/macos/entitlements.xml "${{ steps.version_info.outputs.build_version }}" "${{ steps.version_info.outputs.git_short_hash }}" Release
+          
+      - name: Publish macOS Ryujinx.Headless.SDL2
+        run: |
+          ./distribution/macos/create_macos_build_headless.sh . publish_tmp_headless publish_headless ./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, publish_headless/*.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
-          removeArtifacts: true
           replacesArtifacts: true
           owner: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}
           repo: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}

ARMeilleure/CodeGen/Arm64/ArmCondition.cs

@@ -1,47 +0,0 @@
-using ARMeilleure.IntermediateRepresentation;
-using System;
-
-namespace ARMeilleure.CodeGen.Arm64
-{
-    enum ArmCondition
-    {
-        Eq   = 0,
-        Ne   = 1,
-        GeUn = 2,
-        LtUn = 3,
-        Mi   = 4,
-        Pl   = 5,
-        Vs   = 6,
-        Vc   = 7,
-        GtUn = 8,
-        LeUn = 9,
-        Ge   = 10,
-        Lt   = 11,
-        Gt   = 12,
-        Le   = 13,
-        Al   = 14,
-        Nv   = 15
-    }
-
-    static class ComparisonArm64Extensions
-    {
-        public static ArmCondition ToArmCondition(this Comparison comp)
-        {
-            return comp switch
-            {
-                Comparison.Equal            => ArmCondition.Eq,
-                Comparison.NotEqual         => ArmCondition.Ne,
-                Comparison.Greater          => ArmCondition.Gt,
-                Comparison.LessOrEqual      => ArmCondition.Le,
-                Comparison.GreaterUI        => ArmCondition.GtUn,
-                Comparison.LessOrEqualUI    => ArmCondition.LeUn,
-                Comparison.GreaterOrEqual   => ArmCondition.Ge,
-                Comparison.Less             => ArmCondition.Lt,
-                Comparison.GreaterOrEqualUI => ArmCondition.GeUn,
-                Comparison.LessUI           => ArmCondition.LtUn,
-
-                _ => throw new ArgumentException(null, nameof(comp))
-            };
-        }
-    }
-}

ARMeilleure/CodeGen/Arm64/ArmExtensionType.cs

@@ -1,14 +0,0 @@
-namespace ARMeilleure.CodeGen.Arm64
-{
-    enum ArmExtensionType
-    {
-        Uxtb = 0,
-        Uxth = 1,
-        Uxtw = 2,
-        Uxtx = 3,
-        Sxtb = 4,
-        Sxth = 5,
-        Sxtw = 6,
-        Sxtx = 7
-    }
-}

ARMeilleure/CodeGen/Arm64/ArmShiftType.cs

@@ -1,11 +0,0 @@
-
-namespace ARMeilleure.CodeGen.Arm64
-{
-    enum ArmShiftType
-    {
-        Lsl = 0,
-        Lsr = 1,
-        Asr = 2,
-        Ror = 3
-    }
-}

ARMeilleure/CodeGen/Arm64/CallingConvention.cs

@@ -1,96 +0,0 @@
-using System;
-
-namespace ARMeilleure.CodeGen.Arm64
-{
-    static class CallingConvention
-    {
-        private const int RegistersMask = unchecked((int)0xffffffff);
-
-        // Some of those register have specific roles and can't be used as general purpose registers.
-        // X18 - Reserved for platform specific usage.
-        // X29 - Frame pointer.
-        // X30 - Return address.
-        // X31 - Not an actual register, in some cases maps to SP, and in others to ZR.
-        private const int ReservedRegsMask = (1 << CodeGenCommon.ReservedRegister) | (1 << 18) | (1 << 29) | (1 << 30) | (1 << 31);
-
-        public static int GetIntAvailableRegisters()
-        {
-            return RegistersMask & ~ReservedRegsMask;
-        }
-
-        public static int GetVecAvailableRegisters()
-        {
-            return RegistersMask;
-        }
-
-        public static int GetIntCallerSavedRegisters()
-        {
-            return (GetIntCalleeSavedRegisters() ^ RegistersMask) & ~ReservedRegsMask;
-        }
-
-        public static int GetFpCallerSavedRegisters()
-        {
-            return GetFpCalleeSavedRegisters() ^ RegistersMask;
-        }
-
-        public static int GetVecCallerSavedRegisters()
-        {
-            return GetVecCalleeSavedRegisters() ^ RegistersMask;
-        }
-
-        public static int GetIntCalleeSavedRegisters()
-        {
-            return 0x1ff80000; // X19 to X28
-        }
-
-        public static int GetFpCalleeSavedRegisters()
-        {
-            return 0xff00; // D8 to D15
-        }
-
-        public static int GetVecCalleeSavedRegisters()
-        {
-            return 0;
-        }
-
-        public static int GetArgumentsOnRegsCount()
-        {
-            return 8;
-        }
-
-        public static int GetIntArgumentRegister(int index)
-        {
-            if ((uint)index < (uint)GetArgumentsOnRegsCount())
-            {
-                return index;
-            }
-
-            throw new ArgumentOutOfRangeException(nameof(index));
-        }
-
-        public static int GetVecArgumentRegister(int index)
-        {
-            if ((uint)index < (uint)GetArgumentsOnRegsCount())
-            {
-                return index;
-            }
-
-            throw new ArgumentOutOfRangeException(nameof(index));
-        }
-
-        public static int GetIntReturnRegister()
-        {
-            return 0;
-        }
-
-        public static int GetIntReturnRegisterHigh()
-        {
-            return 1;
-        }
-
-        public static int GetVecReturnRegister()
-        {
-            return 0;
-        }
-    }
-}

ARMeilleure/CodeGen/Arm64/CodeGenCommon.cs

@@ -1,91 +0,0 @@
-using ARMeilleure.IntermediateRepresentation;
-using System.Numerics;
-
-namespace ARMeilleure.CodeGen.Arm64
-{
-    static class CodeGenCommon
-    {
-        public const int TcAddressRegister = 8;
-        public const int ReservedRegister = 17;
-
-        public static bool ConstFitsOnSImm7(int value, int scale)
-        {
-            return (((value >> scale) << 25) >> (25 - scale)) == value;
-        }
-
-        public static bool ConstFitsOnSImm9(int value)
-        {
-            return ((value << 23) >> 23) == value;
-        }
-
-        public static bool ConstFitsOnUImm12(int value)
-        {
-            return (value & 0xfff) == value;
-        }
-
-        public static bool ConstFitsOnUImm12(int value, OperandType type)
-        {
-            int scale = Assembler.GetScaleForType(type);
-            return (((value >> scale) & 0xfff) << scale) == value;
-        }
-
-        public static bool TryEncodeBitMask(Operand operand, out int immN, out int immS, out int immR)
-        {
-            return TryEncodeBitMask(operand.Type, operand.Value, out immN, out immS, out immR);
-        }
-
-        public static bool TryEncodeBitMask(OperandType type, ulong value, out int immN, out int immS, out int immR)
-        {
-            if (type == OperandType.I32)
-            {
-                value |= value << 32;
-            }
-
-            return TryEncodeBitMask(value, out immN, out immS, out immR);
-        }
-
-        public static bool TryEncodeBitMask(ulong value, out int immN, out int immS, out int immR)
-        {
-            // Some special values also can't be encoded:
-            // 0 can't be encoded because we need to subtract 1 from onesCount (which would became negative if 0).
-            // A value with all bits set can't be encoded because it is reserved according to the spec, because:
-            // Any value AND all ones will be equal itself, so it's effectively a no-op.
-            // Any value OR all ones will be equal all ones, so one can just use MOV.
-            // Any value XOR all ones will be equal its inverse, so one can just use MVN.
-            if (value == 0 || value == ulong.MaxValue)
-            {
-                immN = 0;
-                immS = 0;
-                immR = 0;
-
-                return false;
-            }
-
-            // Normalize value, rotating it such that the LSB is 1: Ensures we get a complete element that has not
-            // been cut-in-half across the word boundary.
-            int rotation = BitOperations.TrailingZeroCount(value & (value + 1));
-            ulong rotatedValue = ulong.RotateRight(value, rotation);
-
-            // Now that we have a complete element in the LSB with the LSB = 1, determine size and number of ones
-            // in element.
-            int elementSize = BitOperations.TrailingZeroCount(rotatedValue & (rotatedValue + 1));
-            int onesInElement = BitOperations.TrailingZeroCount(~rotatedValue);
-
-            // Check the value is repeating; also ensures element size is a power of two.
-            if (ulong.RotateRight(value, elementSize) != value)
-            {
-                immN = 0;
-                immS = 0;
-                immR = 0;
-
-                return false;
-            }
-
-            immN = (elementSize >> 6) & 1;
-            immS = (((~elementSize + 1) << 1) | (onesInElement - 1)) & 0x3f;
-            immR = (elementSize - rotation) & (elementSize - 1);
-
-            return true;
-        }
-    }
-}

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(Array.Empty<RelocEntry>());
-            }
-
-            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/HardwareCapabilities.cs

@@ -1,185 +0,0 @@
-using System;
-using System.Linq;
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics.Arm;
-using System.Runtime.Versioning;
-
-namespace ARMeilleure.CodeGen.Arm64
-{
-    static partial class HardwareCapabilities
-    {
-        static HardwareCapabilities()
-        {
-            if (!ArmBase.Arm64.IsSupported)
-            {
-                return;
-            }
-
-            if (OperatingSystem.IsLinux())
-            {
-                LinuxFeatureInfoHwCap = (LinuxFeatureFlagsHwCap)getauxval(AT_HWCAP);
-                LinuxFeatureInfoHwCap2 = (LinuxFeatureFlagsHwCap2)getauxval(AT_HWCAP2);
-            }
-
-            if (OperatingSystem.IsMacOS())
-            {
-                for (int i = 0; i < _sysctlNames.Length; i++)
-                {
-                    if (CheckSysctlName(_sysctlNames[i]))
-                    {
-                        MacOsFeatureInfo |= (MacOsFeatureFlags)(1 << i);
-                    }
-                }
-            }
-        }
-
-#region Linux
-
-        private const ulong AT_HWCAP = 16;
-        private const ulong AT_HWCAP2 = 26;
-
-        [LibraryImport("libc", SetLastError = true)]
-        private static partial ulong getauxval(ulong type);
-
-        [Flags]
-        public enum LinuxFeatureFlagsHwCap : ulong
-        {
-            Fp        = 1 << 0,
-            Asimd     = 1 << 1,
-            Evtstrm   = 1 << 2,
-            Aes       = 1 << 3,
-            Pmull     = 1 << 4,
-            Sha1      = 1 << 5,
-            Sha2      = 1 << 6,
-            Crc32     = 1 << 7,
-            Atomics   = 1 << 8,
-            FpHp      = 1 << 9,
-            AsimdHp   = 1 << 10,
-            CpuId     = 1 << 11,
-            AsimdRdm  = 1 << 12,
-            Jscvt     = 1 << 13,
-            Fcma      = 1 << 14,
-            Lrcpc     = 1 << 15,
-            DcpOp     = 1 << 16,
-            Sha3      = 1 << 17,
-            Sm3       = 1 << 18,
-            Sm4       = 1 << 19,
-            AsimdDp   = 1 << 20,
-            Sha512    = 1 << 21,
-            Sve       = 1 << 22,
-            AsimdFhm  = 1 << 23,
-            Dit       = 1 << 24,
-            Uscat     = 1 << 25,
-            Ilrcpc    = 1 << 26,
-            FlagM     = 1 << 27,
-            Ssbs      = 1 << 28,
-            Sb        = 1 << 29,
-            Paca      = 1 << 30,
-            Pacg      = 1UL << 31
-        }
-
-        [Flags]
-        public enum LinuxFeatureFlagsHwCap2 : ulong
-        {
-            Dcpodp      = 1 << 0,
-            Sve2        = 1 << 1,
-            SveAes      = 1 << 2,
-            SvePmull    = 1 << 3,
-            SveBitperm  = 1 << 4,
-            SveSha3     = 1 << 5,
-            SveSm4      = 1 << 6,
-            FlagM2      = 1 << 7,
-            Frint       = 1 << 8,
-            SveI8mm     = 1 << 9,
-            SveF32mm    = 1 << 10,
-            SveF64mm    = 1 << 11,
-            SveBf16     = 1 << 12,
-            I8mm        = 1 << 13,
-            Bf16        = 1 << 14,
-            Dgh         = 1 << 15,
-            Rng         = 1 << 16,
-            Bti         = 1 << 17,
-            Mte         = 1 << 18,
-            Ecv         = 1 << 19,
-            Afp         = 1 << 20,
-            Rpres       = 1 << 21,
-            Mte3        = 1 << 22,
-            Sme         = 1 << 23,
-            Sme_i16i64  = 1 << 24,
-            Sme_f64f64  = 1 << 25,
-            Sme_i8i32   = 1 << 26,
-            Sme_f16f32  = 1 << 27,
-            Sme_b16f32  = 1 << 28,
-            Sme_f32f32  = 1 << 29,
-            Sme_fa64    = 1 << 30,
-            Wfxt        = 1UL << 31,
-            Ebf16       = 1UL << 32,
-            Sve_Ebf16   = 1UL << 33,
-            Cssc        = 1UL << 34,
-            Rprfm       = 1UL << 35,
-            Sve2p1      = 1UL << 36
-        }
-
-        public static LinuxFeatureFlagsHwCap LinuxFeatureInfoHwCap { get; } = 0;
-        public static LinuxFeatureFlagsHwCap2 LinuxFeatureInfoHwCap2 { get; } = 0;
-
-#endregion
-
-#region macOS
-
-        [LibraryImport("libSystem.dylib", SetLastError = true)]
-        private static unsafe partial int sysctlbyname([MarshalAs(UnmanagedType.LPStr)] string name, out int oldValue, ref ulong oldSize, IntPtr newValue, ulong newValueSize);
-
-        [SupportedOSPlatform("macos")]
-        private static bool CheckSysctlName(string name)
-        {
-            ulong size = sizeof(int);
-            if (sysctlbyname(name, out int val, ref size, IntPtr.Zero, 0) == 0 && size == sizeof(int))
-            {
-                return val != 0;
-            }
-            return false;
-        }
-
-        private static string[] _sysctlNames = new string[]
-        {
-            "hw.optional.floatingpoint",
-            "hw.optional.AdvSIMD",
-            "hw.optional.arm.FEAT_FP16",
-            "hw.optional.arm.FEAT_AES",
-            "hw.optional.arm.FEAT_PMULL",
-            "hw.optional.arm.FEAT_LSE",
-            "hw.optional.armv8_crc32",
-            "hw.optional.arm.FEAT_SHA1",
-            "hw.optional.arm.FEAT_SHA256"
-        };
-
-        [Flags]
-        public enum MacOsFeatureFlags
-        {
-            Fp      = 1 << 0,
-            AdvSimd = 1 << 1,
-            Fp16    = 1 << 2,
-            Aes     = 1 << 3,
-            Pmull   = 1 << 4,
-            Lse     = 1 << 5,
-            Crc32   = 1 << 6,
-            Sha1    = 1 << 7,
-            Sha256  = 1 << 8
-        }
-
-        public static MacOsFeatureFlags MacOsFeatureInfo { get; } = 0;
-
-#endregion
-
-        public static bool SupportsAdvSimd => LinuxFeatureInfoHwCap.HasFlag(LinuxFeatureFlagsHwCap.Asimd) || MacOsFeatureInfo.HasFlag(MacOsFeatureFlags.AdvSimd);
-        public static bool SupportsAes => LinuxFeatureInfoHwCap.HasFlag(LinuxFeatureFlagsHwCap.Aes) || MacOsFeatureInfo.HasFlag(MacOsFeatureFlags.Aes);
-        public static bool SupportsPmull => LinuxFeatureInfoHwCap.HasFlag(LinuxFeatureFlagsHwCap.Pmull) || MacOsFeatureInfo.HasFlag(MacOsFeatureFlags.Pmull);
-        public static bool SupportsLse => LinuxFeatureInfoHwCap.HasFlag(LinuxFeatureFlagsHwCap.Atomics) || MacOsFeatureInfo.HasFlag(MacOsFeatureFlags.Lse);
-        public static bool SupportsCrc32 => LinuxFeatureInfoHwCap.HasFlag(LinuxFeatureFlagsHwCap.Crc32) || MacOsFeatureInfo.HasFlag(MacOsFeatureFlags.Crc32);
-        public static bool SupportsSha1 => LinuxFeatureInfoHwCap.HasFlag(LinuxFeatureFlagsHwCap.Sha1) || MacOsFeatureInfo.HasFlag(MacOsFeatureFlags.Sha1);
-        public static bool SupportsSha256 => LinuxFeatureInfoHwCap.HasFlag(LinuxFeatureFlagsHwCap.Sha2) || MacOsFeatureInfo.HasFlag(MacOsFeatureFlags.Sha256);
-    }
-}

ARMeilleure/CodeGen/Arm64/IntrinsicInfo.cs

@@ -1,14 +0,0 @@
-namespace ARMeilleure.CodeGen.Arm64
-{
-    struct IntrinsicInfo
-    {
-        public uint          Inst { get; }
-        public IntrinsicType Type { get; }
-
-        public IntrinsicInfo(uint inst, IntrinsicType type)
-        {
-            Inst = inst;
-            Type = type;
-        }
-    }
-}

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,892 +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
-{
-    static 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;
-                    }
-
-                    InsertConstantRegCopies(constants, block.Operations, node);
-                    InsertDestructiveRegCopies(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.
-                            InsertCallCopies(constants, block.Operations, node);
-                            break;
-                        case Instruction.CompareAndSwap:
-                        case Instruction.CompareAndSwap16:
-                        case Instruction.CompareAndSwap8:
-                            nextNode = GenerateCompareAndSwap(block.Operations, node);
-                            break;
-                        case Instruction.LoadArgument:
-                            nextNode = InsertLoadArgumentCopy(cctx, ref buffer, block.Operations, preservedArgs, node);
-                            break;
-                        case Instruction.Return:
-                            InsertReturnCopy(block.Operations, node);
-                            break;
-                        case Instruction.Tailcall:
-                            InsertTailcallCopies(constants, block.Operations, stackAlloc, node, node);
-                            break;
-                    }
-                }
-            }
-        }
-
-        private static void InsertConstantRegCopies(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 InsertDestructiveRegCopies(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 InsertCallCopies(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);
-
-                    InsertConstantRegCopies(constants, nodes, nodes.AddBefore(node, copyOp));
-
-                    sources.Add(argReg);
-                }
-                else
-                {
-                    Operand offset = Const(stackOffset);
-
-                    Operation spillOp = Operation(Instruction.SpillArg, default, offset, source);
-
-                    InsertConstantRegCopies(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 InsertTailcallCopies(
-            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);
-
-                    InsertConstantRegCopies(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 GenerateCompareAndSwap(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 InsertReturnCopy(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 InsertLoadArgumentCopy(
-            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.
-                    PreAllocatorCommon.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 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/CompiledFunction.cs

@@ -1,68 +0,0 @@
-using ARMeilleure.CodeGen.Linking;
-using ARMeilleure.CodeGen.Unwinding;
-using ARMeilleure.Translation.Cache;
-using System;
-using System.Runtime.InteropServices;
-
-namespace ARMeilleure.CodeGen
-{
-    /// <summary>
-    /// Represents a compiled function.
-    /// </summary>
-    readonly struct CompiledFunction
-    {
-        /// <summary>
-        /// Gets the machine code of the <see cref="CompiledFunction"/>.
-        /// </summary>
-        public byte[] Code { get; }
-
-        /// <summary>
-        /// Gets the <see cref="Unwinding.UnwindInfo"/> of the <see cref="CompiledFunction"/>.
-        /// </summary>
-        public UnwindInfo UnwindInfo { get; }
-
-        /// <summary>
-        /// Gets the <see cref="Linking.RelocInfo"/> of the <see cref="CompiledFunction"/>.
-        /// </summary>
-        public RelocInfo RelocInfo { get; }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="CompiledFunction"/> struct with the specified machine code,
-        /// unwind info and relocation info.
-        /// </summary>
-        /// <param name="code">Machine code</param>
-        /// <param name="unwindInfo">Unwind info</param>
-        /// <param name="relocInfo">Relocation info</param>
-        internal CompiledFunction(byte[] code, UnwindInfo unwindInfo, RelocInfo relocInfo)
-        {
-            Code       = code;
-            UnwindInfo = unwindInfo;
-            RelocInfo  = relocInfo;
-        }
-
-        /// <summary>
-        /// Maps the <see cref="CompiledFunction"/> onto the <see cref="JitCache"/> and returns a delegate of type
-        /// <typeparamref name="T"/> pointing to the mapped function.
-        /// </summary>
-        /// <typeparam name="T">Type of delegate</typeparam>
-        /// <returns>A delegate of type <typeparamref name="T"/> pointing to the mapped function</returns>
-        public T Map<T>()
-        {
-            return MapWithPointer<T>(out _);
-        }
-
-        /// <summary>
-        /// Maps the <see cref="CompiledFunction"/> onto the <see cref="JitCache"/> and returns a delegate of type
-        /// <typeparamref name="T"/> pointing to the mapped function.
-        /// </summary>
-        /// <typeparam name="T">Type of delegate</typeparam>
-        /// <param name="codePointer">Pointer to the function code in memory</param>
-        /// <returns>A delegate of type <typeparamref name="T"/> pointing to the mapped function</returns>
-        public T MapWithPointer<T>(out IntPtr codePointer)
-        {
-            codePointer = JitCache.Map(this);
-
-            return Marshal.GetDelegateForFunctionPointer<T>(codePointer);
-        }
-    }
-}

ARMeilleure/CodeGen/Optimizations/ConstantFolding.cs

@@ -1,346 +0,0 @@
-using ARMeilleure.IntermediateRepresentation;
-using System;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.CodeGen.Optimizations
-{
-    static class ConstantFolding
-    {
-        public static void RunPass(Operation operation)
-        {
-            if (operation.Destination == default || operation.SourcesCount == 0)
-            {
-                return;
-            }
-
-            if (!AreAllSourcesConstant(operation))
-            {
-                return;
-            }
-
-            OperandType type = operation.Destination.Type;
-
-            switch (operation.Instruction)
-            {
-                case Instruction.Add:
-                    if (operation.GetSource(0).Relocatable ||
-                        operation.GetSource(1).Relocatable)
-                    {
-                        break;
-                    }
-
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateBinaryI32(operation, (x, y) => x + y);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateBinaryI64(operation, (x, y) => x + y);
-                    }
-                    break;
-
-                case Instruction.BitwiseAnd:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateBinaryI32(operation, (x, y) => x & y);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateBinaryI64(operation, (x, y) => x & y);
-                    }
-                    break;
-
-                case Instruction.BitwiseExclusiveOr:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateBinaryI32(operation, (x, y) => x ^ y);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateBinaryI64(operation, (x, y) => x ^ y);
-                    }
-                    break;
-
-                case Instruction.BitwiseNot:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateUnaryI32(operation, (x) => ~x);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateUnaryI64(operation, (x) => ~x);
-                    }
-                    break;
-
-                case Instruction.BitwiseOr:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateBinaryI32(operation, (x, y) => x | y);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateBinaryI64(operation, (x, y) => x | y);
-                    }
-                    break;
-
-                case Instruction.ConvertI64ToI32:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateUnaryI32(operation, (x) => x);
-                    }
-                    break;
-
-                case Instruction.Compare:
-                    if (type == OperandType.I32 &&
-                        operation.GetSource(0).Type == type &&
-                        operation.GetSource(1).Type == type)
-                    {
-                        switch ((Comparison)operation.GetSource(2).Value)
-                        {
-                            case Comparison.Equal:
-                                EvaluateBinaryI32(operation, (x, y) => x == y ? 1 : 0);
-                                break;
-                            case Comparison.NotEqual:
-                                EvaluateBinaryI32(operation, (x, y) => x != y ? 1 : 0);
-                                break;
-                            case Comparison.Greater:
-                                EvaluateBinaryI32(operation, (x, y) => x > y ? 1 : 0);
-                                break;
-                            case Comparison.LessOrEqual:
-                                EvaluateBinaryI32(operation, (x, y) => x <= y ? 1 : 0);
-                                break;
-                            case Comparison.GreaterUI:
-                                EvaluateBinaryI32(operation, (x, y) => (uint)x > (uint)y ? 1 : 0);
-                                break;
-                            case Comparison.LessOrEqualUI:
-                                EvaluateBinaryI32(operation, (x, y) => (uint)x <= (uint)y ? 1 : 0);
-                                break;
-                            case Comparison.GreaterOrEqual:
-                                EvaluateBinaryI32(operation, (x, y) => x >= y ? 1 : 0);
-                                break;
-                            case Comparison.Less:
-                                EvaluateBinaryI32(operation, (x, y) => x < y ? 1 : 0);
-                                break;
-                            case Comparison.GreaterOrEqualUI:
-                                EvaluateBinaryI32(operation, (x, y) => (uint)x >= (uint)y ? 1 : 0);
-                                break;
-                            case Comparison.LessUI:
-                                EvaluateBinaryI32(operation, (x, y) => (uint)x < (uint)y ? 1 : 0);
-                                break;
-                        }
-                    }
-                    break;
-
-                case Instruction.Copy:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateUnaryI32(operation, (x) => x);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateUnaryI64(operation, (x) => x);
-                    }
-                    break;
-
-                case Instruction.Divide:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateBinaryI32(operation, (x, y) => y != 0 ? x / y : 0);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateBinaryI64(operation, (x, y) => y != 0 ? x / y : 0);
-                    }
-                    break;
-
-                case Instruction.DivideUI:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateBinaryI32(operation, (x, y) => y != 0 ? (int)((uint)x / (uint)y) : 0);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateBinaryI64(operation, (x, y) => y != 0 ? (long)((ulong)x / (ulong)y) : 0);
-                    }
-                    break;
-
-                 case Instruction.Multiply:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateBinaryI32(operation, (x, y) => x * y);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateBinaryI64(operation, (x, y) => x * y);
-                    }
-                    break;
-
-                case Instruction.Negate:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateUnaryI32(operation, (x) => -x);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateUnaryI64(operation, (x) => -x);
-                    }
-                    break;
-
-                case Instruction.ShiftLeft:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateBinaryI32(operation, (x, y) => x << y);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateBinaryI64(operation, (x, y) => x << (int)y);
-                    }
-                    break;
-
-                case Instruction.ShiftRightSI:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateBinaryI32(operation, (x, y) => x >> y);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateBinaryI64(operation, (x, y) => x >> (int)y);
-                    }
-                    break;
-
-                case Instruction.ShiftRightUI:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateBinaryI32(operation, (x, y) => (int)((uint)x >> y));
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateBinaryI64(operation, (x, y) => (long)((ulong)x >> (int)y));
-                    }
-                    break;
-
-                case Instruction.SignExtend16:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateUnaryI32(operation, (x) => (short)x);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateUnaryI64(operation, (x) => (short)x);
-                    }
-                    break;
-
-                case Instruction.SignExtend32:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateUnaryI32(operation, (x) => x);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateUnaryI64(operation, (x) => (int)x);
-                    }
-                    break;
-
-                case Instruction.SignExtend8:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateUnaryI32(operation, (x) => (sbyte)x);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateUnaryI64(operation, (x) => (sbyte)x);
-                    }
-                    break;
-
-                case Instruction.ZeroExtend16:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateUnaryI32(operation, (x) => (ushort)x);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateUnaryI64(operation, (x) => (ushort)x);
-                    }
-                    break;
-
-                case Instruction.ZeroExtend32:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateUnaryI32(operation, (x) => x);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateUnaryI64(operation, (x) => (uint)x);
-                    }
-                    break;
-
-                case Instruction.ZeroExtend8:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateUnaryI32(operation, (x) => (byte)x);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateUnaryI64(operation, (x) => (byte)x);
-                    }
-                    break;
-
-                case Instruction.Subtract:
-                    if (type == OperandType.I32)
-                    {
-                        EvaluateBinaryI32(operation, (x, y) => x - y);
-                    }
-                    else if (type == OperandType.I64)
-                    {
-                        EvaluateBinaryI64(operation, (x, y) => x - y);
-                    }
-                    break;
-            }
-        }
-
-        private static bool AreAllSourcesConstant(Operation operation)
-        {
-            for (int index = 0; index < operation.SourcesCount; index++)
-            {
-                Operand srcOp = operation.GetSource(index);
-
-                if (srcOp.Kind != OperandKind.Constant)
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        private static void EvaluateUnaryI32(Operation operation, Func<int, int> op)
-        {
-            int x = operation.GetSource(0).AsInt32();
-
-            operation.TurnIntoCopy(Const(op(x)));
-        }
-
-        private static void EvaluateUnaryI64(Operation operation, Func<long, long> op)
-        {
-            long x = operation.GetSource(0).AsInt64();
-
-            operation.TurnIntoCopy(Const(op(x)));
-        }
-
-        private static void EvaluateBinaryI32(Operation operation, Func<int, int, int> op)
-        {
-            int x = operation.GetSource(0).AsInt32();
-            int y = operation.GetSource(1).AsInt32();
-
-            operation.TurnIntoCopy(Const(op(x, y)));
-        }
-
-        private static void EvaluateBinaryI64(Operation operation, Func<long, long, long> op)
-        {
-            long x = operation.GetSource(0).AsInt64();
-            long y = operation.GetSource(1).AsInt64();
-
-            operation.TurnIntoCopy(Const(op(x, y)));
-        }
-    }
-}

ARMeilleure/CodeGen/Optimizations/Optimizer.cs

@@ -1,252 +0,0 @@
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Translation;
-using System;
-using System.Diagnostics;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.CodeGen.Optimizations
-{
-    static class Optimizer
-    {
-        public static void RunPass(ControlFlowGraph cfg)
-        {
-            // Scratch buffer used to store uses.
-            Span<Operation> buffer = default;
-
-            bool modified;
-
-            do
-            {
-                modified = false;
-
-                for (BasicBlock block = cfg.Blocks.Last; block != null; block = block.ListPrevious)
-                {
-                    Operation node;
-                    Operation prevNode;
-
-                    for (node = block.Operations.Last; node != default; node = prevNode)
-                    {
-                        prevNode = node.ListPrevious;
-
-                        if (IsUnused(node))
-                        {
-                            RemoveNode(block, node);
-
-                            modified = true;
-
-                            continue;
-                        }
-                        else if (node.Instruction == Instruction.Phi)
-                        {
-                            continue;
-                        }
-
-                        ConstantFolding.RunPass(node);
-                        Simplification.RunPass(node);
-
-                        if (DestIsSingleLocalVar(node))
-                        {
-                            if (IsPropagableCompare(node))
-                            {
-                                modified |= PropagateCompare(ref buffer, node);
-
-                                if (modified && IsUnused(node))
-                                {
-                                    RemoveNode(block, node);
-                                }
-                            }
-                            else if (IsPropagableCopy(node))
-                            {
-                                PropagateCopy(ref buffer, node);
-
-                                RemoveNode(block, node);
-
-                                modified = true;
-                            }
-                        }
-                    }
-                }
-            }
-            while (modified);
-        }
-
-        public static void RemoveUnusedNodes(ControlFlowGraph cfg)
-        {
-            bool modified;
-
-            do
-            {
-                modified = false;
-
-                for (BasicBlock block = cfg.Blocks.Last; block != null; block = block.ListPrevious)
-                {
-                    Operation node;
-                    Operation prevNode;
-
-                    for (node = block.Operations.Last; node != default; node = prevNode)
-                    {
-                        prevNode = node.ListPrevious;
-
-                        if (IsUnused(node))
-                        {
-                            RemoveNode(block, node);
-
-                            modified = true;
-                        }
-                    }
-                }
-            }
-            while (modified);
-        }
-
-        private static bool PropagateCompare(ref Span<Operation> buffer, Operation compOp)
-        {
-            // Try to propagate Compare operations into their BranchIf uses, when these BranchIf uses are in the form
-            // of:
-            //
-            // - BranchIf %x, 0x0, Equal        ;; i.e BranchIfFalse %x
-            // - BranchIf %x, 0x0, NotEqual     ;; i.e BranchIfTrue %x
-            //
-            // The commutative property of Equal and NotEqual is taken into consideration as well.
-            //
-            // For example:
-            //
-            //  %x = Compare %a, %b, comp
-            //  BranchIf %x, 0x0, NotEqual
-            //
-            // =>
-            //
-            //  BranchIf %a, %b, comp
-
-            static bool IsZeroBranch(Operation operation, out Comparison compType)
-            {
-                compType = Comparison.Equal;
-
-                if (operation.Instruction != Instruction.BranchIf)
-                {
-                    return false;
-                }
-
-                Operand src1 = operation.GetSource(0);
-                Operand src2 = operation.GetSource(1);
-                Operand comp = operation.GetSource(2);
-
-                compType = (Comparison)comp.AsInt32();
-
-                return (src1.Kind == OperandKind.Constant && src1.Value == 0) ||
-                       (src2.Kind == OperandKind.Constant && src2.Value == 0);
-            }
-
-            bool modified = false;
-
-            Operand dest = compOp.Destination;
-            Operand src1 = compOp.GetSource(0);
-            Operand src2 = compOp.GetSource(1);
-            Operand comp = compOp.GetSource(2);
-
-            Comparison compType = (Comparison)comp.AsInt32();
-
-            Span<Operation> uses = dest.GetUses(ref buffer);
-
-            foreach (Operation use in uses)
-            {
-                // If operation is a BranchIf and has a constant value 0 in its RHS or LHS source operands.
-                if (IsZeroBranch(use, out Comparison otherCompType))
-                {
-                    Comparison propCompType;
-
-                    if (otherCompType == Comparison.NotEqual)
-                    {
-                        propCompType = compType;
-                    }
-                    else if (otherCompType == Comparison.Equal)
-                    {
-                        propCompType = compType.Invert();
-                    }
-                    else
-                    {
-                        continue;
-                    }
-
-                    use.SetSource(0, src1);
-                    use.SetSource(1, src2);
-                    use.SetSource(2, Const((int)propCompType));
-
-                    modified = true;
-                }
-            }
-
-            return modified;
-        }
-
-        private static void PropagateCopy(ref Span<Operation> buffer, Operation copyOp)
-        {
-            // Propagate copy source operand to all uses of the destination operand.
-            Operand dest   = copyOp.Destination;
-            Operand source = copyOp.GetSource(0);
-
-            Span<Operation> uses = dest.GetUses(ref buffer);
-
-            foreach (Operation use in uses)
-            {
-                for (int index = 0; index < use.SourcesCount; index++)
-                {
-                    if (use.GetSource(index) == dest)
-                    {
-                        use.SetSource(index, source);
-                    }
-                }
-            }
-        }
-
-        private static void RemoveNode(BasicBlock block, Operation node)
-        {
-            // Remove a node from the nodes list, and also remove itself
-            // from all the use lists on the operands that this node uses.
-            block.Operations.Remove(node);
-
-            for (int index = 0; index < node.SourcesCount; index++)
-            {
-                node.SetSource(index, default);
-            }
-
-            Debug.Assert(node.Destination == default || node.Destination.UsesCount == 0);
-
-            node.Destination = default;
-        }
-
-        private static bool IsUnused(Operation node)
-        {
-            return DestIsSingleLocalVar(node) && node.Destination.UsesCount == 0 && !HasSideEffects(node);
-        }
-
-        private static bool DestIsSingleLocalVar(Operation node)
-        {
-            return node.DestinationsCount == 1 && node.Destination.Kind == OperandKind.LocalVariable;
-        }
-
-        private static bool HasSideEffects(Operation node)
-        {
-            return node.Instruction == Instruction.Call
-                || node.Instruction == Instruction.Tailcall
-                || node.Instruction == Instruction.CompareAndSwap
-                || node.Instruction == Instruction.CompareAndSwap16
-                || node.Instruction == Instruction.CompareAndSwap8;
-        }
-
-        private static bool IsPropagableCompare(Operation operation)
-        {
-            return operation.Instruction == Instruction.Compare;
-        }
-
-        private static bool IsPropagableCopy(Operation operation)
-        {
-            if (operation.Instruction != Instruction.Copy)
-            {
-                return false;
-            }
-
-            return operation.Destination.Type == operation.GetSource(0).Type;
-        }
-    }
-}

ARMeilleure/CodeGen/Optimizations/Simplification.cs

@@ -1,183 +0,0 @@
-using ARMeilleure.IntermediateRepresentation;
-using System;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.CodeGen.Optimizations
-{
-    static class Simplification
-    {
-        public static void RunPass(Operation operation)
-        {
-            switch (operation.Instruction)
-            {
-                case Instruction.Add:
-                    if (operation.GetSource(0).Relocatable ||
-                        operation.GetSource(1).Relocatable)
-                    {
-                        break;
-                    }
-
-                    TryEliminateBinaryOpComutative(operation, 0);
-                    break;
-
-                case Instruction.BitwiseAnd:
-                    TryEliminateBitwiseAnd(operation);
-                    break;
-
-                case Instruction.BitwiseOr:
-                    TryEliminateBitwiseOr(operation);
-                    break;
-
-                case Instruction.BitwiseExclusiveOr:
-                    TryEliminateBitwiseExclusiveOr(operation);
-                    break;
-
-                case Instruction.ConditionalSelect:
-                    TryEliminateConditionalSelect(operation);
-                    break;
-
-                case Instruction.Divide:
-                    TryEliminateBinaryOpY(operation, 1);
-                    break;
-
-                case Instruction.Multiply:
-                    TryEliminateBinaryOpComutative(operation, 1);
-                    break;
-
-                case Instruction.ShiftLeft:
-                case Instruction.ShiftRightSI:
-                case Instruction.ShiftRightUI:
-                case Instruction.Subtract:
-                    TryEliminateBinaryOpY(operation, 0);
-                    break;
-            }
-        }
-
-        private static void TryEliminateBitwiseAnd(Operation operation)
-        {
-            // Try to recognize and optimize those 3 patterns (in order):
-            // x & 0xFFFFFFFF == x,          0xFFFFFFFF & y == y,
-            // x & 0x00000000 == 0x00000000, 0x00000000 & y == 0x00000000
-            Operand x = operation.GetSource(0);
-            Operand y = operation.GetSource(1);
-
-            if (IsConstEqual(x, AllOnes(x.Type)))
-            {
-                operation.TurnIntoCopy(y);
-            }
-            else if (IsConstEqual(y, AllOnes(y.Type)))
-            {
-                operation.TurnIntoCopy(x);
-            }
-            else if (IsConstEqual(x, 0) || IsConstEqual(y, 0))
-            {
-                operation.TurnIntoCopy(Const(x.Type, 0));
-            }
-        }
-
-        private static void TryEliminateBitwiseOr(Operation operation)
-        {
-            // Try to recognize and optimize those 3 patterns (in order):
-            // x | 0x00000000 == x,          0x00000000 | y == y,
-            // x | 0xFFFFFFFF == 0xFFFFFFFF, 0xFFFFFFFF | y == 0xFFFFFFFF
-            Operand x = operation.GetSource(0);
-            Operand y = operation.GetSource(1);
-
-            if (IsConstEqual(x, 0))
-            {
-                operation.TurnIntoCopy(y);
-            }
-            else if (IsConstEqual(y, 0))
-            {
-                operation.TurnIntoCopy(x);
-            }
-            else if (IsConstEqual(x, AllOnes(x.Type)) || IsConstEqual(y, AllOnes(y.Type)))
-            {
-                operation.TurnIntoCopy(Const(AllOnes(x.Type)));
-            }
-        }
-
-        private static void TryEliminateBitwiseExclusiveOr(Operation operation)
-        {
-            // Try to recognize and optimize those 2 patterns (in order):
-            // x ^ y == 0x00000000 when x == y
-            // 0x00000000 ^ y == y, x ^ 0x00000000 == x
-            Operand x = operation.GetSource(0);
-            Operand y = operation.GetSource(1);
-
-            if (x == y && x.Type.IsInteger())
-            {
-                operation.TurnIntoCopy(Const(x.Type, 0));
-            }
-            else
-            {
-                TryEliminateBinaryOpComutative(operation, 0);
-            }
-        }
-
-        private static void TryEliminateBinaryOpY(Operation operation, ulong comparand)
-        {
-            Operand x = operation.GetSource(0);
-            Operand y = operation.GetSource(1);
-
-            if (IsConstEqual(y, comparand))
-            {
-                operation.TurnIntoCopy(x);
-            }
-        }
-
-        private static void TryEliminateBinaryOpComutative(Operation operation, ulong comparand)
-        {
-            Operand x = operation.GetSource(0);
-            Operand y = operation.GetSource(1);
-
-            if (IsConstEqual(x, comparand))
-            {
-                operation.TurnIntoCopy(y);
-            }
-            else if (IsConstEqual(y, comparand))
-            {
-                operation.TurnIntoCopy(x);
-            }
-        }
-
-        private static void TryEliminateConditionalSelect(Operation operation)
-        {
-            Operand cond = operation.GetSource(0);
-
-            if (cond.Kind != OperandKind.Constant)
-            {
-                return;
-            }
-
-            // The condition is constant, we can turn it into a copy, and select
-            // the source based on the condition value.
-            int srcIndex = cond.Value != 0 ? 1 : 2;
-
-            Operand source = operation.GetSource(srcIndex);
-
-            operation.TurnIntoCopy(source);
-        }
-
-        private static bool IsConstEqual(Operand operand, ulong comparand)
-        {
-            if (operand.Kind != OperandKind.Constant || !operand.Type.IsInteger())
-            {
-                return false;
-            }
-
-            return operand.Value == comparand;
-        }
-
-        private static ulong AllOnes(OperandType type)
-        {
-            switch (type)
-            {
-                case OperandType.I32: return ~0U;
-                case OperandType.I64: return ~0UL;
-            }
-
-            throw new ArgumentException("Invalid operand type \"" + type + "\".");
-        }
-    }
-}

ARMeilleure/CodeGen/RegisterAllocators/UseList.cs

@@ -1,84 +0,0 @@
-using System;
-
-namespace ARMeilleure.CodeGen.RegisterAllocators
-{
-    unsafe struct UseList
-    {
-        private int* _items;
-        private int _capacity;
-        private int _count;
-
-        public int Count => _count;
-        public int FirstUse => _count > 0 ? _items[_count - 1] : LiveInterval.NotFound;
-        public Span<int> Span => new(_items, _count);
-
-        public void Add(int position)
-        {
-            if (_count + 1 > _capacity)
-            {
-                var oldSpan = Span;
-
-                _capacity = Math.Max(4, _capacity * 2);
-                _items = Allocators.Default.Allocate<int>((uint)_capacity);
-
-                var newSpan = Span;
-
-                oldSpan.CopyTo(newSpan);
-            }
-
-            // Use positions are usually inserted in descending order, so inserting in descending order is faster,
-            // since the number of half exchanges is reduced.
-            int i = _count - 1;
-
-            while (i >= 0 && _items[i] < position)
-            {
-                _items[i + 1] = _items[i--];
-            }
-
-            _items[i + 1] = position;
-            _count++;
-        }
-
-        public int NextUse(int position)
-        {
-            int index = NextUseIndex(position);
-
-            return index != LiveInterval.NotFound ? _items[index] : LiveInterval.NotFound;
-        }
-
-        public int NextUseIndex(int position)
-        {
-            int i = _count - 1;
-
-            if (i == -1 || position > _items[0])
-            {
-                return LiveInterval.NotFound;
-            }
-
-            while (i >= 0 && _items[i] < position)
-            {
-                i--;
-            }
-
-            return i;
-        }
-
-        public UseList Split(int position)
-        {
-            int index = NextUseIndex(position);
-
-            // Since the list is in descending order, the new split list takes the front of the list and the current
-            // list takes the back of the list.
-            UseList result = new();
-            result._count = index + 1;
-            result._capacity = result._count;
-            result._items = _items;
-
-            _count = _count - result._count;
-            _capacity = _count;
-            _items = _items + result._count;
-
-            return result;
-        }
-    }
-}

ARMeilleure/CodeGen/Unwinding/UnwindPseudoOp.cs

@@ -1,11 +0,0 @@
-namespace ARMeilleure.CodeGen.Unwinding
-{
-    enum UnwindPseudoOp
-    {
-        PushReg    = 0,
-        SetFrame   = 1,
-        AllocStack = 2,
-        SaveReg    = 3,
-        SaveXmm128 = 4
-    }
-}

ARMeilleure/CodeGen/X86/CallingConvention.cs

@@ -1,158 +0,0 @@
-using System;
-
-namespace ARMeilleure.CodeGen.X86
-{
-    static class CallingConvention
-    {
-        private const int RegistersMask = 0xffff;
-
-        public static int GetIntAvailableRegisters()
-        {
-            return RegistersMask & ~(1 << (int)X86Register.Rsp);
-        }
-
-        public static int GetVecAvailableRegisters()
-        {
-            return RegistersMask;
-        }
-
-        public static int GetIntCallerSavedRegisters()
-        {
-            if (GetCurrentCallConv() == CallConvName.Windows)
-            {
-                return (1 << (int)X86Register.Rax) |
-                       (1 << (int)X86Register.Rcx) |
-                       (1 << (int)X86Register.Rdx) |
-                       (1 << (int)X86Register.R8)  |
-                       (1 << (int)X86Register.R9)  |
-                       (1 << (int)X86Register.R10) |
-                       (1 << (int)X86Register.R11);
-            }
-            else /* if (GetCurrentCallConv() == CallConvName.SystemV) */
-            {
-                return (1 << (int)X86Register.Rax) |
-                       (1 << (int)X86Register.Rcx) |
-                       (1 << (int)X86Register.Rdx) |
-                       (1 << (int)X86Register.Rsi) |
-                       (1 << (int)X86Register.Rdi) |
-                       (1 << (int)X86Register.R8)  |
-                       (1 << (int)X86Register.R9)  |
-                       (1 << (int)X86Register.R10) |
-                       (1 << (int)X86Register.R11);
-            }
-        }
-
-        public static int GetVecCallerSavedRegisters()
-        {
-            if (GetCurrentCallConv() == CallConvName.Windows)
-            {
-                return (1 << (int)X86Register.Xmm0) |
-                       (1 << (int)X86Register.Xmm1) |
-                       (1 << (int)X86Register.Xmm2) |
-                       (1 << (int)X86Register.Xmm3) |
-                       (1 << (int)X86Register.Xmm4) |
-                       (1 << (int)X86Register.Xmm5);
-            }
-            else /* if (GetCurrentCallConv() == CallConvName.SystemV) */
-            {
-                return RegistersMask;
-            }
-        }
-
-        public static int GetIntCalleeSavedRegisters()
-        {
-            return GetIntCallerSavedRegisters() ^ RegistersMask;
-        }
-
-        public static int GetVecCalleeSavedRegisters()
-        {
-            return GetVecCallerSavedRegisters() ^ RegistersMask;
-        }
-
-        public static int GetArgumentsOnRegsCount()
-        {
-            return 4;
-        }
-
-        public static int GetIntArgumentsOnRegsCount()
-        {
-            return 6;
-        }
-
-        public static int GetVecArgumentsOnRegsCount()
-        {
-            return 8;
-        }
-
-        public static X86Register GetIntArgumentRegister(int index)
-        {
-            if (GetCurrentCallConv() == CallConvName.Windows)
-            {
-                switch (index)
-                {
-                    case 0: return X86Register.Rcx;
-                    case 1: return X86Register.Rdx;
-                    case 2: return X86Register.R8;
-                    case 3: return X86Register.R9;
-                }
-            }
-            else /* if (GetCurrentCallConv() == CallConvName.SystemV) */
-            {
-                switch (index)
-                {
-                    case 0: return X86Register.Rdi;
-                    case 1: return X86Register.Rsi;
-                    case 2: return X86Register.Rdx;
-                    case 3: return X86Register.Rcx;
-                    case 4: return X86Register.R8;
-                    case 5: return X86Register.R9;
-                }
-            }
-
-            throw new ArgumentOutOfRangeException(nameof(index));
-        }
-
-        public static X86Register GetVecArgumentRegister(int index)
-        {
-            int count;
-
-            if (GetCurrentCallConv() == CallConvName.Windows)
-            {
-                count = 4;
-            }
-            else /* if (GetCurrentCallConv() == CallConvName.SystemV) */
-            {
-                count = 8;
-            }
-
-            if ((uint)index < count)
-            {
-                return X86Register.Xmm0 + index;
-            }
-
-            throw new ArgumentOutOfRangeException(nameof(index));
-        }
-
-        public static X86Register GetIntReturnRegister()
-        {
-            return X86Register.Rax;
-        }
-
-        public static X86Register GetIntReturnRegisterHigh()
-        {
-            return X86Register.Rdx;
-        }
-
-        public static X86Register GetVecReturnRegister()
-        {
-            return X86Register.Xmm0;
-        }
-
-        public static CallConvName GetCurrentCallConv()
-        {
-            return OperatingSystem.IsWindows()
-                ? CallConvName.Windows
-                : CallConvName.SystemV;
-        }
-    }
-}

ARMeilleure/CodeGen/X86/CodeGenCommon.cs

@@ -1,19 +0,0 @@
-using ARMeilleure.IntermediateRepresentation;
-
-namespace ARMeilleure.CodeGen.X86
-{
-    static class CodeGenCommon
-    {
-        public static bool IsLongConst(Operand op)
-        {
-            long value = op.Type == OperandType.I32 ? op.AsInt32() : op.AsInt64();
-
-            return !ConstFitsOnS32(value);
-        }
-
-        private static bool ConstFitsOnS32(long value)
-        {
-            return value == (int)value;
-        }
-    }
-}

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/IntrinsicInfo.cs

@@ -1,14 +0,0 @@
-namespace ARMeilleure.CodeGen.X86
-{
-    readonly struct IntrinsicInfo
-    {
-        public X86Instruction Inst { get; }
-        public IntrinsicType  Type { get; }
-
-        public IntrinsicInfo(X86Instruction inst, IntrinsicType type)
-        {
-            Inst = inst;
-            Type = type;
-        }
-    }
-}

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/IntrinsicType.cs

@@ -1,18 +0,0 @@
-namespace ARMeilleure.CodeGen.X86
-{
-    enum IntrinsicType
-    {
-        Comis_,
-        Mxcsr,
-        PopCount,
-        Unary,
-        UnaryToGpr,
-        Binary,
-        BinaryGpr,
-        BinaryImm,
-        Crc32,
-        Ternary,
-        TernaryImm,
-        Fma
-    }
-}

ARMeilleure/CodeGen/X86/PreAllocator.cs

@@ -1,790 +0,0 @@
-using ARMeilleure.CodeGen.RegisterAllocators;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Translation;
-using System;
-using System.Diagnostics;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-using static ARMeilleure.IntermediateRepresentation.Operation.Factory;
-
-namespace ARMeilleure.CodeGen.X86
-{
-    class PreAllocator
-    {
-        public static void RunPass(CompilerContext cctx, StackAllocator stackAlloc, out int maxCallArgs)
-        {
-            maxCallArgs = -1;
-
-            Span<Operation> buffer = default;
-
-            CallConvName callConv = CallingConvention.GetCurrentCallConv();
-
-            Operand[] preservedArgs = new Operand[CallingConvention.GetArgumentsOnRegsCount()];
-
-            for (BasicBlock block = cctx.Cfg.Blocks.First; block != null; block = block.ListNext)
-            {
-                Operation nextNode;
-
-                for (Operation node = block.Operations.First; node != default; node = nextNode)
-                {
-                    nextNode = node.ListNext;
-
-                    if (node.Instruction == Instruction.Phi)
-                    {
-                        continue;
-                    }
-
-                    InsertConstantRegCopies(block.Operations, node);
-                    InsertDestructiveRegCopies(block.Operations, node);
-                    InsertConstrainedRegCopies(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.
-                            if (callConv == CallConvName.Windows)
-                            {
-                                PreAllocatorWindows.InsertCallCopies(block.Operations, stackAlloc, node);
-                            }
-                            else /* if (callConv == CallConvName.SystemV) */
-                            {
-                                PreAllocatorSystemV.InsertCallCopies(block.Operations, node);
-                            }
-                            break;
-
-                        case Instruction.ConvertToFPUI:
-                            GenerateConvertToFPUI(block.Operations, node);
-                            break;
-
-                        case Instruction.LoadArgument:
-                            if (callConv == CallConvName.Windows)
-                            {
-                                nextNode = PreAllocatorWindows.InsertLoadArgumentCopy(cctx, ref buffer, block.Operations, preservedArgs, node);
-                            }
-                            else /* if (callConv == CallConvName.SystemV) */
-                            {
-                                nextNode = PreAllocatorSystemV.InsertLoadArgumentCopy(cctx, ref buffer, block.Operations, preservedArgs, node);
-                            }
-                            break;
-
-                        case Instruction.Negate:
-                            if (!node.GetSource(0).Type.IsInteger())
-                            {
-                                GenerateNegate(block.Operations, node);
-                            }
-                            break;
-
-                        case Instruction.Return:
-                            if (callConv == CallConvName.Windows)
-                            {
-                                PreAllocatorWindows.InsertReturnCopy(cctx, block.Operations, preservedArgs, node);
-                            }
-                            else /* if (callConv == CallConvName.SystemV) */
-                            {
-                                PreAllocatorSystemV.InsertReturnCopy(block.Operations, node);
-                            }
-                            break;
-
-                        case Instruction.Tailcall:
-                            if (callConv == CallConvName.Windows)
-                            {
-                                PreAllocatorWindows.InsertTailcallCopies(block.Operations, stackAlloc, node);
-                            }
-                            else
-                            {
-                                PreAllocatorSystemV.InsertTailcallCopies(block.Operations, stackAlloc, node);
-                            }
-                            break;
-
-                        case Instruction.VectorInsert8:
-                            if (!HardwareCapabilities.SupportsSse41)
-                            {
-                                GenerateVectorInsert8(block.Operations, node);
-                            }
-                            break;
-
-                        case Instruction.Extended:
-                            if (node.Intrinsic == Intrinsic.X86Mxcsrmb || node.Intrinsic == Intrinsic.X86Mxcsrub)
-                            {
-                                int stackOffset = stackAlloc.Allocate(OperandType.I32);
-
-                                node.SetSources(new Operand[] { Const(stackOffset), node.GetSource(0) });
-                            }
-                            break;
-                    }
-                }
-            }
-        }
-
-        protected static void InsertConstantRegCopies(IntrusiveList<Operation> nodes, Operation node)
-        {
-            if (node.SourcesCount == 0 || IsXmmIntrinsic(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 = AddXmmCopy(nodes, node, src1);
-
-                    node.SetSource(0, src1);
-                }
-                else if (!HasConstSrc1(inst))
-                {
-                    // 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 = AddCopy(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 = AddXmmCopy(nodes, node, src2);
-
-                    node.SetSource(1, src2);
-                }
-                else if (!HasConstSrc2(inst) || CodeGenCommon.IsLongConst(src2))
-                {
-                    src2 = AddCopy(nodes, node, src2);
-
-                    node.SetSource(1, src2);
-                }
-            }
-        }
-
-        protected static void InsertConstrainedRegCopies(IntrusiveList<Operation> nodes, Operation node)
-        {
-            Operand dest = node.Destination;
-
-            switch (node.Instruction)
-            {
-                case Instruction.CompareAndSwap:
-                case Instruction.CompareAndSwap16:
-                case Instruction.CompareAndSwap8:
-                {
-                    OperandType type = node.GetSource(1).Type;
-
-                    if (type == OperandType.V128)
-                    {
-                        // Handle the many restrictions of the compare and exchange (16 bytes) instruction:
-                        // - The expected value should be in RDX:RAX.
-                        // - The new value to be written should be in RCX:RBX.
-                        // - The value at the memory location is loaded to RDX:RAX.
-                        void SplitOperand(Operand source, Operand lr, Operand hr)
-                        {
-                            nodes.AddBefore(node, Operation(Instruction.VectorExtract, lr, source, Const(0)));
-                            nodes.AddBefore(node, Operation(Instruction.VectorExtract, hr, source, Const(1)));
-                        }
-
-                        Operand rax = Gpr(X86Register.Rax, OperandType.I64);
-                        Operand rbx = Gpr(X86Register.Rbx, OperandType.I64);
-                        Operand rcx = Gpr(X86Register.Rcx, OperandType.I64);
-                        Operand rdx = Gpr(X86Register.Rdx, OperandType.I64);
-
-                        SplitOperand(node.GetSource(1), rax, rdx);
-                        SplitOperand(node.GetSource(2), rbx, rcx);
-
-                        Operation operation = node;
-
-                        node = nodes.AddAfter(node, Operation(Instruction.VectorCreateScalar, dest, rax));
-                        nodes.AddAfter(node, Operation(Instruction.VectorInsert, dest, dest, rdx, Const(1)));
-
-                        operation.SetDestinations(new Operand[] { rdx, rax });
-                        operation.SetSources(new Operand[] { operation.GetSource(0), rdx, rax, rcx, rbx });
-                    }
-                    else
-                    {
-                        // Handle the many restrictions of the compare and exchange (32/64) instruction:
-                        // - The expected value should be in (E/R)AX.
-                        // - The value at the memory location is loaded to (E/R)AX.
-                        Operand expected = node.GetSource(1);
-                        Operand newValue = node.GetSource(2);
-
-                        Operand rax = Gpr(X86Register.Rax, expected.Type);
-
-                        nodes.AddBefore(node, Operation(Instruction.Copy, rax, expected));
-
-                        // We need to store the new value into a temp, since it may
-                        // be a constant, and this instruction does not support immediate operands.
-                        Operand temp = Local(newValue.Type);
-
-                        nodes.AddBefore(node, Operation(Instruction.Copy, temp, newValue));
-
-                        node.SetSources(new Operand[] { node.GetSource(0), rax, temp });
-
-                        nodes.AddAfter(node, Operation(Instruction.Copy, dest, rax));
-
-                        node.Destination = rax;
-                    }
-
-                    break;
-                }
-
-                case Instruction.Divide:
-                case Instruction.DivideUI:
-                {
-                    // Handle the many restrictions of the division instructions:
-                    // - The dividend is always in RDX:RAX.
-                    // - The result is always in RAX.
-                    // - Additionally it also writes the remainder in RDX.
-                    if (dest.Type.IsInteger())
-                    {
-                        Operand src1 = node.GetSource(0);
-
-                        Operand rax = Gpr(X86Register.Rax, src1.Type);
-                        Operand rdx = Gpr(X86Register.Rdx, src1.Type);
-
-                        nodes.AddBefore(node, Operation(Instruction.Copy,    rax, src1));
-                        nodes.AddBefore(node, Operation(Instruction.Clobber, rdx));
-
-                        nodes.AddAfter(node, Operation(Instruction.Copy, dest, rax));
-
-                        node.SetSources(new Operand[] { rdx, rax, node.GetSource(1) });
-                        node.Destination = rax;
-                    }
-
-                    break;
-                }
-
-                case Instruction.Extended:
-                {
-                    bool isBlend = node.Intrinsic == Intrinsic.X86Blendvpd ||
-                                   node.Intrinsic == Intrinsic.X86Blendvps ||
-                                   node.Intrinsic == Intrinsic.X86Pblendvb;
-
-                    // BLENDVPD, BLENDVPS, PBLENDVB last operand is always implied to be XMM0 when VEX is not supported.
-                    // SHA256RNDS2 always has an implied XMM0 as a last operand.
-                    if ((isBlend && !HardwareCapabilities.SupportsVexEncoding) || node.Intrinsic == Intrinsic.X86Sha256Rnds2)
-                    {
-                        Operand xmm0 = Xmm(X86Register.Xmm0, OperandType.V128);
-
-                        nodes.AddBefore(node, Operation(Instruction.Copy, xmm0, node.GetSource(2)));
-
-                        node.SetSource(2, xmm0);
-                    }
-
-                    break;
-                }
-
-                case Instruction.Multiply64HighSI:
-                case Instruction.Multiply64HighUI:
-                {
-                    // Handle the many restrictions of the i64 * i64 = i128 multiply instructions:
-                    // - The multiplicand is always in RAX.
-                    // - The lower 64-bits of the result is always in RAX.
-                    // - The higher 64-bits of the result is always in RDX.
-                    Operand src1 = node.GetSource(0);
-
-                    Operand rax = Gpr(X86Register.Rax, src1.Type);
-                    Operand rdx = Gpr(X86Register.Rdx, src1.Type);
-
-                    nodes.AddBefore(node, Operation(Instruction.Copy, rax, src1));
-
-                    node.SetSource(0, rax);
-
-                    nodes.AddAfter(node, Operation(Instruction.Copy, dest, rdx));
-
-                    node.SetDestinations(new Operand[] { rdx, rax });
-
-                    break;
-                }
-
-                case Instruction.RotateRight:
-                case Instruction.ShiftLeft:
-                case Instruction.ShiftRightSI:
-                case Instruction.ShiftRightUI:
-                {
-                    // The shift register is always implied to be CL (low 8-bits of RCX or ECX).
-                    if (node.GetSource(1).Kind == OperandKind.LocalVariable)
-                    {
-                        Operand rcx = Gpr(X86Register.Rcx, OperandType.I32);
-
-                        nodes.AddBefore(node, Operation(Instruction.Copy, rcx, node.GetSource(1)));
-
-                        node.SetSource(1, rcx);
-                    }
-
-                    break;
-                }
-            }
-        }
-
-        protected static void InsertDestructiveRegCopies(IntrusiveList<Operation> nodes, Operation node)
-        {
-            if (node.Destination == default || node.SourcesCount == 0)
-            {
-                return;
-            }
-
-            Instruction inst = node.Instruction;
-
-            Operand dest = node.Destination;
-            Operand src1 = node.GetSource(0);
-
-            // The multiply instruction (that maps to IMUL) is somewhat special, it has
-            // a three operand form where the second source is a immediate value.
-            bool threeOperandForm = inst == Instruction.Multiply && node.GetSource(1).Kind == OperandKind.Constant;
-
-            if (IsSameOperandDestSrc1(node) && src1.Kind == OperandKind.LocalVariable && !threeOperandForm)
-            {
-                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);
-                }
-            }
-            else if (inst == Instruction.ConditionalSelect)
-            {
-                Operand src2 = node.GetSource(1);
-                Operand src3 = node.GetSource(2);
-
-                if (src1 == dest || src2 == dest)
-                {
-                    Operand temp = Local(dest.Type);
-
-                    nodes.AddBefore(node, Operation(Instruction.Copy, temp, src3));
-
-                    node.SetSource(2, temp);
-
-                    nodes.AddAfter(node, Operation(Instruction.Copy, dest, temp));
-
-                    node.Destination = temp;
-                }
-                else
-                {
-                    nodes.AddBefore(node, Operation(Instruction.Copy, dest, src3));
-
-                    node.SetSource(2, dest);
-                }
-            }
-        }
-
-        private static void GenerateConvertToFPUI(IntrusiveList<Operation> nodes, Operation node)
-        {
-            // Unsigned integer to FP conversions are not supported on X86.
-            // We need to turn them into signed integer to FP conversions, and
-            // adjust the final result.
-            Operand dest   = node.Destination;
-            Operand source = node.GetSource(0);
-
-            Debug.Assert(source.Type.IsInteger(), $"Invalid source type \"{source.Type}\".");
-
-            Operation currentNode = node;
-
-            if (source.Type == OperandType.I32)
-            {
-                // For 32-bits integers, we can just zero-extend to 64-bits,
-                // and then use the 64-bits signed conversion instructions.
-                Operand zex = Local(OperandType.I64);
-
-                node = nodes.AddAfter(node, Operation(Instruction.ZeroExtend32, zex,  source));
-                node = nodes.AddAfter(node, Operation(Instruction.ConvertToFP,  dest, zex));
-            }
-            else /* if (source.Type == OperandType.I64) */
-            {
-                // For 64-bits integers, we need to do the following:
-                // - Ensure that the integer has the most significant bit clear.
-                // -- This can be done by shifting the value right by 1, that is, dividing by 2.
-                // -- The least significant bit is lost in this case though.
-                // - We can then convert the shifted value with a signed integer instruction.
-                // - The result still needs to be corrected after that.
-                // -- First, we need to multiply the result by 2, as we divided it by 2 before.
-                // --- This can be done efficiently by adding the result to itself.
-                // -- Then, we need to add the least significant bit that was shifted out.
-                // --- We can convert the least significant bit to float, and add it to the result.
-                Operand lsb  = Local(OperandType.I64);
-                Operand half = Local(OperandType.I64);
-
-                Operand lsbF = Local(dest.Type);
-
-                node = nodes.AddAfter(node, Operation(Instruction.Copy, lsb,  source));
-                node = nodes.AddAfter(node, Operation(Instruction.Copy, half, source));
-
-                node = nodes.AddAfter(node, Operation(Instruction.BitwiseAnd,   lsb,  lsb,  Const(1L)));
-                node = nodes.AddAfter(node, Operation(Instruction.ShiftRightUI, half, half, Const(1)));
-
-                node = nodes.AddAfter(node, Operation(Instruction.ConvertToFP, lsbF, lsb));
-                node = nodes.AddAfter(node, Operation(Instruction.ConvertToFP, dest, half));
-
-                node = nodes.AddAfter(node, Operation(Instruction.Add, dest, dest, dest));
-                nodes.AddAfter(node, Operation(Instruction.Add, dest, dest, lsbF));
-            }
-
-            Delete(nodes, currentNode);
-        }
-
-        private static void GenerateNegate(IntrusiveList<Operation> nodes, Operation node)
-        {
-            // There's no SSE FP negate instruction, so we need to transform that into
-            // a XOR of the value to be negated with a mask with the highest bit set.
-            // This also produces -0 for a negation of the value 0.
-            Operand dest   = node.Destination;
-            Operand source = node.GetSource(0);
-
-            Debug.Assert(dest.Type == OperandType.FP32 ||
-                         dest.Type == OperandType.FP64, $"Invalid destination type \"{dest.Type}\".");
-
-            Operation currentNode = node;
-
-            Operand res = Local(dest.Type);
-
-            node = nodes.AddAfter(node, Operation(Instruction.VectorOne, res));
-
-            if (dest.Type == OperandType.FP32)
-            {
-                node = nodes.AddAfter(node, Operation(Intrinsic.X86Pslld, res, res, Const(31)));
-            }
-            else /* if (dest.Type == OperandType.FP64) */
-            {
-                node = nodes.AddAfter(node, Operation(Intrinsic.X86Psllq, res, res, Const(63)));
-            }
-
-            node = nodes.AddAfter(node, Operation(Intrinsic.X86Xorps, res, res, source));
-
-            nodes.AddAfter(node, Operation(Instruction.Copy, dest, res));
-
-            Delete(nodes, currentNode);
-        }
-
-        private static void GenerateVectorInsert8(IntrusiveList<Operation> nodes, Operation node)
-        {
-            // Handle vector insertion, when SSE 4.1 is not supported.
-            Operand dest = node.Destination;
-            Operand src1 = node.GetSource(0); // Vector
-            Operand src2 = node.GetSource(1); // Value
-            Operand src3 = node.GetSource(2); // Index
-
-            Debug.Assert(src3.Kind == OperandKind.Constant);
-
-            byte index = src3.AsByte();
-
-            Debug.Assert(index < 16);
-
-            Operation currentNode = node;
-
-            Operand temp1 = Local(OperandType.I32);
-            Operand temp2 = Local(OperandType.I32);
-
-            node = nodes.AddAfter(node, Operation(Instruction.Copy, temp2, src2));
-
-            Operation vextOp = Operation(Instruction.VectorExtract16, temp1, src1, Const(index >> 1));
-
-            node = nodes.AddAfter(node, vextOp);
-
-            if ((index & 1) != 0)
-            {
-                node = nodes.AddAfter(node, Operation(Instruction.ZeroExtend8, temp1, temp1));
-                node = nodes.AddAfter(node, Operation(Instruction.ShiftLeft,   temp2, temp2, Const(8)));
-                node = nodes.AddAfter(node, Operation(Instruction.BitwiseOr,   temp1, temp1, temp2));
-            }
-            else
-            {
-                node = nodes.AddAfter(node, Operation(Instruction.ZeroExtend8, temp2, temp2));
-                node = nodes.AddAfter(node, Operation(Instruction.BitwiseAnd,  temp1, temp1, Const(0xff00)));
-                node = nodes.AddAfter(node, Operation(Instruction.BitwiseOr,   temp1, temp1, temp2));
-            }
-
-            Operation vinsOp = Operation(Instruction.VectorInsert16, dest, src1, temp1, Const(index >> 1));
-
-            nodes.AddAfter(node, vinsOp);
-
-            Delete(nodes, currentNode);
-        }
-
-        protected static Operand AddXmmCopy(IntrusiveList<Operation> nodes, Operation node, Operand source)
-        {
-            Operand temp = Local(source.Type);
-            Operand intConst = AddCopy(nodes, node, GetIntConst(source));
-
-            Operation copyOp = Operation(Instruction.VectorCreateScalar, temp, intConst);
-
-            nodes.AddBefore(node, copyOp);
-
-            return temp;
-        }
-
-        protected static Operand AddCopy(IntrusiveList<Operation> nodes, Operation node, Operand source)
-        {
-            Operand temp = Local(source.Type);
-
-            Operation copyOp = Operation(Instruction.Copy, temp, source);
-
-            nodes.AddBefore(node, copyOp);
-
-            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;
-        }
-
-        protected 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);
-        }
-
-        protected static Operand Gpr(X86Register register, OperandType type)
-        {
-            return Register((int)register, RegisterType.Integer, type);
-        }
-
-        protected static Operand Xmm(X86Register register, OperandType type)
-        {
-            return Register((int)register, RegisterType.Vector, type);
-        }
-
-        private static bool IsSameOperandDestSrc1(Operation operation)
-        {
-            switch (operation.Instruction)
-            {
-                case Instruction.Add:
-                    return !HardwareCapabilities.SupportsVexEncoding && !operation.Destination.Type.IsInteger();
-                case Instruction.Multiply:
-                case Instruction.Subtract:
-                    return !HardwareCapabilities.SupportsVexEncoding || operation.Destination.Type.IsInteger();
-
-                case Instruction.BitwiseAnd:
-                case Instruction.BitwiseExclusiveOr:
-                case Instruction.BitwiseNot:
-                case Instruction.BitwiseOr:
-                case Instruction.ByteSwap:
-                case Instruction.Negate:
-                case Instruction.RotateRight:
-                case Instruction.ShiftLeft:
-                case Instruction.ShiftRightSI:
-                case Instruction.ShiftRightUI:
-                    return true;
-
-                case Instruction.Divide:
-                    return !HardwareCapabilities.SupportsVexEncoding && !operation.Destination.Type.IsInteger();
-
-                case Instruction.VectorInsert:
-                case Instruction.VectorInsert16:
-                case Instruction.VectorInsert8:
-                    return !HardwareCapabilities.SupportsVexEncoding;
-
-                case Instruction.Extended:
-                    return IsIntrinsicSameOperandDestSrc1(operation);
-            }
-
-            return IsVexSameOperandDestSrc1(operation);
-        }
-
-        private static bool IsIntrinsicSameOperandDestSrc1(Operation operation)
-        {
-            IntrinsicInfo info = IntrinsicTable.GetInfo(operation.Intrinsic);
-
-            return info.Type == IntrinsicType.Crc32 || info.Type == IntrinsicType.Fma || IsVexSameOperandDestSrc1(operation);
-        }
-
-        private static bool IsVexSameOperandDestSrc1(Operation operation)
-        {
-            if (IsIntrinsic(operation.Instruction))
-            {
-                IntrinsicInfo info = IntrinsicTable.GetInfo(operation.Intrinsic);
-
-                bool hasVex = HardwareCapabilities.SupportsVexEncoding && Assembler.SupportsVexPrefix(info.Inst);
-
-                bool isUnary = operation.SourcesCount < 2;
-
-                bool hasVecDest = operation.Destination != default && operation.Destination.Type == OperandType.V128;
-
-                return !hasVex && !isUnary && hasVecDest;
-            }
-
-            return false;
-        }
-
-        private static bool HasConstSrc1(Instruction inst)
-        {
-            switch (inst)
-            {
-                case Instruction.Copy:
-                case Instruction.LoadArgument:
-                case Instruction.Spill:
-                case Instruction.SpillArg:
-                    return true;
-            }
-
-            return false;
-        }
-
-        private static bool HasConstSrc2(Instruction inst)
-        {
-            switch (inst)
-            {
-                case Instruction.Add:
-                case Instruction.BitwiseAnd:
-                case Instruction.BitwiseExclusiveOr:
-                case Instruction.BitwiseOr:
-                case Instruction.BranchIf:
-                case Instruction.Compare:
-                case Instruction.Multiply:
-                case Instruction.RotateRight:
-                case Instruction.ShiftLeft:
-                case Instruction.ShiftRightSI:
-                case Instruction.ShiftRightUI:
-                case Instruction.Store:
-                case Instruction.Store16:
-                case Instruction.Store8:
-                case Instruction.Subtract:
-                case Instruction.VectorExtract:
-                case Instruction.VectorExtract16:
-                case Instruction.VectorExtract8:
-                    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 IsIntrinsic(Instruction inst)
-        {
-            return inst == Instruction.Extended;
-        }
-
-        private static bool IsXmmIntrinsic(Operation operation)
-        {
-            if (operation.Instruction != Instruction.Extended)
-            {
-                return false;
-            }
-
-            IntrinsicInfo info = IntrinsicTable.GetInfo(operation.Intrinsic);
-
-            return info.Type != IntrinsicType.Crc32;
-        }
-    }
-}

ARMeilleure/CodeGen/X86/X86Condition.cs

@@ -1,47 +0,0 @@
-using ARMeilleure.IntermediateRepresentation;
-using System;
-
-namespace ARMeilleure.CodeGen.X86
-{
-    enum X86Condition
-    {
-        Overflow       = 0x0,
-        NotOverflow    = 0x1,
-        Below          = 0x2,
-        AboveOrEqual   = 0x3,
-        Equal          = 0x4,
-        NotEqual       = 0x5,
-        BelowOrEqual   = 0x6,
-        Above          = 0x7,
-        Sign           = 0x8,
-        NotSign        = 0x9,
-        ParityEven     = 0xa,
-        ParityOdd      = 0xb,
-        Less           = 0xc,
-        GreaterOrEqual = 0xd,
-        LessOrEqual    = 0xe,
-        Greater        = 0xf
-    }
-
-    static class ComparisonX86Extensions
-    {
-        public static X86Condition ToX86Condition(this Comparison comp)
-        {
-            return comp switch
-            {
-                Comparison.Equal            => X86Condition.Equal,
-                Comparison.NotEqual         => X86Condition.NotEqual,
-                Comparison.Greater          => X86Condition.Greater,
-                Comparison.LessOrEqual      => X86Condition.LessOrEqual,
-                Comparison.GreaterUI        => X86Condition.Above,
-                Comparison.LessOrEqualUI    => X86Condition.BelowOrEqual,
-                Comparison.GreaterOrEqual   => X86Condition.GreaterOrEqual,
-                Comparison.Less             => X86Condition.Less,
-                Comparison.GreaterOrEqualUI => X86Condition.AboveOrEqual,
-                Comparison.LessUI           => X86Condition.Below,
-
-                _ => throw new ArgumentException(null, nameof(comp))
-            };
-        }
-    }
-}

ARMeilleure/CodeGen/X86/X86Register.cs

@@ -1,41 +0,0 @@
-namespace ARMeilleure.CodeGen.X86
-{
-    enum X86Register
-    {
-        Invalid = -1,
-
-        Rax = 0,
-        Rcx = 1,
-        Rdx = 2,
-        Rbx = 3,
-        Rsp = 4,
-        Rbp = 5,
-        Rsi = 6,
-        Rdi = 7,
-        R8  = 8,
-        R9  = 9,
-        R10 = 10,
-        R11 = 11,
-        R12 = 12,
-        R13 = 13,
-        R14 = 14,
-        R15 = 15,
-
-        Xmm0  = 0,
-        Xmm1  = 1,
-        Xmm2  = 2,
-        Xmm3  = 3,
-        Xmm4  = 4,
-        Xmm5  = 5,
-        Xmm6  = 6,
-        Xmm7  = 7,
-        Xmm8  = 8,
-        Xmm9  = 9,
-        Xmm10 = 10,
-        Xmm11 = 11,
-        Xmm12 = 12,
-        Xmm13 = 13,
-        Xmm14 = 14,
-        Xmm15 = 15
-    }
-}

ARMeilleure/Common/BitMap.cs

@@ -1,222 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-namespace ARMeilleure.Common
-{
-    unsafe class BitMap : IEnumerable<int>, IDisposable
-    {
-        private const int IntSize = 64;
-        private const int IntMask = IntSize - 1;
-
-        private int _count;
-        private long* _masks;
-        private readonly Allocator _allocator;
-
-        public BitMap(Allocator allocator)
-        {
-            _allocator = allocator;
-        }
-
-        public BitMap(Allocator allocator, int capacity) : this(allocator)
-        {
-            EnsureCapacity(capacity);
-        }
-
-        public bool Set(int bit)
-        {
-            EnsureCapacity(bit + 1);
-
-            int wordIndex = bit / IntSize;
-            int wordBit = bit & IntMask;
-
-            long wordMask = 1L << wordBit;
-
-            if ((_masks[wordIndex] & wordMask) != 0)
-            {
-                return false;
-            }
-
-            _masks[wordIndex] |= wordMask;
-
-            return true;
-        }
-
-        public void Clear(int bit)
-        {
-            EnsureCapacity(bit + 1);
-
-            int wordIndex = bit / IntSize;
-            int wordBit = bit & IntMask;
-
-            long wordMask = 1L << wordBit;
-
-            _masks[wordIndex] &= ~wordMask;
-        }
-
-        public bool IsSet(int bit)
-        {
-            EnsureCapacity(bit + 1);
-
-            int wordIndex = bit / IntSize;
-            int wordBit = bit & IntMask;
-
-            return (_masks[wordIndex] & (1L << wordBit)) != 0;
-        }
-
-        public int FindFirstUnset()
-        {
-            for (int index = 0; index < _count; index++)
-            {
-                long mask = _masks[index];
-
-                if (mask != -1L)
-                {
-                    return BitOperations.TrailingZeroCount(~mask) + index * IntSize;
-                }
-            }
-
-            return _count * IntSize;
-        }
-
-        public bool Set(BitMap map)
-        {
-            EnsureCapacity(map._count * IntSize);
-
-            bool modified = false;
-
-            for (int index = 0; index < _count; index++)
-            {
-                long newValue = _masks[index] | map._masks[index];
-
-                if (_masks[index] != newValue)
-                {
-                    _masks[index] = newValue;
-
-                    modified = true;
-                }
-            }
-
-            return modified;
-        }
-
-        public bool Clear(BitMap map)
-        {
-            EnsureCapacity(map._count * IntSize);
-
-            bool modified = false;
-
-            for (int index = 0; index < _count; index++)
-            {
-                long newValue = _masks[index] & ~map._masks[index];
-
-                if (_masks[index] != newValue)
-                {
-                    _masks[index] = newValue;
-
-                    modified = true;
-                }
-            }
-
-            return modified;
-        }
-
-        private void EnsureCapacity(int size)
-        {
-            int count = (size + IntMask) / IntSize;
-
-            if (count > _count)
-            {
-                var oldMask = _masks;
-                var oldSpan = new Span<long>(_masks, _count);
-
-                _masks = _allocator.Allocate<long>((uint)count);
-                _count = count;
-
-                var newSpan = new Span<long>(_masks, _count);
-
-                oldSpan.CopyTo(newSpan);
-                newSpan.Slice(oldSpan.Length).Clear();
-
-                _allocator.Free(oldMask);
-            }
-        }
-
-        public void Dispose()
-        {
-            if (_masks != null)
-            {
-                _allocator.Free(_masks);
-
-                _masks = null;
-            }
-        }
-
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
-
-        IEnumerator<int> IEnumerable<int>.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
-
-        public Enumerator GetEnumerator()
-        {
-            return new Enumerator(this);
-        }
-
-        public struct Enumerator : IEnumerator<int>
-        {
-            private long _index;
-            private long _mask;
-            private int _bit;
-            private readonly BitMap _map;
-
-            public int Current => (int)_index * IntSize + _bit;
-            object IEnumerator.Current => Current;
-
-            public Enumerator(BitMap map)
-            {
-                _index = -1;
-                _mask = 0;
-                _bit = 0;
-                _map = map;
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool MoveNext()
-            {
-                if (_mask != 0)
-                {
-                    _mask &= ~(1L << _bit);
-                }
-
-                // Manually hoist these loads, because RyuJIT does not.
-                long count = (uint)_map._count;
-                long* masks = _map._masks;
-
-                while (_mask == 0)
-                {
-                    if (++_index >= count)
-                    {
-                        return false;
-                    }
-
-                    _mask = masks[_index];
-                }
-
-                _bit = BitOperations.TrailingZeroCount(_mask);
-
-                return true;
-            }
-
-            public void Reset() { }
-
-            public void Dispose() { }
-        }
-    }
-}

ARMeilleure/Decoders/Block.cs

@@ -1,101 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace ARMeilleure.Decoders
-{
-    class Block
-    {
-        public ulong Address    { get; set; }
-        public ulong EndAddress { get; set; }
-
-        public Block Next   { get; set; }
-        public Block Branch { get; set; }
-
-        public bool Exit { get; set; }
-
-        public List<OpCode> OpCodes { get; }
-
-        public Block()
-        {
-            OpCodes = new List<OpCode>();
-        }
-
-        public Block(ulong address) : this()
-        {
-            Address = address;
-        }
-
-        public void Split(Block rightBlock)
-        {
-            int splitIndex = BinarySearch(OpCodes, rightBlock.Address);
-
-            if (OpCodes[splitIndex].Address < rightBlock.Address)
-            {
-                splitIndex++;
-            }
-
-            int splitCount = OpCodes.Count - splitIndex;
-
-            if (splitCount <= 0)
-            {
-                throw new ArgumentException("Can't split at right block address.");
-            }
-
-            rightBlock.EndAddress = EndAddress;
-
-            rightBlock.Next   = Next;
-            rightBlock.Branch = Branch;
-
-            rightBlock.OpCodes.AddRange(OpCodes.GetRange(splitIndex, splitCount));
-
-            EndAddress = rightBlock.Address;
-
-            Next   = rightBlock;
-            Branch = null;
-
-            OpCodes.RemoveRange(splitIndex, splitCount);
-        }
-
-        private static int BinarySearch(List<OpCode> opCodes, ulong address)
-        {
-            int left   = 0;
-            int middle = 0;
-            int right  = opCodes.Count - 1;
-
-            while (left <= right)
-            {
-                int size = right - left;
-
-                middle = left + (size >> 1);
-
-                OpCode opCode = opCodes[middle];
-
-                if (address == (ulong)opCode.Address)
-                {
-                    break;
-                }
-
-                if (address < (ulong)opCode.Address)
-                {
-                    right = middle - 1;
-                }
-                else
-                {
-                    left = middle + 1;
-                }
-            }
-
-            return middle;
-        }
-
-        public OpCode GetLastOp()
-        {
-            if (OpCodes.Count > 0)
-            {
-                return OpCodes[OpCodes.Count - 1];
-            }
-
-            return null;
-        }
-    }
-}

ARMeilleure/Decoders/Condition.cs

@@ -1,32 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    enum Condition
-    {
-        Eq   = 0,
-        Ne   = 1,
-        GeUn = 2,
-        LtUn = 3,
-        Mi   = 4,
-        Pl   = 5,
-        Vs   = 6,
-        Vc   = 7,
-        GtUn = 8,
-        LeUn = 9,
-        Ge   = 10,
-        Lt   = 11,
-        Gt   = 12,
-        Le   = 13,
-        Al   = 14,
-        Nv   = 15
-    }
-
-    static class ConditionExtensions
-    {
-        public static Condition Invert(this Condition cond)
-        {
-            // Bit 0 of all conditions is basically a negation bit, so
-            // inverting this bit has the effect of inverting the condition.
-            return (Condition)((int)cond ^ 1);
-        }
-    }
-}

ARMeilleure/Decoders/DataOp.cs

@@ -1,10 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    enum DataOp
-    {
-        Adr        = 0,
-        Arithmetic = 1,
-        Logical    = 2,
-        BitField   = 3
-    }
-}

ARMeilleure/Decoders/Decoder.cs

@@ -1,391 +0,0 @@
-using ARMeilleure.Decoders.Optimizations;
-using ARMeilleure.Instructions;
-using ARMeilleure.Memory;
-using ARMeilleure.State;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-
-namespace ARMeilleure.Decoders
-{
-    static class Decoder
-    {
-        // We define a limit on the number of instructions that a function may have,
-        // this prevents functions being potentially too large, which would
-        // take too long to compile and use too much memory.
-        private const int MaxInstsPerFunction = 2500;
-
-        // For lower code quality translation, we set a lower limit since we're blocking execution.
-        private const int MaxInstsPerFunctionLowCq = 500;
-
-        public static Block[] Decode(IMemoryManager memory, ulong address, ExecutionMode mode, bool highCq, DecoderMode dMode)
-        {
-            List<Block> blocks = new List<Block>();
-
-            Queue<Block> workQueue = new Queue<Block>();
-
-            Dictionary<ulong, Block> visited = new Dictionary<ulong, Block>();
-
-            Debug.Assert(MaxInstsPerFunctionLowCq <= MaxInstsPerFunction);
-
-            int opsCount = 0;
-
-            int instructionLimit = highCq ? MaxInstsPerFunction : MaxInstsPerFunctionLowCq;
-
-            Block GetBlock(ulong blkAddress)
-            {
-                if (!visited.TryGetValue(blkAddress, out Block block))
-                {
-                    block = new Block(blkAddress);
-
-                    if ((dMode != DecoderMode.MultipleBlocks && visited.Count >= 1) || opsCount > instructionLimit || !memory.IsMapped(blkAddress))
-                    {
-                        block.Exit = true;
-                        block.EndAddress = blkAddress;
-                    }
-
-                    workQueue.Enqueue(block);
-
-                    visited.Add(blkAddress, block);
-                }
-
-                return block;
-            }
-
-            GetBlock(address);
-
-            while (workQueue.TryDequeue(out Block currBlock))
-            {
-                // Check if the current block is inside another block.
-                if (BinarySearch(blocks, currBlock.Address, out int nBlkIndex))
-                {
-                    Block nBlock = blocks[nBlkIndex];
-
-                    if (nBlock.Address == currBlock.Address)
-                    {
-                        throw new InvalidOperationException("Found duplicate block address on the list.");
-                    }
-
-                    currBlock.Exit = false;
-
-                    nBlock.Split(currBlock);
-
-                    blocks.Insert(nBlkIndex + 1, currBlock);
-
-                    continue;
-                }
-
-                if (!currBlock.Exit)
-                {
-                    // If we have a block after the current one, set the limit address.
-                    ulong limitAddress = ulong.MaxValue;
-
-                    if (nBlkIndex != blocks.Count)
-                    {
-                        Block nBlock = blocks[nBlkIndex];
-
-                        int nextIndex = nBlkIndex + 1;
-
-                        if (nBlock.Address < currBlock.Address && nextIndex < blocks.Count)
-                        {
-                            limitAddress = blocks[nextIndex].Address;
-                        }
-                        else if (nBlock.Address > currBlock.Address)
-                        {
-                            limitAddress = blocks[nBlkIndex].Address;
-                        }
-                    }
-
-                    if (dMode == DecoderMode.SingleInstruction)
-                    {
-                        // Only read at most one instruction
-                        limitAddress = currBlock.Address + 1;
-                    }
-
-                    FillBlock(memory, mode, currBlock, limitAddress);
-
-                    opsCount += currBlock.OpCodes.Count;
-
-                    if (currBlock.OpCodes.Count != 0)
-                    {
-                        // Set child blocks. "Branch" is the block the branch instruction
-                        // points to (when taken), "Next" is the block at the next address,
-                        // executed when the branch is not taken. For Unconditional Branches
-                        // (except BL/BLR that are sub calls) or end of executable, Next is null.
-                        OpCode lastOp = currBlock.GetLastOp();
-
-                        bool isCall = IsCall(lastOp);
-
-                        if (lastOp is IOpCodeBImm op && !isCall)
-                        {
-                            currBlock.Branch = GetBlock((ulong)op.Immediate);
-                        }
-
-                        if (isCall || !(IsUnconditionalBranch(lastOp) || IsTrap(lastOp)))
-                        {
-                            currBlock.Next = GetBlock(currBlock.EndAddress);
-                        }
-                    }
-                }
-
-                // Insert the new block on the list (sorted by address).
-                if (blocks.Count != 0)
-                {
-                    Block nBlock = blocks[nBlkIndex];
-
-                    blocks.Insert(nBlkIndex + (nBlock.Address < currBlock.Address ? 1 : 0), currBlock);
-                }
-                else
-                {
-                    blocks.Add(currBlock);
-                }
-            }
-
-            if (blocks.Count == 1 && blocks[0].OpCodes.Count == 0)
-            {
-                Debug.Assert(blocks[0].Exit);
-                Debug.Assert(blocks[0].Address == blocks[0].EndAddress);
-
-                throw new InvalidOperationException($"Decoded a single empty exit block. Entry point = 0x{address:X}.");
-            }
-
-            if (dMode == DecoderMode.MultipleBlocks)
-            {
-                return TailCallRemover.RunPass(address, blocks);
-            }
-            else
-            {
-                return blocks.ToArray();
-            }
-        }
-
-        public static bool BinarySearch(List<Block> blocks, ulong address, out int index)
-        {
-            index = 0;
-
-            int left  = 0;
-            int right = blocks.Count - 1;
-
-            while (left <= right)
-            {
-                int size = right - left;
-
-                int middle = left + (size >> 1);
-
-                Block block = blocks[middle];
-
-                index = middle;
-
-                if (address >= block.Address && address < block.EndAddress)
-                {
-                    return true;
-                }
-
-                if (address < block.Address)
-                {
-                    right = middle - 1;
-                }
-                else
-                {
-                    left = middle + 1;
-                }
-            }
-
-            return false;
-        }
-
-        private static void FillBlock(
-            IMemoryManager memory,
-            ExecutionMode  mode,
-            Block          block,
-            ulong          limitAddress)
-        {
-            ulong address = block.Address;
-            int itBlockSize = 0;
-
-            OpCode opCode;
-
-            do
-            {
-                if (address >= limitAddress && itBlockSize == 0)
-                {
-                    break;
-                }
-
-                opCode = DecodeOpCode(memory, address, mode);
-
-                block.OpCodes.Add(opCode);
-
-                address += (ulong)opCode.OpCodeSizeInBytes;
-
-                if (opCode is OpCodeT16IfThen it)
-                {
-                    itBlockSize = it.IfThenBlockSize;
-                }
-                else if (itBlockSize > 0)
-                {
-                    itBlockSize--;
-                }
-            }
-            while (!(IsBranch(opCode) || IsException(opCode)));
-
-            block.EndAddress = address;
-        }
-
-        private static bool IsBranch(OpCode opCode)
-        {
-            return opCode is OpCodeBImm ||
-                   opCode is OpCodeBReg || IsAarch32Branch(opCode);
-        }
-
-        private static bool IsUnconditionalBranch(OpCode opCode)
-        {
-            return opCode is OpCodeBImmAl ||
-                   opCode is OpCodeBReg   || IsAarch32UnconditionalBranch(opCode);
-        }
-
-        private static bool IsAarch32UnconditionalBranch(OpCode opCode)
-        {
-            if (!(opCode is OpCode32 op))
-            {
-                return false;
-            }
-
-            // Compare and branch instructions are always conditional.
-            if (opCode.Instruction.Name == InstName.Cbz ||
-                opCode.Instruction.Name == InstName.Cbnz)
-            {
-                return false;
-            }
-
-            // Note: On ARM32, most instructions have conditional execution,
-            // so there's no "Always" (unconditional) branch like on ARM64.
-            // We need to check if the condition is "Always" instead.
-            return IsAarch32Branch(op) && op.Cond >= Condition.Al;
-        }
-
-        private static bool IsAarch32Branch(OpCode opCode)
-        {
-            // Note: On ARM32, most ALU operations can write to R15 (PC),
-            // so we must consider such operations as a branch in potential aswell.
-            if (opCode is IOpCode32Alu opAlu && opAlu.Rd == RegisterAlias.Aarch32Pc)
-            {
-                if (opCode is OpCodeT32)
-                {
-                    return opCode.Instruction.Name != InstName.Tst && opCode.Instruction.Name != InstName.Teq &&
-                           opCode.Instruction.Name != InstName.Cmp && opCode.Instruction.Name != InstName.Cmn;
-                }
-                return true;
-            }
-
-            // Same thing for memory operations. We have the cases where PC is a target
-            // register (Rt == 15 or (mask & (1 << 15)) != 0), and cases where there is
-            // a write back to PC (wback == true && Rn == 15), however the later may
-            // be "undefined" depending on the CPU, so compilers should not produce that.
-            if (opCode is IOpCode32Mem || opCode is IOpCode32MemMult)
-            {
-                int rt, rn;
-
-                bool wBack, isLoad;
-
-                if (opCode is IOpCode32Mem opMem)
-                {
-                    rt     = opMem.Rt;
-                    rn     = opMem.Rn;
-                    wBack  = opMem.WBack;
-                    isLoad = opMem.IsLoad;
-
-                    // For the dual load, we also need to take into account the
-                    // case were Rt2 == 15 (PC).
-                    if (rt == 14 && opMem.Instruction.Name == InstName.Ldrd)
-                    {
-                        rt = RegisterAlias.Aarch32Pc;
-                    }
-                }
-                else if (opCode is IOpCode32MemMult opMemMult)
-                {
-                    const int pcMask = 1 << RegisterAlias.Aarch32Pc;
-
-                    rt     = (opMemMult.RegisterMask & pcMask) != 0 ? RegisterAlias.Aarch32Pc : 0;
-                    rn     =  opMemMult.Rn;
-                    wBack  =  opMemMult.PostOffset != 0;
-                    isLoad =  opMemMult.IsLoad;
-                }
-                else
-                {
-                    throw new NotImplementedException($"The type \"{opCode.GetType().Name}\" is not implemented on the decoder.");
-                }
-
-                if ((rt == RegisterAlias.Aarch32Pc && isLoad) ||
-                    (rn == RegisterAlias.Aarch32Pc && wBack))
-                {
-                    return true;
-                }
-            }
-
-            // Explicit branch instructions.
-            return opCode is IOpCode32BImm ||
-                   opCode is IOpCode32BReg;
-        }
-
-        private static bool IsCall(OpCode opCode)
-        {
-            return opCode.Instruction.Name == InstName.Bl ||
-                   opCode.Instruction.Name == InstName.Blr ||
-                   opCode.Instruction.Name == InstName.Blx;
-        }
-
-        private static bool IsException(OpCode opCode)
-        {
-            return IsTrap(opCode) || opCode.Instruction.Name == InstName.Svc;
-        }
-
-        private static bool IsTrap(OpCode opCode)
-        {
-            return opCode.Instruction.Name == InstName.Brk ||
-                   opCode.Instruction.Name == InstName.Trap ||
-                   opCode.Instruction.Name == InstName.Und;
-        }
-
-        public static OpCode DecodeOpCode(IMemoryManager memory, ulong address, ExecutionMode mode)
-        {
-            int opCode = memory.Read<int>(address);
-
-            InstDescriptor inst;
-
-            OpCodeTable.MakeOp makeOp;
-
-            if (mode == ExecutionMode.Aarch64)
-            {
-                (inst, makeOp) = OpCodeTable.GetInstA64(opCode);
-            }
-            else
-            {
-                if (mode == ExecutionMode.Aarch32Arm)
-                {
-                    (inst, makeOp) = OpCodeTable.GetInstA32(opCode);
-                }
-                else /* if (mode == ExecutionMode.Aarch32Thumb) */
-                {
-                    (inst, makeOp) = OpCodeTable.GetInstT32(opCode);
-                }
-            }
-
-            if (makeOp != null)
-            {
-                return makeOp(inst, address, opCode);
-            }
-            else
-            {
-                if (mode == ExecutionMode.Aarch32Thumb)
-                {
-                    return new OpCodeT16(inst, address, opCode);
-                }
-                else
-                {
-                    return new OpCode(inst, address, opCode);
-                }
-            }
-        }
-    }
-}

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 < tbl.Length; idx++)
-            {
-                tbl[idx] = ExpandImm8ToFP32((uint)idx);
-            }
-
-            return tbl;
-        }
-
-        private static ulong[] BuildImm8ToFP64Table()
-        {
-            ulong[] tbl = new ulong[256];
-
-            for (int idx = 0; idx < tbl.Length; 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/IOpCode32AluReg.cs

@@ -1,7 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    interface IOpCode32AluReg : IOpCode32Alu
-    {
-        int Rm { get; }
-    }
-}

ARMeilleure/Decoders/IOpCode32Exception.cs

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

ARMeilleure/Decoders/IOpCode32HasSetFlags.cs

@@ -1,7 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    interface IOpCode32HasSetFlags
-    {
-        bool? SetFlags { get; }
-    }
-}

ARMeilleure/Decoders/IOpCode32MemEx.cs

@@ -1,7 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    interface IOpCode32MemEx : IOpCode32Mem
-    {
-        int Rd { get; }
-    }
-}

ARMeilleure/Decoders/IOpCode32MemReg.cs

@@ -1,7 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    interface IOpCode32MemReg : IOpCode32Mem
-    {
-        int Rm { get; }
-    }
-}

ARMeilleure/Decoders/IOpCode32Simd.cs

@@ -1,4 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    interface IOpCode32Simd : IOpCode32, IOpCodeSimd { }
-}

ARMeilleure/Decoders/IOpCodeLit.cs

@@ -1,11 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    interface IOpCodeLit : IOpCode
-    {
-        int  Rt        { get; }
-        long Immediate { get; }
-        int  Size      { get; }
-        bool Signed    { get; }
-        bool Prefetch  { get; }
-    }
-}

ARMeilleure/Decoders/InstDescriptor.cs

@@ -1,18 +0,0 @@
-using ARMeilleure.Instructions;
-
-namespace ARMeilleure.Decoders
-{
-    readonly struct InstDescriptor
-    {
-        public static InstDescriptor Undefined => new InstDescriptor(InstName.Und, InstEmit.Und);
-
-        public InstName    Name    { get; }
-        public InstEmitter Emitter { get; }
-
-        public InstDescriptor(InstName name, InstEmitter emitter)
-        {
-            Name    = name;
-            Emitter = emitter;
-        }
-    }
-}

ARMeilleure/Decoders/InstEmitter.cs

@@ -1,6 +0,0 @@
-using ARMeilleure.Translation;
-
-namespace ARMeilleure.Decoders
-{
-    delegate void InstEmitter(ArmEmitterContext context);
-}

ARMeilleure/Decoders/IntType.cs

@@ -1,14 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    enum IntType
-    {
-        UInt8  = 0,
-        UInt16 = 1,
-        UInt32 = 2,
-        UInt64 = 3,
-        Int8   = 4,
-        Int16  = 5,
-        Int32  = 6,
-        Int64  = 7
-    }
-}

ARMeilleure/Decoders/OpCode.cs

@@ -1,49 +0,0 @@
-using ARMeilleure.IntermediateRepresentation;
-using System;
-
-namespace ARMeilleure.Decoders
-{
-    class OpCode : IOpCode
-    {
-        public ulong Address   { get; }
-        public int   RawOpCode { get; }
-
-        public int OpCodeSizeInBytes { get; protected set; } = 4;
-
-        public InstDescriptor Instruction { get; protected set; }
-
-        public RegisterSize RegisterSize { get; protected set; }
-
-        public static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCode(inst, address, opCode);
-
-        public OpCode(InstDescriptor inst, ulong address, int opCode)
-        {
-            Instruction = inst;
-            Address     = address;
-            RawOpCode   = opCode;
-
-            RegisterSize = RegisterSize.Int64;
-        }
-
-        public int GetPairsCount() => GetBitsCount() / 16;
-        public int GetBytesCount() => GetBitsCount() / 8;
-
-        public int GetBitsCount()
-        {
-            switch (RegisterSize)
-            {
-                case RegisterSize.Int32:   return 32;
-                case RegisterSize.Int64:   return 64;
-                case RegisterSize.Simd64:  return 64;
-                case RegisterSize.Simd128: return 128;
-            }
-
-            throw new InvalidOperationException();
-        }
-
-        public OperandType GetOperandType()
-        {
-            return RegisterSize == RegisterSize.Int32 ? OperandType.I32 : OperandType.I64;
-        }
-    }
-}

ARMeilleure/Decoders/OpCode32Mem.cs

@@ -1,39 +0,0 @@
-using ARMeilleure.Instructions;
-
-namespace ARMeilleure.Decoders
-{
-    class OpCode32Mem : OpCode32, IOpCode32Mem
-    {
-        public int Rt { get; protected set; }
-        public int Rn { get; }
-
-        public int Immediate { get; protected set; }
-
-        public bool Index        { get; }
-        public bool Add          { get; }
-        public bool WBack        { get; }
-        public bool Unprivileged { get; }
-
-        public bool IsLoad { get; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCode32Mem(inst, address, opCode);
-
-        public OpCode32Mem(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            Rt = (opCode >> 12) & 0xf;
-            Rn = (opCode >> 16) & 0xf;
-
-            bool isLoad = (opCode & (1 << 20)) != 0;
-            bool w      = (opCode & (1 << 21)) != 0;
-            bool u      = (opCode & (1 << 23)) != 0;
-            bool p      = (opCode & (1 << 24)) != 0;
-
-            Index        = p;
-            Add          = u;
-            WBack        = !p || w;
-            Unprivileged = !p && w;
-
-            IsLoad = isLoad || inst.Name == InstName.Ldrd;
-        }
-    }
-}

ARMeilleure/Decoders/OpCodeAdr.cs

@@ -1,19 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    class OpCodeAdr : OpCode
-    {
-        public int Rd { get; }
-
-        public long Immediate { get; }
-
-         public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCodeAdr(inst, address, opCode);
-
-        public OpCodeAdr(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            Rd = opCode & 0x1f;
-
-            Immediate  = DecoderHelper.DecodeImmS19_2(opCode);
-            Immediate |= ((long)opCode >> 29) & 3;
-        }
-    }
-}

ARMeilleure/Decoders/OpCodeMem.cs

@@ -1,19 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    class OpCodeMem : OpCode
-    {
-        public int  Rt       { get; protected set; }
-        public int  Rn       { get; protected set; }
-        public int  Size     { get; protected set; }
-        public bool Extend64 { get; protected set; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCodeMem(inst, address, opCode);
-
-        public OpCodeMem(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            Rt   = (opCode >>  0) & 0x1f;
-            Rn   = (opCode >>  5) & 0x1f;
-            Size = (opCode >> 30) & 0x3;
-        }
-    }
-}

ARMeilleure/Decoders/OpCodeMemLit.cs

@@ -1,28 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    class OpCodeMemLit : OpCode, IOpCodeLit
-    {
-        public int  Rt        { get; }
-        public long Immediate { get; }
-        public int  Size      { get; }
-        public bool Signed    { get; }
-        public bool Prefetch  { get; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCodeMemLit(inst, address, opCode);
-
-        public OpCodeMemLit(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            Rt = opCode & 0x1f;
-
-            Immediate = (long)address + DecoderHelper.DecodeImmS19_2(opCode);
-
-            switch ((opCode >> 30) & 3)
-            {
-                case 0: Size = 2; Signed = false; Prefetch = false; break;
-                case 1: Size = 3; Signed = false; Prefetch = false; break;
-                case 2: Size = 2; Signed = true;  Prefetch = false; break;
-                case 3: Size = 0; Signed = false; Prefetch = true;  break;
-            }
-        }
-    }
-}

ARMeilleure/Decoders/OpCodeMemPair.cs

@@ -1,25 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    class OpCodeMemPair : OpCodeMemImm
-    {
-        public int Rt2 { get; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCodeMemPair(inst, address, opCode);
-
-        public OpCodeMemPair(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            Rt2      =  (opCode >> 10) & 0x1f;
-            WBack    = ((opCode >> 23) & 0x1) != 0;
-            PostIdx  = ((opCode >> 23) & 0x3) == 1;
-            Extend64 = ((opCode >> 30) & 0x3) == 1;
-            Size     = ((opCode >> 31) & 0x1) | 2;
-
-            DecodeImm(opCode);
-        }
-
-        protected void DecodeImm(int opCode)
-        {
-            Immediate = ((long)(opCode >> 15) << 57) >> (57 - Size);
-        }
-    }
-}

ARMeilleure/Decoders/OpCodeMemReg.cs

@@ -1,20 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    class OpCodeMemReg : OpCodeMem
-    {
-        public bool Shift { get; }
-        public int  Rm    { get; }
-
-        public IntType IntType { get; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCodeMemReg(inst, address, opCode);
-
-        public OpCodeMemReg(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            Shift    =          ((opCode >> 12) & 0x1) != 0;
-            IntType  = (IntType)((opCode >> 13) & 0x7);
-            Rm       =           (opCode >> 16) & 0x1f;
-            Extend64 =          ((opCode >> 22) & 0x3) == 2;
-        }
-    }
-}

ARMeilleure/Decoders/OpCodeSimd.cs

@@ -1,24 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    class OpCodeSimd : OpCode, IOpCodeSimd
-    {
-        public int Rd   { get; }
-        public int Rn   { get; }
-        public int Opc  { get; }
-        public int Size { get; protected set; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCodeSimd(inst, address, opCode);
-
-        public OpCodeSimd(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            Rd   = (opCode >>  0) & 0x1f;
-            Rn   = (opCode >>  5) & 0x1f;
-            Opc  = (opCode >> 15) & 0x3;
-            Size = (opCode >> 22) & 0x3;
-
-            RegisterSize = ((opCode >> 30) & 1) != 0
-                ? RegisterSize.Simd128
-                : RegisterSize.Simd64;
-        }
-    }
-}

ARMeilleure/Decoders/OpCodeSimdIns.cs

@@ -1,36 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    class OpCodeSimdIns : OpCodeSimd
-    {
-        public int SrcIndex { get; }
-        public int DstIndex { get; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCodeSimdIns(inst, address, opCode);
-
-        public OpCodeSimdIns(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            int imm4 = (opCode >> 11) & 0xf;
-            int imm5 = (opCode >> 16) & 0x1f;
-
-            if (imm5 == 0b10000)
-            {
-                Instruction = InstDescriptor.Undefined;
-
-                return;
-            }
-
-            Size = imm5 & -imm5;
-
-            switch (Size)
-            {
-                case 1: Size = 0; break;
-                case 2: Size = 1; break;
-                case 4: Size = 2; break;
-                case 8: Size = 3; break;
-            }
-
-            SrcIndex = imm4 >>  Size;
-            DstIndex = imm5 >> (Size + 1);
-        }
-    }
-}

ARMeilleure/Decoders/OpCodeSimdMemMs.cs

@@ -1,48 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    class OpCodeSimdMemMs : OpCodeMemReg, IOpCodeSimd
-    {
-        public int  Reps   { get; }
-        public int  SElems { get; }
-        public int  Elems  { get; }
-        public bool WBack  { get; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCodeSimdMemMs(inst, address, opCode);
-
-        public OpCodeSimdMemMs(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            switch ((opCode >> 12) & 0xf)
-            {
-                case 0b0000: Reps = 1; SElems = 4; break;
-                case 0b0010: Reps = 4; SElems = 1; break;
-                case 0b0100: Reps = 1; SElems = 3; break;
-                case 0b0110: Reps = 3; SElems = 1; break;
-                case 0b0111: Reps = 1; SElems = 1; break;
-                case 0b1000: Reps = 1; SElems = 2; break;
-                case 0b1010: Reps = 2; SElems = 1; break;
-
-                default: Instruction = InstDescriptor.Undefined; return;
-            }
-
-            Size  =  (opCode >> 10) & 3;
-            WBack = ((opCode >> 23) & 1) != 0;
-
-            bool q = ((opCode >> 30) & 1) != 0;
-
-            if (!q && Size == 3 && SElems != 1)
-            {
-                Instruction = InstDescriptor.Undefined;
-
-                return;
-            }
-
-            Extend64 = false;
-
-            RegisterSize = q
-                ? RegisterSize.Simd128
-                : RegisterSize.Simd64;
-
-            Elems = (GetBitsCount() >> 3) >> Size;
-        }
-    }
-}

ARMeilleure/Decoders/OpCodeSimdMemSs.cs

@@ -1,97 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    class OpCodeSimdMemSs : OpCodeMemReg, IOpCodeSimd
-    {
-        public int  SElems    { get; }
-        public int  Index     { get; }
-        public bool Replicate { get; }
-        public bool WBack     { get; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCodeSimdMemSs(inst, address, opCode);
-
-        public OpCodeSimdMemSs(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            int size   = (opCode >> 10) & 3;
-            int s      = (opCode >> 12) & 1;
-            int sElems = (opCode >> 12) & 2;
-            int scale  = (opCode >> 14) & 3;
-            int l      = (opCode >> 22) & 1;
-            int q      = (opCode >> 30) & 1;
-
-            sElems |= (opCode >> 21) & 1;
-
-            sElems++;
-
-            int index = (q << 3) | (s << 2) | size;
-
-            switch (scale)
-            {
-                case 1:
-                {
-                    if ((size & 1) != 0)
-                    {
-                        Instruction = InstDescriptor.Undefined;
-
-                        return;
-                    }
-
-                    index >>= 1;
-
-                    break;
-                }
-
-                case 2:
-                {
-                    if ((size & 2) != 0 ||
-                       ((size & 1) != 0 && s != 0))
-                    {
-                        Instruction = InstDescriptor.Undefined;
-
-                        return;
-                    }
-
-                    if ((size & 1) != 0)
-                    {
-                        index >>= 3;
-
-                        scale = 3;
-                    }
-                    else
-                    {
-                        index >>= 2;
-                    }
-
-                    break;
-                }
-
-                case 3:
-                {
-                    if (l == 0 || s != 0)
-                    {
-                        Instruction = InstDescriptor.Undefined;
-
-                        return;
-                    }
-
-                    scale = size;
-
-                    Replicate = true;
-
-                    break;
-                }
-            }
-
-            Index  = index;
-            SElems = sElems;
-            Size   = scale;
-
-            Extend64 = false;
-
-            WBack = ((opCode >> 23) & 1) != 0;
-
-            RegisterSize = q != 0
-                ? RegisterSize.Simd128
-                : RegisterSize.Simd64;
-        }
-    }
-}

ARMeilleure/Decoders/OpCodeSimdReg.cs

@@ -1,18 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    class OpCodeSimdReg : OpCodeSimd
-    {
-        public bool Bit3 { get; }
-        public int  Ra   { get; }
-        public int  Rm   { get; protected set; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCodeSimdReg(inst, address, opCode);
-
-        public OpCodeSimdReg(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            Bit3 = ((opCode >>  3) & 0x1) != 0;
-            Ra   =  (opCode >> 10) & 0x1f;
-            Rm   =  (opCode >> 16) & 0x1f;
-        }
-    }
-}

ARMeilleure/Decoders/OpCodeSystem.cs

@@ -1,24 +0,0 @@
-namespace ARMeilleure.Decoders
-{
-    class OpCodeSystem : OpCode
-    {
-        public int Rt  { get; }
-        public int Op2 { get; }
-        public int CRm { get; }
-        public int CRn { get; }
-        public int Op1 { get; }
-        public int Op0 { get; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCodeSystem(inst, address, opCode);
-
-        public OpCodeSystem(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            Rt  =  (opCode >>  0) & 0x1f;
-            Op2 =  (opCode >>  5) & 0x7;
-            CRm =  (opCode >>  8) & 0xf;
-            CRn =  (opCode >> 12) & 0xf;
-            Op1 =  (opCode >> 16) & 0x7;
-            Op0 = ((opCode >> 19) & 0x1) | 2;
-        }
-    }
-}

ARMeilleure/Decoders/OpCodeT16MemImm5.cs

@@ -1,58 +0,0 @@
-using ARMeilleure.Instructions;
-using System;
-
-namespace ARMeilleure.Decoders
-{
-    class OpCodeT16MemImm5 : OpCodeT16, IOpCode32Mem
-    {
-        public int Rt { get; }
-        public int Rn { get; }
-
-        public bool WBack => false;
-        public bool IsLoad { get; }
-        public bool Index => true;
-        public bool Add => true;
-
-        public int Immediate { get; }
-
-        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCodeT16MemImm5(inst, address, opCode);
-
-        public OpCodeT16MemImm5(InstDescriptor inst, ulong address, int opCode) : base(inst, address, opCode)
-        {
-            Rt = (opCode >> 0) & 7;
-            Rn = (opCode >> 3) & 7;
-
-            switch (inst.Name)
-            {
-                case InstName.Ldr:
-                case InstName.Ldrb:
-                case InstName.Ldrh:
-                    IsLoad = true;
-                    break;
-                case InstName.Str:
-                case InstName.Strb:
-                case InstName.Strh:
-                    IsLoad = false;
-                    break;
-            }
-
-            switch (inst.Name)
-            {
-                case InstName.Str:
-                case InstName.Ldr:
-                    Immediate = ((opCode >> 6) & 0x1f) << 2;
-                    break;
-                case InstName.Strb:
-                case InstName.Ldrb:
-                    Immediate = ((opCode >> 6) & 0x1f);
-                    break;
-                case InstName.Strh:
-                case InstName.Ldrh:
-                    Immediate = ((opCode >> 6) & 0x1f) << 1;
-                    break;
-                default:
-                    throw new InvalidOperationException();
-            }
-        }
-    }
-}

ARMeilleure/Diagnostics/Logger.cs

@@ -1,56 +0,0 @@
-using ARMeilleure.Translation;
-using System;
-using System.Diagnostics;
-
-namespace ARMeilleure.Diagnostics
-{
-    static class Logger
-    {
-        private static long _startTime;
-
-        private static long[] _accumulatedTime;
-
-        static Logger()
-        {
-            _accumulatedTime = new long[(int)PassName.Count];
-        }
-
-        [Conditional("M_DEBUG")]
-        public static void StartPass(PassName name)
-        {
-            WriteOutput(name + " pass started...");
-
-            _startTime = Stopwatch.GetTimestamp();
-        }
-
-        [Conditional("M_DEBUG")]
-        public static void EndPass(PassName name, ControlFlowGraph cfg)
-        {
-            EndPass(name);
-
-            WriteOutput("IR after " + name + " pass:");
-
-            WriteOutput(IRDumper.GetDump(cfg));
-        }
-
-        [Conditional("M_DEBUG")]
-        public static void EndPass(PassName name)
-        {
-            long elapsedTime = Stopwatch.GetTimestamp() - _startTime;
-
-            _accumulatedTime[(int)name] += elapsedTime;
-
-            WriteOutput($"{name} pass ended after {GetMilliseconds(_accumulatedTime[(int)name])} ms...");
-        }
-
-        private static long GetMilliseconds(long ticks)
-        {
-            return (long)(((double)ticks / Stopwatch.Frequency) * 1000);
-        }
-
-        private static void WriteOutput(string text)
-        {
-            Console.WriteLine(text);
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitAlu.cs

@@ -1,400 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.State;
-using ARMeilleure.Translation;
-using System.Diagnostics;
-
-using static ARMeilleure.Instructions.InstEmitAluHelper;
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static partial class InstEmit
-    {
-        public static void Adc(ArmEmitterContext context)  => EmitAdc(context, setFlags: false);
-        public static void Adcs(ArmEmitterContext context) => EmitAdc(context, setFlags: true);
-
-        private static void EmitAdc(ArmEmitterContext context, bool setFlags)
-        {
-            Operand n = GetAluN(context);
-            Operand m = GetAluM(context);
-
-            Operand d = context.Add(n, m);
-
-            Operand carry = GetFlag(PState.CFlag);
-
-            if (context.CurrOp.RegisterSize == RegisterSize.Int64)
-            {
-                carry = context.ZeroExtend32(OperandType.I64, carry);
-            }
-
-            d = context.Add(d, carry);
-
-            if (setFlags)
-            {
-                EmitNZFlagsCheck(context, d);
-
-                EmitAdcsCCheck(context, n, d);
-                EmitAddsVCheck(context, n, m, d);
-            }
-
-            SetAluDOrZR(context, d);
-        }
-
-        public static void Add(ArmEmitterContext context)
-        {
-            SetAluD(context, context.Add(GetAluN(context), GetAluM(context)));
-        }
-
-        public static void Adds(ArmEmitterContext context)
-        {
-            Operand n = GetAluN(context);
-            Operand m = GetAluM(context);
-
-            context.MarkComparison(n, m);
-
-            Operand d = context.Add(n, m);
-
-            EmitNZFlagsCheck(context, d);
-
-            EmitAddsCCheck(context, n, d);
-            EmitAddsVCheck(context, n, m, d);
-
-            SetAluDOrZR(context, d);
-        }
-
-        public static void And(ArmEmitterContext context)
-        {
-            SetAluD(context, context.BitwiseAnd(GetAluN(context), GetAluM(context)));
-        }
-
-        public static void Ands(ArmEmitterContext context)
-        {
-            Operand n = GetAluN(context);
-            Operand m = GetAluM(context);
-
-            Operand d = context.BitwiseAnd(n, m);
-
-            EmitNZFlagsCheck(context, d);
-            EmitCVFlagsClear(context);
-
-            SetAluDOrZR(context, d);
-        }
-
-        public static void Asrv(ArmEmitterContext context)
-        {
-            SetAluDOrZR(context, context.ShiftRightSI(GetAluN(context), GetAluMShift(context)));
-        }
-
-        public static void Bic(ArmEmitterContext context)  => EmitBic(context, setFlags: false);
-        public static void Bics(ArmEmitterContext context) => EmitBic(context, setFlags: true);
-
-        private static void EmitBic(ArmEmitterContext context, bool setFlags)
-        {
-            Operand n = GetAluN(context);
-            Operand m = GetAluM(context);
-
-            Operand d = context.BitwiseAnd(n, context.BitwiseNot(m));
-
-            if (setFlags)
-            {
-                EmitNZFlagsCheck(context, d);
-                EmitCVFlagsClear(context);
-            }
-
-            SetAluD(context, d, setFlags);
-        }
-
-        public static void Cls(ArmEmitterContext context)
-        {
-            OpCodeAlu op = (OpCodeAlu)context.CurrOp;
-
-            Operand n = GetIntOrZR(context, op.Rn);
-
-            Operand nHigh = context.ShiftRightUI(n, Const(1));
-
-            bool is32Bits = op.RegisterSize == RegisterSize.Int32;
-
-            Operand mask = is32Bits ? Const(int.MaxValue) : Const(long.MaxValue);
-
-            Operand nLow = context.BitwiseAnd(n, mask);
-
-            Operand res = context.CountLeadingZeros(context.BitwiseExclusiveOr(nHigh, nLow));
-
-            res = context.Subtract(res, Const(res.Type, 1));
-
-            SetAluDOrZR(context, res);
-        }
-
-        public static void Clz(ArmEmitterContext context)
-        {
-            OpCodeAlu op = (OpCodeAlu)context.CurrOp;
-
-            Operand n = GetIntOrZR(context, op.Rn);
-
-            Operand d = context.CountLeadingZeros(n);
-
-            SetAluDOrZR(context, d);
-        }
-
-        public static void Eon(ArmEmitterContext context)
-        {
-            Operand n = GetAluN(context);
-            Operand m = GetAluM(context);
-
-            Operand d = context.BitwiseExclusiveOr(n, context.BitwiseNot(m));
-
-            SetAluD(context, d);
-        }
-
-        public static void Eor(ArmEmitterContext context)
-        {
-            SetAluD(context, context.BitwiseExclusiveOr(GetAluN(context), GetAluM(context)));
-        }
-
-        public static void Extr(ArmEmitterContext context)
-        {
-            OpCodeAluRs op = (OpCodeAluRs)context.CurrOp;
-
-            Operand res = GetIntOrZR(context, op.Rm);
-
-            if (op.Shift != 0)
-            {
-                if (op.Rn == op.Rm)
-                {
-                    res = context.RotateRight(res, Const(op.Shift));
-                }
-                else
-                {
-                    res = context.ShiftRightUI(res, Const(op.Shift));
-
-                    Operand n = GetIntOrZR(context, op.Rn);
-
-                    int invShift = op.GetBitsCount() - op.Shift;
-
-                    res = context.BitwiseOr(res, context.ShiftLeft(n, Const(invShift)));
-                }
-            }
-
-            SetAluDOrZR(context, res);
-        }
-
-        public static void Lslv(ArmEmitterContext context)
-        {
-            SetAluDOrZR(context, context.ShiftLeft(GetAluN(context), GetAluMShift(context)));
-        }
-
-        public static void Lsrv(ArmEmitterContext context)
-        {
-            SetAluDOrZR(context, context.ShiftRightUI(GetAluN(context), GetAluMShift(context)));
-        }
-
-        public static void Sbc(ArmEmitterContext context)  => EmitSbc(context, setFlags: false);
-        public static void Sbcs(ArmEmitterContext context) => EmitSbc(context, setFlags: true);
-
-        private static void EmitSbc(ArmEmitterContext context, bool setFlags)
-        {
-            Operand n = GetAluN(context);
-            Operand m = GetAluM(context);
-
-            Operand d = context.Subtract(n, m);
-
-            Operand borrow = context.BitwiseExclusiveOr(GetFlag(PState.CFlag), Const(1));
-
-            if (context.CurrOp.RegisterSize == RegisterSize.Int64)
-            {
-                borrow = context.ZeroExtend32(OperandType.I64, borrow);
-            }
-
-            d = context.Subtract(d, borrow);
-
-            if (setFlags)
-            {
-                EmitNZFlagsCheck(context, d);
-
-                EmitSbcsCCheck(context, n, m);
-                EmitSubsVCheck(context, n, m, d);
-            }
-
-            SetAluDOrZR(context, d);
-        }
-
-        public static void Sub(ArmEmitterContext context)
-        {
-            SetAluD(context, context.Subtract(GetAluN(context), GetAluM(context)));
-        }
-
-        public static void Subs(ArmEmitterContext context)
-        {
-            Operand n = GetAluN(context);
-            Operand m = GetAluM(context);
-
-            context.MarkComparison(n, m);
-
-            Operand d = context.Subtract(n, m);
-
-            EmitNZFlagsCheck(context, d);
-
-            EmitSubsCCheck(context, n, m);
-            EmitSubsVCheck(context, n, m, d);
-
-            SetAluDOrZR(context, d);
-        }
-
-        public static void Orn(ArmEmitterContext context)
-        {
-            Operand n = GetAluN(context);
-            Operand m = GetAluM(context);
-
-            Operand d = context.BitwiseOr(n, context.BitwiseNot(m));
-
-            SetAluD(context, d);
-        }
-
-        public static void Orr(ArmEmitterContext context)
-        {
-            SetAluD(context, context.BitwiseOr(GetAluN(context), GetAluM(context)));
-        }
-
-        public static void Rbit(ArmEmitterContext context)
-        {
-            OpCodeAlu op = (OpCodeAlu)context.CurrOp;
-
-            Operand n = GetIntOrZR(context, op.Rn);
-            Operand d;
-
-            if (op.RegisterSize == RegisterSize.Int32)
-            {
-                d = EmitReverseBits32Op(context, n);
-            }
-            else
-            {
-                d = EmitReverseBits64Op(context, n);
-            }
-
-            SetAluDOrZR(context, d);
-        }
-
-        private static Operand EmitReverseBits64Op(ArmEmitterContext context, Operand op)
-        {
-            Debug.Assert(op.Type == OperandType.I64);
-
-            Operand val = context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(op, Const(0xaaaaaaaaaaaaaaaaul)), Const(1)),
-                                            context.ShiftLeft   (context.BitwiseAnd(op, Const(0x5555555555555555ul)), Const(1)));
-
-            val = context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(val, Const(0xccccccccccccccccul)), Const(2)),
-                                    context.ShiftLeft   (context.BitwiseAnd(val, Const(0x3333333333333333ul)), Const(2)));
-            val = context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(val, Const(0xf0f0f0f0f0f0f0f0ul)), Const(4)),
-                                    context.ShiftLeft   (context.BitwiseAnd(val, Const(0x0f0f0f0f0f0f0f0ful)), Const(4)));
-            val = context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(val, Const(0xff00ff00ff00ff00ul)), Const(8)),
-                                    context.ShiftLeft   (context.BitwiseAnd(val, Const(0x00ff00ff00ff00fful)), Const(8)));
-            val = context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(val, Const(0xffff0000ffff0000ul)), Const(16)),
-                                    context.ShiftLeft   (context.BitwiseAnd(val, Const(0x0000ffff0000fffful)), Const(16)));
-
-            return context.BitwiseOr(context.ShiftRightUI(val, Const(32)), context.ShiftLeft(val, Const(32)));
-        }
-
-        public static void Rev16(ArmEmitterContext context)
-        {
-            OpCodeAlu op = (OpCodeAlu)context.CurrOp;
-
-            Operand n = GetIntOrZR(context, op.Rn);
-            Operand d;
-
-            if (op.RegisterSize == RegisterSize.Int32)
-            {
-                d = EmitReverseBytes16_32Op(context, n);
-            }
-            else
-            {
-                d = EmitReverseBytes16_64Op(context, n);
-            }
-
-            SetAluDOrZR(context, d);
-        }
-
-        public static void Rev32(ArmEmitterContext context)
-        {
-            OpCodeAlu op = (OpCodeAlu)context.CurrOp;
-
-            Operand n = GetIntOrZR(context, op.Rn);
-            Operand d;
-
-            if (op.RegisterSize == RegisterSize.Int32)
-            {
-                d = context.ByteSwap(n);
-            }
-            else
-            {
-                d = EmitReverseBytes32_64Op(context, n);
-            }
-
-            SetAluDOrZR(context, d);
-        }
-
-        private static Operand EmitReverseBytes32_64Op(ArmEmitterContext context, Operand op)
-        {
-            Debug.Assert(op.Type == OperandType.I64);
-
-            Operand val = EmitReverseBytes16_64Op(context, op);
-
-            return context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(val, Const(0xffff0000ffff0000ul)), Const(16)),
-                                     context.ShiftLeft   (context.BitwiseAnd(val, Const(0x0000ffff0000fffful)), Const(16)));
-        }
-
-        public static void Rev64(ArmEmitterContext context)
-        {
-            OpCodeAlu op = (OpCodeAlu)context.CurrOp;
-
-            SetAluDOrZR(context, context.ByteSwap(GetIntOrZR(context, op.Rn)));
-        }
-
-        public static void Rorv(ArmEmitterContext context)
-        {
-            SetAluDOrZR(context, context.RotateRight(GetAluN(context), GetAluMShift(context)));
-        }
-
-        private static Operand GetAluMShift(ArmEmitterContext context)
-        {
-            IOpCodeAluRs op = (IOpCodeAluRs)context.CurrOp;
-
-            Operand m = GetIntOrZR(context, op.Rm);
-
-            if (op.RegisterSize == RegisterSize.Int64)
-            {
-                m = context.ConvertI64ToI32(m);
-            }
-
-            return context.BitwiseAnd(m, Const(context.CurrOp.GetBitsCount() - 1));
-        }
-
-        private static void EmitCVFlagsClear(ArmEmitterContext context)
-        {
-            SetFlag(context, PState.CFlag, Const(0));
-            SetFlag(context, PState.VFlag, Const(0));
-        }
-
-        public static void SetAluD(ArmEmitterContext context, Operand d)
-        {
-            SetAluD(context, d, x31IsZR: false);
-        }
-
-        public static void SetAluDOrZR(ArmEmitterContext context, Operand d)
-        {
-            SetAluD(context, d, x31IsZR: true);
-        }
-
-        public static void SetAluD(ArmEmitterContext context, Operand d, bool x31IsZR)
-        {
-            IOpCodeAlu op = (IOpCodeAlu)context.CurrOp;
-
-            if ((x31IsZR || op is IOpCodeAluRs) && op.Rd == RegisterConsts.ZeroIndex)
-            {
-                return;
-            }
-
-            SetIntOrSP(context, op.Rd, d);
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitAluHelper.cs

@@ -1,613 +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.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static class InstEmitAluHelper
-    {
-        public static bool ShouldSetFlags(ArmEmitterContext context)
-        {
-            IOpCode32HasSetFlags op = (IOpCode32HasSetFlags)context.CurrOp;
-
-            if (op.SetFlags == null)
-            {
-                return !context.IsInIfThenBlock;
-            }
-
-            return op.SetFlags.Value;
-        }
-
-        public static void EmitNZFlagsCheck(ArmEmitterContext context, Operand d)
-        {
-            SetFlag(context, PState.NFlag, context.ICompareLess (d, Const(d.Type, 0)));
-            SetFlag(context, PState.ZFlag, context.ICompareEqual(d, Const(d.Type, 0)));
-        }
-
-        public static void EmitAdcsCCheck(ArmEmitterContext context, Operand n, Operand d)
-        {
-            // C = (Rd == Rn && CIn) || Rd < Rn
-            Operand cIn = GetFlag(PState.CFlag);
-
-            Operand cOut = context.BitwiseAnd(context.ICompareEqual(d, n), cIn);
-
-            cOut = context.BitwiseOr(cOut, context.ICompareLessUI(d, n));
-
-            SetFlag(context, PState.CFlag, cOut);
-        }
-
-        public static void EmitAddsCCheck(ArmEmitterContext context, Operand n, Operand d)
-        {
-            // C = Rd < Rn
-            SetFlag(context, PState.CFlag, context.ICompareLessUI(d, n));
-        }
-
-        public static void EmitAddsVCheck(ArmEmitterContext context, Operand n, Operand m, Operand d)
-        {
-            // V = (Rd ^ Rn) & ~(Rn ^ Rm) < 0
-            Operand vOut = context.BitwiseExclusiveOr(d, n);
-
-            vOut = context.BitwiseAnd(vOut, context.BitwiseNot(context.BitwiseExclusiveOr(n, m)));
-
-            vOut = context.ICompareLess(vOut, Const(vOut.Type, 0));
-
-            SetFlag(context, PState.VFlag, vOut);
-        }
-
-        public static void EmitSbcsCCheck(ArmEmitterContext context, Operand n, Operand m)
-        {
-            // C = (Rn == Rm && CIn) || Rn > Rm
-            Operand cIn = GetFlag(PState.CFlag);
-
-            Operand cOut = context.BitwiseAnd(context.ICompareEqual(n, m), cIn);
-
-            cOut = context.BitwiseOr(cOut, context.ICompareGreaterUI(n, m));
-
-            SetFlag(context, PState.CFlag, cOut);
-        }
-
-        public static void EmitSubsCCheck(ArmEmitterContext context, Operand n, Operand m)
-        {
-            // C = Rn >= Rm
-            SetFlag(context, PState.CFlag, context.ICompareGreaterOrEqualUI(n, m));
-        }
-
-        public static void EmitSubsVCheck(ArmEmitterContext context, Operand n, Operand m, Operand d)
-        {
-            // V = (Rd ^ Rn) & (Rn ^ Rm) < 0
-            Operand vOut = context.BitwiseExclusiveOr(d, n);
-
-            vOut = context.BitwiseAnd(vOut, context.BitwiseExclusiveOr(n, m));
-
-            vOut = context.ICompareLess(vOut, Const(vOut.Type, 0));
-
-            SetFlag(context, PState.VFlag, vOut);
-        }
-
-        public static Operand EmitReverseBits32Op(ArmEmitterContext context, Operand op)
-        {
-            Debug.Assert(op.Type == OperandType.I32);
-
-            Operand val = context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(op, Const(0xaaaaaaaau)), Const(1)),
-                                            context.ShiftLeft(context.BitwiseAnd(op, Const(0x55555555u)), Const(1)));
-
-            val = context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(val, Const(0xccccccccu)), Const(2)),
-                                    context.ShiftLeft(context.BitwiseAnd(val, Const(0x33333333u)), Const(2)));
-            val = context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(val, Const(0xf0f0f0f0u)), Const(4)),
-                                    context.ShiftLeft(context.BitwiseAnd(val, Const(0x0f0f0f0fu)), Const(4)));
-            val = context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(val, Const(0xff00ff00u)), Const(8)),
-                                    context.ShiftLeft(context.BitwiseAnd(val, Const(0x00ff00ffu)), Const(8)));
-
-            return context.BitwiseOr(context.ShiftRightUI(val, Const(16)), context.ShiftLeft(val, Const(16)));
-        }
-
-        public static Operand EmitReverseBytes16_64Op(ArmEmitterContext context, Operand op)
-        {
-            Debug.Assert(op.Type == OperandType.I64);
-
-            return context.BitwiseOr(context.ShiftRightUI(context.BitwiseAnd(op, Const(0xff00ff00ff00ff00ul)), Const(8)),
-                                     context.ShiftLeft(context.BitwiseAnd(op, Const(0x00ff00ff00ff00fful)), Const(8)));
-        }
-
-        public static Operand EmitReverseBytes16_32Op(ArmEmitterContext context, Operand op)
-        {
-            Debug.Assert(op.Type == OperandType.I32);
-
-            Operand val = EmitReverseBytes16_64Op(context, context.ZeroExtend32(OperandType.I64, op));
-
-            return context.ConvertI64ToI32(val);
-        }
-
-        private static void EmitAluWritePc(ArmEmitterContext context, Operand value)
-        {
-            Debug.Assert(value.Type == OperandType.I32);
-
-            if (((OpCode32)context.CurrOp).IsThumb)
-            {
-                bool isReturn = IsA32Return(context);
-                if (!isReturn)
-                {
-                    context.StoreToContext();
-                }
-
-                InstEmitFlowHelper.EmitVirtualJump(context, value, isReturn);
-            }
-            else
-            {
-                EmitBxWritePc(context, value);
-            }
-        }
-
-        public static void EmitGenericAluStoreA32(ArmEmitterContext context, int rd, bool setFlags, Operand value)
-        {
-            Debug.Assert(value.Type == OperandType.I32);
-
-            if (rd == RegisterAlias.Aarch32Pc && setFlags)
-            {
-                if (setFlags)
-                {
-                    // TODO: Load SPSR etc.
-
-                    EmitBxWritePc(context, value);
-                }
-                else
-                {
-                    EmitAluWritePc(context, value);
-                }
-            }
-            else
-            {
-                SetIntA32(context, rd, value);
-            }
-        }
-
-        public static Operand GetAluN(ArmEmitterContext context)
-        {
-            if (context.CurrOp is IOpCodeAlu op)
-            {
-                if (op.DataOp == DataOp.Logical || op is IOpCodeAluRs)
-                {
-                    return GetIntOrZR(context, op.Rn);
-                }
-                else
-                {
-                    return GetIntOrSP(context, op.Rn);
-                }
-            }
-            else if (context.CurrOp is IOpCode32Alu op32)
-            {
-                return GetIntA32(context, op32.Rn);
-            }
-            else
-            {
-                throw InvalidOpCodeType(context.CurrOp);
-            }
-        }
-
-        public static Operand GetAluM(ArmEmitterContext context, bool setCarry = true)
-        {
-            switch (context.CurrOp)
-            {
-                // ARM32.
-                case IOpCode32AluImm op:
-                {
-                    if (ShouldSetFlags(context) && op.IsRotated && setCarry)
-                    {
-                        SetFlag(context, PState.CFlag, Const((uint)op.Immediate >> 31));
-                    }
-
-                    return Const(op.Immediate);
-                }
-
-                case IOpCode32AluImm16 op: return Const(op.Immediate);
-
-                case IOpCode32AluRsImm op: return GetMShiftedByImmediate(context, op, setCarry);
-                case IOpCode32AluRsReg op: return GetMShiftedByReg(context, op, setCarry);
-
-                case IOpCode32AluReg op: return GetIntA32(context, op.Rm);
-
-                // ARM64.
-                case IOpCodeAluImm op:
-                {
-                    if (op.GetOperandType() == OperandType.I32)
-                    {
-                        return Const((int)op.Immediate);
-                    }
-                    else
-                    {
-                        return Const(op.Immediate);
-                    }
-                }
-
-                case IOpCodeAluRs op:
-                {
-                    Operand value = GetIntOrZR(context, op.Rm);
-
-                    switch (op.ShiftType)
-                    {
-                        case ShiftType.Lsl: value = context.ShiftLeft   (value, Const(op.Shift)); break;
-                        case ShiftType.Lsr: value = context.ShiftRightUI(value, Const(op.Shift)); break;
-                        case ShiftType.Asr: value = context.ShiftRightSI(value, Const(op.Shift)); break;
-                        case ShiftType.Ror: value = context.RotateRight (value, Const(op.Shift)); break;
-                    }
-
-                    return value;
-                }
-
-                case IOpCodeAluRx op:
-                {
-                    Operand value = GetExtendedM(context, op.Rm, op.IntType);
-
-                    value = context.ShiftLeft(value, Const(op.Shift));
-
-                    return value;
-                }
-
-                default: throw InvalidOpCodeType(context.CurrOp);
-            }
-        }
-
-        private static Exception InvalidOpCodeType(OpCode opCode)
-        {
-            return new InvalidOperationException($"Invalid OpCode type \"{opCode?.GetType().Name ?? "null"}\".");
-        }
-
-        // ARM32 helpers.
-        public static Operand GetMShiftedByImmediate(ArmEmitterContext context, IOpCode32AluRsImm op, bool setCarry)
-        {
-            Operand m = GetIntA32(context, op.Rm);
-
-            int shift = op.Immediate;
-
-            if (shift == 0)
-            {
-                switch (op.ShiftType)
-                {
-                    case ShiftType.Lsr: shift = 32; break;
-                    case ShiftType.Asr: shift = 32; break;
-                    case ShiftType.Ror: shift = 1;  break;
-                }
-            }
-
-            if (shift != 0)
-            {
-                setCarry &= ShouldSetFlags(context);
-
-                switch (op.ShiftType)
-                {
-                    case ShiftType.Lsl: m = GetLslC(context, m, setCarry, shift); break;
-                    case ShiftType.Lsr: m = GetLsrC(context, m, setCarry, shift); break;
-                    case ShiftType.Asr: m = GetAsrC(context, m, setCarry, shift); break;
-                    case ShiftType.Ror:
-                        if (op.Immediate != 0)
-                        {
-                            m = GetRorC(context, m, setCarry, shift);
-                        }
-                        else
-                        {
-                            m = GetRrxC(context, m, setCarry);
-                        }
-                        break;
-                }
-            }
-
-            return m;
-        }
-
-        public static int DecodeImmShift(ShiftType shiftType, int shift)
-        {
-            if (shift == 0)
-            {
-                switch (shiftType)
-                {
-                    case ShiftType.Lsr: shift = 32; break;
-                    case ShiftType.Asr: shift = 32; break;
-                    case ShiftType.Ror: shift = 1;  break;
-                }
-            }
-
-            return shift;
-        }
-
-        public static Operand GetMShiftedByReg(ArmEmitterContext context, IOpCode32AluRsReg op, bool setCarry)
-        {
-            Operand m = GetIntA32(context, op.Rm);
-            Operand s = context.ZeroExtend8(OperandType.I32, GetIntA32(context, op.Rs));
-            Operand shiftIsZero = context.ICompareEqual(s, Const(0));
-
-            Operand zeroResult = m;
-            Operand shiftResult = m;
-
-            setCarry &= ShouldSetFlags(context);
-
-            switch (op.ShiftType)
-            {
-                case ShiftType.Lsl: shiftResult = EmitLslC(context, m, setCarry, s, shiftIsZero); break;
-                case ShiftType.Lsr: shiftResult = EmitLsrC(context, m, setCarry, s, shiftIsZero); break;
-                case ShiftType.Asr: shiftResult = EmitAsrC(context, m, setCarry, s, shiftIsZero); break;
-                case ShiftType.Ror: shiftResult = EmitRorC(context, m, setCarry, s, shiftIsZero); break;
-            }
-
-            return context.ConditionalSelect(shiftIsZero, zeroResult, shiftResult);
-        }
-
-        public static void EmitIfHelper(ArmEmitterContext context, Operand boolValue, Action action, bool expected = true)
-        {
-            Debug.Assert(boolValue.Type == OperandType.I32);
-
-            Operand endLabel = Label();
-
-            if (expected)
-            {
-                context.BranchIfFalse(endLabel, boolValue);
-            }
-            else
-            {
-                context.BranchIfTrue(endLabel, boolValue);
-            }
-
-            action();
-
-            context.MarkLabel(endLabel);
-        }
-
-        public static Operand EmitLslC(ArmEmitterContext context, Operand m, bool setCarry, Operand shift, Operand shiftIsZero)
-        {
-            Debug.Assert(m.Type == OperandType.I32 && shift.Type == OperandType.I32 && shiftIsZero.Type == OperandType.I32);
-
-            Operand shiftLarge = context.ICompareGreaterOrEqual(shift, Const(32));
-            Operand result = context.ShiftLeft(m, shift);
-            if (setCarry)
-            {
-                EmitIfHelper(context, shiftIsZero, () =>
-                {
-                    Operand cOut = context.ShiftRightUI(m, context.Subtract(Const(32), shift));
-
-                    cOut = context.BitwiseAnd(cOut, Const(1));
-                    cOut = context.ConditionalSelect(context.ICompareGreater(shift, Const(32)), Const(0), cOut);
-
-                    SetFlag(context, PState.CFlag, cOut);
-                }, false);
-            }
-
-            return context.ConditionalSelect(shiftLarge, Const(0), result);
-        }
-
-        public static Operand GetLslC(ArmEmitterContext context, Operand m, bool setCarry, int shift)
-        {
-            Debug.Assert(m.Type == OperandType.I32);
-
-            if ((uint)shift > 32)
-            {
-                return GetShiftByMoreThan32(context, setCarry);
-            }
-            else if (shift == 32)
-            {
-                if (setCarry)
-                {
-                    SetCarryMLsb(context, m);
-                }
-
-                return Const(0);
-            }
-            else
-            {
-                if (setCarry)
-                {
-                    Operand cOut = context.ShiftRightUI(m, Const(32 - shift));
-
-                    cOut = context.BitwiseAnd(cOut, Const(1));
-
-                    SetFlag(context, PState.CFlag, cOut);
-                }
-
-                return context.ShiftLeft(m, Const(shift));
-            }
-        }
-
-        public static Operand EmitLsrC(ArmEmitterContext context, Operand m, bool setCarry, Operand shift, Operand shiftIsZero)
-        {
-            Debug.Assert(m.Type == OperandType.I32 && shift.Type == OperandType.I32 && shiftIsZero.Type == OperandType.I32);
-
-            Operand shiftLarge = context.ICompareGreaterOrEqual(shift, Const(32));
-            Operand result = context.ShiftRightUI(m, shift);
-            if (setCarry)
-            {
-                EmitIfHelper(context, shiftIsZero, () =>
-                {
-                    Operand cOut = context.ShiftRightUI(m, context.Subtract(shift, Const(1)));
-
-                    cOut = context.BitwiseAnd(cOut, Const(1));
-                    cOut = context.ConditionalSelect(context.ICompareGreater(shift, Const(32)), Const(0), cOut);
-
-                    SetFlag(context, PState.CFlag, cOut);
-                }, false);
-            }
-
-            return context.ConditionalSelect(shiftLarge, Const(0), result);
-        }
-
-        public static Operand GetLsrC(ArmEmitterContext context, Operand m, bool setCarry, int shift)
-        {
-            Debug.Assert(m.Type == OperandType.I32);
-
-            if ((uint)shift > 32)
-            {
-                return GetShiftByMoreThan32(context, setCarry);
-            }
-            else if (shift == 32)
-            {
-                if (setCarry)
-                {
-                    SetCarryMMsb(context, m);
-                }
-
-                return Const(0);
-            }
-            else
-            {
-                if (setCarry)
-                {
-                    SetCarryMShrOut(context, m, shift);
-                }
-
-                return context.ShiftRightUI(m, Const(shift));
-            }
-        }
-
-        private static Operand GetShiftByMoreThan32(ArmEmitterContext context, bool setCarry)
-        {
-            if (setCarry)
-            {
-                SetFlag(context, PState.CFlag, Const(0));
-            }
-
-            return Const(0);
-        }
-
-        public static Operand EmitAsrC(ArmEmitterContext context, Operand m, bool setCarry, Operand shift, Operand shiftIsZero)
-        {
-            Debug.Assert(m.Type == OperandType.I32 && shift.Type == OperandType.I32 && shiftIsZero.Type == OperandType.I32);
-
-            Operand l32Result;
-            Operand ge32Result;
-
-            Operand less32 = context.ICompareLess(shift, Const(32));
-
-            ge32Result = context.ShiftRightSI(m, Const(31));
-
-            if (setCarry)
-            {
-                EmitIfHelper(context, context.BitwiseOr(less32, shiftIsZero), () =>
-                {
-                    SetCarryMLsb(context, ge32Result);
-                }, false);
-            }
-
-            l32Result = context.ShiftRightSI(m, shift);
-            if (setCarry)
-            {
-                EmitIfHelper(context, context.BitwiseAnd(less32, context.BitwiseNot(shiftIsZero)), () =>
-                {
-                    Operand cOut = context.ShiftRightUI(m, context.Subtract(shift, Const(1)));
-
-                    cOut = context.BitwiseAnd(cOut, Const(1));
-
-                    SetFlag(context, PState.CFlag, cOut);
-                });
-            }
-
-            return context.ConditionalSelect(less32, l32Result, ge32Result);
-        }
-
-        public static Operand GetAsrC(ArmEmitterContext context, Operand m, bool setCarry, int shift)
-        {
-            Debug.Assert(m.Type == OperandType.I32);
-
-            if ((uint)shift >= 32)
-            {
-                m = context.ShiftRightSI(m, Const(31));
-
-                if (setCarry)
-                {
-                    SetCarryMLsb(context, m);
-                }
-
-                return m;
-            }
-            else
-            {
-                if (setCarry)
-                {
-                    SetCarryMShrOut(context, m, shift);
-                }
-
-                return context.ShiftRightSI(m, Const(shift));
-            }
-        }
-
-        public static Operand EmitRorC(ArmEmitterContext context, Operand m, bool setCarry, Operand shift, Operand shiftIsZero)
-        {
-            Debug.Assert(m.Type == OperandType.I32 && shift.Type == OperandType.I32 && shiftIsZero.Type == OperandType.I32);
-
-            shift = context.BitwiseAnd(shift, Const(0x1f));
-            m = context.RotateRight(m, shift);
-
-            if (setCarry)
-            {
-                EmitIfHelper(context, shiftIsZero, () =>
-                {
-                    SetCarryMMsb(context, m);
-                }, false);
-            }
-
-            return m;
-        }
-
-        public static Operand GetRorC(ArmEmitterContext context, Operand m, bool setCarry, int shift)
-        {
-            Debug.Assert(m.Type == OperandType.I32);
-
-            shift &= 0x1f;
-
-            m = context.RotateRight(m, Const(shift));
-
-            if (setCarry)
-            {
-                SetCarryMMsb(context, m);
-            }
-
-            return m;
-        }
-
-        public static Operand GetRrxC(ArmEmitterContext context, Operand m, bool setCarry)
-        {
-            Debug.Assert(m.Type == OperandType.I32);
-
-            // Rotate right by 1 with carry.
-            Operand cIn = context.Copy(GetFlag(PState.CFlag));
-
-            if (setCarry)
-            {
-                SetCarryMLsb(context, m);
-            }
-
-            m = context.ShiftRightUI(m, Const(1));
-
-            m = context.BitwiseOr(m, context.ShiftLeft(cIn, Const(31)));
-
-            return m;
-        }
-
-        private static void SetCarryMLsb(ArmEmitterContext context, Operand m)
-        {
-            Debug.Assert(m.Type == OperandType.I32);
-
-            SetFlag(context, PState.CFlag, context.BitwiseAnd(m, Const(1)));
-        }
-
-        private static void SetCarryMMsb(ArmEmitterContext context, Operand m)
-        {
-            Debug.Assert(m.Type == OperandType.I32);
-
-            SetFlag(context, PState.CFlag, context.ShiftRightUI(m, Const(31)));
-        }
-
-        private static void SetCarryMShrOut(ArmEmitterContext context, Operand m, int shift)
-        {
-            Debug.Assert(m.Type == OperandType.I32);
-
-            Operand cOut = context.ShiftRightUI(m, Const(shift - 1));
-
-            cOut = context.BitwiseAnd(cOut, Const(1));
-
-            SetFlag(context, PState.CFlag, cOut);
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitFlow.cs

@@ -1,107 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.State;
-using ARMeilleure.Translation;
-
-using static ARMeilleure.Instructions.InstEmitFlowHelper;
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static partial class InstEmit
-    {
-        public static void B(ArmEmitterContext context)
-        {
-            OpCodeBImmAl op = (OpCodeBImmAl)context.CurrOp;
-
-            context.Branch(context.GetLabel((ulong)op.Immediate));
-        }
-
-        public static void B_Cond(ArmEmitterContext context)
-        {
-            OpCodeBImmCond op = (OpCodeBImmCond)context.CurrOp;
-
-            EmitBranch(context, op.Cond);
-        }
-
-        public static void Bl(ArmEmitterContext context)
-        {
-            OpCodeBImmAl op = (OpCodeBImmAl)context.CurrOp;
-
-            context.Copy(GetIntOrZR(context, RegisterAlias.Lr), Const(op.Address + 4));
-
-            EmitCall(context, (ulong)op.Immediate);
-        }
-
-        public static void Blr(ArmEmitterContext context)
-        {
-            OpCodeBReg op = (OpCodeBReg)context.CurrOp;
-
-            Operand n = context.Copy(GetIntOrZR(context, op.Rn));
-
-            context.Copy(GetIntOrZR(context, RegisterAlias.Lr), Const(op.Address + 4));
-
-            EmitVirtualCall(context, n);
-        }
-
-        public static void Br(ArmEmitterContext context)
-        {
-            OpCodeBReg op = (OpCodeBReg)context.CurrOp;
-
-            EmitVirtualJump(context, GetIntOrZR(context, op.Rn), op.Rn == RegisterAlias.Lr);
-        }
-
-        public static void Cbnz(ArmEmitterContext context) => EmitCb(context, onNotZero: true);
-        public static void Cbz(ArmEmitterContext context)  => EmitCb(context, onNotZero: false);
-
-        private static void EmitCb(ArmEmitterContext context, bool onNotZero)
-        {
-            OpCodeBImmCmp op = (OpCodeBImmCmp)context.CurrOp;
-
-            EmitBranch(context, GetIntOrZR(context, op.Rt), onNotZero);
-        }
-
-        public static void Ret(ArmEmitterContext context)
-        {
-            OpCodeBReg op = (OpCodeBReg)context.CurrOp;
-
-            context.Return(GetIntOrZR(context, op.Rn));
-        }
-
-        public static void Tbnz(ArmEmitterContext context) => EmitTb(context, onNotZero: true);
-        public static void Tbz(ArmEmitterContext context)  => EmitTb(context, onNotZero: false);
-
-        private static void EmitTb(ArmEmitterContext context, bool onNotZero)
-        {
-            OpCodeBImmTest op = (OpCodeBImmTest)context.CurrOp;
-
-            Operand value = context.BitwiseAnd(GetIntOrZR(context, op.Rt), Const(1L << op.Bit));
-
-            EmitBranch(context, value, onNotZero);
-        }
-
-        private static void EmitBranch(ArmEmitterContext context, Condition cond)
-        {
-            OpCodeBImm op = (OpCodeBImm)context.CurrOp;
-
-            EmitCondBranch(context, context.GetLabel((ulong)op.Immediate), cond);
-        }
-
-        private static void EmitBranch(ArmEmitterContext context, Operand value, bool onNotZero)
-        {
-            OpCodeBImm op = (OpCodeBImm)context.CurrOp;
-
-            Operand lblTarget = context.GetLabel((ulong)op.Immediate);
-
-            if (onNotZero)
-            {
-                context.BranchIfTrue(lblTarget, value);
-            }
-            else
-            {
-                context.BranchIfFalse(lblTarget, value);
-            }
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitHelper.cs

@@ -1,264 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.State;
-using ARMeilleure.Translation;
-using System;
-
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static class InstEmitHelper
-    {
-        public static Operand GetExtendedM(ArmEmitterContext context, int rm, IntType type)
-        {
-            Operand value = GetIntOrZR(context, rm);
-
-            switch (type)
-            {
-                case IntType.UInt8:  value = context.ZeroExtend8 (value.Type, value); break;
-                case IntType.UInt16: value = context.ZeroExtend16(value.Type, value); break;
-                case IntType.UInt32: value = context.ZeroExtend32(value.Type, value); break;
-
-                case IntType.Int8:  value = context.SignExtend8 (value.Type, value); break;
-                case IntType.Int16: value = context.SignExtend16(value.Type, value); break;
-                case IntType.Int32: value = context.SignExtend32(value.Type, value); break;
-            }
-
-            return value;
-        }
-
-        public static Operand GetIntA32(ArmEmitterContext context, int regIndex)
-        {
-            if (regIndex == RegisterAlias.Aarch32Pc)
-            {
-                OpCode32 op = (OpCode32)context.CurrOp;
-
-                return Const((int)op.GetPc());
-            }
-            else
-            {
-                return Register(GetRegisterAlias(context.Mode, regIndex), RegisterType.Integer, OperandType.I32);
-            }
-        }
-
-        public static Operand GetIntA32AlignedPC(ArmEmitterContext context, int regIndex)
-        {
-            if (regIndex == RegisterAlias.Aarch32Pc)
-            {
-                OpCode32 op = (OpCode32)context.CurrOp;
-
-                return Const((int)(op.GetPc() & 0xfffffffc));
-            }
-            else
-            {
-                return Register(GetRegisterAlias(context.Mode, regIndex), RegisterType.Integer, OperandType.I32);
-            }
-        }
-
-        public static Operand GetVecA32(int regIndex)
-        {
-            return Register(regIndex, RegisterType.Vector, OperandType.V128);
-        }
-
-        public static void SetIntA32(ArmEmitterContext context, int regIndex, Operand value)
-        {
-            if (regIndex == RegisterAlias.Aarch32Pc)
-            {
-                if (!IsA32Return(context))
-                {
-                    context.StoreToContext();
-                }
-
-                EmitBxWritePc(context, value);
-            }
-            else
-            {
-                if (value.Type == OperandType.I64)
-                {
-                    value = context.ConvertI64ToI32(value);
-                }
-                Operand reg = Register(GetRegisterAlias(context.Mode, regIndex), RegisterType.Integer, OperandType.I32);
-
-                context.Copy(reg, value);
-            }
-        }
-
-        public static int GetRegisterAlias(Aarch32Mode mode, int regIndex)
-        {
-            // Only registers >= 8 are banked,
-            // with registers in the range [8, 12] being
-            // banked for the FIQ mode, and registers
-            // 13 and 14 being banked for all modes.
-            if ((uint)regIndex < 8)
-            {
-                return regIndex;
-            }
-
-            return GetBankedRegisterAlias(mode, regIndex);
-        }
-
-        public static int GetBankedRegisterAlias(Aarch32Mode mode, int regIndex)
-        {
-            switch (regIndex)
-            {
-                case 8: return mode == Aarch32Mode.Fiq
-                    ? RegisterAlias.R8Fiq
-                    : RegisterAlias.R8Usr;
-
-                case 9: return mode == Aarch32Mode.Fiq
-                    ? RegisterAlias.R9Fiq
-                    : RegisterAlias.R9Usr;
-
-                case 10: return mode == Aarch32Mode.Fiq
-                    ? RegisterAlias.R10Fiq
-                    : RegisterAlias.R10Usr;
-
-                case 11: return mode == Aarch32Mode.Fiq
-                    ? RegisterAlias.R11Fiq
-                    : RegisterAlias.R11Usr;
-
-                case 12: return mode == Aarch32Mode.Fiq
-                    ? RegisterAlias.R12Fiq
-                    : RegisterAlias.R12Usr;
-
-                case 13:
-                    switch (mode)
-                    {
-                        case Aarch32Mode.User:
-                        case Aarch32Mode.System:     return RegisterAlias.SpUsr;
-                        case Aarch32Mode.Fiq:        return RegisterAlias.SpFiq;
-                        case Aarch32Mode.Irq:        return RegisterAlias.SpIrq;
-                        case Aarch32Mode.Supervisor: return RegisterAlias.SpSvc;
-                        case Aarch32Mode.Abort:      return RegisterAlias.SpAbt;
-                        case Aarch32Mode.Hypervisor: return RegisterAlias.SpHyp;
-                        case Aarch32Mode.Undefined:  return RegisterAlias.SpUnd;
-
-                        default: throw new ArgumentException(nameof(mode));
-                    }
-
-                case 14:
-                    switch (mode)
-                    {
-                        case Aarch32Mode.User:
-                        case Aarch32Mode.Hypervisor:
-                        case Aarch32Mode.System:     return RegisterAlias.LrUsr;
-                        case Aarch32Mode.Fiq:        return RegisterAlias.LrFiq;
-                        case Aarch32Mode.Irq:        return RegisterAlias.LrIrq;
-                        case Aarch32Mode.Supervisor: return RegisterAlias.LrSvc;
-                        case Aarch32Mode.Abort:      return RegisterAlias.LrAbt;
-                        case Aarch32Mode.Undefined:  return RegisterAlias.LrUnd;
-
-                        default: throw new ArgumentException(nameof(mode));
-                    }
-
-                default: throw new ArgumentOutOfRangeException(nameof(regIndex));
-            }
-        }
-
-        public static bool IsA32Return(ArmEmitterContext context)
-        {
-            switch (context.CurrOp)
-            {
-                case IOpCode32MemMult op:
-                    return true; // Setting PC using LDM is nearly always a return.
-                case OpCode32AluRsImm op:
-                    return op.Rm == RegisterAlias.Aarch32Lr;
-                case OpCode32AluRsReg op:
-                    return op.Rm == RegisterAlias.Aarch32Lr;
-                case OpCode32AluReg op:
-                    return op.Rm == RegisterAlias.Aarch32Lr;
-                case OpCode32Mem op:
-                    return op.Rn == RegisterAlias.Aarch32Sp && op.WBack && !op.Index; // Setting PC to an address stored on the stack is nearly always a return.
-            }
-            return false;
-        }
-
-        public static void EmitBxWritePc(ArmEmitterContext context, Operand pc, int sourceRegister = 0)
-        {
-            bool isReturn = sourceRegister == RegisterAlias.Aarch32Lr || IsA32Return(context);
-            Operand mode = context.BitwiseAnd(pc, Const(1));
-
-            SetFlag(context, PState.TFlag, mode);
-
-            Operand addr = context.ConditionalSelect(mode, context.BitwiseAnd(pc, Const(~1)), context.BitwiseAnd(pc, Const(~3)));
-
-            InstEmitFlowHelper.EmitVirtualJump(context, addr, isReturn);
-        }
-
-        public static Operand GetIntOrZR(ArmEmitterContext context, int regIndex)
-        {
-            if (regIndex == RegisterConsts.ZeroIndex)
-            {
-                OperandType type = context.CurrOp.GetOperandType();
-
-                return type == OperandType.I32 ? Const(0) : Const(0L);
-            }
-            else
-            {
-                return GetIntOrSP(context, regIndex);
-            }
-        }
-
-        public static void SetIntOrZR(ArmEmitterContext context, int regIndex, Operand value)
-        {
-            if (regIndex == RegisterConsts.ZeroIndex)
-            {
-                return;
-            }
-
-            SetIntOrSP(context, regIndex, value);
-        }
-
-        public static Operand GetIntOrSP(ArmEmitterContext context, int regIndex)
-        {
-            Operand value = Register(regIndex, RegisterType.Integer, OperandType.I64);
-
-            if (context.CurrOp.RegisterSize == RegisterSize.Int32)
-            {
-                value = context.ConvertI64ToI32(value);
-            }
-
-            return value;
-        }
-
-        public static void SetIntOrSP(ArmEmitterContext context, int regIndex, Operand value)
-        {
-            Operand reg = Register(regIndex, RegisterType.Integer, OperandType.I64);
-
-            if (value.Type == OperandType.I32)
-            {
-                value = context.ZeroExtend32(OperandType.I64, value);
-            }
-
-            context.Copy(reg, value);
-        }
-
-        public static Operand GetVec(int regIndex)
-        {
-            return Register(regIndex, RegisterType.Vector, OperandType.V128);
-        }
-
-        public static Operand GetFlag(PState stateFlag)
-        {
-            return Register((int)stateFlag, RegisterType.Flag, OperandType.I32);
-        }
-
-        public static Operand GetFpFlag(FPState stateFlag)
-        {
-            return Register((int)stateFlag, RegisterType.FpFlag, OperandType.I32);
-        }
-
-        public static void SetFlag(ArmEmitterContext context, PState stateFlag, Operand value)
-        {
-            context.Copy(GetFlag(stateFlag), value);
-
-            context.MarkFlagSet(stateFlag);
-        }
-
-        public static void SetFpFlag(ArmEmitterContext context, FPState stateFlag, Operand value)
-        {
-            context.Copy(GetFpFlag(stateFlag), value);
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitMemory.cs

@@ -1,184 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Translation;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.Instructions.InstEmitMemoryHelper;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static partial class InstEmit
-    {
-        public static void Adr(ArmEmitterContext context)
-        {
-            OpCodeAdr op = (OpCodeAdr)context.CurrOp;
-
-            SetIntOrZR(context, op.Rd, Const(op.Address + (ulong)op.Immediate));
-        }
-
-        public static void Adrp(ArmEmitterContext context)
-        {
-            OpCodeAdr op = (OpCodeAdr)context.CurrOp;
-
-            ulong address = (op.Address & ~0xfffUL) + ((ulong)op.Immediate << 12);
-
-            SetIntOrZR(context, op.Rd, Const(address));
-        }
-
-        public static void Ldr(ArmEmitterContext context)  => EmitLdr(context, signed: false);
-        public static void Ldrs(ArmEmitterContext context) => EmitLdr(context, signed: true);
-
-        private static void EmitLdr(ArmEmitterContext context, bool signed)
-        {
-            OpCodeMem op = (OpCodeMem)context.CurrOp;
-
-            Operand address = GetAddress(context);
-
-            if (signed && op.Extend64)
-            {
-                EmitLoadSx64(context, address, op.Rt, op.Size);
-            }
-            else if (signed)
-            {
-                EmitLoadSx32(context, address, op.Rt, op.Size);
-            }
-            else
-            {
-                EmitLoadZx(context, address, op.Rt, op.Size);
-            }
-
-            EmitWBackIfNeeded(context, address);
-        }
-
-        public static void Ldr_Literal(ArmEmitterContext context)
-        {
-            IOpCodeLit op = (IOpCodeLit)context.CurrOp;
-
-            if (op.Prefetch)
-            {
-                return;
-            }
-
-            if (op.Signed)
-            {
-                EmitLoadSx64(context, Const(op.Immediate), op.Rt, op.Size);
-            }
-            else
-            {
-                EmitLoadZx(context, Const(op.Immediate), op.Rt, op.Size);
-            }
-        }
-
-        public static void Ldp(ArmEmitterContext context)
-        {
-            OpCodeMemPair op = (OpCodeMemPair)context.CurrOp;
-
-            void EmitLoad(int rt, Operand ldAddr)
-            {
-                if (op.Extend64)
-                {
-                    EmitLoadSx64(context, ldAddr, rt, op.Size);
-                }
-                else
-                {
-                    EmitLoadZx(context, ldAddr, rt, op.Size);
-                }
-            }
-
-            Operand address = GetAddress(context);
-            Operand address2 = GetAddress(context, 1L << op.Size);
-
-            EmitLoad(op.Rt,  address);
-            EmitLoad(op.Rt2, address2);
-
-            EmitWBackIfNeeded(context, address);
-        }
-
-        public static void Str(ArmEmitterContext context)
-        {
-            OpCodeMem op = (OpCodeMem)context.CurrOp;
-
-            Operand address = GetAddress(context);
-
-            EmitStore(context, address, op.Rt, op.Size);
-
-            EmitWBackIfNeeded(context, address);
-        }
-
-        public static void Stp(ArmEmitterContext context)
-        {
-            OpCodeMemPair op = (OpCodeMemPair)context.CurrOp;
-
-            Operand address = GetAddress(context);
-            Operand address2 = GetAddress(context, 1L << op.Size);
-
-            EmitStore(context, address,  op.Rt,  op.Size);
-            EmitStore(context, address2, op.Rt2, op.Size);
-
-            EmitWBackIfNeeded(context, address);
-        }
-
-        private static Operand GetAddress(ArmEmitterContext context, long addend = 0)
-        {
-            Operand address = default;
-
-            switch (context.CurrOp)
-            {
-                case OpCodeMemImm op:
-                {
-                    address = context.Copy(GetIntOrSP(context, op.Rn));
-
-                    // Pre-indexing.
-                    if (!op.PostIdx)
-                    {
-                        address = context.Add(address, Const(op.Immediate + addend));
-                    }
-                    else if (addend != 0)
-                    {
-                        address = context.Add(address, Const(addend));
-                    }
-
-                    break;
-                }
-
-                case OpCodeMemReg op:
-                {
-                    Operand n = GetIntOrSP(context, op.Rn);
-
-                    Operand m = GetExtendedM(context, op.Rm, op.IntType);
-
-                    if (op.Shift)
-                    {
-                        m = context.ShiftLeft(m, Const(op.Size));
-                    }
-
-                    address = context.Add(n, m);
-
-                    if (addend != 0)
-                    {
-                        address = context.Add(address, Const(addend));
-                    }
-
-                    break;
-                }
-            }
-
-            return address;
-        }
-
-        private static void EmitWBackIfNeeded(ArmEmitterContext context, Operand address)
-        {
-            // Check whenever the current OpCode has post-indexed write back, if so write it.
-            if (context.CurrOp is OpCodeMemImm op && op.WBack)
-            {
-                if (op.PostIdx)
-                {
-                    address = context.Add(address, Const(op.Immediate));
-                }
-
-                SetIntOrSP(context, op.Rn, address);
-            }
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitMemoryHelper.cs

@@ -1,648 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Memory;
-using ARMeilleure.Translation;
-using ARMeilleure.Translation.PTC;
-using System;
-using System.Reflection;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static class InstEmitMemoryHelper
-    {
-        private const int PageBits = 12;
-        private const int PageMask = (1 << PageBits) - 1;
-
-        private enum Extension
-        {
-            Zx,
-            Sx32,
-            Sx64
-        }
-
-        public static void EmitLoadZx(ArmEmitterContext context, Operand address, int rt, int size)
-        {
-            EmitLoad(context, address, Extension.Zx, rt, size);
-        }
-
-        public static void EmitLoadSx32(ArmEmitterContext context, Operand address, int rt, int size)
-        {
-            EmitLoad(context, address, Extension.Sx32, rt, size);
-        }
-
-        public static void EmitLoadSx64(ArmEmitterContext context, Operand address, int rt, int size)
-        {
-            EmitLoad(context, address, Extension.Sx64, rt, size);
-        }
-
-        private static void EmitLoad(ArmEmitterContext context, Operand address, Extension ext, int rt, int size)
-        {
-            bool isSimd = IsSimd(context);
-
-            if ((uint)size > (isSimd ? 4 : 3))
-            {
-                throw new ArgumentOutOfRangeException(nameof(size));
-            }
-
-            if (isSimd)
-            {
-                EmitReadVector(context, address, context.VectorZero(), rt, 0, size);
-            }
-            else
-            {
-                EmitReadInt(context, address, rt, size);
-            }
-
-            if (!isSimd && !(context.CurrOp is OpCode32 && rt == State.RegisterAlias.Aarch32Pc))
-            {
-                Operand value = GetInt(context, rt);
-
-                if (ext == Extension.Sx32 || ext == Extension.Sx64)
-                {
-                    OperandType destType = ext == Extension.Sx64 ? OperandType.I64 : OperandType.I32;
-
-                    switch (size)
-                    {
-                        case 0: value = context.SignExtend8 (destType, value); break;
-                        case 1: value = context.SignExtend16(destType, value); break;
-                        case 2: value = context.SignExtend32(destType, value); break;
-                    }
-                }
-
-                SetInt(context, rt, value);
-            }
-        }
-
-        public static void EmitLoadSimd(
-            ArmEmitterContext context,
-            Operand address,
-            Operand vector,
-            int rt,
-            int elem,
-            int size)
-        {
-            EmitReadVector(context, address, vector, rt, elem, size);
-        }
-
-        public static void EmitStore(ArmEmitterContext context, Operand address, int rt, int size)
-        {
-            bool isSimd = IsSimd(context);
-
-            if ((uint)size > (isSimd ? 4 : 3))
-            {
-                throw new ArgumentOutOfRangeException(nameof(size));
-            }
-
-            if (isSimd)
-            {
-                EmitWriteVector(context, address, rt, 0, size);
-            }
-            else
-            {
-                EmitWriteInt(context, address, rt, size);
-            }
-        }
-
-        public static void EmitStoreSimd(
-            ArmEmitterContext context,
-            Operand address,
-            int rt,
-            int elem,
-            int size)
-        {
-            EmitWriteVector(context, address, rt, elem, size);
-        }
-
-        private static bool IsSimd(ArmEmitterContext context)
-        {
-            return context.CurrOp is IOpCodeSimd &&
-                 !(context.CurrOp is OpCodeSimdMemMs ||
-                   context.CurrOp is OpCodeSimdMemSs);
-        }
-
-        public static Operand EmitReadInt(ArmEmitterContext context, Operand address, int size)
-        {
-            Operand temp = context.AllocateLocal(size == 3 ? OperandType.I64 : OperandType.I32);
-
-            Operand lblSlowPath = Label();
-            Operand lblEnd      = Label();
-
-            Operand physAddr = EmitPtPointerLoad(context, address, lblSlowPath, write: false, size);
-
-            Operand value = default;
-
-            switch (size)
-            {
-                case 0: value = context.Load8 (physAddr);                  break;
-                case 1: value = context.Load16(physAddr);                  break;
-                case 2: value = context.Load  (OperandType.I32, physAddr); break;
-                case 3: value = context.Load  (OperandType.I64, physAddr); break;
-            }
-
-            context.Copy(temp, value);
-
-            if (!context.Memory.Type.IsHostMapped())
-            {
-                context.Branch(lblEnd);
-
-                context.MarkLabel(lblSlowPath, BasicBlockFrequency.Cold);
-
-                context.Copy(temp, EmitReadIntFallback(context, address, size));
-
-                context.MarkLabel(lblEnd);
-            }
-
-            return temp;
-        }
-
-        private static void EmitReadInt(ArmEmitterContext context, Operand address, int rt, int size)
-        {
-            Operand lblSlowPath = Label();
-            Operand lblEnd      = Label();
-
-            Operand physAddr = EmitPtPointerLoad(context, address, lblSlowPath, write: false, size);
-
-            Operand value = default;
-
-            switch (size)
-            {
-                case 0: value = context.Load8 (physAddr);                  break;
-                case 1: value = context.Load16(physAddr);                  break;
-                case 2: value = context.Load  (OperandType.I32, physAddr); break;
-                case 3: value = context.Load  (OperandType.I64, physAddr); break;
-            }
-
-            SetInt(context, rt, value);
-
-            if (!context.Memory.Type.IsHostMapped())
-            {
-                context.Branch(lblEnd);
-
-                context.MarkLabel(lblSlowPath, BasicBlockFrequency.Cold);
-
-                EmitReadIntFallback(context, address, rt, size);
-
-                context.MarkLabel(lblEnd);
-            }
-        }
-
-        public static Operand EmitReadIntAligned(ArmEmitterContext context, Operand address, int size)
-        {
-            if ((uint)size > 4)
-            {
-                throw new ArgumentOutOfRangeException(nameof(size));
-            }
-
-            Operand physAddr = EmitPtPointerLoad(context, address, default, write: false, size);
-
-            return size switch
-            {
-                0 => context.Load8(physAddr),
-                1 => context.Load16(physAddr),
-                2 => context.Load(OperandType.I32, physAddr),
-                3 => context.Load(OperandType.I64, physAddr),
-                _ => context.Load(OperandType.V128, physAddr)
-            };
-        }
-
-        private static void EmitReadVector(
-            ArmEmitterContext context,
-            Operand address,
-            Operand vector,
-            int rt,
-            int elem,
-            int size)
-        {
-            Operand lblSlowPath = Label();
-            Operand lblEnd      = Label();
-
-            Operand physAddr = EmitPtPointerLoad(context, address, lblSlowPath, write: false, size);
-
-            Operand value = default;
-
-            switch (size)
-            {
-                case 0: value = context.VectorInsert8 (vector, context.Load8(physAddr), elem);                 break;
-                case 1: value = context.VectorInsert16(vector, context.Load16(physAddr), elem);                break;
-                case 2: value = context.VectorInsert  (vector, context.Load(OperandType.I32, physAddr), elem); break;
-                case 3: value = context.VectorInsert  (vector, context.Load(OperandType.I64, physAddr), elem); break;
-                case 4: value = context.Load          (OperandType.V128, physAddr);                            break;
-            }
-
-            context.Copy(GetVec(rt), value);
-
-            if (!context.Memory.Type.IsHostMapped())
-            {
-                context.Branch(lblEnd);
-
-                context.MarkLabel(lblSlowPath, BasicBlockFrequency.Cold);
-
-                EmitReadVectorFallback(context, address, vector, rt, elem, size);
-
-                context.MarkLabel(lblEnd);
-            }
-        }
-
-        private static Operand VectorCreate(ArmEmitterContext context, Operand value)
-        {
-            return context.VectorInsert(context.VectorZero(), value, 0);
-        }
-
-        private static void EmitWriteInt(ArmEmitterContext context, Operand address, int rt, int size)
-        {
-            Operand lblSlowPath = Label();
-            Operand lblEnd      = Label();
-
-            Operand physAddr = EmitPtPointerLoad(context, address, lblSlowPath, write: true, size);
-
-            Operand value = GetInt(context, rt);
-
-            if (size < 3 && value.Type == OperandType.I64)
-            {
-                value = context.ConvertI64ToI32(value);
-            }
-
-            switch (size)
-            {
-                case 0: context.Store8 (physAddr, value); break;
-                case 1: context.Store16(physAddr, value); break;
-                case 2: context.Store  (physAddr, value); break;
-                case 3: context.Store  (physAddr, value); break;
-            }
-
-            if (!context.Memory.Type.IsHostMapped())
-            {
-                context.Branch(lblEnd);
-
-                context.MarkLabel(lblSlowPath, BasicBlockFrequency.Cold);
-
-                EmitWriteIntFallback(context, address, rt, size);
-
-                context.MarkLabel(lblEnd);
-            }
-        }
-
-        public static void EmitWriteIntAligned(ArmEmitterContext context, Operand address, Operand value, int size)
-        {
-            if ((uint)size > 4)
-            {
-                throw new ArgumentOutOfRangeException(nameof(size));
-            }
-
-            Operand physAddr = EmitPtPointerLoad(context, address, default, write: true, size);
-
-            if (size < 3 && value.Type == OperandType.I64)
-            {
-                value = context.ConvertI64ToI32(value);
-            }
-
-            if (size == 0)
-            {
-                context.Store8(physAddr, value);
-            }
-            else if (size == 1)
-            {
-                context.Store16(physAddr, value);
-            }
-            else
-            {
-                context.Store(physAddr, value);
-            }
-        }
-
-        private static void EmitWriteVector(
-            ArmEmitterContext context,
-            Operand address,
-            int rt,
-            int elem,
-            int size)
-        {
-            Operand lblSlowPath = Label();
-            Operand lblEnd      = Label();
-
-            Operand physAddr = EmitPtPointerLoad(context, address, lblSlowPath, write: true, size);
-
-            Operand value = GetVec(rt);
-
-            switch (size)
-            {
-                case 0: context.Store8 (physAddr, context.VectorExtract8(value, elem));                 break;
-                case 1: context.Store16(physAddr, context.VectorExtract16(value, elem));                break;
-                case 2: context.Store  (physAddr, context.VectorExtract(OperandType.I32, value, elem)); break;
-                case 3: context.Store  (physAddr, context.VectorExtract(OperandType.I64, value, elem)); break;
-                case 4: context.Store  (physAddr, value);                                               break;
-            }
-
-            if (!context.Memory.Type.IsHostMapped())
-            {
-                context.Branch(lblEnd);
-
-                context.MarkLabel(lblSlowPath, BasicBlockFrequency.Cold);
-
-                EmitWriteVectorFallback(context, address, rt, elem, size);
-
-                context.MarkLabel(lblEnd);
-            }
-        }
-
-        public static Operand EmitPtPointerLoad(ArmEmitterContext context, Operand address, Operand lblSlowPath, bool write, int size)
-        {
-            if (context.Memory.Type.IsHostMapped())
-            {
-                return EmitHostMappedPointer(context, address);
-            }
-
-            int ptLevelBits = context.Memory.AddressSpaceBits - PageBits;
-            int ptLevelSize = 1 << ptLevelBits;
-            int ptLevelMask = ptLevelSize - 1;
-
-            Operand addrRotated = size != 0 ? context.RotateRight(address, Const(size)) : address;
-            Operand addrShifted = context.ShiftRightUI(addrRotated, Const(PageBits - size));
-
-            Operand pte = !context.HasPtc
-                ? Const(context.Memory.PageTablePointer.ToInt64())
-                : Const(context.Memory.PageTablePointer.ToInt64(), Ptc.PageTableSymbol);
-
-            Operand pteOffset = context.BitwiseAnd(addrShifted, Const(addrShifted.Type, ptLevelMask));
-
-            if (pteOffset.Type == OperandType.I32)
-            {
-                pteOffset = context.ZeroExtend32(OperandType.I64, pteOffset);
-            }
-
-            pte = context.Load(OperandType.I64, context.Add(pte, context.ShiftLeft(pteOffset, Const(3))));
-
-            if (addrShifted.Type == OperandType.I32)
-            {
-                addrShifted = context.ZeroExtend32(OperandType.I64, addrShifted);
-            }
-
-            // If the VA is out of range, or not aligned to the access size, force PTE to 0 by masking it.
-            pte = context.BitwiseAnd(pte, context.ShiftRightSI(context.Add(addrShifted, Const(-(long)ptLevelSize)), Const(63)));
-
-            if (lblSlowPath != default)
-            {
-                if (write)
-                {
-                    context.BranchIf(lblSlowPath, pte, Const(0L), Comparison.LessOrEqual);
-                    pte = context.BitwiseAnd(pte, Const(0xffffffffffffUL)); // Ignore any software protection bits. (they are still used by C# memory access)
-                }
-                else
-                {
-                    pte = context.ShiftLeft(pte, Const(1));
-                    context.BranchIf(lblSlowPath, pte, Const(0L), Comparison.LessOrEqual);
-                    pte = context.ShiftRightUI(pte, Const(1));
-                }
-            }
-            else
-            {
-                // When no label is provided to jump to a slow path if the address is invalid,
-                // we do the validation ourselves, and throw if needed.
-
-                Operand lblNotWatched = Label();
-
-                // Is the page currently being tracked for read/write? If so we need to call SignalMemoryTracking.
-                context.BranchIf(lblNotWatched, pte, Const(0L), Comparison.GreaterOrEqual, BasicBlockFrequency.Cold);
-
-                // Signal memory tracking. Size here doesn't matter as address is assumed to be size aligned here.
-                context.Call(typeof(NativeInterface).GetMethod(nameof(NativeInterface.SignalMemoryTracking)), address, Const(1UL), Const(write ? 1 : 0));
-                context.MarkLabel(lblNotWatched);
-
-                pte = context.BitwiseAnd(pte, Const(0xffffffffffffUL)); // Ignore any software protection bits. (they are still used by C# memory access)
-
-                Operand lblNonNull = Label();
-
-                // Skip exception if the PTE address is non-null (not zero).
-                context.BranchIfTrue(lblNonNull, pte, BasicBlockFrequency.Cold);
-
-                // The call is not expected to return (it should throw).
-                context.Call(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ThrowInvalidMemoryAccess)), address);
-                context.MarkLabel(lblNonNull);
-            }
-
-            Operand pageOffset = context.BitwiseAnd(address, Const(address.Type, PageMask));
-
-            if (pageOffset.Type == OperandType.I32)
-            {
-                pageOffset = context.ZeroExtend32(OperandType.I64, pageOffset);
-            }
-
-            return context.Add(pte, pageOffset);
-        }
-
-        public static Operand EmitHostMappedPointer(ArmEmitterContext context, Operand address)
-        {
-            if (address.Type == OperandType.I32)
-            {
-                address = context.ZeroExtend32(OperandType.I64, address);
-            }
-
-            if (context.Memory.Type == MemoryManagerType.HostMapped)
-            {
-                Operand mask = Const(ulong.MaxValue >> (64 - context.Memory.AddressSpaceBits));
-                address = context.BitwiseAnd(address, mask);
-            }
-
-            Operand baseAddr = !context.HasPtc
-                ? Const(context.Memory.PageTablePointer.ToInt64())
-                : Const(context.Memory.PageTablePointer.ToInt64(), Ptc.PageTableSymbol);
-
-            return context.Add(baseAddr, address);
-        }
-
-        private static void EmitReadIntFallback(ArmEmitterContext context, Operand address, int rt, int size)
-        {
-            SetInt(context, rt, EmitReadIntFallback(context, address, size));
-        }
-
-        private static Operand EmitReadIntFallback(ArmEmitterContext context, Operand address, int size)
-        {
-            MethodInfo info = null;
-
-            switch (size)
-            {
-                case 0: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadByte));   break;
-                case 1: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt16)); break;
-                case 2: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt32)); break;
-                case 3: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt64)); break;
-            }
-
-            return context.Call(info, address);
-        }
-
-        private static void EmitReadVectorFallback(
-            ArmEmitterContext context,
-            Operand address,
-            Operand vector,
-            int rt,
-            int elem,
-            int size)
-        {
-            MethodInfo info = null;
-
-            switch (size)
-            {
-                case 0: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadByte));      break;
-                case 1: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt16));    break;
-                case 2: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt32));    break;
-                case 3: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt64));    break;
-                case 4: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadVector128)); break;
-            }
-
-            Operand value = context.Call(info, address);
-
-            switch (size)
-            {
-                case 0: value = context.VectorInsert8 (vector, value, elem); break;
-                case 1: value = context.VectorInsert16(vector, value, elem); break;
-                case 2: value = context.VectorInsert  (vector, value, elem); break;
-                case 3: value = context.VectorInsert  (vector, value, elem); break;
-            }
-
-            context.Copy(GetVec(rt), value);
-        }
-
-        private static void EmitWriteIntFallback(ArmEmitterContext context, Operand address, int rt, int size)
-        {
-            MethodInfo info = null;
-
-            switch (size)
-            {
-                case 0: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteByte));   break;
-                case 1: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt16)); break;
-                case 2: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt32)); break;
-                case 3: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt64)); break;
-            }
-
-            Operand value = GetInt(context, rt);
-
-            if (size < 3 && value.Type == OperandType.I64)
-            {
-                value = context.ConvertI64ToI32(value);
-            }
-
-            context.Call(info, address, value);
-        }
-
-        private static void EmitWriteVectorFallback(
-            ArmEmitterContext context,
-            Operand address,
-            int rt,
-            int elem,
-            int size)
-        {
-            MethodInfo info = null;
-
-            switch (size)
-            {
-                case 0: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteByte));      break;
-                case 1: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt16));    break;
-                case 2: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt32));    break;
-                case 3: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt64));    break;
-                case 4: info = typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteVector128)); break;
-            }
-
-            Operand value = default;
-
-            if (size < 4)
-            {
-                switch (size)
-                {
-                    case 0: value = context.VectorExtract8 (GetVec(rt), elem);                  break;
-                    case 1: value = context.VectorExtract16(GetVec(rt), elem);                  break;
-                    case 2: value = context.VectorExtract  (OperandType.I32, GetVec(rt), elem); break;
-                    case 3: value = context.VectorExtract  (OperandType.I64, GetVec(rt), elem); break;
-                }
-            }
-            else
-            {
-                value = GetVec(rt);
-            }
-
-            context.Call(info, address, value);
-        }
-
-        private static Operand GetInt(ArmEmitterContext context, int rt)
-        {
-            return context.CurrOp is OpCode32 ? GetIntA32(context, rt) : GetIntOrZR(context, rt);
-        }
-
-        private static void SetInt(ArmEmitterContext context, int rt, Operand value)
-        {
-            if (context.CurrOp is OpCode32)
-            {
-                SetIntA32(context, rt, value);
-            }
-            else
-            {
-                SetIntOrZR(context, rt, value);
-            }
-        }
-
-        // ARM32 helpers.
-        public static Operand GetMemM(ArmEmitterContext context, bool setCarry = true)
-        {
-            switch (context.CurrOp)
-            {
-                case IOpCode32MemRsImm op: return GetMShiftedByImmediate(context, op, setCarry);
-
-                case IOpCode32MemReg op: return GetIntA32(context, op.Rm);
-
-                case IOpCode32Mem op: return Const(op.Immediate);
-
-                case OpCode32SimdMemImm op: return Const(op.Immediate);
-
-                default: throw InvalidOpCodeType(context.CurrOp);
-            }
-        }
-
-        private static Exception InvalidOpCodeType(OpCode opCode)
-        {
-            return new InvalidOperationException($"Invalid OpCode type \"{opCode?.GetType().Name ?? "null"}\".");
-        }
-
-        public static Operand GetMShiftedByImmediate(ArmEmitterContext context, IOpCode32MemRsImm op, bool setCarry)
-        {
-            Operand m = GetIntA32(context, op.Rm);
-
-            int shift = op.Immediate;
-
-            if (shift == 0)
-            {
-                switch (op.ShiftType)
-                {
-                    case ShiftType.Lsr: shift = 32; break;
-                    case ShiftType.Asr: shift = 32; break;
-                    case ShiftType.Ror: shift = 1; break;
-                }
-            }
-
-            if (shift != 0)
-            {
-                setCarry &= false;
-
-                switch (op.ShiftType)
-                {
-                    case ShiftType.Lsl: m = InstEmitAluHelper.GetLslC(context, m, setCarry, shift); break;
-                    case ShiftType.Lsr: m = InstEmitAluHelper.GetLsrC(context, m, setCarry, shift); break;
-                    case ShiftType.Asr: m = InstEmitAluHelper.GetAsrC(context, m, setCarry, shift); break;
-                    case ShiftType.Ror:
-                        if (op.Immediate != 0)
-                        {
-                            m = InstEmitAluHelper.GetRorC(context, m, setCarry, shift);
-                        }
-                        else
-                        {
-                            m = InstEmitAluHelper.GetRrxC(context, m, setCarry);
-                        }
-                        break;
-                }
-            }
-
-            return m;
-        }
-    }
-}

ARMeilleure/Instructions/InstEmitMove.cs

@@ -1,41 +0,0 @@
-using ARMeilleure.Decoders;
-using ARMeilleure.IntermediateRepresentation;
-using ARMeilleure.Translation;
-
-using static ARMeilleure.Instructions.InstEmitHelper;
-using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
-
-namespace ARMeilleure.Instructions
-{
-    static partial class InstEmit
-    {
-        public static void Movk(ArmEmitterContext context)
-        {
-            OpCodeMov op = (OpCodeMov)context.CurrOp;
-
-            OperandType type = op.GetOperandType();
-
-            Operand res = GetIntOrZR(context, op.Rd);
-
-            res = context.BitwiseAnd(res, Const(type, ~(0xffffL << op.Bit)));
-
-            res = context.BitwiseOr(res, Const(type, op.Immediate));
-
-            SetIntOrZR(context, op.Rd, res);
-        }
-
-        public static void Movn(ArmEmitterContext context)
-        {
-            OpCodeMov op = (OpCodeMov)context.CurrOp;
-
-            SetIntOrZR(context, op.Rd, Const(op.GetOperandType(), ~op.Immediate));
-        }
-
-        public static void Movz(ArmEmitterContext context)
-        {
-            OpCodeMov op = (OpCodeMov)context.CurrOp;
-
-            SetIntOrZR(context, op.Rd, Const(op.GetOperandType(), op.Immediate));
-        }
-    }
-}

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/InstName.cs

@@ -1,685 +0,0 @@
-namespace ARMeilleure.Instructions
-{
-    enum InstName
-    {
-        // Base (AArch64)
-        Adc,
-        Adcs,
-        Add,
-        Adds,
-        Adr,
-        Adrp,
-        And,
-        Ands,
-        Asrv,
-        B,
-        B_Cond,
-        Bfm,
-        Bic,
-        Bics,
-        Bl,
-        Blr,
-        Br,
-        Brk,
-        Cbnz,
-        Cbz,
-        Ccmn,
-        Ccmp,
-        Clrex,
-        Cls,
-        Clz,
-        Crc32b,
-        Crc32h,
-        Crc32w,
-        Crc32x,
-        Crc32cb,
-        Crc32ch,
-        Crc32cw,
-        Crc32cx,
-        Csdb,
-        Csel,
-        Csinc,
-        Csinv,
-        Csneg,
-        Dmb,
-        Dsb,
-        Eon,
-        Eor,
-        Esb,
-        Extr,
-        Hint,
-        Isb,
-        It,
-        Ldar,
-        Ldaxp,
-        Ldaxr,
-        Ldp,
-        Ldr,
-        Ldr_Literal,
-        Ldrs,
-        Ldxr,
-        Ldxp,
-        Lslv,
-        Lsrv,
-        Madd,
-        Movk,
-        Movn,
-        Movz,
-        Mrs,
-        Msr,
-        Msub,
-        Nop,
-        Orn,
-        Orr,
-        Prfm,
-        Rbit,
-        Ret,
-        Rev16,
-        Rev32,
-        Rev64,
-        Rorv,
-        Sbc,
-        Sbcs,
-        Sbfm,
-        Sdiv,
-        Sel,
-        Sev,
-        Sevl,
-        Shsub8,
-        Smaddl,
-        Smsubl,
-        Smulh,
-        Smull,
-        Smulw_,
-        Ssat,
-        Ssat16,
-        Stlr,
-        Stlxp,
-        Stlxr,
-        Stp,
-        Str,
-        Stxp,
-        Stxr,
-        Sub,
-        Subs,
-        Svc,
-        Sxtb,
-        Sxth,
-        Sys,
-        Tbnz,
-        Tbz,
-        Tsb,
-        Ubfm,
-        Udiv,
-        Umaddl,
-        Umsubl,
-        Umulh,
-        Und,
-        Wfe,
-        Wfi,
-        Yield,
-
-        // FP & SIMD (AArch64)
-        Abs_S,
-        Abs_V,
-        Add_S,
-        Add_V,
-        Addhn_V,
-        Addp_S,
-        Addp_V,
-        Addv_V,
-        Aesd_V,
-        Aese_V,
-        Aesimc_V,
-        Aesmc_V,
-        And_V,
-        Bic_V,
-        Bic_Vi,
-        Bif_V,
-        Bit_V,
-        Bsl_V,
-        Cls_V,
-        Clz_V,
-        Cmeq_S,
-        Cmeq_V,
-        Cmge_S,
-        Cmge_V,
-        Cmgt_S,
-        Cmgt_V,
-        Cmhi_S,
-        Cmhi_V,
-        Cmhs_S,
-        Cmhs_V,
-        Cmle_S,
-        Cmle_V,
-        Cmlt_S,
-        Cmlt_V,
-        Cmtst_S,
-        Cmtst_V,
-        Cnt_V,
-        Dup_Gp,
-        Dup_S,
-        Dup_V,
-        Eor_V,
-        Ext_V,
-        Fabd_S,
-        Fabd_V,
-        Fabs_S,
-        Fabs_V,
-        Facge_S,
-        Facge_V,
-        Facgt_S,
-        Facgt_V,
-        Fadd_S,
-        Fadd_V,
-        Faddp_S,
-        Faddp_V,
-        Fccmp_S,
-        Fccmpe_S,
-        Fcmeq_S,
-        Fcmeq_V,
-        Fcmge_S,
-        Fcmge_V,
-        Fcmgt_S,
-        Fcmgt_V,
-        Fcmle_S,
-        Fcmle_V,
-        Fcmlt_S,
-        Fcmlt_V,
-        Fcmp_S,
-        Fcmpe_S,
-        Fcsel_S,
-        Fcvt_S,
-        Fcvtas_Gp,
-        Fcvtas_S,
-        Fcvtas_V,
-        Fcvtau_Gp,
-        Fcvtau_S,
-        Fcvtau_V,
-        Fcvtl_V,
-        Fcvtms_Gp,
-        Fcvtms_V,
-        Fcvtmu_Gp,
-        Fcvtn_V,
-        Fcvtns_Gp,
-        Fcvtns_S,
-        Fcvtns_V,
-        Fcvtnu_S,
-        Fcvtnu_V,
-        Fcvtps_Gp,
-        Fcvtpu_Gp,
-        Fcvtzs_Gp,
-        Fcvtzs_Gp_Fixed,
-        Fcvtzs_S,
-        Fcvtzs_V,
-        Fcvtzs_V_Fixed,
-        Fcvtzu_Gp,
-        Fcvtzu_Gp_Fixed,
-        Fcvtzu_S,
-        Fcvtzu_V,
-        Fcvtzu_V_Fixed,
-        Fdiv_S,
-        Fdiv_V,
-        Fmadd_S,
-        Fmax_S,
-        Fmax_V,
-        Fmaxnm_S,
-        Fmaxnm_V,
-        Fmaxnmp_S,
-        Fmaxnmp_V,
-        Fmaxnmv_V,
-        Fmaxp_V,
-        Fmaxv_V,
-        Fmin_S,
-        Fmin_V,
-        Fminnm_S,
-        Fminnm_V,
-        Fminnmp_S,
-        Fminnmp_V,
-        Fminnmv_V,
-        Fminp_V,
-        Fminv_V,
-        Fmla_Se,
-        Fmla_V,
-        Fmla_Ve,
-        Fmls_Se,
-        Fmls_V,
-        Fmls_Ve,
-        Fmov_S,
-        Fmov_Si,
-        Fmov_Vi,
-        Fmov_Ftoi,
-        Fmov_Itof,
-        Fmov_Ftoi1,
-        Fmov_Itof1,
-        Fmsub_S,
-        Fmul_S,
-        Fmul_Se,
-        Fmul_V,
-        Fmul_Ve,
-        Fmulx_S,
-        Fmulx_Se,
-        Fmulx_V,
-        Fmulx_Ve,
-        Fneg_S,
-        Fneg_V,
-        Fnmadd_S,
-        Fnmsub_S,
-        Fnmul_S,
-        Frecpe_S,
-        Frecpe_V,
-        Frecps_S,
-        Frecps_V,
-        Frecpx_S,
-        Frinta_S,
-        Frinta_V,
-        Frinti_S,
-        Frinti_V,
-        Frintm_S,
-        Frintm_V,
-        Frintn_S,
-        Frintn_V,
-        Frintp_S,
-        Frintp_V,
-        Frintx_S,
-        Frintx_V,
-        Frintz_S,
-        Frintz_V,
-        Frsqrte_S,
-        Frsqrte_V,
-        Frsqrts_S,
-        Frsqrts_V,
-        Fsqrt_S,
-        Fsqrt_V,
-        Fsub_S,
-        Fsub_V,
-        Ins_Gp,
-        Ins_V,
-        Ld__Vms,
-        Ld__Vss,
-        Mla_V,
-        Mla_Ve,
-        Mls_V,
-        Mls_Ve,
-        Movi_V,
-        Mul_V,
-        Mul_Ve,
-        Mvni_V,
-        Neg_S,
-        Neg_V,
-        Not_V,
-        Orn_V,
-        Orr_V,
-        Orr_Vi,
-        Pmull_V,
-        Raddhn_V,
-        Rbit_V,
-        Rev16_V,
-        Rev32_V,
-        Rev64_V,
-        Rshrn_V,
-        Rsubhn_V,
-        Saba_V,
-        Sabal_V,
-        Sabd_V,
-        Sabdl_V,
-        Sadalp_V,
-        Saddl_V,
-        Saddlp_V,
-        Saddlv_V,
-        Saddw_V,
-        Scvtf_Gp,
-        Scvtf_Gp_Fixed,
-        Scvtf_S,
-        Scvtf_S_Fixed,
-        Scvtf_V,
-        Scvtf_V_Fixed,
-        Sha1c_V,
-        Sha1h_V,
-        Sha1m_V,
-        Sha1p_V,
-        Sha1su0_V,
-        Sha1su1_V,
-        Sha256h_V,
-        Sha256h2_V,
-        Sha256su0_V,
-        Sha256su1_V,
-        Shadd_V,
-        Shl_S,
-        Shl_V,
-        Shll_V,
-        Shrn_V,
-        Shsub_V,
-        Sli_S,
-        Sli_V,
-        Smax_V,
-        Smaxp_V,
-        Smaxv_V,
-        Smin_V,
-        Sminp_V,
-        Sminv_V,
-        Smlal_V,
-        Smlal_Ve,
-        Smlsl_V,
-        Smlsl_Ve,
-        Smov_S,
-        Smull_V,
-        Smull_Ve,
-        Sqabs_S,
-        Sqabs_V,
-        Sqadd_S,
-        Sqadd_V,
-        Sqdmulh_S,
-        Sqdmulh_V,
-        Sqdmulh_Ve,
-        Sqneg_S,
-        Sqneg_V,
-        Sqrdmulh_S,
-        Sqrdmulh_V,
-        Sqrdmulh_Ve,
-        Sqrshl_V,
-        Sqrshrn_S,
-        Sqrshrn_V,
-        Sqrshrun_S,
-        Sqrshrun_V,
-        Sqshl_V,
-        Sqshrn_S,
-        Sqshrn_V,
-        Sqshrun_S,
-        Sqshrun_V,
-        Sqsub_S,
-        Sqsub_V,
-        Sqxtn_S,
-        Sqxtn_V,
-        Sqxtun_S,
-        Sqxtun_V,
-        Srhadd_V,
-        Sri_S,
-        Sri_V,
-        Srshl_V,
-        Srshr_S,
-        Srshr_V,
-        Srsra_S,
-        Srsra_V,
-        Sshl_S,
-        Sshl_V,
-        Sshll_V,
-        Sshr_S,
-        Sshr_V,
-        Ssra_S,
-        Ssra_V,
-        Ssubl_V,
-        Ssubw_V,
-        St__Vms,
-        St__Vss,
-        Sub_S,
-        Sub_V,
-        Subhn_V,
-        Suqadd_S,
-        Suqadd_V,
-        Tbl_V,
-        Tbx_V,
-        Trn1_V,
-        Trn2_V,
-        Uaba_V,
-        Uabal_V,
-        Uabd_V,
-        Uabdl_V,
-        Uadalp_V,
-        Uaddl_V,
-        Uaddlp_V,
-        Uaddlv_V,
-        Uaddw_V,
-        Ucvtf_Gp,
-        Ucvtf_Gp_Fixed,
-        Ucvtf_S,
-        Ucvtf_S_Fixed,
-        Ucvtf_V,
-        Ucvtf_V_Fixed,
-        Uhadd_V,
-        Uhsub_V,
-        Umax_V,
-        Umaxp_V,
-        Umaxv_V,
-        Umin_V,
-        Uminp_V,
-        Uminv_V,
-        Umlal_V,
-        Umlal_Ve,
-        Umlsl_V,
-        Umlsl_Ve,
-        Umov_S,
-        Umull_V,
-        Umull_Ve,
-        Uqadd_S,
-        Uqadd_V,
-        Uqrshl_V,
-        Uqrshrn_S,
-        Uqrshrn_V,
-        Uqshl_V,
-        Uqshrn_S,
-        Uqshrn_V,
-        Uqsub_S,
-        Uqsub_V,
-        Uqxtn_S,
-        Uqxtn_V,
-        Urhadd_V,
-        Urshl_V,
-        Urshr_S,
-        Urshr_V,
-        Ursra_S,
-        Ursra_V,
-        Ushl_S,
-        Ushl_V,
-        Ushll_V,
-        Ushr_S,
-        Ushr_V,
-        Usqadd_S,
-        Usqadd_V,
-        Usra_S,
-        Usra_V,
-        Usubl_V,
-        Usubw_V,
-        Uzp1_V,
-        Uzp2_V,
-        Xtn_V,
-        Zip1_V,
-        Zip2_V,
-
-        // Base (AArch32)
-        Bfc,
-        Bfi,
-        Blx,
-        Bx,
-        Cmp,
-        Cmn,
-        Movt,
-        Mul,
-        Lda,
-        Ldab,
-        Ldaex,
-        Ldaexb,
-        Ldaexd,
-        Ldaexh,
-        Ldah,
-        Ldm,
-        Ldrb,
-        Ldrd,
-        Ldrex,
-        Ldrexb,
-        Ldrexd,
-        Ldrexh,
-        Ldrh,
-        Ldrsb,
-        Ldrsh,
-        Mcr,
-        Mla,
-        Mls,
-        Mov,
-        Mrc,
-        Mrrc,
-        Mvn,
-        Pkh,
-        Pld,
-        Pop,
-        Push,
-        Rev,
-        Revsh,
-        Rsb,
-        Rsc,
-        Sadd8,
-        Sbfx,
-        Shadd8,
-        Smla__,
-        Smlal,
-        Smlal__,
-        Smlaw_,
-        Smmla,
-        Smmls,
-        Smul__,
-        Smmul,
-        Ssub8,
-        Stl,
-        Stlb,
-        Stlex,
-        Stlexb,
-        Stlexd,
-        Stlexh,
-        Stlh,
-        Stm,
-        Strb,
-        Strd,
-        Strex,
-        Strexb,
-        Strexd,
-        Strexh,
-        Strh,
-        Sxtb16,
-        Tbb,
-        Tbh,
-        Teq,
-        Trap,
-        Tst,
-        Uadd8,
-        Ubfx,
-        Uhadd8,
-        Uhsub8,
-        Umaal,
-        Umlal,
-        Umull,
-        Usat,
-        Usat16,
-        Usub8,
-        Uxtb,
-        Uxtb16,
-        Uxth,
-
-        // FP & SIMD (AArch32)
-        Vabd,
-        Vabdl,
-        Vabs,
-        Vadd,
-        Vaddl,
-        Vaddw,
-        Vand,
-        Vbic,
-        Vbif,
-        Vbit,
-        Vbsl,
-        Vceq,
-        Vcge,
-        Vcgt,
-        Vcle,
-        Vclt,
-        Vcmp,
-        Vcmpe,
-        Vcnt,
-        Vcvt,
-        Vdiv,
-        Vdup,
-        Veor,
-        Vext,
-        Vfma,
-        Vfms,
-        Vfnma,
-        Vfnms,
-        Vhadd,
-        Vld1,
-        Vld2,
-        Vld3,
-        Vld4,
-        Vldm,
-        Vldr,
-        Vmax,
-        Vmaxnm,
-        Vmin,
-        Vminnm,
-        Vmla,
-        Vmlal,
-        Vmls,
-        Vmlsl,
-        Vmov,
-        Vmovl,
-        Vmovn,
-        Vmrs,
-        Vmsr,
-        Vmul,
-        Vmull,
-        Vmvn,
-        Vneg,
-        Vnmul,
-        Vnmla,
-        Vnmls,
-        Vorn,
-        Vorr,
-        Vpadd,
-        Vpaddl,
-        Vpmax,
-        Vpmin,
-        Vqadd,
-        Vqdmulh,
-        Vqmovn,
-        Vqmovun,
-        Vqrshrn,
-        Vqrshrun,
-        Vqshrn,
-        Vqshrun,
-        Vqsub,
-        Vrev,
-        Vrhadd,
-        Vrint,
-        Vrinta,
-        Vrintm,
-        Vrintn,
-        Vrintp,
-        Vrintx,
-        Vrshr,
-        Vrshrn,
-        Vsel,
-        Vshl,
-        Vshll,
-        Vshr,
-        Vshrn,
-        Vst1,
-        Vst2,
-        Vst3,
-        Vst4,
-        Vstm,
-        Vstr,
-        Vsqrt,
-        Vrecpe,
-        Vrecps,
-        Vrsqrte,
-        Vrsqrts,
-        Vrsra,
-        Vsra,
-        Vsub,
-        Vsubl,
-        Vsubw,
-        Vtbl,
-        Vtrn,
-        Vtst,
-        Vuzp,
-        Vzip,
-    }
-}

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/BasicBlock.cs

@@ -1,159 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-
-namespace ARMeilleure.IntermediateRepresentation
-{
-    class BasicBlock : IEquatable<BasicBlock>, IIntrusiveListNode<BasicBlock>
-    {
-        private const uint MaxSuccessors = 2;
-
-        private int _succCount;
-        private BasicBlock _succ0;
-        private BasicBlock _succ1;
-        private HashSet<BasicBlock> _domFrontiers;
-
-        public int Index { get; set; }
-        public BasicBlockFrequency Frequency { get; set; }
-        public BasicBlock ListPrevious { get; set; }
-        public BasicBlock ListNext { get; set; }
-        public IntrusiveList<Operation> Operations { get; }
-        public List<BasicBlock> Predecessors { get; }
-        public BasicBlock ImmediateDominator { get; set; }
-
-        public int SuccessorsCount => _succCount;
-
-        public HashSet<BasicBlock> DominanceFrontiers
-        {
-            get
-            {
-                if (_domFrontiers == null)
-                {
-                    _domFrontiers = new HashSet<BasicBlock>();
-                }
-
-                return _domFrontiers;
-            }
-        }
-
-        public BasicBlock() : this(index: -1) { }
-
-        public BasicBlock(int index)
-        {
-            Operations = new IntrusiveList<Operation>();
-            Predecessors = new List<BasicBlock>();
-
-            Index = index;
-        }
-
-        public void AddSuccessor(BasicBlock block)
-        {
-            ArgumentNullException.ThrowIfNull(block);
-
-            if ((uint)_succCount + 1 > MaxSuccessors)
-            {
-                ThrowSuccessorOverflow();
-            }
-
-            block.Predecessors.Add(this);
-
-            GetSuccessorUnsafe(_succCount++) = block;
-        }
-
-        public void RemoveSuccessor(int index)
-        {
-            if ((uint)index >= (uint)_succCount)
-            {
-                ThrowOutOfRange(nameof(index));
-            }
-
-            ref BasicBlock oldBlock = ref GetSuccessorUnsafe(index);
-
-            oldBlock.Predecessors.Remove(this);
-            oldBlock = null;
-
-            if (index == 0)
-            {
-                _succ0 = _succ1;
-            }
-
-            _succCount--;
-        }
-
-        public BasicBlock GetSuccessor(int index)
-        {
-            if ((uint)index >= (uint)_succCount)
-            {
-                ThrowOutOfRange(nameof(index));
-            }
-
-            return GetSuccessorUnsafe(index);
-        }
-
-        private ref BasicBlock GetSuccessorUnsafe(int index)
-        {
-            return ref Unsafe.Add(ref _succ0, index);
-        }
-
-        public void SetSuccessor(int index, BasicBlock block)
-        {
-            ArgumentNullException.ThrowIfNull(block);
-
-            if ((uint)index >= (uint)_succCount)
-            {
-                ThrowOutOfRange(nameof(index));
-            }
-
-            ref BasicBlock oldBlock = ref GetSuccessorUnsafe(index);
-
-            oldBlock.Predecessors.Remove(this);
-            block.Predecessors.Add(this);
-            
-            oldBlock = block;
-        }
-
-        public void Append(Operation node)
-        {
-            Operation last = Operations.Last;
-
-            // Append node before terminal or to end if no terminal.
-            if (last == default)
-            {
-                Operations.AddLast(node);
-
-                return;
-            }
-
-            switch (last.Instruction)
-            {
-                case Instruction.Return:
-                case Instruction.Tailcall:
-                case Instruction.BranchIf:
-                    Operations.AddBefore(last, node);
-                    break;
-
-                default:
-                    Operations.AddLast(node);
-                    break;
-            }
-        }
-
-        private static void ThrowOutOfRange(string name) => throw new ArgumentOutOfRangeException(name);
-        private static void ThrowSuccessorOverflow() => throw new OverflowException($"BasicBlock can only have {MaxSuccessors} successors.");
-
-        public bool Equals(BasicBlock other)
-        {
-            return other == this;
-        }
-
-        public override bool Equals(object obj)
-        {
-            return Equals(obj as BasicBlock);
-        }
-
-        public override int GetHashCode()
-        {
-            return base.GetHashCode();
-        }
-    }
-}

ARMeilleure/IntermediateRepresentation/BasicBlockFrequency.cs

@@ -1,8 +0,0 @@
-namespace ARMeilleure.IntermediateRepresentation
-{
-    enum BasicBlockFrequency
-    {
-        Default,
-        Cold
-    }
-}

ARMeilleure/IntermediateRepresentation/Comparison.cs

@@ -1,24 +0,0 @@
-namespace ARMeilleure.IntermediateRepresentation
-{
-    enum Comparison
-    {
-        Equal             = 0,
-        NotEqual          = 1,
-        Greater           = 2,
-        LessOrEqual       = 3,
-        GreaterUI         = 4,
-        LessOrEqualUI     = 5,
-        GreaterOrEqual    = 6,
-        Less              = 7,
-        GreaterOrEqualUI  = 8,
-        LessUI            = 9
-    }
-
-    static class ComparisonExtensions
-    {
-        public static Comparison Invert(this Comparison comp)
-        {
-            return (Comparison)((int)comp ^ 1);
-        }
-    }
-}

ARMeilleure/IntermediateRepresentation/IIntrusiveListNode.cs

@@ -1,8 +0,0 @@
-namespace ARMeilleure.IntermediateRepresentation
-{
-    interface IIntrusiveListNode<T>
-    {
-        T ListPrevious { get; set; }
-        T ListNext { get; set; }
-    }
-}

ARMeilleure/IntermediateRepresentation/Instruction.cs

@@ -1,72 +0,0 @@
-namespace ARMeilleure.IntermediateRepresentation
-{
-    enum Instruction : ushort
-    {
-        Add,
-        BitwiseAnd,
-        BitwiseExclusiveOr,
-        BitwiseNot,
-        BitwiseOr,
-        BranchIf,
-        ByteSwap,
-        Call,
-        Compare,
-        CompareAndSwap,
-        CompareAndSwap16,
-        CompareAndSwap8,
-        ConditionalSelect,
-        ConvertI64ToI32,
-        ConvertToFP,
-        ConvertToFPUI,
-        Copy,
-        CountLeadingZeros,
-        Divide,
-        DivideUI,
-        Load,
-        Load16,
-        Load8,
-        LoadArgument,
-        MemoryBarrier,
-        Multiply,
-        Multiply64HighSI,
-        Multiply64HighUI,
-        Negate,
-        Return,
-        RotateRight,
-        ShiftLeft,
-        ShiftRightSI,
-        ShiftRightUI,
-        SignExtend16,
-        SignExtend32,
-        SignExtend8,
-        StackAlloc,
-        Store,
-        Store16,
-        Store8,
-        Subtract,
-        Tailcall,
-        VectorCreateScalar,
-        VectorExtract,
-        VectorExtract16,
-        VectorExtract8,
-        VectorInsert,
-        VectorInsert16,
-        VectorInsert8,
-        VectorOne,
-        VectorZero,
-        VectorZeroUpper64,
-        VectorZeroUpper96,
-        ZeroExtend16,
-        ZeroExtend32,
-        ZeroExtend8,
-
-        Clobber,
-        Extended,
-        Fill,
-        LoadFromContext,
-        Phi,
-        Spill,
-        SpillArg,
-        StoreToContext
-    }
-}

ARMeilleure/IntermediateRepresentation/Operand.cs

@@ -1,594 +0,0 @@
-using ARMeilleure.CodeGen.Linking;
-using ARMeilleure.Common;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace ARMeilleure.IntermediateRepresentation
-{
-    unsafe struct Operand : IEquatable<Operand>
-    {
-        internal struct Data
-        {
-            public byte Kind;
-            public byte Type;
-            public byte SymbolType;
-            public byte Padding; // Unused space.
-            public ushort AssignmentsCount;
-            public ushort AssignmentsCapacity;
-            public uint UsesCount;
-            public uint UsesCapacity;
-            public Operation* Assignments;
-            public Operation* Uses;
-            public ulong Value;
-            public ulong SymbolValue;
-        }
-
-        private Data* _data;
-
-        public OperandKind Kind
-        {
-            get => (OperandKind)_data->Kind;
-            private set => _data->Kind = (byte)value;
-        }
-
-        public OperandType Type
-        {
-            get => (OperandType)_data->Type;
-            private set => _data->Type = (byte)value;
-        }
-
-        public ulong Value
-        {
-            get => _data->Value;
-            private set => _data->Value = value;
-        }
-
-        public Symbol Symbol
-        {
-            get
-            {
-                Debug.Assert(Kind != OperandKind.Memory);
-
-                return new Symbol((SymbolType)_data->SymbolType, _data->SymbolValue);
-            }
-            private set
-            {
-                Debug.Assert(Kind != OperandKind.Memory);
-
-                if (value.Type == SymbolType.None)
-                {
-                    _data->SymbolType = (byte)SymbolType.None;
-                }
-                else
-                {
-                    _data->SymbolType = (byte)value.Type;
-                    _data->SymbolValue = value.Value;
-                }
-            }
-        }
-
-        public ReadOnlySpan<Operation> Assignments
-        {
-            get
-            {
-                Debug.Assert(Kind != OperandKind.Memory);
-
-                return new ReadOnlySpan<Operation>(_data->Assignments, _data->AssignmentsCount);
-            }
-        }
-
-        public ReadOnlySpan<Operation> Uses
-        {
-            get
-            {
-                Debug.Assert(Kind != OperandKind.Memory);
-
-                return new ReadOnlySpan<Operation>(_data->Uses, (int)_data->UsesCount);
-            }
-        }
-
-        public int UsesCount => (int)_data->UsesCount;
-        public int AssignmentsCount => _data->AssignmentsCount;
-
-        public bool Relocatable => Symbol.Type != SymbolType.None;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Register GetRegister()
-        {
-            Debug.Assert(Kind == OperandKind.Register);
-
-            return new Register((int)Value & 0xffffff, (RegisterType)(Value >> 24));
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public MemoryOperand GetMemory()
-        {
-            Debug.Assert(Kind == OperandKind.Memory);
-
-            return new MemoryOperand(this);
-        }
-
-        public int GetLocalNumber()
-        {
-            Debug.Assert(Kind == OperandKind.LocalVariable);
-
-            return (int)Value;
-        }
-
-        public byte AsByte()
-        {
-            return (byte)Value;
-        }
-
-        public short AsInt16()
-        {
-            return (short)Value;
-        }
-
-        public int AsInt32()
-        {
-            return (int)Value;
-        }
-
-        public long AsInt64()
-        {
-            return (long)Value;
-        }
-
-        public float AsFloat()
-        {
-            return BitConverter.Int32BitsToSingle((int)Value);
-        }
-
-        public double AsDouble()
-        {
-            return BitConverter.Int64BitsToDouble((long)Value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal ref ulong GetValueUnsafe()
-        {
-            return ref _data->Value;
-        }
-
-        internal void NumberLocal(int number)
-        {
-            if (Kind != OperandKind.LocalVariable)
-            {
-                throw new InvalidOperationException("The operand is not a local variable.");
-            }
-
-            Value = (ulong)number;
-        }
-
-        public void AddAssignment(Operation operation)
-        {
-            if (Kind == OperandKind.LocalVariable)
-            {
-                Add(operation, ref _data->Assignments, ref _data->AssignmentsCount, ref _data->AssignmentsCapacity);
-            }
-            else if (Kind == OperandKind.Memory)
-            {
-                MemoryOperand memOp = GetMemory();
-                Operand addr = memOp.BaseAddress;
-                Operand index = memOp.Index;
-
-                if (addr != default)
-                {
-                    Add(operation, ref addr._data->Assignments, ref addr._data->AssignmentsCount, ref addr._data->AssignmentsCapacity);
-                }
-
-                if (index != default)
-                {
-                    Add(operation, ref index._data->Assignments, ref index._data->AssignmentsCount, ref index._data->AssignmentsCapacity);
-                }
-            }
-        }
-
-        public void RemoveAssignment(Operation operation)
-        {
-            if (Kind == OperandKind.LocalVariable)
-            {
-                Remove(operation, ref _data->Assignments, ref _data->AssignmentsCount);
-            }
-            else if (Kind == OperandKind.Memory)
-            {
-                MemoryOperand memOp = GetMemory();
-                Operand addr = memOp.BaseAddress;
-                Operand index = memOp.Index;
-
-                if (addr != default)
-                {
-                    Remove(operation, ref addr._data->Assignments, ref addr._data->AssignmentsCount);
-                }
-
-                if (index != default)
-                {
-                    Remove(operation, ref index._data->Assignments, ref index._data->AssignmentsCount);
-                }
-            }
-        }
-
-        public void AddUse(Operation operation)
-        {
-            if (Kind == OperandKind.LocalVariable)
-            {
-                Add(operation, ref _data->Uses, ref _data->UsesCount, ref _data->UsesCapacity);
-            }
-            else if (Kind == OperandKind.Memory)
-            {
-                MemoryOperand memOp = GetMemory();
-                Operand addr = memOp.BaseAddress;
-                Operand index = memOp.Index;
-
-                if (addr != default)
-                {
-                    Add(operation, ref addr._data->Uses, ref addr._data->UsesCount, ref addr._data->UsesCapacity);
-                }
-
-                if (index != default)
-                {
-                    Add(operation, ref index._data->Uses, ref index._data->UsesCount, ref index._data->UsesCapacity);
-                }
-            }
-        }
-
-        public void RemoveUse(Operation operation)
-        {
-            if (Kind == OperandKind.LocalVariable)
-            {
-                Remove(operation, ref _data->Uses, ref _data->UsesCount);
-            }
-            else if (Kind == OperandKind.Memory)
-            {
-                MemoryOperand memOp = GetMemory();
-                Operand addr = memOp.BaseAddress;
-                Operand index = memOp.Index;
-
-                if (addr != default)
-                {
-                    Remove(operation, ref addr._data->Uses, ref addr._data->UsesCount);
-                }
-
-                if (index != default)
-                {
-                    Remove(operation, ref index._data->Uses, ref index._data->UsesCount);
-                }
-            }
-        }
-
-        public Span<Operation> GetUses(ref Span<Operation> buffer)
-        {
-            ReadOnlySpan<Operation> uses = Uses;
-
-            if (buffer.Length < uses.Length)
-            {
-                buffer = Allocators.Default.AllocateSpan<Operation>((uint)uses.Length);
-            }
-
-            uses.CopyTo(buffer);
-
-            return buffer.Slice(0, uses.Length);
-        }
-
-        private static void New<T>(ref T* data, ref ushort count, ref ushort capacity, ushort initialCapacity) where T : unmanaged
-        {
-            count = 0;
-            capacity = initialCapacity;
-            data = Allocators.References.Allocate<T>(initialCapacity);
-        }
-
-        private static void New<T>(ref T* data, ref uint count, ref uint capacity, uint initialCapacity) where T : unmanaged
-        {
-            count = 0;
-            capacity = initialCapacity;
-            data = Allocators.References.Allocate<T>(initialCapacity);
-        }
-
-        private static void Add<T>(T item, ref T* data, ref ushort count, ref ushort capacity) where T : unmanaged
-        {
-            if (count < capacity)
-            {
-                data[(uint)count++] = item;
-
-                return;
-            }
-
-            // Could not add item in the fast path, fallback onto the slow path.
-            ExpandAdd(item, ref data, ref count, ref capacity);
-
-            static void ExpandAdd(T item, ref T* data, ref ushort count, ref ushort capacity)
-            {
-                ushort newCount = checked((ushort)(count + 1));
-                ushort newCapacity = (ushort)Math.Min(capacity * 2, ushort.MaxValue);
-
-                var oldSpan = new Span<T>(data, count);
-
-                capacity = newCapacity;
-                data = Allocators.References.Allocate<T>(capacity);
-
-                oldSpan.CopyTo(new Span<T>(data, count));
-
-                data[count] = item;
-                count = newCount;
-            }
-        }
-
-        private static void Add<T>(T item, ref T* data, ref uint count, ref uint capacity) where T : unmanaged
-        {
-            if (count < capacity)
-            {
-                data[count++] = item;
-
-                return;
-            }
-
-            // Could not add item in the fast path, fallback onto the slow path.
-            ExpandAdd(item, ref data, ref count, ref capacity);
-
-            static void ExpandAdd(T item, ref T* data, ref uint count, ref uint capacity)
-            {
-                uint newCount = checked(count + 1);
-                uint newCapacity = (uint)Math.Min(capacity * 2, int.MaxValue);
-
-                if (newCapacity <= capacity)
-                {
-                    throw new OverflowException();
-                }
-
-                var oldSpan = new Span<T>(data, (int)count);
-
-                capacity = newCapacity;
-                data = Allocators.References.Allocate<T>(capacity);
-
-                oldSpan.CopyTo(new Span<T>(data, (int)count));
-
-                data[count] = item;
-                count = newCount;
-            }
-        }
-
-        private static void Remove<T>(in T item, ref T* data, ref ushort count) where T : unmanaged
-        {
-            var span = new Span<T>(data, count);
-
-            for (int i = 0; i < span.Length; i++)
-            {
-                if (EqualityComparer<T>.Default.Equals(span[i], item))
-                {
-                    if (i + 1 < count)
-                    {
-                        span.Slice(i + 1).CopyTo(span.Slice(i));
-                    }
-
-                    count--;
-
-                    return;
-                }
-            }
-        }
-
-        private static void Remove<T>(in T item, ref T* data, ref uint count) where T : unmanaged
-        {
-            var span = new Span<T>(data, (int)count);
-
-            for (int i = 0; i < span.Length; i++)
-            {
-                if (EqualityComparer<T>.Default.Equals(span[i], item))
-                {
-                    if (i + 1 < count)
-                    {
-                        span.Slice(i + 1).CopyTo(span.Slice(i));
-                    }
-
-                    count--;
-
-                    return;
-                }
-            }
-        }
-
-        public override int GetHashCode()
-        {
-            return ((ulong)_data).GetHashCode();
-        }
-
-        public bool Equals(Operand operand)
-        {
-            return operand._data == _data;
-        }
-
-        public override bool Equals(object obj)
-        {
-            return obj is Operand operand && Equals(operand);
-        }
-
-        public static bool operator ==(Operand a, Operand b)
-        {
-            return a.Equals(b);
-        }
-
-        public static bool operator !=(Operand a, Operand b)
-        {
-            return !a.Equals(b);
-        }
-
-        public static class Factory
-        {
-            private const int InternTableSize = 256;
-            private const int InternTableProbeLength = 8;
-
-            [ThreadStatic]
-            private static Data* _internTable;
-
-            private static Data* InternTable
-            {
-                get
-                {
-                    if (_internTable == null)
-                    {
-                        _internTable = (Data*)NativeAllocator.Instance.Allocate((uint)sizeof(Data) * InternTableSize);
-
-                        // Make sure the table is zeroed.
-                        new Span<Data>(_internTable, InternTableSize).Clear();
-                    }
-
-                    return _internTable;
-                }
-            }
-
-            private static Operand Make(OperandKind kind, OperandType type, ulong value, Symbol symbol = default)
-            {
-                Debug.Assert(kind != OperandKind.None);
-
-                Data* data = null;
-
-                // If constant or register, then try to look up in the intern table before allocating.
-                if (kind == OperandKind.Constant || kind == OperandKind.Register)
-                {
-                    uint hash = (uint)HashCode.Combine(kind, type, value);
-
-                    // Look in the next InternTableProbeLength slots for a match.
-                    for (uint i = 0; i < InternTableProbeLength; i++)
-                    {
-                        Operand interned = new();
-                        interned._data = &InternTable[(hash + i) % InternTableSize];
-
-                        // If slot matches the allocation request then return that slot.
-                        if (interned.Kind == kind && interned.Type == type && interned.Value == value && interned.Symbol == symbol)
-                        {
-                            return interned;
-                        }
-                        // Otherwise if the slot is not occupied, we store in that slot.
-                        else if (interned.Kind == OperandKind.None)
-                        {
-                            data = interned._data;
-
-                            break;
-                        }
-                    }
-                }
-
-                // If we could not get a slot from the intern table, we allocate somewhere else and store there.
-                if (data == null)
-                {
-                    data = Allocators.Operands.Allocate<Data>();
-                }
-
-                *data = default;
-
-                Operand result = new();
-                result._data = data;
-                result.Value = value;
-                result.Kind = kind;
-                result.Type = type;
-
-                if (kind != OperandKind.Memory)
-                {
-                    result.Symbol = symbol;
-                }
-
-                // If local variable, then the use and def list is initialized with default sizes.
-                if (kind == OperandKind.LocalVariable)
-                {
-                    New(ref result._data->Assignments, ref result._data->AssignmentsCount, ref result._data->AssignmentsCapacity, 1);
-                    New(ref result._data->Uses, ref result._data->UsesCount, ref result._data->UsesCapacity, 4);
-                }
-
-                return result;
-            }
-
-            public static Operand Const(OperandType type, long value)
-            {
-                Debug.Assert(type is OperandType.I32 or OperandType.I64);
-
-                return type == OperandType.I32 ? Const((int)value) : Const(value);
-            }
-
-            public static Operand Const(bool value)
-            {
-                return Const(value ? 1 : 0);
-            }
-
-            public static Operand Const(int value)
-            {
-                return Const((uint)value);
-            }
-
-            public static Operand Const(uint value)
-            {
-                return Make(OperandKind.Constant, OperandType.I32, value);
-            }
-
-            public static Operand Const(long value)
-            {
-                return Const(value, symbol: default);
-            }
-
-            public static Operand Const<T>(ref T reference, Symbol symbol = default)
-            {
-                return Const((long)Unsafe.AsPointer(ref reference), symbol);
-            }
-
-            public static Operand Const(long value, Symbol symbol)
-            {
-                return Make(OperandKind.Constant, OperandType.I64, (ulong)value, symbol);
-            }
-
-            public static Operand Const(ulong value)
-            {
-                return Make(OperandKind.Constant, OperandType.I64, value);
-            }
-
-            public static Operand ConstF(float value)
-            {
-                return Make(OperandKind.Constant, OperandType.FP32, (ulong)BitConverter.SingleToInt32Bits(value));
-            }
-
-            public static Operand ConstF(double value)
-            {
-                return Make(OperandKind.Constant, OperandType.FP64, (ulong)BitConverter.DoubleToInt64Bits(value));
-            }
-
-            public static Operand Label()
-            {
-                return Make(OperandKind.Label, OperandType.None, 0);
-            }
-
-            public static Operand Local(OperandType type)
-            {
-                return Make(OperandKind.LocalVariable, type, 0);
-            }
-
-            public static Operand Register(int index, RegisterType regType, OperandType type)
-            {
-                return Make(OperandKind.Register, type, (ulong)((int)regType << 24 | index));
-            }
-
-            public static Operand Undef()
-            {
-                return Make(OperandKind.Undefined, OperandType.None, 0);
-            }
-
-            public static Operand MemoryOp(
-                OperandType type,
-                Operand baseAddress,
-                Operand index = default,
-                Multiplier scale = Multiplier.x1,
-                int displacement = 0)
-            {
-                Operand result = Make(OperandKind.Memory, type, 0);
-
-                MemoryOperand memory = result.GetMemory();
-                memory.BaseAddress = baseAddress;
-                memory.Index = index;
-                memory.Scale = scale;
-                memory.Displacement = displacement;
-
-                return result;
-            }
-        }
-    }
-}

ARMeilleure/IntermediateRepresentation/OperandKind.cs

@@ -1,13 +0,0 @@
-namespace ARMeilleure.IntermediateRepresentation
-{
-    enum OperandKind
-    {
-        None,
-        Constant,
-        Label,
-        LocalVariable,
-        Memory,
-        Register,
-        Undefined
-    }
-}

ARMeilleure/IntermediateRepresentation/OperandType.cs

@@ -1,65 +0,0 @@
-using System;
-
-namespace ARMeilleure.IntermediateRepresentation
-{
-    enum OperandType
-    {
-        None,
-        I32,
-        I64,
-        FP32,
-        FP64,
-        V128
-    }
-
-    static class OperandTypeExtensions
-    {
-        public static bool IsInteger(this OperandType type)
-        {
-            return type == OperandType.I32 ||
-                   type == OperandType.I64;
-        }
-
-        public static RegisterType ToRegisterType(this OperandType type)
-        {
-            switch (type)
-            {
-                case OperandType.FP32: return RegisterType.Vector;
-                case OperandType.FP64: return RegisterType.Vector;
-                case OperandType.I32:  return RegisterType.Integer;
-                case OperandType.I64:  return RegisterType.Integer;
-                case OperandType.V128: return RegisterType.Vector;
-            }
-
-            throw new InvalidOperationException($"Invalid operand type \"{type}\".");
-        }
-
-        public static int GetSizeInBytes(this OperandType type)
-        {
-            switch (type)
-            {
-                case OperandType.FP32: return 4;
-                case OperandType.FP64: return 8;
-                case OperandType.I32:  return 4;
-                case OperandType.I64:  return 8;
-                case OperandType.V128: return 16;
-            }
-
-            throw new InvalidOperationException($"Invalid operand type \"{type}\".");
-        }
-
-        public static int GetSizeInBytesLog2(this OperandType type)
-        {
-            switch (type)
-            {
-                case OperandType.FP32: return 2;
-                case OperandType.FP64: return 3;
-                case OperandType.I32:  return 2;
-                case OperandType.I64:  return 3;
-                case OperandType.V128: return 4;
-            }
-
-            throw new InvalidOperationException($"Invalid operand type \"{type}\".");
-        }
-    }
-}

ARMeilleure/IntermediateRepresentation/Operation.cs

@@ -1,376 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace ARMeilleure.IntermediateRepresentation
-{
-    unsafe struct Operation : IEquatable<Operation>, IIntrusiveListNode<Operation>
-    {
-        internal struct Data
-        {
-            public ushort Instruction;
-            public ushort Intrinsic;
-            public ushort SourcesCount;
-            public ushort DestinationsCount;
-            public Operation ListPrevious;
-            public Operation ListNext;
-            public Operand* Destinations;
-            public Operand* Sources;
-        }
-
-        private Data* _data;
-
-        public Instruction Instruction
-        {
-            get => (Instruction)_data->Instruction;
-            private set => _data->Instruction = (ushort)value;
-        }
-
-        public Intrinsic Intrinsic
-        {
-            get => (Intrinsic)_data->Intrinsic;
-            private set => _data->Intrinsic = (ushort)value;
-        }
-
-        public Operation ListPrevious
-        {
-            get => _data->ListPrevious;
-            set => _data->ListPrevious = value;
-        }
-
-        public Operation ListNext
-        {
-            get => _data->ListNext;
-            set => _data->ListNext = value;
-        }
-
-        public Operand Destination
-        {
-            get => _data->DestinationsCount != 0 ? GetDestination(0) : default;
-            set => SetDestination(value);
-        }
-
-        public int DestinationsCount => _data->DestinationsCount;
-        public int SourcesCount => _data->SourcesCount;
-
-        internal Span<Operand> DestinationsUnsafe => new(_data->Destinations, _data->DestinationsCount);
-        internal Span<Operand> SourcesUnsafe => new(_data->Sources, _data->SourcesCount);
-
-        public PhiOperation AsPhi()
-        {
-            Debug.Assert(Instruction == Instruction.Phi);
-
-            return new PhiOperation(this);
-        }
-
-        public Operand GetDestination(int index)
-        {
-            return DestinationsUnsafe[index];
-        }
-
-        public Operand GetSource(int index)
-        {
-            return SourcesUnsafe[index];
-        }
-
-        public void SetDestination(int index, Operand dest)
-        {
-            ref Operand curDest = ref DestinationsUnsafe[index];
-
-            RemoveAssignment(curDest);
-            AddAssignment(dest);
-
-            curDest = dest;
-        }
-
-        public void SetSource(int index, Operand src)
-        {
-            ref Operand curSrc = ref SourcesUnsafe[index];
-
-            RemoveUse(curSrc);
-            AddUse(src);
-
-            curSrc = src;
-        }
-
-        private void RemoveOldDestinations()
-        {
-            for (int i = 0; i < _data->DestinationsCount; i++)
-            {
-                RemoveAssignment(_data->Destinations[i]);
-            }
-        }
-
-        public void SetDestination(Operand dest)
-        {
-            RemoveOldDestinations();
-
-            if (dest == default)
-            {
-                _data->DestinationsCount = 0;
-            }
-            else
-            {
-                EnsureCapacity(ref _data->Destinations, ref _data->DestinationsCount, 1);
-
-                _data->Destinations[0] = dest;
-
-                AddAssignment(dest);
-            }
-        }
-
-        public void SetDestinations(Operand[] dests)
-        {
-            RemoveOldDestinations();
-
-            EnsureCapacity(ref _data->Destinations, ref _data->DestinationsCount, dests.Length);
-
-            for (int index = 0; index < dests.Length; index++)
-            {
-                Operand newOp = dests[index];
-
-                _data->Destinations[index] = newOp;
-
-                AddAssignment(newOp);
-            }
-        }
-
-        private void RemoveOldSources()
-        {
-            for (int index = 0; index < _data->SourcesCount; index++)
-            {
-                RemoveUse(_data->Sources[index]);
-            }
-        }
-
-        public void SetSource(Operand src)
-        {
-            RemoveOldSources();
-
-            if (src == default)
-            {
-                _data->SourcesCount = 0;
-            }
-            else
-            {
-                EnsureCapacity(ref _data->Sources, ref _data->SourcesCount, 1);
-
-                _data->Sources[0] = src;
-
-                AddUse(src);
-            }
-        }
-
-        public void SetSources(Operand[] srcs)
-        {
-            RemoveOldSources();
-
-            EnsureCapacity(ref _data->Sources, ref _data->SourcesCount, srcs.Length);
-
-            for (int index = 0; index < srcs.Length; index++)
-            {
-                Operand newOp = srcs[index];
-
-                _data->Sources[index] = newOp;
-
-                AddUse(newOp);
-            }
-        }
-
-        public void TurnIntoCopy(Operand source)
-        {
-            Instruction = Instruction.Copy;
-
-            SetSource(source);
-        }
-
-        private void AddAssignment(Operand op)
-        {
-            if (op != default)
-            {
-                op.AddAssignment(this);
-            }
-        }
-
-        private void RemoveAssignment(Operand op)
-        {
-            if (op != default)
-            {
-                op.RemoveAssignment(this);
-            }
-        }
-
-        private void AddUse(Operand op)
-        {
-            if (op != default)
-            {
-                op.AddUse(this);
-            }
-        }
-
-        private void RemoveUse(Operand op)
-        {
-            if (op != default)
-            {
-                op.RemoveUse(this);
-            }
-        }
-
-        public bool Equals(Operation operation)
-        {
-            return operation._data == _data;
-        }
-
-        public override bool Equals(object obj)
-        {
-            return obj is Operation operation && Equals(operation);
-        }
-
-        public override int GetHashCode()
-        {
-            return HashCode.Combine((IntPtr)_data);
-        }
-
-        public static bool operator ==(Operation a, Operation b)
-        {
-            return a.Equals(b);
-        }
-
-        public static bool operator !=(Operation a, Operation b)
-        {
-            return !a.Equals(b);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void EnsureCapacity(ref Operand* list, ref ushort capacity, int newCapacity)
-        {
-            if (newCapacity > ushort.MaxValue)
-            {
-                ThrowOverflow(newCapacity);
-            }
-            // We only need to allocate a new buffer if we're increasing the size.
-            else if (newCapacity > capacity)
-            {
-                list = Allocators.References.Allocate<Operand>((uint)newCapacity);
-            }
-
-            capacity = (ushort)newCapacity;
-        }
-
-        private static void ThrowOverflow(int count) =>
-            throw new OverflowException($"Exceeded maximum size for Source or Destinations. Required {count}.");
-
-        public static class Factory
-        {
-            private static Operation Make(Instruction inst, int destCount, int srcCount)
-            {
-                Data* data = Allocators.Operations.Allocate<Data>();
-                *data = default;
-
-                Operation result = new();
-                result._data = data;
-                result.Instruction = inst;
-
-                EnsureCapacity(ref result._data->Destinations, ref result._data->DestinationsCount, destCount);
-                EnsureCapacity(ref result._data->Sources, ref result._data->SourcesCount, srcCount);
-
-                result.DestinationsUnsafe.Clear();
-                result.SourcesUnsafe.Clear();
-
-                return result;
-            }
-
-            public static Operation Operation(Instruction inst, Operand dest)
-            {
-                Operation result = Make(inst, 0, 0);
-                result.SetDestination(dest);
-                return result;
-            }
-
-            public static Operation Operation(Instruction inst, Operand dest, Operand src0)
-            {
-                Operation result = Make(inst, 0, 1);
-                result.SetDestination(dest);
-                result.SetSource(0, src0);
-                return result;
-            }
-
-            public static Operation Operation(Instruction inst, Operand dest, Operand src0, Operand src1)
-            {
-                Operation result = Make(inst, 0, 2);
-                result.SetDestination(dest);
-                result.SetSource(0, src0);
-                result.SetSource(1, src1);
-                return result;
-            }
-
-            public static Operation Operation(Instruction inst, Operand dest, Operand src0, Operand src1, Operand src2)
-            {
-                Operation result = Make(inst, 0, 3);
-                result.SetDestination(dest);
-                result.SetSource(0, src0);
-                result.SetSource(1, src1);
-                result.SetSource(2, src2);
-                return result;
-            }
-
-            public static Operation Operation(Instruction inst, Operand dest, int srcCount)
-            {
-                Operation result = Make(inst, 0, srcCount);
-                result.SetDestination(dest);
-                return result;
-            }
-
-            public static Operation Operation(Instruction inst, Operand dest, Operand[] srcs)
-            {
-                Operation result = Make(inst, 0, srcs.Length);
-
-                result.SetDestination(dest);
-
-                for (int index = 0; index < srcs.Length; index++)
-                {
-                    result.SetSource(index, srcs[index]);
-                }
-
-                return result;
-            }
-
-            public static Operation Operation(Intrinsic intrin, Operand dest, params Operand[] srcs)
-            {
-                Operation result = Make(Instruction.Extended, 0, srcs.Length);
-
-                result.Intrinsic = intrin;
-                result.SetDestination(dest);
-
-                for (int index = 0; index < srcs.Length; index++)
-                {
-                    result.SetSource(index, srcs[index]);
-                }
-
-                return result;
-            }
-
-            public static Operation Operation(Instruction inst, Operand[] dests, Operand[] srcs)
-            {
-                Operation result = Make(inst, dests.Length, srcs.Length);
-
-                for (int index = 0; index < dests.Length; index++)
-                {
-                    result.SetDestination(index, dests[index]);
-                }
-
-                for (int index = 0; index < srcs.Length; index++)
-                {
-                    result.SetSource(index, srcs[index]);
-                }
-
-                return result;
-            }
-
-            public static Operation PhiOperation(Operand dest, int srcCount)
-            {
-                return Operation(Instruction.Phi, dest, srcCount * 2);
-            }
-        }
-    }
-}

ARMeilleure/IntermediateRepresentation/Register.cs

@@ -1,43 +0,0 @@
-using System;
-
-namespace ARMeilleure.IntermediateRepresentation
-{
-    readonly struct Register : IEquatable<Register>
-    {
-        public int Index { get; }
-
-        public RegisterType Type { get; }
-
-        public Register(int index, RegisterType type)
-        {
-            Index = index;
-            Type  = type;
-        }
-
-        public override int GetHashCode()
-        {
-            return (ushort)Index | ((int)Type << 16);
-        }
-
-        public static bool operator ==(Register x, Register y)
-        {
-            return x.Equals(y);
-        }
-
-        public static bool operator !=(Register x, Register y)
-        {
-            return !x.Equals(y);
-        }
-
-        public override bool Equals(object obj)
-        {
-            return obj is Register reg && Equals(reg);
-        }
-
-        public bool Equals(Register other)
-        {
-            return other.Index == Index &&
-                   other.Type  == Type;
-        }
-    }
-}

ARMeilleure/IntermediateRepresentation/RegisterType.cs

@@ -1,10 +0,0 @@
-namespace ARMeilleure.IntermediateRepresentation
-{
-    enum RegisterType
-    {
-        Integer,
-        Vector,
-        Flag,
-        FpFlag
-    }
-}

ARMeilleure/Memory/IJitMemoryAllocator.cs

@@ -1,10 +0,0 @@
-namespace ARMeilleure.Memory
-{
-    public interface IJitMemoryAllocator
-    {
-        IJitMemoryBlock Allocate(ulong size);
-        IJitMemoryBlock Reserve(ulong size);
-
-        ulong GetPageSize();
-    }
-}

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/Native/JitSupportDarwin.cs

@@ -1,13 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-using System.Runtime.Versioning;
-
-namespace ARMeilleure.Native
-{
-    [SupportedOSPlatform("macos")]
-    public static partial class JitSupportDarwin
-    {
-        [LibraryImport("libarmeilleure-jitsupport", EntryPoint = "armeilleure_jit_memcpy")]
-        public static partial void Copy(IntPtr dst, IntPtr src, ulong n);
-    }
-}

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