Docs: Update for release FEX-2104

2026-10-07 22:00:19 +02:00 · 2021-04-02 11:35:29 -07:00
1758 changed files with 71911 additions and 280768 deletions
@@ -1,45 +0,0 @@
---
-name: Potential Game Bug
-about: A bug in FEX-Emu that causes a problem in a game
-title: "[Game]: [Short Problem Description]"
-labels: Game related
-assignees: ''
-
---
-
-**What Game**
-The game name.
-A link to the storefront where to get the game. GOG, Steam, Itch.io, etc
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots and Video**
-If applicable, add screenshots and video to help explain your problem.
-
-**System information:**
- - OS: [eg: Ubuntu 21.10]
- - CPU/SoC: [eg: Snapdragon 888, Intel Core i8-12900k]
- - Video driver version: [eg: OpenGL ES 3.2 Mesa 22.0.0-devel (git-9ff086052a)]
- - RootFS used: [eg: Ubuntu 21.10 Official Rootfs]
- - FEX version: (FEXGetConfig --version) [eg: FEX-2112-155-gc691d709]
- - Thunks Enabled: [Yes/No]
-
-**Additional context**
- - Is this an x86 or x86-64 game: [x86/x86-64/Both]
- - Does this reproduce on x86-64 host with FEX: [Yes/No/Untested]
- - Does this reproduce on AArch64 with Radeon/Intel/Nvidia: [Yes/No/Untested]
- - Is this a Vulkan game: [Yes/No/Unknown]
-   - If Yes, What is your Vulkan driver:
-
-Add any other context about the problem here.
@@ -13,41 +13,24 @@ env:
  BUILD_TYPE: Release
  CC: clang
  CXX: clang++
-  FEX_FORCE32BITALLOCATOR: 1
-  FEX_ENABLEAVX: 1

 jobs:
  build:
    runs-on: ${{ matrix.arch }}
    strategy:
      matrix:
-        arch: [[self-hosted, x64], [self-hosted, ARMv8.0], [self-hosted, ARMv8.2], [self-hosted, ARMv8.4]]
+        arch: [[self-hosted, x64], [self-hosted, ARMv8.0], [self-hosted, ARMv8.2]]
      fail-fast: false

    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2

    - name: Set runner label
      run: echo "runner_label=${{ matrix.arch[1] }}" >> $GITHUB_ENV

-    - name: Set rootfs paths
-      run: |
-        echo "FEX_ROOTFS_MOUNT=/mnt/AutoNFS/rootfs/" >> $GITHUB_ENV
-        echo "FEX_ROOTFS_PATH=$HOME/Rootfs/" >> $GITHUB_ENV
-        echo "FEX_ROOTFS=$HOME/Rootfs/" >> $GITHUB_ENV
-        echo "ROOTFS=$HOME/Rootfs/" >> $GITHUB_ENV
-
-    - name: Update RootFS cache
-      # Use a bash shell so we can use the same syntax for environment variable
-      # access regardless of the host operating system
-      shell: bash
-      run: $GITHUB_WORKSPACE/Scripts/CI_FetchRootFS.py
-
    - name : submodule checkout
      # Need to update submodules
-      run: |
-        git submodule sync --recursive
-        git submodule update --init --depth 1
+      run: git submodule update --init --depth 1

    - name: Clean Build Environment
      run: rm -Rf ${{runner.workspace}}/build
@@ -65,7 +48,7 @@ jobs:
      # Note the current convention is to use the -S and -B options here to specify source
      # and build directories, but this is only available with CMake 3.13 and higher.
      # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
-      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -G Ninja -DENABLE_LTO=False -DENABLE_ASSERTIONS=True -DENABLE_X86_HOST_DEBUG=True -DENABLE_INTERPRETER=True -DBUILD_FEX_LINUX_TESTS=True -DBUILD_THUNKS=True -DCMAKE_INSTALL_PREFIX=${{runner.workspace}}/build/install
+      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -G Ninja -DENABLE_LTO=False -DENABLE_ASSERTIONS=True -DENABLE_X86_HOST_DEBUG=True

    - name: Build
      working-directory: ${{runner.workspace}}/build
@@ -73,11 +56,6 @@ jobs:
      # Execute the build.  You can specify a specific target with "--target <NAME>"
      run: cmake --build . --config $BUILD_TYPE

-    - name: Install
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      run: cmake --build . --config $BUILD_TYPE --target install
-
    - name: ASM Tests
      working-directory: ${{runner.workspace}}/build
      shell: bash
@@ -138,18 +116,6 @@ jobs:
      working-directory: ${{runner.workspace}}/build
      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_GCC64.log || true

-    - name: gcc target tests 32
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the gvisor tests
-      run: cmake --build . --config $BUILD_TYPE --target gcc_target_tests_32
-
-    - name: GCC32 Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_GCC32.log || true
-
    - name: Struct verifier tests
      working-directory: ${{runner.workspace}}/build
      shell: bash
@@ -161,89 +127,6 @@ jobs:
      working-directory: ${{runner.workspace}}/build
      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_StructVerifier.log || true

-    - name: APITest tests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      run: cmake --build . --config $BUILD_TYPE --target api_tests
-
-    - name: APITest Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_APITests.log || true
-
-    - name: FEXCore APITest tests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      run: cmake --build . --config $BUILD_TYPE --target fexcore_apitests
-
-    - name: FEXCore APITest Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_FEXCoreAPITests.log || true
-
-    - name: ARMEmitter tests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      run: cmake --build . --config $BUILD_TYPE --target emitter_tests
-
-    - name: ARMEmitter Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_ARMEmitterTests.log || true
-
-    - name: FEXLinuxTests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      run: cmake --build . --config $BUILD_TYPE --target fex_linux_tests_all
-
-    - name: FEXLinuxTests Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_FEXLinuxTests.log || true
-
-    - name: Thunkgen tests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      run: cmake --build . --config $BUILD_TYPE --target thunkgen_tests
-
-    - name: Thunkgen Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_ThunkgenTests.log || true
-
-    - name: Test GL No-Thunks
-      if: matrix.arch[1] == 'x64'
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      env:
-        DISPLAY: ":0"
-      run: cmake --build . --config $BUILD_TYPE --target thunk_functional_tests_nothunks
-
-    - name: No thunks Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_NoThunkResults.log || true
-
-    - name: Test GL Thunks
-      if: matrix.arch[1] == 'x64'
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      env:
-        DISPLAY: ":0"
-      run: cmake --build . --config $BUILD_TYPE --target thunk_functional_tests_thunks
-
-    - name: Thunks Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_ThunkResults.log || true
-
    - name: Truncate test results
      if: ${{ always() }}
      shell: bash
@@ -252,21 +135,15 @@ jobs:
      # ASM tests get quite close to 10MB
      run: truncate --size=<20M ${{runner.workspace}}/build/Testing/Temporary/LastTest_*.log || true

-    - name: Remove old SHM regions
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --target remove_old_shm_regions
-
    - name: Set runner name
      if: ${{ always() }}
      run: echo "runner_name=$(hostname)" >> $GITHUB_ENV

    - name: Upload results
      if: ${{ always() }}
-      uses: 'actions/upload-artifact@v3'
-      timeout-minutes: 1
+      uses: 'actions/upload-artifact@v2'
      with:
        name: Results-${{ env.runner_name }}
        path: ${{runner.workspace}}/build/Testing/Temporary/LastTest_*.log
        retention-days: 3
+
@@ -1,208 +0,0 @@
-name: GLIBC fault test
-# This workflow file is the same as the `Build + Test` with some key differences
-# - Runs on any x86 and ARM64 runner
-# - Disables the glibc jemalloc compile option
-# - Enables the glibc allocator fault option
-# - Disables gvisor tests to reduce stress on CI machines (tmp/shm tests overwhelm them)
-# - Disables thunk tests since they are incompatible with glibc fault allocator
-# - Disables ARMEmitter tests (We don't want to fault test vixl's disassembler)
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-env:
-  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
-  BUILD_TYPE: Release
-  CC: clang
-  CXX: clang++
-  FEX_FORCE32BITALLOCATOR: 1
-  FEX_ENABLEAVX: 1
-
-jobs:
-  build:
-    runs-on: ${{ matrix.arch }}
-    strategy:
-      matrix:
-        # Run on an x86 device and any ARM runner.
-        arch: [[self-hosted, x64], [self-hosted, ARM64]]
-      fail-fast: false
-
-    steps:
-    - uses: actions/checkout@v3
-
-    - name: Set runner label
-      run: echo "runner_label=${{ matrix.arch[1] }}" >> $GITHUB_ENV
-
-    - name: Set rootfs paths
-      run: |
-        echo "FEX_ROOTFS_MOUNT=/mnt/AutoNFS/rootfs/" >> $GITHUB_ENV
-        echo "FEX_ROOTFS_PATH=$HOME/Rootfs/" >> $GITHUB_ENV
-        echo "FEX_ROOTFS=$HOME/Rootfs/" >> $GITHUB_ENV
-        echo "ROOTFS=$HOME/Rootfs/" >> $GITHUB_ENV
-
-    - name: Update RootFS cache
-      # Use a bash shell so we can use the same syntax for environment variable
-      # access regardless of the host operating system
-      shell: bash
-      run: $GITHUB_WORKSPACE/Scripts/CI_FetchRootFS.py
-
-    - name : submodule checkout
-      # Need to update submodules
-      run: |
-        git submodule sync --recursive
-        git submodule update --init --depth 1
-
-    - name: Clean Build Environment
-      run: rm -Rf ${{runner.workspace}}/build
-
-    - name: Create Build Environment
-      # Some projects don't allow in-source building, so create a separate build directory
-      # We'll use this as our working directory for all subsequent commands
-      run: cmake -E make_directory ${{runner.workspace}}/build
-
-    - name: Configure CMake
-      # Use a bash shell so we can use the same syntax for environment variable
-      # access regardless of the host operating system
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      # Note the current convention is to use the -S and -B options here to specify source
-      # and build directories, but this is only available with CMake 3.13 and higher.
-      # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
-      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -G Ninja -DENABLE_LTO=False -DENABLE_ASSERTIONS=True -DENABLE_X86_HOST_DEBUG=True -DENABLE_INTERPRETER=True -DBUILD_FEX_LINUX_TESTS=True -DENABLE_GLIBC_ALLOCATOR_HOOK_FAULT=True -DENABLE_JEMALLOC_GLIBC_ALLOC=False -DCMAKE_INSTALL_PREFIX=${{runner.workspace}}/build/install
-
-    - name: Build
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the build.  You can specify a specific target with "--target <NAME>"
-      run: cmake --build . --config $BUILD_TYPE
-
-    - name: Install
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      run: cmake --build . --config $BUILD_TYPE --target install
-
-    - name: ASM Tests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the unit tests
-      run: cmake --build . --config $BUILD_TYPE --target asm_tests
-
-    - name: ASM Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_ASM.log || true
-
-    - name: IR Tests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the unit tests
-      run: cmake --build . --config $BUILD_TYPE --target ir_tests
-
-    - name: IR Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_IR.log || true
-
-    - name: Posix Tests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the posixtest
-      run: cmake --build . --config $BUILD_TYPE --target posix_tests
-
-    - name: Posix Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_Posix.log || true
-
-    - name: gcc target tests 64
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the gvisor tests
-      run: cmake --build . --config $BUILD_TYPE --target gcc_target_tests_64
-
-    - name: GCC64 Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_GCC64.log || true
-
-    - name: gcc target tests 32
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the gvisor tests
-      run: cmake --build . --config $BUILD_TYPE --target gcc_target_tests_32
-
-    - name: GCC32 Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_GCC32.log || true
-
-    - name: APITest tests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      run: cmake --build . --config $BUILD_TYPE --target api_tests
-
-    - name: APITest Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_APITests.log || true
-
-    - name: FEXCore APITest tests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      run: cmake --build . --config $BUILD_TYPE --target fexcore_apitests
-
-    - name: FEXCore APITest Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_FEXCoreAPITests.log || true
-
-    - name: FEXLinuxTests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      run: cmake --build . --config $BUILD_TYPE --target fex_linux_tests_all
-
-    - name: FEXLinuxTests Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_FEXLinuxTests.log || true
-
-    - name: Truncate test results
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      # Cap out the log files at 20M in case something crash spins and dumps fault text
-      # ASM tests get quite close to 10MB
-      run: truncate --size=<20M ${{runner.workspace}}/build/Testing/Temporary/LastTest_*.log || true
-
-    - name: Remove old SHM regions
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: cmake --build . --config $BUILD_TYPE --target remove_old_shm_regions
-
-    - name: Set runner name
-      if: ${{ always() }}
-      run: echo "runner_name=$(hostname)" >> $GITHUB_ENV
-
-    - name: Upload results
-      if: ${{ always() }}
-      uses: 'actions/upload-artifact@v3'
-      timeout-minutes: 1
-      with:
-        name: Results-${{ env.runner_name }}
-        path: ${{runner.workspace}}/build/Testing/Temporary/LastTest_*.log
-        retention-days: 3
-
@@ -1,109 +0,0 @@
-name: Instruction Count CI run
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-env:
-  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
-  BUILD_TYPE: Release
-  CC: clang
-  CXX: clang++
-  FEX_ENABLEAVX: 1
-
-jobs:
-  build:
-    runs-on: ${{ matrix.arch }}
-    strategy:
-      matrix:
-        arch: [[self-hosted, ARM64]]
-      fail-fast: false
-
-    steps:
-    - uses: actions/checkout@v3
-
-    - name: Set runner label
-      run: echo "runner_label=${{ matrix.arch[1] }}" >> $GITHUB_ENV
-
-    - name: Set rootfs paths
-      run: |
-        echo "FEX_ROOTFS_MOUNT=/mnt/AutoNFS/rootfs/" >> $GITHUB_ENV
-        echo "FEX_ROOTFS_PATH=$HOME/Rootfs/" >> $GITHUB_ENV
-        echo "FEX_ROOTFS=$HOME/Rootfs/" >> $GITHUB_ENV
-        echo "ROOTFS=$HOME/Rootfs/" >> $GITHUB_ENV
-
-    - name: Update RootFS cache
-      # Use a bash shell so we can use the same syntax for environment variable
-      # access regardless of the host operating system
-      shell: bash
-      run: $GITHUB_WORKSPACE/Scripts/CI_FetchRootFS.py
-
-    - name : submodule checkout
-      # Need to update submodules
-      run: |
-        git submodule sync --recursive
-        git submodule update --init --depth 1
-
-    - name: Clean Build Environment
-      run: rm -Rf ${{runner.workspace}}/build
-
-    - name: Create Build Environment
-      # Some projects don't allow in-source building, so create a separate build directory
-      # We'll use this as our working directory for all subsequent commands
-      run: cmake -E make_directory ${{runner.workspace}}/build
-
-    - name: Configure CMake
-      # Use a bash shell so we can use the same syntax for environment variable
-      # access regardless of the host operating system
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      # Note the current convention is to use the -S and -B options here to specify source
-      # and build directories, but this is only available with CMake 3.13 and higher.
-      # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
-      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -G Ninja -DENABLE_VIXL_SIMULATOR=False -DENABLE_VIXL_DISASSEMBLER=True -DENABLE_LTO=False -DENABLE_ASSERTIONS=True
-
-    - name: Build
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      env:
-        FEX_DISABLETELEMETRY: 1
-      # Execute the build.  You can specify a specific target with "--target <NAME>"
-      run: cmake --build . --config $BUILD_TYPE --target CodeSizeValidation instcountci_test_files
-
-    - name: Instruction Count Tests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the unit tests
-      run: cmake --build . --config $BUILD_TYPE --target instcountci_tests
-
-    - name: Instruction Count Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_InstCountCI.log || true
-
-    - name: Truncate test results
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      # Cap out the log files at 20M in case something crash spins and dumps fault text
-      # ASM tests get quite close to 10MB
-      run: truncate --size=<20M ${{runner.workspace}}/build/Testing/Temporary/LastTest_*.log || true
-
-    - name: Set runner name
-      if: ${{ always() }}
-      run: echo "runner_name=$(hostname)" >> $GITHUB_ENV
-
-    - name: Upload results
-      if: ${{ always() }}
-      uses: 'actions/upload-artifact@v3'
-      timeout-minutes: 1
-      with:
-        name: Results-${{ env.runner_name }}
-        path: ${{runner.workspace}}/build/Testing/Temporary/LastTest_*.log
-        retention-days: 3
-
@@ -1,97 +0,0 @@
-name: Mingw build
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-env:
-  BUILD_TYPE: Debug
-  FEX_ENABLEAVX: 1
-
-jobs:
-  build:
-    runs-on: ${{ matrix.arch }}
-    strategy:
-      matrix:
-        arch: [[self-hosted, x64, mingw], [self-hosted, ARM64, mingw]]
-      fail-fast: false
-
-    steps:
-    - uses: actions/checkout@v3
-
-    - name: Set runner label
-      run: echo "runner_label=${{ matrix.arch[1] }}" >> $GITHUB_ENV
-
-    - name: Add MingGW to PATH
-      run: echo "$HOME/llvm-mingw/build/bin/" >> $GITHUB_PATH
-
-    - name: Set CC x86
-      if: matrix.arch[1] == 'x64'
-      run: |
-        echo "MINGW_TRIPLE=x86_64-w64-mingw32" >> $GITHUB_ENV
-
-    - name: Set CC Arm64
-      if: matrix.arch[1] == 'ARM64'
-      run: |
-        echo "MINGW_TRIPLE=aarch64-w64-mingw32" >> $GITHUB_ENV
-
-    - name: Set rootfs paths
-      run: |
-        echo "FEX_ROOTFS_MOUNT=/mnt/AutoNFS/rootfs/" >> $GITHUB_ENV
-        echo "FEX_ROOTFS_PATH=$HOME/Rootfs/" >> $GITHUB_ENV
-        echo "FEX_ROOTFS=$HOME/Rootfs/" >> $GITHUB_ENV
-        echo "ROOTFS=$HOME/Rootfs/" >> $GITHUB_ENV
-
-    - name: Update RootFS cache
-      # Use a bash shell so we can use the same syntax for environment variable
-      # access regardless of the host operating system
-      shell: bash
-      run: $GITHUB_WORKSPACE/Scripts/CI_FetchRootFS.py
-
-    - name : submodule checkout
-      # Need to update submodules
-      run: |
-        git submodule sync --recursive
-        git submodule update --init --depth 1
-
-    - name: Clean Build Environment
-      run: rm -Rf ${{runner.workspace}}/build
-
-    - name: Create Build Environment
-      # Some projects don't allow in-source building, so create a separate build directory
-      # We'll use this as our working directory for all subsequent commands
-      run: cmake -E make_directory ${{runner.workspace}}/build
-
-    - name: Configure CMake
-      # Use a bash shell so we can use the same syntax for environment variable
-      # access regardless of the host operating system
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      # Note the current convention is to use the -S and -B options here to specify source
-      # and build directories, but this is only available with CMake 3.13 and higher.
-      # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
-      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_TOOLCHAIN_FILE=$GITHUB_WORKSPACE/toolchain_mingw.cmake -DMINGW_TRIPLE=$MINGW_TRIPLE -G Ninja -DENABLE_LTO=False -DENABLE_ASSERTIONS=True -DENABLE_X86_HOST_DEBUG=True -DENABLE_INTERPRETER=False -DBUILD_TESTS=False -DENABLE_JEMALLOC=False -DENABLE_JEMALLOC_GLIBC_ALLOC=False -DCMAKE_INSTALL_PREFIX=${{runner.workspace}}/build/install
-
-    - name: Build
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the build.  You can specify a specific target with "--target <NAME>"
-      run: cmake --build . --config $BUILD_TYPE
-
-    - name: Set runner name
-      if: ${{ always() }}
-      run: echo "runner_name=$(hostname)" >> $GITHUB_ENV
-
-    - name: Upload results
-      if: ${{ always() }}
-      uses: 'actions/upload-artifact@v3'
-      timeout-minutes: 1
-      with:
-        name: Results-${{ env.runner_name }}
-        path: ${{runner.workspace}}/build/Testing/Temporary/LastTest_*.log
-        retention-days: 3
-
@@ -1,135 +0,0 @@
-name: Vixl Simulator run
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-env:
-  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
-  BUILD_TYPE: Release
-  CC: clang
-  CXX: clang++
-  FEX_ENABLEAVX: 1
-
-jobs:
-  build:
-    runs-on: ${{ matrix.arch }}
-    strategy:
-      matrix:
-        # Only the x86-64 runner is fast enough to run this
-        arch: [[self-hosted, x64], [self-hosted, ARMv8.4]]
-      fail-fast: false
-
-    steps:
-    - uses: actions/checkout@v3
-
-    - name: Set runner label
-      run: echo "runner_label=${{ matrix.arch[1] }}" >> $GITHUB_ENV
-
-    - name: Set rootfs paths
-      run: |
-        echo "FEX_ROOTFS_MOUNT=/mnt/AutoNFS/rootfs/" >> $GITHUB_ENV
-        echo "FEX_ROOTFS_PATH=$HOME/Rootfs/" >> $GITHUB_ENV
-        echo "FEX_ROOTFS=$HOME/Rootfs/" >> $GITHUB_ENV
-        echo "ROOTFS=$HOME/Rootfs/" >> $GITHUB_ENV
-
-    - name: Update RootFS cache
-      # Use a bash shell so we can use the same syntax for environment variable
-      # access regardless of the host operating system
-      shell: bash
-      run: $GITHUB_WORKSPACE/Scripts/CI_FetchRootFS.py
-
-    - name : submodule checkout
-      # Need to update submodules
-      run: |
-        git submodule sync --recursive
-        git submodule update --init --depth 1
-
-    - name: Clean Build Environment
-      run: rm -Rf ${{runner.workspace}}/build
-
-    - name: Create Build Environment
-      # Some projects don't allow in-source building, so create a separate build directory
-      # We'll use this as our working directory for all subsequent commands
-      run: cmake -E make_directory ${{runner.workspace}}/build
-
-    - name: Configure CMake
-      # Use a bash shell so we can use the same syntax for environment variable
-      # access regardless of the host operating system
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      # Note the current convention is to use the -S and -B options here to specify source
-      # and build directories, but this is only available with CMake 3.13 and higher.
-      # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
-      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -G Ninja -DENABLE_VIXL_SIMULATOR=True -DENABLE_VIXL_DISASSEMBLER=True -DENABLE_LTO=False -DENABLE_ASSERTIONS=True -DENABLE_X86_HOST_DEBUG=True
-
-    - name: Build
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the build.  You can specify a specific target with "--target <NAME>"
-      run: cmake --build . --config $BUILD_TYPE
-
-    - name: ASM Tests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the unit tests
-      run: cmake --build . --config $BUILD_TYPE --target asm_tests
-
-    - name: ASM Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_ASM.log || true
-
-    - name: ASM Tests 128-bit
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      env:
-        FEX_HOSTFEATURES: "disableavx"
-        FEX_FORCESVEWIDTH: "128"
-      # Execute the unit tests
-      run: cmake --build . --config $BUILD_TYPE --target asm_tests
-
-    - name: ASM Test 128-bit Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_ASM128bit.log || true
-
-    - name: IR Tests
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the unit tests
-      run: cmake --build . --config $BUILD_TYPE --target ir_tests
-
-    - name: IR Test Results move
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      run: mv ${{runner.workspace}}/build/Testing/Temporary/LastTest.log ${{runner.workspace}}/build/Testing/Temporary/LastTest_IR.log || true
-
-    - name: Truncate test results
-      if: ${{ always() }}
-      shell: bash
-      working-directory: ${{runner.workspace}}/build
-      # Cap out the log files at 20M in case something crash spins and dumps fault text
-      # ASM tests get quite close to 10MB
-      run: truncate --size=<20M ${{runner.workspace}}/build/Testing/Temporary/LastTest_*.log || true
-
-    - name: Set runner name
-      if: ${{ always() }}
-      run: echo "runner_name=$(hostname)" >> $GITHUB_ENV
-
-    - name: Upload results
-      if: ${{ always() }}
-      uses: 'actions/upload-artifact@v3'
-      timeout-minutes: 1
-      with:
-        name: Results-${{ env.runner_name }}
-        path: ${{runner.workspace}}/build/Testing/Temporary/LastTest_*.log
-        retention-days: 3
-
@@ -10,4 +10,3 @@ out/
 .vscode/
 .vs/
 *.pyc
-.cache
@@ -1,9 +1,9 @@
 [submodule "External/vixl"]
 	shallow = true
 	path = External/vixl
-	url = https://github.com/FEX-Emu/vixl.git
+	url = https://github.com/Sonicadvance1/vixl.git
 [submodule "External/cpp-optparse"]
-	path = Source/Common/cpp-optparse
+	path = External/cpp-optparse
 	url = https://github.com/Sonicadvance1/cpp-optparse
 [submodule "External/imgui"]
 	path = External/imgui
@@ -30,29 +30,3 @@
        shallow = true
 	path = External/fex-gcc-target-tests-bins
 	url = https://github.com/FEX-Emu/fex-gcc-target-tests-bins.git
-[submodule "External/jemalloc"]
-	path = External/jemalloc
-	url = https://github.com/FEX-Emu/jemalloc.git
-[submodule "External/fmt"]
-	path = External/fmt
-	url = https://github.com/fmtlib/fmt.git
-[submodule "External/drm-headers"]
-	path = External/drm-headers
-	url = https://github.com/FEX-Emu/drm-headers.git
-[submodule "External/xxhash"]
-	path = External/xxhash
-	url = https://github.com/FEX-Emu/xxHash.git
-[submodule "External/Catch2"]
-	path = External/Catch2
-	url = https://github.com/catchorg/Catch2.git
-[submodule "External/robin-map"]
-	shallow = true
-	path = External/robin-map
-	url = https://github.com/FEX-Emu/robin-map.git
-[submodule "External/Vulkan-Headers"]
-	shallow = true
-	path = External/Vulkan-Headers
-	url = https://github.com/KhronosGroup/Vulkan-Headers.git
-[submodule "External/jemalloc_glibc"]
-	path = External/jemalloc_glibc
-	url = https://github.com/FEX-Emu/jemalloc.git
@@ -1,5 +0,0 @@
-{
-  "ThunksDB": {
-    "GL": 1
-  }
-}
@@ -1,5 +0,0 @@
-{
-  "ThunksDB": {
-    "Vulkan": 1
-  }
-}
@@ -1,21 +0,0 @@
-if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
-  message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt")
-endif()
-
-file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
-string(REGEX REPLACE "\n" ";" files "${files}")
-foreach(file ${files})
-  message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
-  if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
-    exec_program(
-      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
-      OUTPUT_VARIABLE rm_out
-      RETURN_VALUE rm_retval
-      )
-    if(NOT "${rm_retval}" STREQUAL 0)
-      message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
-    endif()
-  else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
-    message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
-  endif()
-endforeach()
@@ -1,30 +0,0 @@
-# Extracts a version from the passed in version string in the form of "<Major>.<Minor>.<Patch>".
-# If a part of the version is missing then it gets set as zero.
-# Version variables returned in:
-# ${Package}_VERSION_MAJOR
-# ${Package}_VERSION_MINOR
-# ${Package}_VERSION_PATCH
-function(version_to_variables VERSION _Package)
-  string(REPLACE "." ";" VERSION_LIST "${VERSION}")
-  list (LENGTH VERSION_LIST VERSION_LEN)
-  if (${VERSION_LEN} GREATER 0)
-    list(GET VERSION_LIST 0 VERSION_MAJOR)
-    set(${_Package}_VERSION_MAJOR ${VERSION_MAJOR} PARENT_SCOPE)
-  else()
-    set(${_Package}_VERSION_MAJOR 0 PARENT_SCOPE)
-  endif()
-
-  if (${VERSION_LEN} GREATER 1)
-    list(GET VERSION_LIST 1 VERSION_MINOR)
-    set(${_Package}_VERSION_MINOR ${VERSION_MINOR} PARENT_SCOPE)
-  else()
-    set(${_Package}_VERSION_MINOR 0 PARENT_SCOPE)
-  endif()
-
-  if (${VERSION_LEN} GREATER 2)
-    list(GET VERSION_LIST 2 VERSION_PATCH)
-    set(${_Package}_VERSION_PATCH ${VERSION_PATCH} PARENT_SCOPE)
-  else()
-    set(${_Package}_VERSION_PATCH 0 PARENT_SCOPE)
-  endif()
-endfunction()
@@ -1,86 +1,24 @@
 cmake_minimum_required(VERSION 3.14)
 project(FEX)

-INCLUDE (CheckIncludeFiles)
-CHECK_INCLUDE_FILES ("gdb/jit-reader.h" HAVE_GDB_JIT_READER_H)
-
 option(BUILD_TESTS "Build unit tests to ensure sanity" TRUE)
-option(BUILD_FEX_LINUX_TESTS "Build FEXLinuxTests, requires x86 compiler" FALSE)
 option(BUILD_THUNKS "Build thunks" FALSE)
-option(BUILD_FEXCONFIG "Build FEXConfig, requires SDL2 and X11" TRUE)
-option(ENABLE_CLANG_THUNKS "Build thunks with clang" FALSE)
 option(ENABLE_CLANG_FORMAT "Run clang format over the source" FALSE)
 option(ENABLE_IWYU "Enables include what you use program" FALSE)
 option(ENABLE_LTO "Enable LTO with compilation" TRUE)
 option(ENABLE_XRAY "Enable building with LLVM X-Ray" FALSE)
-set(USE_LINKER "" CACHE STRING "Allow overriding the linker path directly")
+option(ENABLE_LLD "Enable linking with LLD" FALSE)
 option(ENABLE_ASAN "Enables Clang ASAN" FALSE)
 option(ENABLE_TSAN "Enables Clang TSAN" FALSE)
 option(ENABLE_ASSERTIONS "Enables assertions in build" FALSE)
-option(ENABLE_GDB_SYMBOLS "Enables GDBSymbols integration support" ${HAVE_GDB_JIT_READER_H})
+option(ENABLE_VISUAL_DEBUGGER "Enables the visual debugger for compiling" FALSE)
 option(ENABLE_STRICT_WERROR "Enables stricter -Werror for CI" FALSE)
 option(ENABLE_WERROR "Enables -Werror" FALSE)
-option(ENABLE_JEMALLOC "Enables jemalloc allocator" TRUE)
-option(ENABLE_JEMALLOC_GLIBC_ALLOC "Enables jemalloc glibc allocator" TRUE)
-option(ENABLE_OFFLINE_TELEMETRY "Enables FEX offline telemetry" TRUE)
-option(ENABLE_COMPILE_TIME_TRACE "Enables time trace compile option" FALSE)
-option(ENABLE_LIBCXX "Enables LLVM libc++" FALSE)
-option(ENABLE_INTERPRETER "Enables FEX's Interpreter" FALSE)
-option(ENABLE_CCACHE "Enables ccache for compile caching" TRUE)
-option(ENABLE_TERMUX_BUILD "Forces building for Termux on a non-Termux build machine" FALSE)
-option(ENABLE_VIXL_SIMULATOR "Forces the FEX JIT to use the VIXL simulator" FALSE)
-option(ENABLE_VIXL_DISASSEMBLER "Enables debug disassembler output with VIXL" FALSE)
-option(COMPILE_VIXL_DISASSEMBLER "Compiles the vixl disassembler in to vixl" FALSE)
-option(ENABLE_FEXCORE_PROFILER "Enables use of the FEXCore timeline profiling capabilities" FALSE)
-set (FEXCORE_PROFILER_BACKEND "gpuvis" CACHE STRING "Set which backend you want to use for the FEXCore profiler")
-option(ENABLE_GLIBC_ALLOCATOR_HOOK_FAULT "Enables glibc memory allocation hooking with fault for CI testing")

-set (X86_32_TOOLCHAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/toolchain_x86_32.cmake" CACHE FILEPATH "Toolchain file for the (cross-)compiler targeting i686")
-set (X86_64_TOOLCHAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/toolchain_x86_64.cmake" CACHE FILEPATH "Toolchain file for the (cross-)compiler targeting x86_64")
+set (X86_C_COMPILER "x86_64-linux-gnu-gcc" CACHE STRING "c compiler for compiling x86 guest libs")
+set (X86_CXX_COMPILER "x86_64-linux-gnu-g++" CACHE STRING "c++ compiler for compiling x86 guest libs")
 set (DATA_DIRECTORY "${CMAKE_INSTALL_PREFIX}/share/fex-emu" CACHE PATH "global data directory")

-string(FIND ${CMAKE_BASE_NAME} mingw CONTAINS_MINGW)
-if (NOT CONTAINS_MINGW EQUAL -1)
-  message (STATUS "Mingw build")
-  set (MINGW_BUILD TRUE)
-  set (ENABLE_JEMALLOC FALSE)
-endif()
-
-if (ENABLE_FEXCORE_PROFILER)
-  add_definitions(-DENABLE_FEXCORE_PROFILER=1)
-  string(TOUPPER "${FEXCORE_PROFILER_BACKEND}" FEXCORE_PROFILER_BACKEND)
-
-  if (FEXCORE_PROFILER_BACKEND STREQUAL "GPUVIS")
-    add_definitions(-DFEXCORE_PROFILER_BACKEND=1)
-  else()
-    message(FATAL_ERROR "Unknown FEXCore profiler backend ${FEXCORE_PROFILER_BACKEND}")
-  endif()
-endif()
-
-if (ENABLE_JEMALLOC_GLIBC_ALLOC AND ENABLE_GLIBC_ALLOCATOR_HOOK_FAULT)
-  message(FATAL_ERROR "Can't have both glibc fault allocator and jemalloc glibc allocator enabled at the same time")
-endif()
-
-if (ENABLE_GLIBC_ALLOCATOR_HOOK_FAULT)
-  add_definitions(-DGLIBC_ALLOCATOR_FAULT=1)
-endif()
-
-# uninstall target
-if(NOT TARGET uninstall)
-  configure_file(
-    "${CMAKE_CURRENT_SOURCE_DIR}/CMakeFiles/cmake_uninstall.cmake.in"
-    "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/cmake_uninstall.cmake"
-    IMMEDIATE @ONLY)
-
-  add_custom_target(uninstall
-    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/cmake_uninstall.cmake)
-endif()
-
-# These options are meant for package management
-set (TUNE_CPU "native" CACHE STRING "Override the CPU the build is tuned for")
-set (TUNE_ARCH "generic" CACHE STRING "Override the Arch the build is tuned for")
-set (OVERRIDE_VERSION "detect" CACHE STRING "Override the FEX version in the format of <MMYY>{.<REV>}")
-
 string(TOUPPER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE)
 if (CMAKE_BUILD_TYPE MATCHES "DEBUG")
  set(ENABLE_ASSERTIONS TRUE)
@@ -91,17 +29,6 @@ if (ENABLE_ASSERTIONS)
  add_definitions(-DASSERTIONS_ENABLED=1)
 endif()

-if (ENABLE_GDB_SYMBOLS)
-  message(STATUS "GDBSymbols support enabled")
-  add_definitions(-DGDB_SYMBOLS_ENABLED=1)
-endif()
-
-
-if (ENABLE_INTERPRETER)
-  message(STATUS "Interpreter enabled")
-  add_definitions(-DINTERPRETER_ENABLED=1)
-endif()
-
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Bin)
@@ -117,6 +44,38 @@ else()
  set(CMAKE_INTERPROCEDURAL_OPTIMIZATION FALSE)
 endif()

+find_program(CCACHE_PROGRAM ccache)
+if(CCACHE_PROGRAM)
+  message(STATUS "CCache enabled")
+  set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
+endif()
+
+if (ENABLE_XRAY)
+  add_compile_options(-fxray-instrument)
+  link_libraries(-fxray-instrument)
+endif()
+
+if (ENABLE_LLD)
+  link_libraries(-fuse-ld=lld)
+endif()
+
+if (ENABLE_ASAN)
+  add_definitions(-DENABLE_ASAN=1)
+  add_compile_options(-fno-omit-frame-pointer -fsanitize=address)
+  link_libraries(-fno-omit-frame-pointer -fsanitize=address)
+endif()
+
+if (ENABLE_TSAN)
+  add_compile_options(-fno-omit-frame-pointer -fsanitize=thread)
+  link_libraries(-fno-omit-frame-pointer -fsanitize=thread)
+endif()
+
+set (CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -fno-omit-frame-pointer")
+set (CMAKE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_LINKER_FLAGS_RELWITHDEBINFO} -fno-omit-frame-pointer")
+
+set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer")
+set (CMAKE_LINKER_FLAGS_RELEASE "${CMAKE_LINKER_FLAGS_RELEASE} -fomit-frame-pointer")
+
 if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
  option(ENABLE_X86_HOST_DEBUG "Enables compiling on x86_64 host" FALSE)
  if (NOT ENABLE_X86_HOST_DEBUG)
@@ -131,140 +90,26 @@ if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
  set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcx16")
 endif()

-if (CMAKE_SYSTEM_PROCESSOR MATCHES "^aarch64|^arm64|^armv8\.*")
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
  set(_M_ARM_64 1)
  add_definitions(-D_M_ARM_64=1)
 endif()

-if (ENABLE_CCACHE)
-  find_program(CCACHE_PROGRAM ccache)
-  if(CCACHE_PROGRAM)
-    message(STATUS "CCache enabled")
-    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
-  endif()
-endif()
-
-if (ENABLE_XRAY)
-  add_compile_options(-fxray-instrument)
-  link_libraries(-fxray-instrument)
-endif()
-
-if (ENABLE_COMPILE_TIME_TRACE)
-  add_compile_options(-ftime-trace)
-  link_libraries(-ftime-trace)
-endif()
-
-set (PTHREAD_LIB pthread)
-
-if (USE_LINKER)
-  message(STATUS "Overriding linker to: ${USE_LINKER}")
-  add_link_options("-fuse-ld=${USE_LINKER}")
-endif()
-
-if (ENABLE_LIBCXX)
-  message(WARNING "This is an unsupported configuration and should only be used for testing")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++")
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -lc++abi")
-endif()
-
-if (NOT ENABLE_OFFLINE_TELEMETRY)
-  # Disable FEX offline telemetry entirely if asked
-  add_definitions(-DFEX_DISABLE_TELEMETRY=1)
-endif()
-
-if(DEFINED ENV{TERMUX_VERSION} OR ENABLE_TERMUX_BUILD)
-  add_definitions(-DTERMUX_BUILD=1)
-  set(TERMUX_BUILD 1)
-
-  # Termux doesn't support Jemalloc due to bad interactions between emutls, jemalloc, and scudo
-  set(ENABLE_JEMALLOC FALSE)
-
-  # Termux builds can't rely on X11 packages
-  # SDL2 isn't even compiled with GL support so our GUIs wouldn't even work
-  set(BUILD_FEXCONFIG FALSE)
-endif()
-
-if (ENABLE_ASAN)
-  add_definitions(-DENABLE_ASAN=1)
-  add_compile_options(-fno-omit-frame-pointer -fsanitize=address -fsanitize-address-use-after-scope)
-  link_libraries(-fno-omit-frame-pointer -fsanitize=address -fsanitize-address-use-after-scope)
-endif()
-
-if (ENABLE_TSAN)
-  add_compile_options(-fno-omit-frame-pointer -fsanitize=thread)
-  link_libraries(-fno-omit-frame-pointer -fsanitize=thread)
-endif()
-
-if (ENABLE_JEMALLOC_GLIBC_ALLOC)
-  # The glibc jemalloc subproject which hooks the glibc allocator.
-  # Required for thunks to work.
-  # All host native libraries will use this allocator, while *most* other FEX internal allocations will use the other jemalloc allocator.
-  add_definitions(-DENABLE_JEMALLOC_GLIBC=1)
-  add_subdirectory(External/jemalloc_glibc/)
-else()
-  message (STATUS
-    " jemalloc glibc allocator disabled!\n"
-    " This is not a recommended configuration!\n"
-    " This will very explicitly break thunk execution!\n"
-    " Use at your own risk!")
-endif()
-
-if (ENABLE_JEMALLOC)
-  # The jemalloc subproject that all FEXCore fextl objects allocate through.
-  add_definitions(-DENABLE_JEMALLOC=1)
-  add_subdirectory(External/jemalloc/)
-  include_directories(External/jemalloc/pregen/include/)
-else()
-  message (STATUS
-    " jemalloc disabled!\n"
-    " This is not a recommended configuration!\n"
-    " This will very explicitly break 32-bit application execution!\n"
-    " Use at your own risk!")
-endif()
-
-set (CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -fno-omit-frame-pointer")
-set (CMAKE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_LINKER_FLAGS_RELWITHDEBINFO} -fno-omit-frame-pointer")
-
-set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer")
-set (CMAKE_LINKER_FLAGS_RELEASE "${CMAKE_LINKER_FLAGS_RELEASE} -fomit-frame-pointer")
-
-include_directories(External/robin-map/include/)
-
-if (BUILD_TESTS)
-  # Enable vixl disassembler if tests are enabled.
-  set(COMPILE_VIXL_DISASSEMBLER TRUE)
-endif()
-
 add_subdirectory(External/vixl/)
-include_directories(SYSTEM External/vixl/src/)
+include_directories(External/vixl/src/)

 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
  # This means we were attempted to get compiled with GCC
  message(FATAL_ERROR "FEX doesn't support getting compiled with GCC!")
 endif()

-find_package(PkgConfig REQUIRED)
 find_package(Python 3.0 REQUIRED COMPONENTS Interpreter)

-add_subdirectory(External/xxhash/)
-include_directories(External/xxhash/)
-
 add_definitions(-Wno-trigraphs)
 add_definitions(-DGLOBAL_DATA_DIRECTORY="${DATA_DIRECTORY}/")

-if (BUILD_TESTS)
-  option(CATCH_BUILD_STATIC_LIBRARY "" ON)
-  set(CATCH_BUILD_STATIC_LIBRARY ON)
-  add_subdirectory(External/Catch2/)
-
-  # Pull in catch_discover_tests definition
-  list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/External/Catch2/contrib/")
-  include(Catch)
-endif()
-
-# Disable fmt install
-set(FMT_INSTALL OFF)
-add_subdirectory(External/fmt/)
+add_subdirectory(External/cpp-optparse/)
+include_directories(External/cpp-optparse/)

 add_subdirectory(External/imgui/)
 include_directories(External/imgui/)
@@ -299,6 +144,11 @@ if(ENUM_ENUM_WARNING)
  add_compile_options(-Wno-deprecated-enum-enum-conversion)
 endif()

+check_cxx_compiler_flag("-march=native" COMPILER_SUPPORTS_MARCH_NATIVE)
+if(COMPILER_SUPPORTS_MARCH_NATIVE)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
+endif()
+
 if(ENABLE_WERROR OR ENABLE_STRICT_WERROR)
  add_compile_options(-Werror)
  if (NOT ENABLE_STRICT_WERROR)
@@ -307,51 +157,19 @@ if(ENABLE_WERROR OR ENABLE_STRICT_WERROR)
  endif()
 endif()

-if (NOT TUNE_ARCH STREQUAL "generic")
-  check_cxx_compiler_flag("-march=${TUNE_ARCH}" COMPILER_SUPPORTS_ARCH_TYPE)
-  if(COMPILER_SUPPORTS_ARCH_TYPE)
-    add_compile_options("-march=${TUNE_ARCH}")
-  else()
-    message(FATAL_ERROR "Trying to compile arch type '${TUNE_ARCH}' but the compiler doesn't support this")
-  endif()
-endif()
+if(_M_ARM_64)
+  # Due to an oversight in llvm, it declares any reasonably new Kryo CPU to only be ARMv8.0
+  # Manually detect newer CPU revisions until clang and llvm fixes their bug
+  # This script will either provide a supported CPU or 'native'
+  # Additionally -march doesn't work under AArch64+Clang, so you have to use -mcpu or -mtune
+  execute_process(COMMAND python3 "${PROJECT_SOURCE_DIR}/Scripts/aarch64_fit_native.py" "/proc/cpuinfo"
+    OUTPUT_VARIABLE AARCH64_CPU)

-if (TUNE_CPU STREQUAL "native")
-  if(_M_ARM_64)
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 999999.0)
-      # Clang 12.0 fixed the -mcpu=native bug with mixed big.little implementers
-      # Clang can not currently check for native Apple M1 type in hypervisor. Currently disabled
-      check_cxx_compiler_flag("-mcpu=native" COMPILER_SUPPORTS_CPU_TYPE)
-      if(COMPILER_SUPPORTS_CPU_TYPE)
-        add_compile_options("-mcpu=native")
-      endif()
-    else()
-      # Due to an oversight in llvm, it declares any reasonably new Kryo CPU to only be ARMv8.0
-      # Manually detect newer CPU revisions until clang and llvm fixes their bug
-      # This script will either provide a supported CPU or 'native'
-      # Additionally -march doesn't work under AArch64+Clang, so you have to use -mcpu or -mtune
-      execute_process(COMMAND python3 "${PROJECT_SOURCE_DIR}/Scripts/aarch64_fit_native.py" "/proc/cpuinfo" "${CMAKE_CXX_COMPILER_VERSION}"
-        OUTPUT_VARIABLE AARCH64_CPU)
+  string(STRIP ${AARCH64_CPU} AARCH64_CPU)

-      string(STRIP ${AARCH64_CPU} AARCH64_CPU)
-
-      check_cxx_compiler_flag("-mcpu=${AARCH64_CPU}" COMPILER_SUPPORTS_CPU_TYPE)
-      if(COMPILER_SUPPORTS_CPU_TYPE)
-        add_compile_options("-mcpu=${AARCH64_CPU}")
-      endif()
-    endif()
-  else()
-    check_cxx_compiler_flag("-march=native" COMPILER_SUPPORTS_MARCH_NATIVE)
-    if(COMPILER_SUPPORTS_MARCH_NATIVE)
-      add_compile_options("-march=native")
-    endif()
-  endif()
-else()
-  check_cxx_compiler_flag("-mcpu=${TUNE_CPU}" COMPILER_SUPPORTS_CPU_TYPE)
+  check_cxx_compiler_flag("-mcpu=${AARCH64_CPU}" COMPILER_SUPPORTS_CPU_TYPE)
  if(COMPILER_SUPPORTS_CPU_TYPE)
-    add_compile_options("-mcpu=${TUNE_CPU}")
-  else()
-    message(FATAL_ERROR "Trying to compile cpu type '${TUNE_CPU}' but the compiler doesn't support this")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcpu=${AARCH64_CPU}")
  endif()
 endif()

@@ -418,181 +236,58 @@ add_compile_options(-Wall)

 configure_file(
  ${CMAKE_CURRENT_SOURCE_DIR}/include/Config.h.in
-  ${CMAKE_BINARY_DIR}/generated/ConfigDefines.h)
+  ${CMAKE_BINARY_DIR}/generated/Config.h)

 if (BUILD_TESTS)
  include(CTest)
  enable_testing()
  message(STATUS "Unit tests are enabled")
 endif()
-
-add_subdirectory(FEXHeaderUtils/)
-add_subdirectory(FEXCore/)
-
-# Binfmt_misc files must be installed prior to Source/ installs
-add_subdirectory(Data/binfmts/)
+add_subdirectory(External/FEXCore)

 add_subdirectory(Source/)
 add_subdirectory(Data/AppConfig/)

-# Install the ThunksDB file
-file(GLOB CONFIG_SOURCES CONFIGURE_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/Data/*.json)
-
-# Any application configuration json file gets installed
-foreach(CONFIG_SRC ${CONFIG_SOURCES})
-  install(FILES ${CONFIG_SRC}
-    DESTINATION ${DATA_DIRECTORY}/)
-endforeach()
-
 if (BUILD_TESTS)
  add_subdirectory(unittests/)
 endif()

 if (BUILD_THUNKS)
-  set (FEX_PROJECT_SOURCE_DIR ${PROJECT_SOURCE_DIR})
-  add_subdirectory(ThunkLibs/Generator)
-
-  # Thunk targets for both host libraries and IDE integration
-  add_subdirectory(ThunkLibs/HostLibs)
-
-  # Thunk targets for IDE integration of guest code, only
-  add_subdirectory(ThunkLibs/GuestLibs)
-
-  # Thunk targets for guest libraries
  include(ExternalProject)
+
+  ExternalProject_Add(host-libs
+    PREFIX host-libs
+    SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ThunkLibs/HostLibs"
+    BINARY_DIR "Host"
+    CMAKE_ARGS "-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}"
+    INSTALL_COMMAND ""
+    BUILD_ALWAYS ON
+  )
+
+  install(
+    CODE "MESSAGE(\"-- Installing: host-libs\")"
+    CODE "
+    EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} --build . --target ThunkHostsInstall
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Host
+    )"
+    DEPENDS host-libs
+  )
+
  ExternalProject_Add(guest-libs
    PREFIX guest-libs
    SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ThunkLibs/GuestLibs"
    BINARY_DIR "Guest"
-    CMAKE_ARGS
-      "-DBITNESS=64"
-      "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-      "-DENABLE_CLANG_THUNKS=${ENABLE_CLANG_THUNKS}"
-      "-DCMAKE_TOOLCHAIN_FILE:FILEPATH=${X86_64_TOOLCHAIN_FILE}"
-      "-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}"
-      "-DSTRUCT_VERIFIER=${CMAKE_SOURCE_DIR}/Scripts/StructPackVerifier.py"
-      "-DFEX_PROJECT_SOURCE_DIR=${FEX_PROJECT_SOURCE_DIR}"
-      "-DGENERATOR_EXE=$<TARGET_FILE:thunkgen>"
+    CMAKE_ARGS "-DX86_C_COMPILER:STRING=${X86_C_COMPILER}" "-DX86_CXX_COMPILER:STRING=${X86_CXX_COMPILER}" "-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}"
    INSTALL_COMMAND ""
    BUILD_ALWAYS ON
-    DEPENDS thunkgen
-  )
-
-  ExternalProject_Add(guest-libs-32
-    PREFIX guest-libs-32
-    SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ThunkLibs/GuestLibs"
-    BINARY_DIR "Guest_32"
-    CMAKE_ARGS
-      "-DBITNESS=32"
-      "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-      "-DENABLE_CLANG_THUNKS=${ENABLE_CLANG_THUNKS}"
-      "-DCMAKE_TOOLCHAIN_FILE:FILEPATH=${X86_32_TOOLCHAIN_FILE}"
-      "-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}"
-      "-DSTRUCT_VERIFIER=${CMAKE_SOURCE_DIR}/Scripts/StructPackVerifier.py"
-      "-DFEX_PROJECT_SOURCE_DIR=${FEX_PROJECT_SOURCE_DIR}"
-      "-DGENERATOR_EXE=$<TARGET_FILE:thunkgen>"
-    INSTALL_COMMAND ""
-    BUILD_ALWAYS ON
-    DEPENDS thunkgen
  )

  install(
    CODE "MESSAGE(\"-- Installing: guest-libs\")"
    CODE "
-    EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} --build . --target install
+    EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} --build . --target ThunkGuestsInstall
    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Guest
    )"
    DEPENDS guest-libs
  )
-
-  install(
-    CODE "MESSAGE(\"-- Installing: guest-libs-32\")"
-    CODE "
-    EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} --build . --target install
-    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Guest_32
-    )"
-    DEPENDS guest-libs-32
-  )
-
-  add_custom_target(uninstall_guest-libs
-    COMMAND ${CMAKE_COMMAND} "--build" "." "--target" "uninstall"
-    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Guest
-  )
-
-  add_custom_target(uninstall_guest-libs-32
-    COMMAND ${CMAKE_COMMAND} "--build" "." "--target" "uninstall"
-    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Guest_32
-  )
-
-  add_dependencies(uninstall uninstall_guest-libs)
-  add_dependencies(uninstall uninstall_guest-libs-32)
 endif()
-
-set(FEX_VERSION_MAJOR "0")
-set(FEX_VERSION_MINOR "0")
-set(FEX_VERSION_PATCH "0")
-
-if (OVERRIDE_VERSION STREQUAL "detect")
-  find_package(Git)
-  if (GIT_FOUND)
-    execute_process(
-      COMMAND ${GIT_EXECUTABLE} describe --abbrev=0
-      WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-      OUTPUT_VARIABLE GIT_DESCRIBE_STRING
-      RESULT_VARIABLE GIT_ERROR
-      ERROR_QUIET
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-
-    if (NOT ${GIT_ERROR} EQUAL 0)
-      # Likely built in a way that doesn't have tags
-      # Setup a version tag that is unknown
-      set(GIT_DESCRIBE_STRING "FEX-0000")
-    endif()
-  endif()
-else()
-  set(GIT_DESCRIBE_STRING "FEX-${OVERRIDE_VERSION}")
-endif()
-
-# Parse the version here
-# Change something like `FEX-2106.1-76-<hash>` in to a list
-string(REPLACE "-" ";" DESCRIBE_LIST ${GIT_DESCRIBE_STRING})
-
-# Extract the `2106.1` element
-list(GET DESCRIBE_LIST 1 DESCRIBE_LIST)
-
-# Change `2106.1` in to a list
-string(REPLACE "." ";" DESCRIBE_LIST ${DESCRIBE_LIST})
-
-# Calculate list size
-list(LENGTH DESCRIBE_LIST LIST_SIZE)
-
-# Pull out the major version
-list(GET DESCRIBE_LIST 0 FEX_VERSION_MAJOR)
-
-# Minor version only exists if there is a .1 at the end
-# eg: 2106 versus 2106.1
-if (LIST_SIZE GREATER 1)
-  list(GET DESCRIBE_LIST 1 FEX_VERSION_MINOR)
-endif()
-
-# Package creation
-set (CPACK_GENERATOR "DEB")
-set (CPACK_PACKAGE_NAME fex-emu)
-set (CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${GIT_DESCRIBE_STRING}_${CMAKE_SYSTEM_PROCESSOR}")
-set (CPACK_PACKAGE_CONTACT "FEX-Emu Maintainers <team@fex-emu.com>")
-set (CPACK_PACKAGE_VERSION_MAJOR "${FEX_VERSION_MAJOR}")
-set (CPACK_PACKAGE_VERSION_MINOR "${FEX_VERSION_MINOR}")
-set (CPACK_PACKAGE_VERSION_PATCH "${FEX_VERSION_PATCH}")
-set (CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/CPack/Description.txt")
-
-# Debian defines
-set (CPACK_DEBIAN_PACKAGE_DEPENDS "libc6, libstdc++6, libepoxy0, libsdl2-2.0-0, libegl1, libx11-6, squashfuse")
-set (CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA
-  "${CMAKE_CURRENT_SOURCE_DIR}/CPack/postinst;${CMAKE_CURRENT_SOURCE_DIR}/CPack/prerm;${CMAKE_CURRENT_SOURCE_DIR}/CPack/triggers")
-if (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
-  # binfmt_misc conflicts with qemu-user-static
-  # We also only install binfmt_misc on aarch64 hosts
-  set (CPACK_DEBIAN_PACKAGE_CONFLICTS "${CPACK_DEBIAN_PACKAGE_CONFLICTS}, qemu-user-static")
-endif()
-include (CPack)
@@ -55,7 +55,7 @@ further defined and clarified by project maintainers.
 ## Enforcement

 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at team@fex-emu.com. All
+reported by contacting the project team at team@fex-emu.org. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.
@@ -1,3 +0,0 @@
-x86 and x86-64 Linux emulator
-
-FEX is very much work in progress, so expect things to change.
@@ -1,18 +0,0 @@
-#!/bin/sh
-set -e
-update_binfmt() {
-  # Check for update-binfmts
-  command -v update-binfmts >/dev/null || return 0
-
-  # Setup binfmt_misc
-  update-binfmts --import FEX-x86
-  update-binfmts --import FEX-x86_64
-}
-
-# Install FEXInterpreter hardlink
-# Needs to be done before setting up binfmt_misc
-ln -f /usr/bin/FEXLoader /usr/bin/FEXInterpreter
-
-if [ $(uname -m) = 'aarch64' ]; then
-  update_binfmt
-fi
@@ -1,17 +0,0 @@
-#!/bin/sh
-set -e
-update_binfmt() {
-  # Check for update-binfmts
-  command -v update-binfmts >/dev/null || return 0
-
-  # Uninstall
-  update-binfmts --unimport FEX-x86
-  update-binfmts --unimport FEX-x86_64
-}
-
-if [ $(uname -m) = 'aarch64' ]; then
-  update_binfmt
-fi
-
-# Remove FEXInterpreter hardlink
-unlink /usr/bin/FEXInterpreter
@@ -1 +0,0 @@
-activate-noawait ldconfig
@@ -11,15 +11,15 @@ endforeach()
 # First generate then install it
 foreach(GEN_CONFIG_SRC ${GEN_CONFIG_SOURCES})
  # Get the filename only component
-  get_filename_component(CONFIG_NAME ${GEN_CONFIG_SRC} NAME_WLE)
+  get_filename_component(CONFIG_NAME ${GEN_CONFIG_SRC} NAME_WE)

  # Configure it
  configure_file(
    ${GEN_CONFIG_SRC}
-    ${CMAKE_BINARY_DIR}/Data/AppConfig/${CONFIG_NAME})
+    ${CMAKE_BINARY_DIR}/Data/AppConfig/${CONFIG_NAME}.json)

  # Then install the configured json
  install(
-    FILES ${CMAKE_BINARY_DIR}/Data/AppConfig/${CONFIG_NAME}
+    FILES ${CMAKE_BINARY_DIR}/Data/AppConfig/${CONFIG_NAME}.json
    DESTINATION ${DATA_DIRECTORY}/AppConfig/)
 endforeach()
@@ -1,5 +0,0 @@
-{
-  "Config": {
-    "HideHypervisorBit": "1"
-  }
-}
@@ -1,5 +0,0 @@
-{
-  "Config": {
-    "AdditionalArguments": "--no-sandbox"
-  }
-}
@@ -1,189 +0,0 @@
-{
-  "DB": {
-    "GL": {
-      "Library" : "libGL-guest.so",
-      "Depends": [
-        "X11"
-      ],
-      "Overlay": [
-        "@PREFIX_LIB@/libGL.so",
-        "@PREFIX_LIB@/libGL.so.1",
-        "@PREFIX_LIB@/libGL.so.1.2.0",
-        "@PREFIX_LIB@/libGL.so.1.7.0"
-      ]
-    },
-    "GLESv2": {
-      "Library": "libGLESv2-guest.so",
-      "Depends": [
-        "X11"
-      ],
-      "Overlay": [
-        "@PREFIX_LIB@/libGLESv2.so",
-        "@PREFIX_LIB@/libGLESv2.so.2",
-        "@PREFIX_LIB@/libGLESv2.so.2.0.0"
-      ]
-    },
-    "X11": {
-      "Library": "libX11-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libX11.so",
-        "@PREFIX_LIB@/libX11.so.6",
-        "@PREFIX_LIB@/libX11.so.6.4.0"
-      ]
-    },
-    "Vulkan": {
-      "Library": "libvulkan-guest.so",
-      "Depends": [
-        "xcb"
-      ],
-      "Overlay": [
-        "@PREFIX_LIB@/libvulkan.so",
-        "@PREFIX_LIB@/libvulkan.so.1",
-        "@HOME@/.local/share/Steam/ubuntu12_32/steam-runtime/pinned_libs_64/libvulkan.so.1"
-      ],
-      "Comment": [
-        "Vulkan library relies on xcb, otherwise it crashes with jemalloc"
-      ]
-    },
-    "xcb": {
-      "Depends": [
-        "X11"
-      ],
-      "Library": "libxcb-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libxcb.so",
-        "@PREFIX_LIB@/libxcb.so.1",
-        "@PREFIX_LIB@/libxcb.so.1.1.0"
-      ]
-    },
-    "xcb-dri2": {
-      "Library": "libxcb-dri2-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libxcb-dri2.so",
-        "@PREFIX_LIB@/libxcb-dri2.so.0",
-        "@PREFIX_LIB@/libxcb-dri2.so.0.0.0"
-      ]
-    },
-    "xcb-dri3": {
-      "Library": "libxcb-dri3-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libxcb-dri3.so",
-        "@PREFIX_LIB@/libxcb-dri3.so.0",
-        "@PREFIX_LIB@/libxcb-dri3.so.0.0.0"
-      ]
-    },
-    "xcb-xfixes": {
-      "Library": "libxcb-xfixes-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libxcb-xfixes.so",
-        "@PREFIX_LIB@/libxcb-xfixes.so.0",
-        "@PREFIX_LIB@/libxcb-xfixes.so.0.0.0"
-      ]
-    },
-    "xcb-shm": {
-      "Library": "libxcb-shm-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libxcb-shm.so",
-        "@PREFIX_LIB@/libxcb-shm.so.0",
-        "@PREFIX_LIB@/libxcb-shm.so.0.0.0"
-      ]
-    },
-    "xcb-sync": {
-      "Library": "libxcb-sync-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libxcb-sync.so",
-        "@PREFIX_LIB@/libxcb-sync.so.1",
-        "@PREFIX_LIB@/libxcb-sync.so.1.0.0"
-      ]
-    },
-    "xcb-randr": {
-      "Library": "libxcb-randr-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libxcb-randr.so",
-        "@PREFIX_LIB@/libxcb-randr.so.0",
-        "@PREFIX_LIB@/libxcb-randr.so.0.1.0"
-      ]
-    },
-    "xcb-present": {
-      "Library": "libxcb-present-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libxcb-present.so",
-        "@PREFIX_LIB@/libxcb-present.so.0",
-        "@PREFIX_LIB@/libxcb-present.so.0.0.0"
-      ]
-    },
-    "xcb-glx": {
-      "Library": "libxcb-glx-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libxcb-glx.so",
-        "@PREFIX_LIB@/libxcb-glx.so.0",
-        "@PREFIX_LIB@/libxcb-glx.so.0.0.0"
-      ]
-    },
-    "xshmfence": {
-      "Library": "libxshmfence-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libxshmfence.so",
-        "@PREFIX_LIB@/libxshmfence.so.1",
-        "@PREFIX_LIB@/libxshmfence.so.1.0.0"
-      ]
-    },
-    "drm": {
-      "Library": "libdrm-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libdrm.so",
-        "@PREFIX_LIB@/libdrm.so.2",
-        "@PREFIX_LIB@/libdrm.so.2.4.0"
-      ]
-    },
-    "asound": {
-      "Library": "libasound-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libasound.so",
-        "@PREFIX_LIB@/libasound.so.2",
-        "@PREFIX_LIB@/libasound.so.2.0.0"
-      ]
-    },
-    "Xrender": {
-      "Library": "libXrender-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libXrender.so",
-        "@PREFIX_LIB@/libXrender.so.1",
-        "@PREFIX_LIB@/libXrender.so.1.3.0"
-      ]
-    },
-    "Xext": {
-      "Library": "libXext-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libXext.so",
-        "@PREFIX_LIB@/libXext.so.6",
-        "@PREFIX_LIB@/libXext.so.6.4.0"
-      ]
-    },
-    "Xfixes": {
-      "Library": "libXfixes-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libXfixes.so",
-        "@PREFIX_LIB@/libXfixes.so.3",
-        "@PREFIX_LIB@/libXfixes.so.3.1.0"
-      ]
-    },
-    "OpenCL": {
-      "Library" : "libOpenCL-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libOpenCL.so",
-        "@PREFIX_LIB@/libOpenCL.so.1",
-        "@PREFIX_LIB@/libOpenCL.so.1.0.0"
-      ]
-    },
-    "WaylandClient": {
-      "Library" : "libwayland-client-guest.so",
-      "Overlay": [
-        "@PREFIX_LIB@/libwayland-client.so",
-        "@PREFIX_LIB@/libwayland-client.so.0",
-        "@PREFIX_LIB@/libwayland-client.so.0.20.0"
-      ]
-    },
-    "":{}
-  }
-}
@@ -1,17 +0,0 @@
-function(GenBinFmt Name)
-  # Get the filename only component
-  get_filename_component(FMT_NAME ${Name} NAME_WE)
-
-  # Configure it
-  configure_file(
-    ${Name}
-    ${CMAKE_BINARY_DIR}/Data/binfmts/${FMT_NAME})
-
-  # Then install the configured binfmt
-  install(
-    FILES ${CMAKE_BINARY_DIR}/Data/binfmts/${FMT_NAME}
-    DESTINATION ${CMAKE_INSTALL_PREFIX}/share/binfmts/)
-endfunction()
-
-GenBinFmt(FEX-x86.in)
-GenBinFmt(FEX-x86_64.in)
@@ -1,9 +0,0 @@
-package fex
-interpreter @CMAKE_INSTALL_PREFIX@/bin/FEXInterpreter
-magic \x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x03\x00
-offset 0
-mask \xff\xff\xff\xff\xff\xfe\xfe\x00\x00\x00\x00\xff\xff\xff\xff\xff\xfe\xff\xff\xff
-credentials yes
-fix_binary yes
-preserve yes
-expose_interpreter optional
@@ -1,9 +0,0 @@
-package fex
-interpreter @CMAKE_INSTALL_PREFIX@/bin/FEXInterpreter
-magic \x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x3e\x00
-offset 0
-mask \xff\xff\xff\xff\xff\xfe\xfe\x00\x00\x00\x00\xff\xff\xff\xff\xff\xfe\xff\xff\xff
-credentials yes
-fix_binary yes
-preserve yes
-expose_interpreter optional
@@ -3,7 +3,7 @@ FROM ubuntu:20.04 as builder

 RUN DEBIAN_FRONTEND="noninteractive" apt-get update
 RUN DEBIAN_FRONTEND="noninteractive" apt install -y cmake \
-clang-10 llvm-10 nasm ninja-build \
+clang-10 llvm-10 nasm ninja-build libnuma-dev \
 libcap-dev libglfw3-dev libepoxy-dev python3-dev \
 python3 linux-headers-generic

@@ -23,7 +23,7 @@ FROM ubuntu:20.04

 RUN DEBIAN_FRONTEND="noninteractive" apt-get update
 RUN DEBIAN_FRONTEND="noninteractive" apt install -y \
-libcap-dev libglfw3-dev libepoxy-dev
+libnuma-dev libcap-dev libglfw3-dev libepoxy-dev

 COPY --from=builder /opt/FEX/build/Bin/* /usr/bin/

@@ -9,20 +9,14 @@ if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcx16")
 endif()

-if (CMAKE_SYSTEM_PROCESSOR MATCHES "^aarch64|^arm64|^armv8\.*")
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
  set(_M_ARM_64 1)
 endif()

-if (ENABLE_VIXL_SIMULATOR)
-  # If the vixl simulator is enabled then we are using the ARM64 JIT
-  option(ENABLE_JIT_X86_64 "Enable the x86_64 JIT" FALSE)
-  option(ENABLE_JIT_ARM64 "Enable the ARM64 JIT" TRUE)
-else()
-  option(ENABLE_JIT_X86_64 "Enable the x86_64 JIT" ${_M_X86_64})
-  option(ENABLE_JIT_ARM64 "Enable the ARM64 JIT" ${_M_ARM_64})
-endif()
-
+set(ENABLE_JIT_X86_64 ${_M_X86_64} CACHE BOOL "Enable the x86_64 JIT")
+set(ENABLE_JIT_ARM64 ${_M_ARM_64} CACHE BOOL "Enable the ARM64 JIT")
 option(ENABLE_CLANG_FORMAT "Run clang format over the source" FALSE)
+option(ENABLE_JITSYMBOLS "Enable visibility of JITSymbols in profiling tools" FALSE)

 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 cmake_policy(SET CMP0083 NEW) # Follow new PIE policy
@@ -34,6 +28,7 @@ set(CMAKE_INCLUDE_CURRENT_DIR ON)
 include(CheckCXXCompilerFlag)
 include(CheckIncludeFileCXX)

+
 if (EXISTS ${CMAKE_CURRENT_DIR}/External/vixl/)
    # Useful to have for freestanding libFEXCore
    add_subdirectory(External/vixl/)
@@ -43,32 +38,27 @@ endif()
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

+# Find our git hash
+find_package(Git)
+
 set(GIT_SHORT_HASH "Unknown")
 set(GIT_DESCRIBE_STRING "FEX-Unknown")

-if (OVERRIDE_VERSION STREQUAL "detect")
-# Find our git hash
-  find_package(Git)
-
-  if (GIT_FOUND)
-    execute_process(
-      COMMAND ${GIT_EXECUTABLE} rev-parse --short=7 HEAD
-      WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-      OUTPUT_VARIABLE GIT_SHORT_HASH
-      ERROR_QUIET
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-    execute_process(
-      COMMAND ${GIT_EXECUTABLE} describe --abbrev=7
-      WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
-      OUTPUT_VARIABLE GIT_DESCRIBE_STRING
-      ERROR_QUIET
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-  endif()
-else()
-  set(GIT_SHORT_HASH "${OVERRIDE_VERSION}")
-  set(GIT_DESCRIBE_STRING "FEX-${OVERRIDE_VERSION}")
+if (GIT_FOUND)
+  execute_process(
+    COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD
+    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+    OUTPUT_VARIABLE GIT_SHORT_HASH
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  execute_process(
+    COMMAND ${GIT_EXECUTABLE} describe
+    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+    OUTPUT_VARIABLE GIT_DESCRIBE_STRING
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
 endif()

 configure_file(
@@ -77,13 +67,8 @@ configure_file(

 include_directories(${CMAKE_BINARY_DIR}/generated)

-add_compile_options(-fno-exceptions)
 add_subdirectory(Source/)

 install (DIRECTORY include/FEXCore ${CMAKE_BINARY_DIR}/include/FEXCore
  DESTINATION include
  COMPONENT Development)
-
-if (BUILD_TESTS)
-  add_subdirectory(unittests/)
-endif()
@@ -18,8 +18,14 @@ This project aims to provide a fast and functional x86-64 emulation library that
 * Portable library implementation in order to support easy integration in to applications
 ### Target Host Architecture
 The target host architecture for this library is AArch64. Specifically the ARMv8.1 version or newer.
-The CPU IR is designed with AArch64 in mind but should allow for other architectures as well.
-x86-64 host support is available for ease of development, but is not a priority.
+The CPU IR is designed with AArch64 in mind but there is a desire to run the recompiled code on other architectures as well.
+Multiple architecture support is desired for easier bringup and debugging, performance isn't as much of a priority there (ex. x86-64(guest) translated to x86-64(host))
+### Not currently goals but will be in the future
+* 32bit x86 support
+  * This will be a desire in the future, but to lower the amount of work required, decided to push this off for now.
+* Integration in to WINE
+* Later generation of x86-64 instruction sets
+  * Including AVX, F16C, XOP, FMA, AVX2, etc
 ### Not desired
 * Kernel space emulation
 * CPL0-2 emulation
@@ -27,3 +33,7 @@ x86-64 host support is available for ease of development, but is not a priority.
 * IRQs
 * SVM
 * "Cycle Accurate" emulation
+### Dependencies
+ * clang-tidy if you want to ensure the code stays tidy
+ * cmake
+ * A C++17 compliant compiler (There are assumptions made about using Clang and LTO)
@@ -22,14 +22,12 @@ def print_header():
 #define OPT_UINT64(group, enum, json, default) OPT_BASE(uint64_t, group, enum, json, default)
 #endif
 #ifndef OPT_STR
-#define OPT_STR(group, enum, json, default) OPT_BASE(fextl::string, group, enum, json, default)
+#define OPT_STR(group, enum, json, default) OPT_BASE(std::string, group, enum, json, default)
 #endif
 #ifndef OPT_STRARRAY
-#define OPT_STRARRAY(group, enum, json, default) OPT_BASE(fextl::string, group, enum, json, default)
-#endif
-#ifndef OPT_STRENUM
-#define OPT_STRENUM(group, enum, json, default) OPT_BASE(uint64_t, group, enum, json, default)
+#define OPT_STRARRAY(group, enum, json, default) OPT_BASE(std::string, group, enum, json, default)
 #endif
+
 '''
    output_file.write(header)

@@ -42,7 +40,6 @@ def print_tail():
 #undef OPT_UINT64
 #undef OPT_STR
 #undef OPT_STRARRAY
-#undef OPT_STRENUM
 '''
    output_file.write(tail)

@@ -101,19 +98,14 @@ def print_man_option(short, long, desc, default):
    output_man.write("\\fBdefault:\\fR {0}\n".format(default))
    output_man.write(".Pp\n\n")

-def print_man_env_option(name, desc, default, no_json_key):
-    output_man.write("\\fBFEX_{0}\\fR\n".format(name.upper()))
+def print_man_env_option(name, desc, default):
+    output_man.write("\\fBFEX_{0}\\fR\n".format(name))

    # Print description
    for line in desc:
        output_man.write(".Pp\n")
        output_man.write("{0}\n".format(line))

-    if (not no_json_key):
-        output_man.write(".Pp\n")
-        output_man.write("\\fBJSON key:\\fR '{0}'\n".format(name))
-        output_man.write(".Pp\n\n")
-
    output_man.write(".Pp\n")
    output_man.write("\\fBdefault:\\fR {0}\n".format(default))
    output_man.write(".Pp\n\n")
@@ -130,13 +122,12 @@ def print_man_options(options):
                short = op_vals["ShortArg"]

            default = op_vals["Default"]
-            value_type = op_vals["Type"]

            # Textual default rather than enum based
            if ("TextDefault" in op_vals):
                default = op_vals["TextDefault"]

-            if (value_type == "str" or value_type == "strarray" or value_type == "strenum"):
+            if (op_vals["Type"] == "str" or op_vals["Type"] == "strarray"):
                # Wrap the string argument in quotes
                default = "'" + default + "'"
            print_man_option(
@@ -145,12 +136,6 @@ def print_man_options(options):
                op_vals["Desc"],
                default
            )
-            if (value_type == "strenum"):
-                Enums = op_vals["Enums"]
-                output_man.write("\\fBAvailable Options:\\fR\n")
-                for enum_op_key, enum_op_vals in Enums.items():
-                    output_man.write("{}, ".format(enum_op_vals))
-                output_man.write("\n")

    output_man.write(".El\n")

@@ -160,65 +145,21 @@ def print_man_environment(options):
    for op_group, group_vals in options.items():
        for op_key, op_vals in group_vals.items():
            default = op_vals["Default"]
-            value_type = op_vals["Type"]

            # Textual default rather than enum based
            if ("TextDefault" in op_vals):
                default = op_vals["TextDefault"]

-            if (value_type == "str" or value_type == "strarray" or value_type == "strenum"):
+            if (op_vals["Type"] == "str" or op_vals["Type"] == "strarray"):
                # Wrap the string argument in quotes
                default = "'" + default + "'"
            print_man_env_option(
-                op_key,
+                op_key.upper(),
                op_vals["Desc"],
-                default,
-                False
+                default
            )

-            if (value_type == "strenum"):
-                Enums = op_vals["Enums"]
-                output_man.write("\\fBAvailable Options:\\fR\n")
-                for enum_op_key, enum_op_vals in Enums.items():
-                    output_man.write("{}, ".format(enum_op_vals))
-                output_man.write("\n")
-
-    print_man_environment_tail()
    output_man.write(".El\n")
-
-def print_man_environment_tail():
-
-    # Additional environment variables that live outside of the normal loop
-    print_man_env_option(
-    "FEX_APP_CONFIG_LOCATION",
-    [
-    "Allows the user to override where FEX looks for configuration files",
-    "By default FEX will look in {$HOME, $XDG_CONFIG_HOME}/.fex-emu/",
-    "This will override the full path",
-    ],
-    "''", True)
-
-    print_man_env_option(
-    "FEX_APP_CONFIG",
-    [
-    "Allows the user to override where FEX looks for only the application config file",
-    "By default FEX will look in {$HOME, $XDG_CONFIG_HOME}/.fex-emu/Config.json",
-    "This will override this file location",
-    "One must be careful with this option as it will override any applications that load with execve as well"
-    "If you need to support applications that execve then use FEX_APP_CONFIG_LOCATION instead"
-    ],
-    "''", True)
-
-    print_man_env_option(
-    "FEX_APP_DATA_LOCATION",
-    [
-    "Allows the user to override where FEX looks for data files",
-    "By default FEX will look in {$HOME, $XDG_DATA_HOME}/.fex-emu/",
-    "This will override the full path",
-    "This is the folder where FEX stores generated files like IR cache"
-    ],
-    "''", True)
-
 def print_man_header():
    header ='''.Dd {0}
 .Dt FEX
@@ -352,7 +293,7 @@ def print_argloader_options(options):
        for op_key, op_vals in group_vals.items():
            default = op_vals["Default"]

-            if (op_vals["Type"] == "str" or op_vals["Type"] == "strarray" or op_vals["Type"] == "strenum"):
+            if (op_vals["Type"] == "str" or op_vals["Type"] == "strarray"):
                # Wrap the string argument in quotes
                default = "\"" + default + "\""

@@ -389,21 +330,15 @@ def print_parse_argloader_options(options):

            value_type = op_vals["Type"]
            NeedsString = False
-            conversion_func = "fextl::fmt::format(\"{}\", "
+            conversion_func = "std::to_string"
            if ("ArgumentHandler" in op_vals):
                NeedsString = True
-                conversion_func = "FEXCore::Config::Handler::{0}(".format(op_vals["ArgumentHandler"])
+                conversion_func = "FEX::Handler::{0}".format(op_vals["ArgumentHandler"])
            if (value_type == "str"):
                NeedsString = True
-                conversion_func = "("
-            if (value_type == "bool"):
-                # boolean values need a decimal specifier. Otherwise fmt prints strings.
-                conversion_func = "fextl::fmt::format(\"{:d}\", "
+                conversion_func = ""

-            if (value_type == "strenum"):
-                output_argloader.write("\tfextl::string UserValue = Options[\"{0}\"];\n".format(op_key))
-                output_argloader.write("\tSet(FEXCore::Config::ConfigOption::CONFIG_{}, FEXCore::Config::EnumParser<FEXCore::Config::{}ConfigPair>(FEXCore::Config::{}_EnumPairs, UserValue));\n".format(op_key.upper(), op_key, op_key, op_key))
-            elif (value_type == "strarray"):
+            if (value_type == "strarray"):
                # these need a bit more help
                output_argloader.write("\tauto Array = Options.all(\"{0}\");\n".format(op_key))
                output_argloader.write("\tfor (auto iter = Array.begin(); iter != Array.end(); ++iter) {\n")
@@ -411,73 +346,15 @@ def print_parse_argloader_options(options):
                output_argloader.write("\t}\n")
            else:
                if (NeedsString):
-                    output_argloader.write("\tfextl::string UserValue = Options[\"{0}\"];\n".format(op_key))
+                    output_argloader.write("\tstd::string UserValue = Options[\"{0}\"];\n".format(op_key))
                else:
                    output_argloader.write("\t{0} UserValue = Options.get(\"{1}\");\n".format(value_type, op_key))

-                output_argloader.write("\tSet(FEXCore::Config::ConfigOption::CONFIG_{0}, {1}UserValue));\n".format(op_key.upper(), conversion_func))
+                output_argloader.write("\tSet(FEXCore::Config::ConfigOption::CONFIG_{0}, {1}(UserValue));\n".format(op_key.upper(), conversion_func))
            output_argloader.write("}\n")

    output_argloader.write("#endif\n")

-
-def print_parse_envloader_options(options):
-    output_argloader.write("#ifdef ENVLOADER\n")
-    output_argloader.write("#undef ENVLOADER\n")
-    output_argloader.write("if (false) {}\n")
-
-    for op_group, group_vals in options.items():
-        for op_key, op_vals in group_vals.items():
-            value_type = op_vals["Type"]
-            if (value_type == "strenum"):
-                output_argloader.write("else if (Key == \"FEX_{0}\") {{\n".format(op_key.upper()))
-                output_argloader.write("Value = FEXCore::Config::EnumParser<FEXCore::Config::{}ConfigPair>(FEXCore::Config::{}_EnumPairs, Value_View);\n".format(op_key, op_key, op_key))
-                output_argloader.write("}\n")
-
-            if ("ArgumentHandler" in op_vals):
-                conversion_func = "FEXCore::Config::Handler::{0}".format(op_vals["ArgumentHandler"])
-                output_argloader.write("else if (Key == \"FEX_{0}\") {{\n".format(op_key.upper()))
-                output_argloader.write("Value = {0}(Value_View);\n".format(conversion_func))
-                output_argloader.write("}\n")
-    output_argloader.write("#endif\n")
-
-def print_parse_enum_options(options):
-    output_argloader.write("#ifdef ENUMDEFINES\n")
-    output_argloader.write("#undef ENUMDEFINES\n")
-    for op_group, group_vals in options.items():
-        for op_key, op_vals in group_vals.items():
-            if (op_vals["Type"] == "strenum"):
-                output_argloader.write("enum class {} : uint64_t {{\n".format(op_key))
-                Enums = op_vals["Enums"]
-                i = 0
-                # Always have an OFF.
-                output_argloader.write("\tOFF = 0,\n")
-                for enum_op_key, enum_op_vals in Enums.items():
-                    output_argloader.write("\t{} = 1ULL << {},\n".format(enum_op_key.upper(), i))
-                    i += 1
-
-                output_argloader.write("};\n")
-                output_argloader.write("FEX_DEF_NUM_OPS({})\n".format(op_key))
-
-
-    for op_group, group_vals in options.items():
-        for op_key, op_vals in group_vals.items():
-            if (op_vals["Type"] == "strenum"):
-                Enums = op_vals["Enums"]
-
-                output_argloader.write("using {}ConfigPair = std::pair<std::string_view, FEXCore::Config::{}>;\n".format(op_key, op_key))
-                output_argloader.write("constexpr static std::array<{}ConfigPair, {}> {}_EnumPairs = {{{{\n".format(op_key, len(Enums) + 1, op_key))
-                i = 0
-                # Always have an OFF.
-                output_argloader.write("\t{{ \"off\", FEXCore::Config::{}::OFF }},\n".format(op_key))
-                for enum_op_key, enum_op_vals in Enums.items():
-                    output_argloader.write("\t{{ \"{}\", FEXCore::Config::{}::{} }},\n".format(enum_op_vals, op_key, enum_op_key.upper()))
-                    i += 1
-
-                output_argloader.write("}};\n")
-
-    output_argloader.write("#endif\n")
-
 def check_for_duplicate_options(options):
    short_map = []
    long_map = []
@@ -552,11 +429,4 @@ output_man.close()
 output_argloader = open(output_argumentloader_filename, "w")
 print_argloader_options(options);
 print_parse_argloader_options(options);
-
-# Generate environment loader code
-print_parse_envloader_options(options);
-
-# Generate enum variable options
-print_parse_enum_options(options);
-
 output_argloader.close()
@@ -7,12 +7,17 @@ OpClasses = collections.OrderedDict()
 def get_ir_classes(ops, defines):
    global OpClasses

-    for op_class, opslist in ops.items():
-        if not (op_class in OpClasses):
-            OpClasses[op_class] = []
+    for op_key, op_vals in ops.items():
+        if not ("Last" in op_vals):
+            OpClass = "#Unknown"

-        for op, op_val in opslist.items():
-            OpClasses[op_class].append([op, op_val])
+            if ("OpClass" in op_vals):
+                OpClass = op_vals["OpClass"]
+
+            if not (OpClass in OpClasses):
+                OpClasses[OpClass] = []
+
+            OpClasses[OpClass].append([op_key, op_vals])

    # Sort the dictionary after we are done parsing it
    OpClasses = collections.OrderedDict(sorted(OpClasses.items()))
@@ -33,9 +38,41 @@ def print_ir_ops():
            op_key = op[0]
            op_vals = op[1]
            output_file.write("## %s\n" % (op_key))
+            HasDest = ("HasDest" in op_vals and op_vals["HasDest"] == True)
+            HasSSAArgs = ("SSAArgs" in op_vals and len(op_vals["SSAArgs"]) > 0)
+            HasSSAArgNames = "SSANames" in op_vals
+            HasArgs = "Args" in op_vals
+            SSAArgsCount = 0
+            ArgCount = 0
+            if (HasSSAArgs):
+                SSAArgsCount = int(op_vals["SSAArgs"])
+            if (HasArgs):
+                ArgCount = len(op_vals["Args"])
+
+            TotalArgsCount = SSAArgsCount + (ArgCount / 2)

            output_file.write(">")
-            output_file.write(op_key)
+            if (HasDest):
+                output_file.write("%dest = ")
+
+            output_file.write("%s " % op_key)
+
+            ArgComma = (", ", "")
+            if (HasSSAArgs):
+                for i in range(0, SSAArgsCount):
+                    FinalArg = (i + 1) == TotalArgsCount
+                    if (HasSSAArgNames):
+                        output_file.write("%%%s%s" % (op_vals["SSANames"][i], ArgComma[FinalArg]))
+                    else:
+                        output_file.write("%%ssa%d%s" % (i, ArgComma[FinalArg]))
+
+            if (HasArgs):
+                Args = op_vals["Args"]
+                for i in range(0, ArgCount, 2):
+                    FinalArg = ((i / 2) + SSAArgsCount + 1) == TotalArgsCount
+                    data_type = Args[i]
+                    data_name = Args[i + 1]
+                    output_file.write("\<%s %s\>%s" % (data_type, data_name, ArgComma[FinalArg]))

            output_file.write("\n\n")

@@ -0,0 +1,643 @@
+import json
+import sys
+
+# Print out enum values
+def print_enums(ops, defines):
+    output_file.write("#ifdef IROP_ENUM\n")
+    output_file.write("enum IROps : uint8_t {\n")
+
+    for op_key, op_vals in ops.items():
+        output_file.write("\t\tOP_%s,\n" % op_key.upper())
+
+    output_file.write("};\n")
+
+    output_file.write("#undef IROP_ENUM\n")
+    output_file.write("#endif\n\n")
+
+# Print out struct definitions
+def print_ir_structs(ops, defines):
+    output_file.write("#ifdef IROP_STRUCTS\n")
+
+    # Print out defines here
+    for op_val in defines:
+        output_file.write("\t%s;\n" % op_val)
+
+    output_file.write("// Default structs\n")
+    output_file.write("struct __attribute__((packed)) IROp_Header {\n")
+    output_file.write("\tvoid* Data[0];\n")
+    output_file.write("\tIROps Op;\n\n")
+    output_file.write("\tuint8_t Size;\n")
+    output_file.write("\tuint8_t NumArgs;\n")
+    output_file.write("\tuint8_t ElementSize : 7;\n")
+    output_file.write("\tbool HasDest : 1;\n")
+
+    output_file.write("\ttemplate<typename T>\n")
+    output_file.write("\tT const* C() const { return reinterpret_cast<T const*>(Data); }\n")
+    output_file.write("\ttemplate<typename T>\n")
+    output_file.write("\tT* CW() { return reinterpret_cast<T*>(Data); }\n")
+
+    output_file.write("\tOrderedNodeWrapper Args[0];\n")
+
+    output_file.write("};\n\n");
+
+    output_file.write("// User defined IR Op structs\n")
+    for op_key, op_vals in ops.items():
+        SSAArgs = 0
+        HasArgs = False
+        HasSSANames = False
+
+        if ("SSAArgs" in op_vals):
+            SSAArgs = int(op_vals["SSAArgs"])
+
+        if ("Args" in op_vals and len(op_vals["Args"]) != 0):
+            HasArgs = True
+
+        if ("SSANames" in op_vals and len(op_vals["SSANames"]) != 0):
+            HasSSANames = True
+
+        output_file.write("struct __attribute__((packed)) IROp_%s {\n" % op_key)
+        output_file.write("\tIROp_Header Header;\n\n")
+
+        # SSA arguments have a hard requirement to appear after the header
+        if (SSAArgs != 0):
+            if (HasSSANames):
+                for i in range(0, SSAArgs):
+                    output_file.write("\tOrderedNodeWrapper %s;\n" % (op_vals["SSANames"][i]));
+
+            else:
+                output_file.write("private:\n")
+                for i in range(0, SSAArgs):
+                    output_file.write("\tuint64_t : (sizeof(OrderedNodeWrapper) * 8);\n");
+                output_file.write("public:\n")
+
+        if (HasArgs):
+            output_file.write("\t// User defined data\n")
+
+            # Print out arguments in IR Op
+            for i in range(0, len(op_vals["Args"]), 2):
+                data_type = op_vals["Args"][i]
+                data_name = op_vals["Args"][i+1]
+                output_file.write("\t%s %s;\n" % (data_type, data_name))
+
+        output_file.write("\tstatic constexpr IROps OPCODE = OP_%s;\n" % op_key.upper())
+
+        output_file.write("};\n")
+
+        # Add a static assert that the IR ops must be pod
+        output_file.write("static_assert(std::is_trivial<IROp_%s>::value);\n\n" % op_key)
+        output_file.write("static_assert(std::is_standard_layout<IROp_%s>::value);\n\n" % op_key)
+
+    output_file.write("#undef IROP_STRUCTS\n")
+    output_file.write("#endif\n\n")
+
+# Print out const expression to calculate IR Op sizes
+def print_ir_sizes(ops, defines):
+    output_file.write("#ifdef IROP_SIZES\n")
+
+    output_file.write("constexpr std::array<size_t, IROps::OP_LAST + 1> IRSizes = {\n")
+    for op_key, op_vals in ops.items():
+        if ("Last" in op_vals):
+            output_file.write("\t-1ULL,\n")
+        else:
+            output_file.write("\tsizeof(IROp_%s),\n" % op_key)
+
+    output_file.write("};\n\n")
+
+    output_file.write("// Make sure our array maps directly to the IROps enum\n")
+    output_file.write("static_assert(IRSizes[IROps::OP_LAST] == -1ULL);\n\n")
+
+    output_file.write("[[maybe_unused]] static size_t GetSize(IROps Op) { return IRSizes[Op]; }\n\n")
+
+    output_file.write("std::string_view const& GetName(IROps Op);\n")
+    output_file.write("uint8_t GetArgs(IROps Op);\n")
+    output_file.write("FEXCore::IR::RegisterClassType GetRegClass(IROps Op);\n\n")
+    output_file.write("bool HasSideEffects(IROps Op);\n")
+
+    output_file.write("#undef IROP_SIZES\n")
+    output_file.write("#endif\n\n")
+
+def print_ir_reg_classes(ops, defines):
+    output_file.write("#ifdef IROP_REG_CLASSES_IMPL\n")
+
+    output_file.write("constexpr std::array<FEXCore::IR::RegisterClassType, IROps::OP_LAST + 1> IRRegClasses = {\n")
+    for op_key, op_vals in ops.items():
+        if ("Last" in op_vals):
+            output_file.write("\tFEXCore::IR::InvalidClass,\n")
+        else:
+            Class = "Invalid"
+            if ("HasDest" in op_vals and not ("DestClass" in op_vals)):
+                sys.exit("IR op %s has destination with no destination class" % (op_key))
+
+            if ("DestClass" in op_vals):
+                Class = op_vals["DestClass"]
+            output_file.write("\tFEXCore::IR::%sClass,\n" % Class)
+
+    output_file.write("};\n\n")
+
+    output_file.write("// Make sure our array maps directly to the IROps enum\n")
+    output_file.write("static_assert(IRRegClasses[IROps::OP_LAST] == FEXCore::IR::InvalidClass);\n\n")
+
+    output_file.write("FEXCore::IR::RegisterClassType GetRegClass(IROps Op) { return IRRegClasses[Op]; }\n\n")
+
+    output_file.write("#undef IROP_REG_CLASSES_IMPL\n")
+    output_file.write("#endif\n\n")
+
+# Print out the name printer implementation
+def print_ir_getname(ops, defines):
+    output_file.write("#ifdef IROP_GETNAME_IMPL\n")
+    output_file.write("constexpr std::array<std::string_view const, OP_LAST + 1> IRNames = {\n")
+    for op_key, op_vals in ops.items():
+        output_file.write("\t\"%s\",\n" % op_key)
+
+    output_file.write("};\n\n")
+
+    output_file.write("static_assert(IRNames[OP_LAST] == \"Last\");\n\n")
+
+    output_file.write("std::string_view const& GetName(IROps Op) {\n")
+    output_file.write("  return IRNames[Op];\n")
+    output_file.write("}\n")
+
+    output_file.write("#undef IROP_GETNAME_IMPL\n")
+    output_file.write("#endif\n\n")
+
+# Print out the number of SSA args that need to be RA'd
+def print_ir_getraargs(ops, defines):
+    output_file.write("#ifdef IROP_GETRAARGS_IMPL\n")
+
+    output_file.write("constexpr std::array<uint8_t, OP_LAST + 1> IRArgs = {\n")
+    for op_key, op_vals in ops.items():
+        SSAArgs = 0
+        if ("SSAArgs" in op_vals):
+            SSAArgs = int(op_vals["SSAArgs"])
+
+        if ("RAOverride" in op_vals):
+            SSAArgs = int(op_vals["RAOverride"])
+
+        output_file.write("\t%d,\n" % SSAArgs)
+
+    output_file.write("};\n\n")
+
+    output_file.write("uint8_t GetArgs(IROps Op) {\n")
+    output_file.write("  return IRArgs[Op];\n")
+    output_file.write("}\n")
+
+    output_file.write("#undef IROP_GETRAARGS_IMPL\n")
+    output_file.write("#endif\n\n")
+
+def print_ir_hassideeffects(ops, defines):
+    output_file.write("#ifdef IROP_HASSIDEEFFECTS_IMPL\n")
+
+    output_file.write("constexpr std::array<uint8_t, OP_LAST + 1> SideEffects = {\n")
+    for op_key, op_vals in ops.items():
+        HasSideEffects = False
+        if ("HasSideEffects" in op_vals):
+            HasSideEffects = op_vals["HasSideEffects"]
+
+        output_file.write("\t%s,\n" % ("true" if HasSideEffects else "false"))
+
+    output_file.write("};\n\n")
+
+    output_file.write("bool HasSideEffects(IROps Op) {\n")
+    output_file.write("  return SideEffects[Op];\n")
+    output_file.write("}\n")
+
+    output_file.write("#undef IROP_HASSIDEEFFECTS_IMPL\n")
+    output_file.write("#endif\n\n")
+
+# Print out IR argument printing
+def print_ir_arg_printer(ops, defines):
+    output_file.write("#ifdef IROP_ARGPRINTER_HELPER\n")
+    output_file.write("switch (IROp->Op) {\n")
+    for op_key, op_vals in ops.items():
+        if not ("Last" in op_vals):
+            SSAArgs = 0
+            HasArgs = False
+            HasHelperArgs = False
+
+            # Does this not want a printer?
+            if ("ArgPrinter" in op_vals and op_vals["ArgPrinter"] == False):
+                continue
+
+            if ("SSAArgs" in op_vals):
+                SSAArgs = int(op_vals["SSAArgs"])
+
+            if ("Args" in op_vals and len(op_vals["Args"]) != 0):
+                HasArgs = True
+
+            if ("HelperArgs" in op_vals and len(op_vals["HelperArgs"]) != 0):
+                HasHelperArgs = True
+
+            output_file.write("case IROps::OP_%s: {\n" % op_key.upper())
+            if (HasArgs or SSAArgs != 0):
+                output_file.write("\tauto Op = IROp->C<IR::IROp_%s>();\n" % op_key)
+                output_file.write("\t*out << \" \";\n")
+
+                # Print SSA args first
+                if (SSAArgs != 0):
+                    for i in range(0, SSAArgs):
+                        LastArg = (SSAArgs - i - 1) == 0 and not HasArgs
+                        output_file.write("\tPrintArg(out, IR, Op->Header.Args[%d], RAData);\n" % i)
+                        if not (LastArg):
+                            output_file.write("\t*out << \", \";\n")
+
+                # Now print user defined arguments
+                if (HasArgs):
+                    ArgCount = len(op_vals["Args"])
+
+                    for i in range(0, len(op_vals["Args"]), 2):
+                        data_name = op_vals["Args"][i+1]
+                        LastArg = (ArgCount - i - 2) == 0
+                        CondArg2 = (", ", "")
+                        output_file.write("\tPrintArg(out, IR, Op->%s);\n" % data_name)
+                        if not (LastArg):
+                            output_file.write("\t*out << \", \";\n")
+
+            output_file.write("break;\n")
+            output_file.write("}\n")
+
+
+    output_file.write("#undef IROP_ARGPRINTER_HELPER\n")
+    output_file.write("#endif\n")
+
+# Print out IR allocator helpers
+def print_ir_allocator_helpers(ops, defines):
+    output_file.write("#ifdef IROP_ALLOCATE_HELPERS\n")
+
+    output_file.write("\ttemplate <class T>\n")
+    output_file.write("\tstruct Wrapper final {\n")
+    output_file.write("\t\tT *first;\n")
+    output_file.write("\t\tOrderedNode *Node; ///< Actual offset of this IR in ths list\n")
+    output_file.write("\t\t\n")
+    output_file.write("\t\toperator Wrapper<IROp_Header>() const { return Wrapper<IROp_Header> {reinterpret_cast<IROp_Header*>(first), Node}; }\n")
+    output_file.write("\t\toperator OrderedNode *() { return Node; }\n")
+    output_file.write("\t\toperator OpNodeWrapper () { return Node->Header.Value; }\n")
+    output_file.write("\t};\n")
+
+    output_file.write("\ttemplate <class T>\n")
+    output_file.write("\tusing IRPair = Wrapper<T>;\n\n")
+
+    output_file.write("\tIRPair<IROp_Header> AllocateRawOp(size_t HeaderSize) {\n")
+    output_file.write("\t\tauto Op = reinterpret_cast<IROp_Header*>(Data.Allocate(HeaderSize));\n")
+    output_file.write("\t\tmemset(Op, 0, HeaderSize);\n")
+    output_file.write("\t\tOp->Op = IROps::OP_DUMMY;\n")
+    output_file.write("\t\treturn IRPair<IROp_Header>{Op, CreateNode(Op)};\n")
+    output_file.write("\t}\n\n")
+
+    output_file.write("\ttemplate<class T, IROps T2>\n")
+    output_file.write("\tT *AllocateOrphanOp() {\n")
+    output_file.write("\t\tsize_t Size = FEXCore::IR::GetSize(T2);\n")
+    output_file.write("\t\tauto Op = reinterpret_cast<T*>(Data.Allocate(Size));\n")
+    output_file.write("\t\tmemset(Op, 0, Size);\n")
+    output_file.write("\t\tOp->Header.Op = T2;\n")
+    output_file.write("\t\treturn Op;\n")
+    output_file.write("\t}\n\n")
+
+    output_file.write("\ttemplate<class T, IROps T2>\n")
+    output_file.write("\tIRPair<T> AllocateOp() {\n")
+    output_file.write("\t\tsize_t Size = FEXCore::IR::GetSize(T2);\n")
+    output_file.write("\t\tauto Op = reinterpret_cast<T*>(Data.Allocate(Size));\n")
+    output_file.write("\t\tmemset(Op, 0, Size);\n")
+    output_file.write("\t\tOp->Header.Op = T2;\n")
+    output_file.write("\t\treturn IRPair<T>{Op, CreateNode(&Op->Header)};\n")
+    output_file.write("\t}\n\n")
+
+    output_file.write("\tuint8_t GetOpSize(OrderedNode *Op) const {\n")
+    output_file.write("\t\tauto HeaderOp = Op->Header.Value.GetNode(Data.Begin());\n")
+    output_file.write("\t\treturn HeaderOp->Size;\n")
+    output_file.write("\t}\n\n")
+
+    output_file.write("\tuint8_t GetOpElements(OrderedNode *Op) const {\n")
+    output_file.write("\t\tauto HeaderOp = Op->Header.Value.GetNode(Data.Begin());\n")
+    output_file.write("\t\tLogMan::Throw::A(HeaderOp->HasDest, \"Op %s has no dest\\n\", GetName(HeaderOp->Op));\n")
+    output_file.write("\t\treturn HeaderOp->Size / HeaderOp->ElementSize;\n")
+    output_file.write("\t}\n\n")
+
+    output_file.write("\tbool OpHasDest(OrderedNode *Op) const {\n")
+    output_file.write("\t\tauto HeaderOp = Op->Header.Value.GetNode(Data.Begin());\n")
+    output_file.write("\t\treturn HeaderOp->HasDest;\n")
+    output_file.write("\t}\n\n")
+
+    # Generate helpers with operands
+    for op_key, op_vals in ops.items():
+        if not ("Last" in op_vals):
+            SSAArgs = 0
+            HasArgs = False
+            HasHelperArgs = False
+            HasDest = False
+            HasFixedDestSize = False
+            FixedDestSize = 0
+            HasDestSize = False;
+            NumElements = "1"
+            DestSize = ""
+
+            if ("SSAArgs" in op_vals):
+                SSAArgs = int(op_vals["SSAArgs"])
+
+            if ("Args" in op_vals and len(op_vals["Args"]) != 0):
+                HasArgs = True
+
+            if ("HelperArgs" in op_vals and len(op_vals["HelperArgs"]) != 0):
+                HasHelperArgs = True
+
+            if ("HelperGen" in op_vals and op_vals["HelperGen"] == False):
+                continue;
+
+            if ("HasDest" in op_vals and op_vals["HasDest"] == True):
+                HasDest = True
+
+            if ("FixedDestSize" in op_vals):
+                HasFixedDestSize = True
+                FixedDestSize = int(op_vals["FixedDestSize"])
+
+            if ("DestSize" in op_vals):
+                HasDestSize = True
+                DestSize = op_vals["DestSize"]
+
+            if ("NumElements" in op_vals):
+                NumElements = op_vals["NumElements"]
+
+            output_file.write("\tIRPair<IROp_%s> _%s(" % (op_key, op_key))
+
+            # Output SSA args first
+            if (SSAArgs != 0):
+                for i in range(0, SSAArgs):
+                    LastArg = (SSAArgs - i - 1) == 0 and not (HasArgs or HasHelperArgs)
+                    CondArg2 = (", ", "")
+                    output_file.write("OrderedNode *ssa%d%s" % (i, CondArg2[LastArg]))
+
+            if (HasArgs or HasHelperArgs):
+                ArgCount = 0
+                Args = []
+                if (HasArgs):
+                    ArgCount += len(op_vals["Args"])
+                    Args += op_vals["Args"]
+
+                if (HasHelperArgs):
+                    ArgCount += len(op_vals["HelperArgs"])
+                    Args += op_vals["HelperArgs"]
+
+                for i in range(0, ArgCount, 2):
+                    data_type = Args[i]
+                    data_name = Args[i+1]
+                    LastArg = (ArgCount - i - 2) == 0
+                    CondArg2 = (", ", "")
+
+                    output_file.write("%s %s%s" % (data_type, data_name, CondArg2[LastArg]))
+
+            output_file.write(") {\n")
+
+            output_file.write("\t\tauto Op = AllocateOp<IROp_%s, IROps::OP_%s>();\n" % (op_key, op_key.upper()))
+            output_file.write("\t\tOp.first->Header.NumArgs = %d;\n" % (SSAArgs))
+
+            if (SSAArgs != 0):
+                for i in range(0, SSAArgs):
+                    output_file.write("\t\tOp.first->Header.Args[%d] = ssa%d->Wrapped(ListData.Begin());\n" % (i, i))
+                    output_file.write("\t\tssa%d->AddUse();\n" % (i))
+
+            if (HasArgs):
+                for i in range(1, len(op_vals["Args"]), 2):
+                    data_name = op_vals["Args"][i]
+                    output_file.write("\t\tOp.first->%s = %s;\n" % (data_name, data_name))
+
+            if (HasFixedDestSize):
+                output_file.write("\t\tOp.first->Header.Size = %d;\n" % FixedDestSize)
+            if (HasDestSize):
+                output_file.write("\t\tOp.first->Header.Size = %s;\n" % DestSize)
+
+            if (HasDest):
+                # We can only infer a size if we have arguments
+                if not (HasFixedDestSize or HasDestSize):
+                    # We need to infer destination size
+                    output_file.write("\t\tuint8_t InferSize = 0;\n")
+                    if (SSAArgs != 0):
+                        for i in range(0, SSAArgs):
+                            output_file.write("\t\tuint8_t Size%d = GetOpSize(ssa%s);\n" % (i, i))
+                            output_file.write("\t\tInferSize = std::max(InferSize, Size%d);\n" % (i))
+
+                    output_file.write("\t\tOp.first->Header.Size = InferSize;\n")
+
+            output_file.write("\t\tOp.first->Header.ElementSize = Op.first->Header.Size / (%s);\n" % NumElements)
+
+            if (HasDest):
+                output_file.write("\t\tOp.first->Header.HasDest = true;\n")
+
+            output_file.write("\t\treturn Op;\n")
+            output_file.write("\t}\n\n")
+
+    output_file.write("#undef IROP_ALLOCATE_HELPERS\n")
+    output_file.write("#endif\n")
+
+
+# IR parser allocators
+def print_ir_parser_allocator_helpers(ops, defines):
+    output_file.write("#ifdef IROP_PARSER_ALLOCATE_HELPERS\n")
+
+    # Generate helpers with operands
+    for op_key, op_vals in ops.items():
+        if not ("Last" in op_vals):
+            SSAArgs = 0
+            HasArgs = False
+            HasDest = False
+            HasFixedDestSize = False
+            FixedDestSize = 0
+            HasDestSize = False;
+            NumElements = "1"
+            DestSize = ""
+
+            if ("SSAArgs" in op_vals):
+                SSAArgs = int(op_vals["SSAArgs"])
+
+            if ("Args" in op_vals and len(op_vals["Args"]) != 0):
+                HasArgs = True
+
+            if ("HelperGen" in op_vals and op_vals["HelperGen"] == False):
+                continue;
+
+            if ("HasDest" in op_vals and op_vals["HasDest"] == True):
+                HasDest = True
+
+            if ("FixedDestSize" in op_vals):
+                HasFixedDestSize = True
+                FixedDestSize = int(op_vals["FixedDestSize"])
+
+            if ("DestSize" in op_vals):
+                HasDestSize = True
+                DestSize = op_vals["DestSize"]
+
+            if ("NumElements" in op_vals):
+                NumElements = op_vals["NumElements"]
+
+            CondArg2 = (", ", "")
+
+            output_file.write("\tIRPair<IROp_%s> _Parser_%s(FEXCore::IR::TypeDefinition _ParsedSize%s" %
+                (op_key, op_key, CondArg2[(0 if (HasArgs or SSAArgs != 0) else 1)]))
+
+            # Output SSA args first
+            if (SSAArgs != 0):
+                for i in range(0, SSAArgs):
+                    LastArg = (SSAArgs - i - 1) == 0 and not (HasArgs)
+                    output_file.write("OrderedNode *ssa%d%s" % (i, CondArg2[LastArg]))
+
+            if (HasArgs):
+                ArgCount = 0
+                Args = []
+                if (HasArgs):
+                    ArgCount += len(op_vals["Args"])
+                    Args += op_vals["Args"]
+
+                for i in range(0, ArgCount, 2):
+                    data_type = Args[i]
+                    data_name = Args[i+1]
+                    LastArg = (ArgCount - i - 2) == 0
+
+                    output_file.write("%s %s%s" % (data_type, data_name, CondArg2[LastArg]))
+
+            output_file.write(") {\n")
+
+            output_file.write("\t\tauto Op = AllocateOp<IROp_%s, IROps::OP_%s>();\n" % (op_key, op_key.upper()))
+            output_file.write("\t\tOp.first->Header.NumArgs = %d;\n" % (SSAArgs))
+
+            if (SSAArgs != 0):
+                for i in range(0, SSAArgs):
+                    output_file.write("\t\tOp.first->Header.Args[%d] = ssa%d->Wrapped(ListData.Begin());\n" % (i, i))
+                    output_file.write("\t\tssa%d->AddUse();\n" % (i))
+
+            if (HasArgs):
+                for i in range(1, len(op_vals["Args"]), 2):
+                    data_name = op_vals["Args"][i]
+                    output_file.write("\t\tOp.first->%s = %s;\n" % (data_name, data_name))
+
+            output_file.write("\t\tOp.first->Header.Size = _ParsedSize.Bytes() * _ParsedSize.Elements();\n")
+            output_file.write("\t\tOp.first->Header.ElementSize = _ParsedSize.Bytes();\n")
+
+            if (HasDest):
+                output_file.write("\t\tOp.first->Header.HasDest = true;\n")
+
+            output_file.write("\t\treturn Op;\n")
+            output_file.write("\t}\n\n")
+
+    output_file.write("#undef IROP_PARSER_ALLOCATE_HELPERS\n")
+    output_file.write("#endif\n")
+
+# IR parser switch statement generation
+def print_ir_parser_switch_helper(ops, defines):
+    output_file.write("#ifdef IROP_PARSER_SWITCH_HELPERS\n")
+
+    # Generate helpers with operands
+    for op_key, op_vals in ops.items():
+        if not ("Last" in op_vals):
+            SSAArgs = 0
+            HasArgs = False
+            HasDest = False
+            HasFixedDestSize = False
+            FixedDestSize = 0
+            HasDestSize = False;
+            NumElements = "1"
+            DestSize = ""
+
+            if ("SSAArgs" in op_vals):
+                SSAArgs = int(op_vals["SSAArgs"])
+
+            if ("Args" in op_vals and len(op_vals["Args"]) != 0):
+                HasArgs = True
+
+            if ("SwitchGen" in op_vals and op_vals["SwitchGen"] == False):
+                continue;
+
+            if ("HasDest" in op_vals and op_vals["HasDest"] == True):
+                HasDest = True
+
+            if ("FixedDestSize" in op_vals):
+                HasFixedDestSize = True
+                FixedDestSize = int(op_vals["FixedDestSize"])
+
+            if ("DestSize" in op_vals):
+                HasDestSize = True
+                DestSize = op_vals["DestSize"]
+
+            if ("NumElements" in op_vals):
+                NumElements = op_vals["NumElements"]
+
+            CondArg2 = (", ", "")
+
+            output_file.write("\tcase FEXCore::IR::IROps::OP_%s: {\n" % (op_key.upper()))
+
+            # Output SSA args first
+            if (SSAArgs != 0):
+                for i in range(0, SSAArgs):
+                    output_file.write("\t\tauto ssa_arg%d = DecodeValue<OrderedNode*>(Def.Args[%d]);\n" % (i, i))
+                    output_file.write("\t\tif (!CheckPrintError(Def, ssa_arg%d.first)) return false;\n" % (i))
+
+            if (HasArgs):
+                ArgCount = 0
+                Args = []
+                if (HasArgs):
+                    ArgCount += len(op_vals["Args"])
+                    Args += op_vals["Args"]
+
+                for i in range(0, ArgCount, 2):
+                    data_type = Args[i]
+                    data_name = Args[i+1]
+                    LastArg = (ArgCount - i - 2) == 0
+
+                    output_file.write("\t\tauto arg%d = DecodeValue<%s>(Def.Args[%d]);\n" % (SSAArgs + (i / 2), data_type, SSAArgs + (i / 2)))
+                    output_file.write("\t\tif (!CheckPrintError(Def, arg%d.first)) return false;\n" % (SSAArgs + (i / 2)))
+
+            output_file.write("\t\tDef.Node = _Parser_%s(Def.Size\n" % (op_key))
+
+            if (SSAArgs != 0):
+                for i in range(0, SSAArgs):
+                    output_file.write("\t\t, ssa_arg%d.second\n" % (i))
+
+            if (HasArgs):
+                ArgCount = 0
+                Args = []
+                if (HasArgs):
+                    ArgCount += len(op_vals["Args"])
+                    Args += op_vals["Args"]
+
+                for i in range(0, ArgCount, 2):
+                    data_type = Args[i]
+                    data_name = Args[i+1]
+                    LastArg = (ArgCount - i - 2) == 0
+
+                    output_file.write("\t\t, arg%d.second\n" % (SSAArgs + (i / 2)))
+
+            output_file.write("\t\t);\n")
+
+            output_file.write("\t\tSSANameMapper[Def.Definition] = Def.Node;\n")
+
+            output_file.write("\t\tbreak;\n")
+            output_file.write("\t}\n")
+
+    output_file.write("#undef IROP_PARSER_SWITCH_HELPERS\n")
+    output_file.write("#endif\n")
+if (len(sys.argv) < 3):
+    sys.exit()
+
+output_filename = sys.argv[2]
+json_file = open(sys.argv[1], "r")
+json_text = json_file.read()
+json_file.close()
+
+json_object = json.loads(json_text)
+json_object = {k.upper(): v for k, v in json_object.items()}
+
+ops = json_object["OPS"]
+defines = json_object["DEFINES"]
+
+output_file = open(output_filename, "w")
+
+print_enums(ops, defines)
+print_ir_structs(ops, defines)
+print_ir_sizes(ops, defines)
+print_ir_reg_classes(ops, defines)
+print_ir_getname(ops, defines)
+print_ir_getraargs(ops, defines)
+print_ir_hassideeffects(ops, defines)
+print_ir_arg_printer(ops, defines)
+print_ir_allocator_helpers(ops, defines)
+print_ir_parser_allocator_helpers(ops, defines)
+print_ir_parser_switch_helper(ops, defines)
+
+output_file.close()
@@ -1,21 +1,9 @@
-set (MAN_DIR share/man CACHE PATH "MAN_DIR")
-
-set (FEXCORE_BASE_SRCS
-  Interface/Config/Config.cpp
-  Utils/Allocator.cpp
-  Utils/CPUInfo.cpp
-  Utils/FileLoading.cpp
-  Utils/ForcedAssert.cpp
-  Utils/LogManager.cpp
-  )
-
-if (NOT MINGW_BUILD)
-  list(APPEND FEXCORE_BASE_SRCS
-    Utils/Allocator/64BitAllocator.cpp)
-endif()
+set (MAN_DIR ${CMAKE_INSTALL_PREFIX}/share/man CACHE PATH "MAN_DIR")

 set (SRCS
+  Common/Paths.cpp
  Common/JitSymbols.cpp
+  Common/NetStream.cpp
  Common/SoftFloat-3e/extF80_add.c
  Common/SoftFloat-3e/extF80_div.c
  Common/SoftFloat-3e/extF80_sub.c
@@ -83,33 +71,27 @@ set (SRCS
  Common/SoftFloat-3e/f32_to_extF80.c
  Common/SoftFloat-3e/s_normSubnormalF32Sig.c
  Common/SoftFloat-3e/s_f32UIToCommonNaN.c
+  Interface/Config/Config.cpp
  Interface/Context/Context.cpp
  Interface/Core/LookupCache.cpp
  Interface/Core/BlockSamplingData.cpp
+  Interface/Core/CompileService.cpp
  Interface/Core/Core.cpp
-  Interface/Core/CPUBackend.cpp
  Interface/Core/CPUID.cpp
  Interface/Core/Frontend.cpp
  Interface/Core/GdbServer.cpp
  Interface/Core/HostFeatures.cpp
-  Interface/Core/ObjectCache/JobHandling.cpp
-  Interface/Core/ObjectCache/NamedRegionObjectHandler.cpp
-  Interface/Core/ObjectCache/ObjectCacheService.cpp
-  Interface/Core/OpcodeDispatcher/Crypto.cpp
-  Interface/Core/OpcodeDispatcher/Flags.cpp
-  Interface/Core/OpcodeDispatcher/Vector.cpp
-  Interface/Core/OpcodeDispatcher/X87.cpp
-  Interface/Core/OpcodeDispatcher/X87F64.cpp
  Interface/Core/OpcodeDispatcher.cpp
-  Interface/Core/SignalDelegator.cpp
  Interface/Core/X86Tables.cpp
  Interface/Core/X86DebugInfo.cpp
  Interface/Core/X86HelperGen.cpp
+  Interface/Core/ArchHelpers/Arm64_stubs.cpp
  Interface/Core/ArchHelpers/Arm64Emitter.cpp
  Interface/Core/Dispatcher/Dispatcher.cpp
  Interface/Core/Dispatcher/X86Dispatcher.cpp
  Interface/Core/Dispatcher/Arm64Dispatcher.cpp
-  Interface/Core/Interpreter/Fallbacks/InterpreterFallbacks.cpp
+  Interface/Core/Interpreter/InterpreterCore.cpp
+  Interface/Core/Interpreter/InterpreterOps.cpp
  Interface/Core/X86Tables/BaseTables.cpp
  Interface/Core/X86Tables/DDDTables.cpp
  Interface/Core/X86Tables/EVEXTables.cpp
@@ -123,8 +105,6 @@ set (SRCS
  Interface/Core/X86Tables/X87Tables.cpp
  Interface/Core/X86Tables/XOPTables.cpp
  Interface/HLE/Thunks/Thunks.cpp
-  Interface/GDBJIT/GDBJIT.cpp
-  Interface/IR/AOTIR.cpp
  Interface/IR/IRDumper.cpp
  Interface/IR/IRParser.cpp
  Interface/IR/IREmitter.cpp
@@ -133,50 +113,26 @@ set (SRCS
  Interface/IR/Passes/DeadCodeElimination.cpp
  Interface/IR/Passes/DeadContextStoreElimination.cpp
  Interface/IR/Passes/IRCompaction.cpp
-  Interface/IR/Passes/IRDumperPass.cpp
  Interface/IR/Passes/IRValidation.cpp
-  Interface/IR/Passes/RAValidation.cpp
-  Interface/IR/Passes/LongDivideRemovalPass.cpp
  Interface/IR/Passes/ValueDominanceValidation.cpp
+  Interface/IR/Passes/PhiValidation.cpp
  Interface/IR/Passes/RedundantFlagCalculationElimination.cpp
  Interface/IR/Passes/DeadStoreElimination.cpp
+  Interface/IR/Passes/StaticRegisterAllocationPass.cpp
  Interface/IR/Passes/RegisterAllocationPass.cpp
  Interface/IR/Passes/SyscallOptimization.cpp
-  Utils/NetStream.cpp
-  Utils/Telemetry.cpp
+  Utils/ELFLoader.cpp
+  Utils/ELFSymbolDatabase.cpp
+  Utils/LogManager.cpp
  Utils/Threads.cpp
-  Utils/Profiler.cpp
  )

-if (_M_ARM_64)
-  list(APPEND SRCS Utils/ArchHelpers/Arm64.cpp)
-else()
-  list(APPEND SRCS Utils/ArchHelpers/Arm64_stubs.cpp)
-endif()
-
-if (ENABLE_GLIBC_ALLOCATOR_HOOK_FAULT)
-  list(APPEND FEXCORE_BASE_SRCS
-    Utils/AllocatorOverride.cpp)
-endif()
-
-if (ENABLE_INTERPRETER)
+if(_M_ARM_64)
  list(APPEND SRCS
-    Interface/Core/Interpreter/InterpreterCore.cpp
-    Interface/Core/Interpreter/InterpreterOps.cpp
-    Interface/Core/Interpreter/ALUOps.cpp
-    Interface/Core/Interpreter/AtomicOps.cpp
-    Interface/Core/Interpreter/BranchOps.cpp
-    Interface/Core/Interpreter/ConversionOps.cpp
-    Interface/Core/Interpreter/EncryptionOps.cpp
-    Interface/Core/Interpreter/F80Ops.cpp
-    Interface/Core/Interpreter/FlagOps.cpp
-    Interface/Core/Interpreter/MemoryOps.cpp
-    Interface/Core/Interpreter/MiscOps.cpp
-    Interface/Core/Interpreter/MoveOps.cpp
-    Interface/Core/Interpreter/VectorOps.cpp)
+    Interface/Core/ArchHelpers/Arm64.cpp)
 endif()

-set(DEFINES -DTHREAD_LOCAL=_Thread_local)
+set(DEFINES )

 if (_M_X86_64)
  list(APPEND DEFINES -D_M_X86_64=1)
@@ -186,15 +142,6 @@ if (_M_ARM_64)
  list(APPEND DEFINES -D_M_ARM_64=1)
 endif()

-if (ENABLE_VIXL_SIMULATOR)
-  # We can run the simulator on both x86-64 or AArch64 hosts
-  list(APPEND DEFINES -DVIXL_SIMULATOR=1 -DVIXL_INCLUDE_SIMULATOR_AARCH64=1)
-endif()
-
-if (ENABLE_VIXL_DISASSEMBLER)
-  list(APPEND DEFINES -DVIXL_DISASSEMBLER=1)
-endif()
-
 if (ENABLE_JIT_X86_64)
  list(APPEND SRCS
    Interface/Core/JIT/x86_64/JIT.cpp
@@ -207,9 +154,7 @@ if (ENABLE_JIT_X86_64)
    Interface/Core/JIT/x86_64/MemoryOps.cpp
    Interface/Core/JIT/x86_64/MiscOps.cpp
    Interface/Core/JIT/x86_64/MoveOps.cpp
-    Interface/Core/JIT/x86_64/VectorOps.cpp
-    Interface/Core/JIT/x86_64/x64Relocations.cpp
-    )
+    Interface/Core/JIT/x86_64/VectorOps.cpp)
  list(APPEND DEFINES -DJIT_X86_64)
 endif()

@@ -226,42 +171,25 @@ if (ENABLE_JIT_ARM64)
    Interface/Core/JIT/Arm64/MemoryOps.cpp
    Interface/Core/JIT/Arm64/MiscOps.cpp
    Interface/Core/JIT/Arm64/MoveOps.cpp
-    Interface/Core/JIT/Arm64/VectorOps.cpp
-    Interface/Core/JIT/Arm64/Arm64Relocations.cpp
-    )
+    Interface/Core/JIT/Arm64/VectorOps.cpp)
 endif()

-set (LIBS fmt::fmt vixl xxhash FEXHeaderUtils)
-
-if (NOT MINGW_BUILD)
-  list (APPEND LIBS dl)
-else()
-  list (APPEND LIBS synchronization)
+if (ENABLE_JITSYMBOLS)
+  list(APPEND DEFINES -DENABLE_JITSYMBOLS=1)
 endif()

-if (ENABLE_JEMALLOC)
-  list (APPEND LIBS FEX_jemalloc)
-endif()
-
-if (ENABLE_JEMALLOC_GLIBC_ALLOC)
-  list (APPEND LIBS FEX_jemalloc_glibc)
-endif()
-
-# Generate config
-configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/Interface/Config/Config.json.in
-  ${CMAKE_BINARY_DIR}/generated/Config/Config.json)
-
 # Generate IR include file
 set(OUTPUT_IR_FOLDER "${CMAKE_BINARY_DIR}/include/FEXCore/IR")
 set(OUTPUT_NAME "${OUTPUT_IR_FOLDER}/IRDefines.inc")
 set(INPUT_NAME "${CMAKE_CURRENT_SOURCE_DIR}/Interface/IR/IR.json")

-file(MAKE_DIRECTORY "${OUTPUT_IR_FOLDER}")
+add_custom_target(CREATE_IR_FOLDER ALL
+  COMMAND ${CMAKE_COMMAND} -E make_directory "${OUTPUT_IR_FOLDER}")

 add_custom_command(
  OUTPUT "${OUTPUT_NAME}"
  DEPENDS "${INPUT_NAME}"
+  DEPENDS CREATE_IR_FOLDER
  DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/../Scripts/json_ir_generator.py"
  COMMAND "python3" "${CMAKE_CURRENT_SOURCE_DIR}/../Scripts/json_ir_generator.py" "${INPUT_NAME}" "${OUTPUT_NAME}"
  )
@@ -275,6 +203,7 @@ set(OUTPUT_IR_DOC "${CMAKE_BINARY_DIR}/IR.md")
 add_custom_command(
  OUTPUT "${OUTPUT_IR_DOC}"
  DEPENDS "${INPUT_NAME}"
+  DEPENDS CREATE_IR_FOLDER
  DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/../Scripts/json_ir_doc_generator.py"
  COMMAND "python3" "${CMAKE_CURRENT_SOURCE_DIR}/../Scripts/json_ir_doc_generator.py" "${INPUT_NAME}" "${OUTPUT_IR_DOC}"
  )
@@ -291,28 +220,23 @@ add_custom_target(IR_INC
 set(OUTPUT_CONFIG_FOLDER "${CMAKE_BINARY_DIR}/include/FEXCore/Config")
 set(OUTPUT_CONFIG_NAME "${OUTPUT_CONFIG_FOLDER}/ConfigValues.inl")
 set(OUTPUT_CONFIG_OPTION_NAME "${OUTPUT_CONFIG_FOLDER}/ConfigOptions.inl")
-set(INPUT_CONFIG_NAME "${CMAKE_BINARY_DIR}/generated/Config/Config.json")
+set(INPUT_CONFIG_NAME "${CMAKE_CURRENT_SOURCE_DIR}/Interface/Config/Config.json")
 set(OUTPUT_MAN_NAME "${CMAKE_BINARY_DIR}/generated/FEX.1")
-set(OUTPUT_MAN_NAME_COMPRESS "${CMAKE_BINARY_DIR}/generated/FEX.1.gz")

-file(MAKE_DIRECTORY "${OUTPUT_CONFIG_FOLDER}")
+add_custom_target(CREATE_CONFIG_FOLDER ALL
+  COMMAND ${CMAKE_COMMAND} -E make_directory "${OUTPUT_CONFIG_FOLDER}")

 add_custom_command(
  OUTPUT "${OUTPUT_CONFIG_NAME}"
  OUTPUT "${OUTPUT_CONFIG_OPTION_NAME}"
  OUTPUT "${OUTPUT_MAN_NAME}"
  DEPENDS "${INPUT_CONFIG_NAME}"
+  DEPENDS CREATE_CONFIG_FOLDER
  DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/../Scripts/config_generator.py"
  COMMAND "python3" "${CMAKE_CURRENT_SOURCE_DIR}/../Scripts/config_generator.py" "${INPUT_CONFIG_NAME}" "${OUTPUT_CONFIG_NAME}" "${OUTPUT_MAN_NAME}"
  "${OUTPUT_CONFIG_OPTION_NAME}"
  )

-add_custom_command(
-  OUTPUT "${OUTPUT_MAN_NAME_COMPRESS}"
-  DEPENDS "${OUTPUT_MAN_NAME}"
-  COMMAND "gzip" "-kf9n" "${OUTPUT_MAN_NAME}"
-  )
-
 set_source_files_properties(${OUTPUT_CONFIG_NAME} PROPERTIES
  GENERATED TRUE)
 set_source_files_properties(${OUTPUT_CONFIG_OPTION_NAME} PROPERTIES
@@ -320,28 +244,29 @@ set_source_files_properties(${OUTPUT_CONFIG_OPTION_NAME} PROPERTIES

 set_source_files_properties(${OUTPUT_MAN_NAME} PROPERTIES
  GENERATED TRUE)
-set_source_files_properties(${OUTPUT_MAN_NAME_COMPRESS} PROPERTIES
-  GENERATED TRUE)

 # Create the target
 add_custom_target(CONFIG_INC
  DEPENDS "${OUTPUT_CONFIG_NAME}"
  DEPENDS "${OUTPUT_CONFIG_OPTION_NAME}"
-  DEPENDS "${OUTPUT_MAN_NAME}"
-  DEPENDS "${OUTPUT_MAN_NAME_COMPRESS}")
+  DEPENDS "${OUTPUT_MAN_NAME}")

-# Install the compressed man page
-install(FILES ${OUTPUT_MAN_NAME_COMPRESS} DESTINATION ${MAN_DIR}/man1)
+# Install the man page
+install(FILES ${OUTPUT_MAN_NAME} DESTINATION ${MAN_DIR}/man1)

 # Add in diagnostic colours if the option is available.
 # Ninja code generator will kill colours if this isn't here
 check_cxx_compiler_flag(-fdiagnostics-color=always GCC_COLOR)
 check_cxx_compiler_flag(-fcolor-diagnostics CLANG_COLOR)

-function(AddDefaultOptionsToTarget Name)
-  set_target_properties(${Name} PROPERTIES C_VISIBILITY_PRESET hidden)
-  set_target_properties(${Name} PROPERTIES CXX_VISIBILITY_PRESET hidden)
-  set_target_properties(${Name} PROPERTIES VISIBILITY_INLINES_HIDDEN TRUE)
+function(AddObject Name Type)
+  add_library(${Name} ${Type} ${SRCS})
+  add_dependencies(${Name} IR_INC)
+  add_dependencies(${Name} CONFIG_INC)
+
+  target_link_libraries(${Name} pthread rt vixl ${LINUX_LIBS} dl)
+  set_target_properties(${Name} PROPERTIES OUTPUT_NAME FEXCore)
+
  target_include_directories(${Name} PUBLIC "${CMAKE_CURRENT_BINARY_DIR}")

  target_include_directories(${Name} PRIVATE IncludePrivate/)
@@ -351,18 +276,13 @@ function(AddDefaultOptionsToTarget Name)
  target_include_directories(${Name} PUBLIC "${CMAKE_BINARY_DIR}/include/")

  target_compile_definitions(${Name} PRIVATE ${DEFINES})
-  add_dependencies(${Name} CONFIG_INC IR_INC)

  target_compile_options(${Name}
    PRIVATE
    -Wall
-    -Werror=cast-qual
-    -Werror=ignored-qualifiers
    -Werror=implicit-fallthrough

    -Wno-trigraphs
-    -ffunction-sections
-    -fwrapv
  )

  if (GCC_COLOR)
@@ -375,59 +295,26 @@ function(AddDefaultOptionsToTarget Name)
      PRIVATE
      "-fcolor-diagnostics")
  endif()
-
-  if (CMAKE_BUILD_TYPE MATCHES "RELEASE")
-    target_link_options(${Name}
-      PRIVATE
-      "LINKER:--gc-sections"
-      "LINKER:--strip-all"
-      "LINKER:--as-needed"
-    )
-  endif()
-endfunction()
-
-# Build FEXCore_Config static library
-add_library(FEXCore_Base STATIC ${FEXCORE_BASE_SRCS})
-target_link_libraries(FEXCore_Base ${LIBS})
-AddDefaultOptionsToTarget(FEXCore_Base)
-
-function(AddObject Name Type)
-  add_library(${Name} ${Type} ${SRCS})
-
-  target_link_libraries(${Name} FEXCore_Base)
-  AddDefaultOptionsToTarget(${Name})
-
-  set_target_properties(${Name} PROPERTIES OUTPUT_NAME FEXCore)
 endfunction()

 function(AddLibrary Name Type)
  add_library(${Name} ${Type} $<TARGET_OBJECTS:${PROJECT_NAME}_object>)
-  target_link_libraries(${Name} FEXCore_Base)
+  target_link_libraries(${Name} pthread rt vixl ${LINUX_LIBS} dl)
  set_target_properties(${Name} PROPERTIES OUTPUT_NAME FEXCore)
-  if (MINGW_BUILD)
-    # Mingw build isn't building a linux shared library, so it can't have a SONAME.
-    set_target_properties(${Name} PROPERTIES NO_SONAME ON)
-    # Change the suffixes otherwise cmake continues using .a and .so
-    if (${Type} STREQUAL SHARED)
-      set_target_properties(${Name} PROPERTIES SUFFIX ".dll")
-    elseif(${Type} STREQUAL STATIC)
-      set_target_properties(${Name} PROPERTIES SUFFIX ".lib")
-    endif()
-  endif()

-  AddDefaultOptionsToTarget(${Name})
+  target_include_directories(${Name} PUBLIC "${CMAKE_CURRENT_BINARY_DIR}")
+  target_include_directories(${Name} PUBLIC "${PROJECT_SOURCE_DIR}/include/")
+  target_include_directories(${Name} PUBLIC "${CMAKE_BINARY_DIR}/include/")
 endfunction()

 AddObject(${PROJECT_NAME}_object OBJECT)
 AddLibrary(${PROJECT_NAME} STATIC)
 AddLibrary(${PROJECT_NAME}_shared SHARED)

-if (NOT MINGW_BUILD)
-  install(TARGETS ${PROJECT_NAME} ${PROJECT_NAME}_shared
-    LIBRARY
-      DESTINATION lib
-      COMPONENT Libraries
-    ARCHIVE
-      DESTINATION lib
-      COMPONENT Libraries)
-endif()
+install(TARGETS ${PROJECT_NAME} ${PROJECT_NAME}_shared
+  LIBRARY
+    DESTINATION lib
+    COMPONENT Libraries
+  ARCHIVE
+    DESTINATION lib
+    COMPONENT Libraries)
@@ -1,16 +1,12 @@
 #pragma once
-
-#include <FEXCore/Utils/Allocator.h>
-#include <FEXCore/Utils/MathUtils.h>
+#include "Common/MathUtils.h"
 #include <FEXCore/Utils/LogManager.h>

-#include <cstdint>
-#include <cstdlib>
 #include <cstring>
+#include <stdint.h>
+#include <stdlib.h>
 #include <type_traits>

-namespace FEXCore {
-
 template<typename T>
 struct BitSet final {
  using ElementType = T;
@@ -20,16 +16,16 @@ struct BitSet final {
  ElementType *Memory;
  void Allocate(size_t Elements) {
    size_t AllocateSize = AlignUp(Elements, MinimumSizeBits) / MinimumSize;
-    LOGMAN_THROW_AA_FMT((AllocateSize * MinimumSize) >= Elements, "Fail");
-    Memory = static_cast<ElementType*>(FEXCore::Allocator::malloc(AllocateSize));
+    LogMan::Throw::A((AllocateSize * MinimumSize) >= Elements, "Fail");
+    Memory = static_cast<ElementType*>(malloc(AllocateSize));
  }
  void Realloc(size_t Elements) {
    size_t AllocateSize = AlignUp(Elements, MinimumSizeBits) / MinimumSize;
-    LOGMAN_THROW_AA_FMT((AllocateSize * MinimumSize) >= Elements, "Fail");
-    Memory = static_cast<ElementType*>(FEXCore::Allocator::realloc(Memory, AllocateSize));
+    LogMan::Throw::A((AllocateSize * MinimumSize) >= Elements, "Fail");
+    Memory = static_cast<ElementType*>(realloc(Memory, AllocateSize));
  }
  void Free() {
-    FEXCore::Allocator::free(Memory);
+    free(Memory);
    Memory = nullptr;
  }
  bool Get(T Element) {
@@ -64,8 +60,8 @@ struct BitSetView final {
  ElementType *Memory;

  void GetView(BitSet<T> &Set, uint64_t ElementOffset) {
-    LOGMAN_THROW_AA_FMT((ElementOffset % MinimumSize) == 0,
-                       "Bitset view offset needs to be aligned to size of backing element");
+    LogMan::Throw::A((ElementOffset % MinimumSize) == 0,
+        "Bitset view offset needs to be aligned to size of backing element");
    Memory = &Set.Memory[ElementOffset / MinimumSizeBits];
  }

@@ -90,12 +86,11 @@ struct BitSetView final {
  bool operator[](T Element) {
    return Get(Element);
  }
+
 };

 static_assert(sizeof(BitSet<uint32_t>) == sizeof(uintptr_t), "Needs to just be a pointer");
-static_assert(std::is_trivially_copyable_v<BitSet<uint32_t>>, "Needs to trivially copyable");
+static_assert(std::is_trivially_copyable<BitSet<uint32_t>>::value, "Needs to trivially copyable");

 static_assert(sizeof(BitSetView<uint32_t>) == sizeof(uintptr_t), "Needs to just be a pointer");
-static_assert(std::is_trivially_copyable_v<BitSetView<uint32_t>>, "Needs to trivially copyable");
-
-} // namespace FEXCore
+static_assert(std::is_trivially_copyable<BitSetView<uint32_t>>::value, "Needs to trivially copyable");
@@ -0,0 +1,45 @@
+#include "Common/JitSymbols.h"
+
+#include <string>
+#include <sstream>
+#include <unistd.h>
+
+namespace FEXCore {
+  JITSymbols::JITSymbols() {
+    std::stringstream PerfMap;
+    PerfMap << "/tmp/perf-" << getpid() << ".map";
+
+    fp = fopen(PerfMap.str().c_str(), "wb");
+    if (fp) {
+      // Disable buffering on this file
+      setvbuf(fp, nullptr, _IONBF, 0);
+    }
+  }
+
+  JITSymbols::~JITSymbols() {
+    if (fp) {
+      fclose(fp);
+    }
+  }
+
+  void JITSymbols::Register(void *HostAddr, uint64_t GuestAddr, uint32_t CodeSize) {
+    if (!fp) return;
+
+    // Linux perf format is very straightforward
+    // `<HostPtr> <Size> <Name>\n`
+    std::stringstream String;
+    String << std::hex << HostAddr << " " << CodeSize << " " << "JIT_0x" << GuestAddr << "_" << HostAddr << std::endl;
+    fwrite(String.str().c_str(), 1, String.str().size(), fp);
+  }
+
+  void JITSymbols::Register(void *HostAddr, uint32_t CodeSize, std::string const &Name) {
+    if (!fp) return;
+
+    // Linux perf format is very straightforward
+    // `<HostPtr> <Size> <Name>\n`
+    std::stringstream String;
+    String << std::hex << HostAddr << " " << CodeSize << " " << Name << "_" << HostAddr << std::endl;
+    fwrite(String.str().c_str(), 1, String.str().size(), fp);
+  }
+}
+
@@ -0,0 +1,17 @@
+#pragma once
+#include <cstdint>
+#include <cstdio>
+#include <string>
+
+namespace FEXCore {
+class JITSymbols final {
+public:
+  JITSymbols();
+  ~JITSymbols();
+  void Register(void *HostAddr, uint64_t GuestAddr, uint32_t CodeSize);
+  void Register(void *HostAddr, uint32_t CodeSize, std::string const &Name);
+
+private:
+  FILE* fp{};
+};
+}
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <stdint.h>
+
+static inline uint64_t AlignUp(uint64_t value, uint64_t size) {
+  return value + (size - value % size) % size;
+};
+
+static inline uint64_t AlignDown(uint64_t value, uint64_t size) {
+  return value - value % size;
+};
+
+
@@ -0,0 +1,86 @@
+#include "NetStream.h"
+
+#include <cstring>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <stdio.h>
+#include <unistd.h>
+
+int NetStream::NetBuf::flushBuffer(const char *buffer, size_t size) {
+    size_t total = 0;
+
+    // Send data
+    while (total < size) {
+        size_t sent = send(socket, (const void*)(buffer + total), size - total, 0);
+        if (sent == -1) {
+            // lets just assume all errors are end of file.
+            return -1;
+        }
+        total += sent;
+    }
+
+    return 0;
+}
+
+std::streamsize NetStream::NetBuf::xsputn(const char* buffer, std::streamsize size) {
+    size_t buf_remaining = epptr() - pptr();
+
+    // Check if the string fits neatly in our buffer
+    if (size <= buf_remaining) {
+        std::memcpy(pptr(), buffer, size);
+        pbump(size);
+        return size;
+    }
+
+    // Otherwise, flush the buffer first
+    if (sync() < 0) {
+        return traits_type::eof();
+    }
+
+    if (size > sizeof(output_buffer) / 2) {
+        // If we have a large string, bypass the buffer
+        flushBuffer(buffer, size);
+        return size;
+    } else {
+        return xsputn(buffer, size);
+    }
+}
+
+std::streambuf::int_type NetStream::NetBuf::overflow(std::streambuf::int_type ch) {
+    // we always leave room for one extra char
+    *pptr() = (char) ch;
+    pbump(1);
+    return sync();
+}
+
+int NetStream::NetBuf::sync() {
+    // Flush and reset output buffer to zero
+    if(flushBuffer(pbase(), pptr() - pbase()) < 0) {
+        return -1;
+    }
+    reset_output_buffer();
+    return 0;
+}
+
+std::streambuf::int_type NetStream::NetBuf::underflow() {
+    ssize_t size = recv(socket, (void *)std::begin(input_buffer), sizeof(input_buffer), 0);
+
+    if (size <= 0) {
+        setg(nullptr, nullptr, nullptr);
+        return traits_type::eof();
+    }
+
+    setg(&input_buffer[0], &input_buffer[0], &input_buffer[size]);
+
+    return traits_type::to_int_type(*gptr());
+}
+
+NetStream::~NetStream() {
+    delete rdbuf();
+}
+
+NetStream::NetBuf::~NetBuf() {
+  close(socket);
+}
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <array>
+#include <iostream>
+#include <string.h>
+
+class NetStream : public std::iostream {
+public:
+    NetStream(int socketfd) : std::iostream(new NetBuf(socketfd)) {}
+    virtual ~NetStream();
+
+private:
+    class NetBuf : public std::streambuf {
+
+    public:
+        NetBuf(int socketfd) {
+            socket = socketfd;
+            reset_output_buffer();
+        }
+        virtual ~NetBuf();
+
+    protected:
+        virtual std::streamsize xsputn(const char* buffer, std::streamsize size);
+
+        virtual std::streambuf::int_type underflow();
+        virtual std::streambuf::int_type overflow(std::streambuf::int_type ch);
+        virtual int sync();
+
+    private:
+        void reset_output_buffer() {
+            // we always leave room for one extra char
+            setp(std::begin(output_buffer), std::end(output_buffer) -1);
+        }
+
+        int flushBuffer(const char *buffer, size_t size);
+
+        int socket;
+        std::array<char, 1400> output_buffer;
+        std::array<char, 1500> input_buffer; // enough for a typical packet
+    };
+};
@@ -0,0 +1,50 @@
+#include "Common/Paths.h"
+#include <FEXCore/Utils/LogManager.h>
+
+#include <cstdlib>
+#include <filesystem>
+#include <sys/stat.h>
+
+namespace FEXCore::Paths {
+  std::string CachePath;
+  std::string EntryCache;
+
+  void InitializePaths() {
+    char const *HomeDir = getenv("HOME");
+
+    if (!HomeDir) {
+      HomeDir = getenv("PWD");
+    }
+
+    if (!HomeDir) {
+      HomeDir = ".";
+    }
+
+    char *XDGDataDir = getenv("XDG_DATA_DIR");
+    if (XDGDataDir) {
+      CachePath = XDGDataDir;
+    }
+    else {
+      if (HomeDir) {
+        CachePath = HomeDir;
+      }
+    }
+
+    CachePath += "/.fex-emu/";
+    EntryCache = CachePath + "/EntryCache/";
+
+    // Ensure the folder structure is created for our Data
+    if (!std::filesystem::exists(EntryCache) &&
+        !std::filesystem::create_directories(EntryCache)) {
+      LogMan::Msg::D("Couldn't create EntryCache directory: '%s'", EntryCache.c_str());
+    }
+  }
+
+  std::string GetCachePath() {
+    return CachePath;
+  }
+
+  std::string GetEntryCachePath() {
+    return EntryCache;
+  }
+}
@@ -0,0 +1,8 @@
+#pragma once
+#include <string>
+
+namespace FEXCore::Paths {
+  void InitializePaths();
+  std::string GetCachePath();
+  std::string GetEntryCachePath();
+}