Update switch pattern detection

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -32,6 +32,7 @@ bld/
 [Ll]og/
 [Ll]ogs/
 [Oo]ut/
+/[Bb]uild/
 
 # Visual Studio 2015/2017 cache/options directory
 .vs/

.gitmodules

@@ -13,3 +13,6 @@
 [submodule "thirdparty/tiny-AES-c"]
 	path = thirdparty/tiny-AES-c
 	url = https://github.com/kokke/tiny-AES-c.git
+[submodule "thirdparty/simde"]
+	path = thirdparty/simde
+	url = https://github.com/simd-everywhere/simde.git

README.md

@@ -1,60 +1,71 @@
 # XenonRecompUnlimited
-
-<p align="center">
-<img src="https://github.com/testdriveupgrade/XenonRecompUnlim/blob/main/recomp_scheme.jpg" width="1024"/>
- </p>
-
-XenonRecompUnlimited - it's special fork of XenonRecomp for TDU engine, like experimental fork-version with fresh updates
+XenonRecompUnlimited - it's special fork of XenonRecomp for EOT, like experimental fork-version with fresh updates
 
 (unfortunattely at this moment XenonRecomp updates long-term )
 
 Some  new commands of PowerPC CPU checked, but other experimental
 
-### Simplified step-by-step Instructions
-**I think default recompiler instruction too hard, because there a lot of text, that can be explained easier and a lot of not primary information, but less "obviously instructions(for some people it can be not obviously)" **
-**Due to hard instructions a lot of enthusiasts can't GET TO THE MOST INTERESTING THINGS**
-
-1)Install git 
-https://git-scm.com/downloads/win
-
-2)open cmd(terminal) in directory and write: git clone --recursive https://github.com/testdriveupgrade/XenonRecompUnlimited.git
-
-
-3)install clang-cl in Visual Studio installer (or install clang-llvm)
-(install if you dont have VS  https://visualstudio.microsoft.com/vs/ )
-
-4)install CMAKE newer or 3.20
-https://cmake.org/download/
-
-(create folder build in output) directory
-
-5)press "configure"
-
-target Visual Studio 2022
-
-(don't select x86, it should be x64(as default))
-the parameter of CMAKE write: ClangCL
-
-then "build"
-
-and after "open"
-
-6)After that in Visual Studio press "Run - green triangle"
-
-Then you get exe files of Xenon Analyse and Recomp
-
-7)file works
-
-You should convert your .iso dump to .xex file (recomment to choose GUI)
-https://github.com/wiredopposite/XGDTool/releases/tag/v1.0.0
-(and there select input(folder with .iso)/output(target folder) and choose "Extract"), you will get semi-unpacked game with .xex
-
-(I think integrated XenonR patcher works not good) use xextool to uncompress and unecrypt the .xex file
-https://digiex.net/threads/xextool-6-3-download.9523/
-(IT'S VERY IMPORTANT TO WRITE DIRECTORY PATH IN SPECIFIC WAY better to use these format example:  )
-
+### Quick Start
+These instructions describe how to build XenonRecompUnlimited on Windows using Visual Studio 2022.
+
+1. **Prepare your game files**
+   - Extract the game ISO using [Iso Extract](https://www.filehorse.com/download-xbox-360-iso-extract/?utm_source=chatgpt.com).
+   - Decrypt, uncompress and apply updates with [xextool](https://digiex.net/threads/xextool-6-3-download.9523/):
+     ```cmd
+     xextool -eu -cu -p default.xexp -o default_patched.xex default.xex
+     ```
+   - Keep `default_patched.xex` for analysis.
+
+2. **Install dependencies**
+   - [Git](https://git-scm.com/downloads/win)
+   - [Visual Studio 2022](https://visualstudio.microsoft.com/vs/) with the "Desktop development with C++" workload and the `clang-cl` component
+   - [CMake 3.20 or later](https://cmake.org/download/)
+
+3. **Clone the repository**
+
+   ```cmd
+   git clone --recursive https://github.com/EOT-RecompTest/XenonRecomp.git
+   ```
+
+4. **Configure the project**
+   - Open the repository folder in CMake-GUI as a Source Repository
+   - Create a build folder in the repository, and select that as the build folder in CMake-GUI
+   - Click **Configure**
+   - Select `ClangCL` as the toolchain and `x64` as the target architecture
+   - Go through the configuration and once complete, Click **Build**
+
+5. **Run Visual Studio**
+   - Open the generated sln file in your build folder
+   - Click **Build** >> **Build All** in Visual Studio
+   - This builds `XenonAnalyse` and `XenonRecomp` executables in the build directories
+
+6. **Analyze and recompile**
+      ```bash
+   ./XenonAnalyse default_patched.xex switch_tables.toml
+   ```
+    ```bash
+   ./XenonRecomp config.toml XenonUtils/ppc_context.h
+   ```
+
+### Quick Start on macOS
+
+1. **Install dependencies**
+   - Install [Homebrew](https://brew.sh/) and then `brew install llvm cmake`.
+   - Install [CLion](https://www.jetbrains.com/clion/) or another CMake IDE.
+
+2. **Clone the repository** (same as Windows).
+
+3. **Open the project in CLion**
+   - Set the CMake profile to use `-DCMAKE_OSX_ARCHITECTURES=x86_64`.
+   - Configure and build the `XenonAnalyse` and `XenonRecomp` targets.
+
+4. **Run the tools**
+   - Prefix all of your commands with `arch -x86_64` to run under Rosetta 2.
+   - Use `XenonAnalyse` on `default_patched.xex` to generate a switch table file.
+   - Run `XenonRecomp` with your configuration and `XenonUtils/ppc_context.h` to produce C++ code.
 ## About XenonAnalyser
 
+
 Some games have different .xex properties, for example some games contain setjmp and longjmp (can be necessary offset), but other don't;
 
 To find them use bin analysis programs, like Binary Ninja, etc.. (use instruction from Jump table)
@@ -177,6 +188,10 @@ Additionally, mid-asm hooks can be inserted directly into the translated C++ cod
 
 ## Usage
 
+After building the tools you can follow this basic workflow:
+1. Run `XenonAnalyse` on your patched XEX to create a jump table TOML file.
+2. Edit or create a recompiler configuration referencing this file.
+3. Run `XenonRecomp` with your configuration and `XenonUtils/ppc_context.h` to generate the C++ sources.
 ### XenonAnalyse
 
 XenonAnalyse, when used as a command-line application, allows an XEX file to be passed as an input argument to output a TOML file containing all the detected jump tables in the executable:

XenonAnalyse/README.md

@@ -0,0 +1,37 @@
+# XenonAnalyse
+
+This folder contains the code for the jump table scanner. It was recently updated to support alternate instruction sequences that appear in some XEX files.  In these binaries an `ori r0,r0,0` instruction behaves as a NOP and may appear between the real instructions that form a switch pattern.  The code now treats this opcode as `NOP` when matching patterns.
+
+## Issues Encountered
+
+* **Switch table detection failures** – the original patterns only matched one strict order of instructions. A different game contained ORI padding instructions or reordered the RLWINM/ADDI operations, causing detection to fail.
+* **Compilation problems** – building with a compiler older than C++17 or without the required third party libraries leads to errors such as `constructor not allowed in anonymous aggregate` or missing headers. The repository relies on submodules for `fmt`, `tomlplusplus` and `xxHash`.
+
+## Fixes Made
+
+* Added alternate pattern arrays in `main.cpp` (`absoluteSwitchAlt`, `computedSwitchAlt`, `offsetSwitchAlt`, `wordOffsetSwitchAlt`). These account for padding NOPs (`ori r0,r0,0`) and swapped instruction order so the scanner works across different disassemblies.
+* Replaced all occurrences of `PPC_INST_ORI` with `PPC_INST_NOP` in the pattern definitions to explicitly match the disassembler's `NOP` opcode.
+* Updated table reading logic to select instruction offsets for both patterns. The computed switch detector now accepts an alternate form with a NOP before the final `addi` and without the trailing `bctr`.
+
+## Getting Your Build Working
+
+1. **Update submodules**: run `git submodule update --init --recursive` so CMake can find the bundled libraries.
+2. **Use a modern compiler**: the project expects at least C++17 support. Visual Studio 2022 with clang-cl or a recent clang/gcc build is recommended.
+3. Configure with CMake 3.20+ and build normally (e.g. `cmake -S . -B build && cmake --build build`).
+
+When analyzing a new XEX, run `XenonAnalyse <xex> <output.toml>` to produce a list of jump tables.
+
+## Example patterns from `Default_patched.xex`
+
+During validation we located representative tables for each switch type in the
+reference disassembly:
+
+* **Absolute** – e.g. at `0x8208f8f8` the instructions `lis`, `rlwinm`, `subi`,
+  `lwzx`, `mtspr`, `bctr` form the classic pattern.
+* **Computed** – at `0x8222e9d8` a byte index is loaded via `lbzx`, shifted with
+  `rlwinm`, then combined with a base pointer before jumping.
+* **WordOffset** – around `0x82245eac` a halfword table is indexed with
+  `lhzx` and combined with a base address using `add` before branching.
+
+No byte‑offset tables were spotted in this particular binary, but the scanner
+supports them if encountered.