Version 3.4.4

* Copy strings without escape sequences in them

* Add support for more encodings from encoding_rs

Also use encoding_rs instead of CStr for UTF-8.

.cargo/config.toml

@@ -0,0 +1,4 @@
+# statically link the C runtime so the executable does not depend on
+# that shared/dynamic library.
+[target.'cfg(all(target_env = "msvc", target_os = "windows"))']
+rustflags = ["-C", "target-feature=+crt-static"]

.editorconfig

@@ -0,0 +1,2 @@
+[*.md]
+trim_trailing_whitespace = false

.github/workflows/build.yaml

@@ -4,13 +4,17 @@ on:
   pull_request:
   push:
     paths-ignore:
-      - '*.md'
-      - 'LICENSE*'
+      - "*.md"
+      - "LICENSE*"
   workflow_dispatch:
 
+permissions:
+  # For npm publish provenance
+  id-token: write
+
 env:
-  CARGO_BIN_NAME: objdiff
-  CARGO_TARGET_DIR: target
+  BUILD_PROFILE: release-lto
+  CARGO_INCREMENTAL: 0
 
 jobs:
   check:
@@ -20,17 +24,37 @@ jobs:
       RUSTFLAGS: -D warnings
     steps:
       - name: Install dependencies
-        run: sudo apt-get -y install libgtk-3-dev
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install libgtk-3-dev
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Setup Rust toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
-          components: rustfmt, clippy
+          components: clippy
+      - name: Cache Rust workspace
+        uses: Swatinem/rust-cache@v2
       - name: Cargo check
-        run: cargo check --all-features
+        run: cargo check --all-targets --all-features --workspace
       - name: Cargo clippy
-        run: cargo clippy --all-features
+        run: cargo clippy --all-targets --all-features --workspace
+
+  fmt:
+    name: Format
+    runs-on: ubuntu-latest
+    env:
+      RUSTFLAGS: -D warnings
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Rust toolchain
+        # We use nightly options in rustfmt.toml
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: rustfmt
+      - name: Cargo fmt
+        run: cargo fmt --all --check
 
   deny:
     name: Deny
@@ -43,8 +67,8 @@ jobs:
     # Prevent new advisories from failing CI
     continue-on-error: ${{ matrix.checks == 'advisories' }}
     steps:
-      - uses: actions/checkout@v3
-      - uses: EmbarkStudios/cargo-deny-action@v1
+      - uses: actions/checkout@v4
+      - uses: EmbarkStudios/cargo-deny-action@v2
         with:
           command: check ${{ matrix.checks }}
 
@@ -58,76 +82,308 @@ jobs:
     steps:
       - name: Install dependencies
         if: matrix.platform == 'ubuntu-latest'
-        run: sudo apt-get -y install libgtk-3-dev
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install libgtk-3-dev
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Setup Rust toolchain
         uses: dtolnay/rust-toolchain@stable
+      - name: Cache Rust workspace
+        uses: Swatinem/rust-cache@v2
       - name: Cargo test
-        run: cargo test --release --all-features
+        run: cargo test --release --all-features --workspace
 
-  build:
-    name: Build
+  build-cli:
+    name: Build objdiff-cli
+    env:
+      CARGO_BIN_NAME: objdiff-cli
     strategy:
       matrix:
         include:
           - platform: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
+            target: x86_64-unknown-linux-musl
             name: linux-x86_64
-            packages: libgtk-3-dev
+            build: zigbuild
+            features: default
+          - platform: ubuntu-latest
+            target: i686-unknown-linux-musl
+            name: linux-i686
+            build: zigbuild
+            features: default
+          - platform: ubuntu-latest
+            target: aarch64-unknown-linux-musl
+            name: linux-aarch64
+            build: zigbuild
+            features: default
+          - platform: windows-latest
+            target: i686-pc-windows-msvc
+            name: windows-x86
+            build: build
+            features: default
           - platform: windows-latest
             target: x86_64-pc-windows-msvc
             name: windows-x86_64
+            build: build
+            features: default
+          - platform: windows-latest
+            target: aarch64-pc-windows-msvc
+            name: windows-arm64
+            build: build
+            features: default
           - platform: macos-latest
             target: x86_64-apple-darwin
             name: macos-x86_64
+            build: build
+            features: default
           - platform: macos-latest
             target: aarch64-apple-darwin
             name: macos-arm64
+            build: build
+            features: default
+      fail-fast: false
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install uv
+        if: matrix.build == 'zigbuild'
+        uses: astral-sh/setup-uv@v6
+      - name: Install cargo-zigbuild
+        if: matrix.build == 'zigbuild'
+        run: |
+          uv tool install cargo-zigbuild==0.20.1 --with-executables-from ziglang==0.15.1
+          echo "CARGO_ZIGBUILD_ZIG_PATH=$(uv tool dir)/cargo-zigbuild/bin/python-zig" >> $GITHUB_ENV
+      - name: Setup Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+      - name: Cache Rust workspace
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ matrix.target }}
+      - name: Cargo build
+        run: >
+          cargo ${{ matrix.build }} --profile ${{ env.BUILD_PROFILE }} --target ${{ matrix.target }}
+          --bin ${{ env.CARGO_BIN_NAME }} --features ${{ matrix.features }}
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.CARGO_BIN_NAME }}-${{ matrix.name }}
+          path: |
+            target/${{ matrix.target }}/${{ env.BUILD_PROFILE }}/${{ env.CARGO_BIN_NAME }}
+            target/${{ matrix.target }}/${{ env.BUILD_PROFILE }}/${{ env.CARGO_BIN_NAME }}.exe
+          if-no-files-found: error
+
+  build-gui:
+    name: Build objdiff-gui
+    env:
+      CARGO_BIN_NAME: objdiff
+    strategy:
+      matrix:
+        include:
+          - platform: ubuntu-latest
+            target: x86_64-unknown-linux-gnu.2.31
+            target_base: x86_64-unknown-linux-gnu
+            name: linux-x86_64
+            packages: libgtk-3-dev
+            build: zigbuild
+            features: default
+          - platform: windows-latest
+            target: x86_64-pc-windows-msvc
+            name: windows-x86_64
+            build: build
+            features: default
+          - platform: macos-latest
+            target: x86_64-apple-darwin
+            name: macos-x86_64
+            build: build
+            features: default
+          - platform: macos-latest
+            target: aarch64-apple-darwin
+            name: macos-arm64
+            build: build
+            features: default
       fail-fast: false
     runs-on: ${{ matrix.platform }}
     steps:
       - name: Install dependencies
         if: matrix.packages != ''
-        run: sudo apt-get -y install ${{ matrix.packages }}
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ${{ matrix.packages }}
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
+      - name: Install uv
+        if: matrix.build == 'zigbuild'
+        uses: astral-sh/setup-uv@v6
+      - name: Install cargo-zigbuild
+        if: matrix.build == 'zigbuild'
+        run: |
+          uv tool install cargo-zigbuild==0.20.1 --with-executables-from ziglang==0.15.1
+          echo "CARGO_ZIGBUILD_ZIG_PATH=$(uv tool dir)/cargo-zigbuild/bin/python-zig" >> $GITHUB_ENV
       - name: Setup Rust toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
-          targets: ${{ matrix.target }}
-      - name: Cargo build
-        run: cargo build --release --all-features --target ${{ matrix.target }} --bin ${{ env.CARGO_BIN_NAME }}
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v3
+          targets: ${{ matrix.target_base || matrix.target }}
+      - name: Cache Rust workspace
+        uses: Swatinem/rust-cache@v2
         with:
-          name: ${{ matrix.name }}
+          key: ${{ matrix.target }}
+      - name: Cargo build
+        run: >
+          cargo ${{ matrix.build }} --profile ${{ env.BUILD_PROFILE }} --target ${{ matrix.target }}
+          --bin ${{ env.CARGO_BIN_NAME }} --features ${{ matrix.features }}
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.CARGO_BIN_NAME }}-${{ matrix.name }}
           path: |
-            ${{ env.CARGO_TARGET_DIR }}/release/${{ env.CARGO_BIN_NAME }}
-            ${{ env.CARGO_TARGET_DIR }}/release/${{ env.CARGO_BIN_NAME }}.exe
-            ${{ env.CARGO_TARGET_DIR }}/${{ matrix.target }}/release/${{ env.CARGO_BIN_NAME }}
-            ${{ env.CARGO_TARGET_DIR }}/${{ matrix.target }}/release/${{ env.CARGO_BIN_NAME }}.exe
+            target/${{ matrix.target_base || matrix.target }}/${{ env.BUILD_PROFILE }}/${{ env.CARGO_BIN_NAME }}
+            target/${{ matrix.target_base || matrix.target }}/${{ env.BUILD_PROFILE }}/${{ env.CARGO_BIN_NAME }}.exe
           if-no-files-found: error
 
-  release:
-    name: Release
+  build-wasm:
+    name: Build objdiff-wasm
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Rust toolchain
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: rust-src
+      - name: Cache Rust workspace
+        uses: Swatinem/rust-cache@v2
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - name: Install dependencies
+        run: npm -C objdiff-wasm ci
+      - name: Build
+        run: npm -C objdiff-wasm run build
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: wasm
+          path: objdiff-wasm/dist/
+          if-no-files-found: error
+
+  check-version:
+    name: Check package versions
     if: startsWith(github.ref, 'refs/tags/')
     runs-on: ubuntu-latest
-    needs: [ build ]
+    needs: [ build-cli, build-gui, build-wasm ]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Check git tag against package versions
+        shell: bash
+        run: |
+          set -eou pipefail
+          tag='${{github.ref}}'
+          tag="${tag#refs/tags/}"
+          version=$(grep '^version' Cargo.toml | head -1 | awk -F' = ' '{print $2}' | tr -d '"')
+          version="v$version"
+          if [ "$tag" != "$version" ]; then
+            echo "::error::Git tag doesn't match the Cargo version! ($tag != $version)"
+            exit 1
+          fi
+          version="v$(jq -r .version objdiff-wasm/package.json)"
+          if [ "$tag" != "$version" ]; then
+            echo "::error::Git tag doesn't match the npm version! ($tag != $version)"
+            exit 1
+          fi
+
+  release-github:
+    name: Release (GitHub)
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    needs: [ check-version ]
+    permissions:
+      contents: write
     steps:
       - name: Download artifacts
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
+          pattern: objdiff-*
           path: artifacts
       - name: Rename artifacts
         working-directory: artifacts
         run: |
+          set -euo pipefail
           mkdir ../out
-          for i in */*/release/$CARGO_BIN_NAME*; do
-            mv "$i" "../out/$(sed -E "s/([^/]+)\/[^/]+\/release\/($CARGO_BIN_NAME)/\2-\1/" <<< "$i")"
+          for dir in */; do
+            for file in "$dir"*; do
+              base=$(basename "$file")
+              name="${base%.*}"
+              ext="${base##*.}"
+              if [ "$ext" = "$base" ]; then
+                  ext=""
+              else
+                  ext=".$ext"
+              fi
+              arch="${dir%/}" # remove trailing slash
+              arch="${arch##"$name-"}" # remove bin name
+              dst="../out/${name}-${arch}${ext}"
+              mv "$file" "$dst"
+            done
           done
           ls -R ../out
       - name: Release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
         with:
           files: out/*
+          draft: true
+          generate_release_notes: true
+
+  release-cargo:
+    name: Release (Cargo)
+    if: 'false' # TODO re-enable when all dependencies are published
+    runs-on: ubuntu-latest
+    needs: [ check-version ]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Publish
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        run: cargo publish -p objdiff-core
+
+  release-npm:
+    name: Release (npm)
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    needs: [ check-version ]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+          registry-url: 'https://registry.npmjs.org'
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: wasm
+          path: objdiff-wasm/dist
+      - name: Publish
+        working-directory: objdiff-wasm
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: |
+          set -euo pipefail
+          version=$(jq -r '.version' package.json)
+          tag="latest"
+          # Check for prerelease by looking for a dash
+          case "$version" in
+            *-*)
+              tag=$(echo "$version" | sed -e 's/^[^-]*-//' -e 's/\..*$//')
+              ;;
+          esac
+          echo "Publishing version $version with tag '$tag'..."
+          npm publish --provenance --access public --tag "$tag"

.gitignore

@@ -3,10 +3,6 @@ target/
 **/*.rs.bk
 generated/
 
-# cargo-mobile
-.cargo/
-/gen
-
 # macOS
 .DS_Store
 
@@ -22,3 +18,4 @@ android.keystore
 *.frag
 *.vert
 *.metal
+.vscode/

.pre-commit-config.yaml

@@ -0,0 +1,36 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+        args: [--markdown-linebreak-ext=md]
+      - id: end-of-file-fixer
+      - id: fix-byte-order-marker
+      - id: check-yaml
+      - id: check-added-large-files
+  - repo: local
+    hooks:
+      - id: cargo-fmt
+        name: cargo fmt
+        description: Run cargo fmt on all project files.
+        language: system
+        entry: cargo
+        args: ["+nightly", "fmt", "--all"]
+        pass_filenames: false
+      - id: cargo clippy
+        name: cargo clippy
+        description: Run cargo clippy on all project files.
+        language: system
+        entry: cargo
+        args: ["+nightly", "clippy", "--all-targets", "--all-features", "--workspace"]
+        pass_filenames: false
+      - id: cargo-deny
+        name: cargo deny
+        description: Run cargo deny on all project files.
+        language: system
+        entry: cargo
+        args: ["deny", "check"]
+        pass_filenames: false
+        always_run: true

AGENTS.md

@@ -0,0 +1,44 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+
+- `objdiff-core`: core library with diffing logic and shared components
+- `objdiff-cli`: CLI/TUI with `ratatui`
+- `objdiff-gui`: GUI with `eframe`/`egui`
+- `objdiff-wasm`: WebAssembly bindings
+
+objdiff has three main frontends: GUI, CLI/TUI, and [web](https://github.com/encounter/objdiff-web) (utilizing `objdiff-wasm`).
+
+`objdiff-gui` is the most fully-featured and is the primary target for new features.
+
+`objdiff-cli` has an interactive TUI `diff` mode (powered by `ratatui`) and a non-interactive `report` mode to generate detailed progress reports (e.g. for <https://decomp.dev>).
+
+`objdiff-wasm` is compiled into a [WebAssembly Component](https://component-model.bytecodealliance.org/). The [API](objdiff-wasm/wit/objdiff.wit) is defined using [WIT](https://component-model.bytecodealliance.org/design/wit.html). The web interface is separate, but mirrors the GUI in functionality.
+
+## Build, Test, and Development Commands
+
+Run `cargo build` for a debug build and `cargo build --release` for an optimized build.
+The CLI can be exercised with `cargo run --release --bin objdiff-cli -- --help`.
+
+The WASM build is not included in the workspace by default due to differences in toolchain and target; build it with `npm -C objdiff-wasm run build`. (nightly required)
+In general, do NOT use `--workspace`, as it will include the WASM crate and likely fail. Formatting and linting commands are exempt.
+
+Pre-commit tasks:
+
+- `cargo test` to run the test suite
+- `cargo +nightly fmt --all` to format code (nightly required)
+- `cargo +nightly clippy --all-targets --all-features --workspace -- -D warnings` to lint code (nightly required)
+- `cargo deny check` (`cargo install --locked cargo-deny` if needed) if dependencies change
+
+## Testing Guidelines
+
+Favor focused unit tests adjacent to the code, and integration scenarios in `objdiff-core/tests`.
+Integration tests utilize snapshots with the `insta` crate; run `curl -LsSf https://insta.rs/install.sh | sh` if needed.
+To generate updated snapshots, use `cargo insta test`, review diffs manually, then accept changes with `cargo insta accept` (or simply `mv` to accept specific snapshots).
+
+## Configuration Tips
+
+- `config.schema.json`: JSON schema for the user-facing project config file (`objdiff.json`)
+- `objdiff-core/config-schema.json`: Internal options schema to generate `DiffObjConfig` (see `objdiff-core/config_gen.rs`)
+
+The project configuration (`objdiff.json`) is intended to be generated by the projects' build system. It includes paths to the target (expected) and base (current) object files, along with build commands and file watch patterns. See `README.md` for a summary of key options.

Cargo.toml

@@ -1,62 +1,32 @@
-[package]
-name = "objdiff"
-version = "0.2.0"
-edition = "2021"
-rust-version = "1.62"
+[workspace]
+members = [
+    "objdiff-cli",
+    "objdiff-core",
+    "objdiff-gui",
+    "objdiff-wasm",
+]
+default-members = [
+    "objdiff-cli",
+    "objdiff-core",
+    "objdiff-gui",
+    # Exclude objdiff-wasm by default
+]
+resolver = "3"
+
+[workspace.package]
+version = "3.4.4"
 authors = ["Luke Street <luke@street.dev>"]
+edition = "2024"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/encounter/objdiff"
-readme = "README.md"
-description = """
-A local diffing tool for decompilation projects.
-"""
-publish = false
+rust-version = "1.88"
 
-[profile.release]
-lto = "thin"
+[profile.release-lto]
+inherits = "release"
+lto = "fat"
 strip = "debuginfo"
+codegen-units = 1
 
-[dependencies]
-anyhow = "1.0.66"
-cfg-if = "1.0.0"
-const_format = "0.2.30"
-cwdemangle = { git = "https://github.com/encounter/cwdemangle", rev = "286f3d1d29ee2457db89043782725631845c3e4c" }
-eframe = { version = "0.19.0", features = ["persistence"] } # , "wgpu"
-egui = "0.19.0"
-egui_extras = "0.19.0"
-flagset = "0.4.3"
-log = "0.4.17"
-memmap2 = "0.5.8"
-notify = "5.0.0"
-object = { version = "0.30.0", features = ["read_core", "std", "elf"], default-features = false }
-ppc750cl = { git = "https://github.com/encounter/ppc750cl", rev = "aa631a33de7882c679afca89350898b87cb3ba3f" }
-rabbitizer = { git = "https://github.com/encounter/rabbitizer-rs", rev = "10c279b2ef251c62885b1dcdcfe740b0db8e9956" }
-rfd = { version = "0.10.0" } # , default-features = false, features = ['xdg-portal']
-self_update = "0.32.0"
-serde = { version = "1", features = ["derive"] }
-thiserror = "1.0.37"
-time = { version = "0.3.17", features = ["formatting", "local-offset"] }
-toml = "0.5.9"
-twox-hash = "1.6.3"
-tempfile = "3.3.0"
-reqwest = "0.11.13"
-
-[target.'cfg(windows)'.dependencies]
-path-slash = "0.2.1"
-winapi = "0.3.9"
-
-[target.'cfg(unix)'.dependencies]
-exec = "0.3.1"
-
-# native:
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-tracing-subscriber = "0.3"
-
-# web:
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-console_error_panic_hook = "0.1.7"
-tracing-wasm = "0.2"
-
-[build-dependencies]
-anyhow = "1.0.66"
-vergen = { version = "7.4.3", features = ["build", "cargo", "git"], default-features = false }
+[profile.release-min]
+inherits = "release-lto"
+opt-level = "z"

README.md

@@ -3,26 +3,205 @@
 [Build Status]: https://github.com/encounter/objdiff/actions/workflows/build.yaml/badge.svg
 [actions]: https://github.com/encounter/objdiff/actions
 
-A local diffing tool for decompilation projects.
+A local diffing tool for decompilation projects. Inspired by [decomp.me](https://decomp.me) and [asm-differ](https://github.com/simonlindholm/asm-differ).
 
-Currently supports:
-- PowerPC 750CL (GameCube & Wii)
-- MIPS (Nintendo 64)
+Features:
+
+- Compare entire object files: functions and data
+- Built-in C++ symbol demangling (GCC, MSVC, CodeWarrior, Itanium)
+- Automatic rebuild on source file changes
+- Project integration via [configuration file](#configuration)
+- Search and filter objects with quick switching
+- Click-to-highlight values and registers
+- Detailed progress reporting (powers [decomp.dev](https://decomp.dev))
+- WebAssembly API, [web interface](https://github.com/encounter/objdiff-web) and [Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=decomp-dev.objdiff) (WIP)
+
+Supports:
+
+- ARM (GBA, DS, 3DS)
+- ARM64 (Switch)
+- MIPS (N64, PS1, PS2, PSP)
+- PowerPC (GameCube, Wii, PS3, Xbox 360)
+- SuperH (Saturn, Dreamcast)
+- x86, x86_64 (PC)
+
+See [Usage](#usage) for more information.
+
+## Downloads
+
+To build from source, see [Building](#building).
+
+### GUI
+
+- [Windows (x86_64)](https://github.com/encounter/objdiff/releases/latest/download/objdiff-windows-x86_64.exe)
+- [Linux (x86_64)](https://github.com/encounter/objdiff/releases/latest/download/objdiff-linux-x86_64)
+- [macOS (arm64)](https://github.com/encounter/objdiff/releases/latest/download/objdiff-macos-arm64)
+- [macOS (x86_64)](https://github.com/encounter/objdiff/releases/latest/download/objdiff-macos-x86_64)
+
+For Linux and macOS, run `chmod +x objdiff-*` to make the binary executable.
+
+### CLI
+
+CLI binaries are available on the [releases page](https://github.com/encounter/objdiff/releases).
+
+## Screenshots
 
 ![Symbol Screenshot](assets/screen-symbols.png)
 ![Diff Screenshot](assets/screen-diff.png)
 
-### License
+## Usage
+
+objdiff compares two relocatable object files (`.o`). Here's how it works:
+
+1. **Create an `objdiff.json` configuration file** in your project root (or generate it with your build script).  
+  This file lists **all objects in the project** with their target ("expected") and base ("current") paths.
+
+2. **Load the project** in objdiff.
+
+3. **Select an object** from the sidebar to begin diffing.
+
+4. **objdiff automatically:**
+   - Executes the build system to compile the base object (from current source code)
+   - Compares the two objects and displays the differences
+   - Watches for source file changes and rebuilds when detected
+
+The configuration file allows complete flexibility in project structure - your build directories can have any layout as long as the paths are specified correctly.
+
+See [Configuration](#configuration) for setup details.
+
+## Configuration
+
+Projects can add an `objdiff.json` file to configure the tool automatically. The configuration file must be located in
+the root project directory.
+
+If your project has a generator script (e.g. `configure.py`), it's highly recommended to generate the objdiff configuration
+file as well. You can then add `objdiff.json` to your `.gitignore` to prevent it from being committed.
+
+```json
+{
+  "$schema": "https://raw.githubusercontent.com/encounter/objdiff/main/config.schema.json",
+  "custom_make": "ninja",
+  "custom_args": [
+    "-d",
+    "keeprsp"
+  ],
+  "build_target": false,
+  "build_base": true,
+  "watch_patterns": [
+    "*.c",
+    "*.cc",
+    "*.cp",
+    "*.cpp",
+    "*.cxx",
+    "*.c++",
+    "*.h",
+    "*.hh",
+    "*.hp",
+    "*.hpp",
+    "*.hxx",
+    "*.h++",
+    "*.pch",
+    "*.pch++",
+    "*.inc",
+    "*.s",
+    "*.S",
+    "*.asm",
+    "*.py",
+    "*.yml",
+    "*.txt",
+    "*.json"
+  ],
+  "ignore_patterns": [
+    "build/**/*"
+  ],
+  "units": [
+    {
+      "name": "main/MetroTRK/mslsupp",
+      "target_path": "build/asm/MetroTRK/mslsupp.o",
+      "base_path": "build/src/MetroTRK/mslsupp.o",
+      "metadata": {}
+    }
+  ]
+}
+```
+
+### Schema
+
+> [!NOTE]  
+> View [config.schema.json](config.schema.json) for all available options. Below is a summary of the most important options.
+
+#### Build Configuration
+
+**`custom_make`** _(optional, default: `"make"`)_  
+If the project uses a different build system (e.g. `ninja`), specify it here. The build command will be `[custom_make] [custom_args] path/to/object.o`.
+
+**`custom_args`** _(optional)_  
+Additional arguments to pass to the build command prior to the object path.
+
+**`build_target`**  _(default: `false`)_  
+If true, objdiff will build the target objects before diffing (e.g. `make path/to/target.o`). Useful if target objects are not built by default or can change based on project configuration. Requires proper build system configuration.
+
+**`build_base`**  _(default: `true`)_  
+If true, objdiff will build the base objects before diffing (e.g. `make path/to/base.o`). It's unlikely you'll want to disable this unless using an external tool to rebuild the base object.
+
+#### File Watching
+
+**`watch_patterns`** _(optional, default: listed above)_  
+A list of glob patterns to watch for changes ([supported syntax](https://docs.rs/globset/latest/globset/#syntax)). When these files change, objdiff automatically rebuilds and re-compares objects.
+
+**`ignore_patterns`** _(optional, default: listed above)_  
+A list of glob patterns to explicitly ignore when watching for changes ([supported syntax](https://docs.rs/globset/latest/globset/#syntax)).
+
+#### Units (Objects)
+
+**`units`** _(optional)_  
+If specified, objdiff displays a list of objects in the sidebar for easy navigation. Each unit contains:
+
+- **`name`** _(optional)_ - The display name in the UI. Defaults to the object's `path`.
+- **`target_path`** _(optional)_ - Path to the "target" or "expected" object (the **intended result**).
+- **`base_path`** _(optional)_ - Path to the "base" or "current" object (built from **current source code**). Omit if there is no source object yet.
+- **`metadata.auto_generated`** _(optional)_ - Hides the object from the sidebar but includes it in progress reports.
+- **`metadata.complete`** _(optional)_ - Marks the object as "complete" (linked) when `true` or "incomplete" when `false`.
+
+## Building
+
+Install Rust via [rustup](https://rustup.rs).
+
+```shell
+git clone https://github.com/encounter/objdiff.git
+cd objdiff
+cargo run --release
+```
+
+Or install directly with cargo:
+
+```shell
+cargo install --locked --git https://github.com/encounter/objdiff.git objdiff-gui objdiff-cli
+```
+
+Binaries will be installed to `~/.cargo/bin` as `objdiff` and `objdiff-cli`.
+
+## Contributing
+
+Install `pre-commit` to run linting and formatting automatically:
+
+```shell
+rustup toolchain install nightly  # Required for cargo fmt/clippy
+cargo install --locked cargo-deny # https://github.com/EmbarkStudios/cargo-deny
+uv tool install pre-commit        # https://docs.astral.sh/uv, or use pipx or pip
+pre-commit install
+```
+
+## License
 
 Licensed under either of
 
-* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or <http://www.apache.org/licenses/LICENSE-2.0>)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
 
 at your option.
 
 ### Contribution
 
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any
-additional terms or conditions.
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as
+defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

build.rs

@@ -1,4 +0,0 @@
-use anyhow::Result;
-use vergen::{vergen, Config};
-
-fn main() -> Result<()> { vergen(Config::default()) }

config.schema.json

@@ -0,0 +1,281 @@
+{
+  "$schema": "https://json-schema.org/draft-07/schema",
+  "$id": "https://raw.githubusercontent.com/encounter/objdiff/main/config.schema.json",
+  "title": "objdiff configuration",
+  "description": "Configuration file for objdiff",
+  "type": "object",
+  "properties": {
+    "min_version": {
+      "type": "string",
+      "description": "Minimum version of objdiff required to load this configuration file.",
+      "examples": [
+        "1.0.0",
+        "2.0.0-beta.1"
+      ]
+    },
+    "custom_make": {
+      "type": "string",
+      "description": "If the project uses a different build system (e.g. ninja), specify it here.\nThe build command will be `[custom_make] [custom_args] path/to/object.o`.",
+      "examples": [
+        "make",
+        "ninja"
+      ],
+      "default": "make"
+    },
+    "custom_args": {
+      "type": "array",
+      "description": "Additional arguments to pass to the build command prior to the object path.",
+      "items": {
+        "type": "string"
+      }
+    },
+    "target_dir": {
+      "type": "string",
+      "description": "Relative from the root of the project, this where the \"target\" or \"expected\" objects are located.\nThese are the intended result of the match.",
+      "deprecated": true
+    },
+    "base_dir": {
+      "type": "string",
+      "description": "Relative from the root of the project, this is where the \"base\" or \"actual\" objects are located.\nThese are objects built from the current source code.",
+      "deprecated": true
+    },
+    "build_target": {
+      "type": "boolean",
+      "description": "If true, objdiff will build the target objects before diffing (e.g. `make path/to/target.o`).\nUseful if target objects are not built by default or can change based on project configuration.\nRequires proper build system configuration.",
+      "default": false
+    },
+    "build_base": {
+      "type": "boolean",
+      "description": "If true, objdiff will build the base objects before diffing (e.g. `make path/to/base.o`).\nIt's unlikely you'll want to disable this unless using an external tool to rebuild the base object.",
+      "default": true
+    },
+    "watch_patterns": {
+      "type": "array",
+      "description": "A list of glob patterns to watch for changes.\nWhen these files change, objdiff automatically rebuilds and re-compares objects.\nSupported syntax: https://docs.rs/globset/latest/globset/#syntax",
+      "items": {
+        "type": "string"
+      },
+      "default": [
+        "*.c",
+        "*.cc",
+        "*.cp",
+        "*.cpp",
+        "*.cxx",
+        "*.c++",
+        "*.h",
+        "*.hh",
+        "*.hp",
+        "*.hpp",
+        "*.hxx",
+        "*.h++",
+        "*.pch",
+        "*.pch++",
+        "*.inc",
+        "*.s",
+        "*.S",
+        "*.asm",
+        "*.py",
+        "*.yml",
+        "*.txt",
+        "*.json"
+      ]
+    },
+    "ignore_patterns": {
+      "type": "array",
+      "description": "A list of glob patterns to explicitly ignore when watching for changes.\nSupported syntax: https://docs.rs/globset/latest/globset/#syntax",
+      "items": {
+        "type": "string"
+      },
+      "default": [
+        "build/**/*"
+      ]
+    },
+    "objects": {
+      "type": "array",
+      "description": "Use units instead.",
+      "deprecated": true,
+      "items": {
+        "$ref": "#/$defs/unit"
+      }
+    },
+    "units": {
+      "type": "array",
+      "description": "If specified, objdiff will display a list of objects in the sidebar for easy navigation.",
+      "items": {
+        "$ref": "#/$defs/unit"
+      }
+    },
+    "progress_categories": {
+      "type": "array",
+      "description": "Progress categories used for objdiff-cli report.",
+      "items": {
+        "$ref": "#/$defs/progress_category"
+      }
+    },
+    "options": {
+      "type": "object",
+      "description": "Diff configuration options that should be applied automatically when the project is loaded.",
+      "additionalProperties": {
+        "oneOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "string"
+          }
+        ]
+      },
+      "examples": [
+        {
+          "demangler": "gnu_legacy"
+        }
+      ]
+    }
+  },
+  "$defs": {
+    "unit": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "The display name in the UI. Defaults to the object's path."
+        },
+        "path": {
+          "type": "string",
+          "description": "Relative path to the object from the target_dir and base_dir.\nRequires target_dir and base_dir to be specified.",
+          "deprecated": true
+        },
+        "target_path": {
+          "type": "string",
+          "description": "Path to the \"target\" or \"expected\" object (the intended result)."
+        },
+        "base_path": {
+          "type": "string",
+          "description": "Path to the \"base\" or \"current\" object (built from current source code).\nOmit if there is no source object yet."
+        },
+        "reverse_fn_order": {
+          "type": "boolean",
+          "description": "Displays function symbols in reversed order.\nUsed to support MWCC's -inline deferred option, which reverses the order of functions in the object file.",
+          "deprecated": true
+        },
+        "complete": {
+          "type": "boolean",
+          "description": "Marks the object as \"complete\" (or \"linked\") in the object list.\nThis is useful for marking objects that are fully decompiled. A value of `false` will mark the object as \"incomplete\".",
+          "deprecated": true
+        },
+        "scratch": {
+          "ref": "#/$defs/scratch"
+        },
+        "metadata": {
+          "ref": "#/$defs/metadata"
+        },
+        "symbol_mappings": {
+          "type": "object",
+          "description": "Manual symbol mappings from target to base.",
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "options": {
+          "type": "object",
+          "description": "Diff configuration options that should be applied when this unit is active.",
+          "additionalProperties": {
+            "oneOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "string"
+              }
+            ]
+          }
+        }
+      }
+    },
+    "scratch": {
+      "type": "object",
+      "description": "If present, objdiff will display a button to create a decomp.me scratch.",
+      "properties": {
+        "platform": {
+          "type": "string",
+          "description": "The decomp.me platform ID to use for the scratch.",
+          "examples": [
+            "gc_wii",
+            "n64"
+          ]
+        },
+        "compiler": {
+          "type": "string",
+          "description": "The decomp.me compiler ID to use for the scratch.",
+          "examples": [
+            "mwcc_242_81",
+            "ido7.1"
+          ]
+        },
+        "c_flags": {
+          "type": "string",
+          "description": "C flags to use for the scratch. Exclude any include paths."
+        },
+        "ctx_path": {
+          "type": "string",
+          "description": "Path to the context file to use for the scratch."
+        },
+        "build_ctx": {
+          "type": "boolean",
+          "description": "If true, objdiff will run the build command with the context file as an argument to generate it.",
+          "default": false
+        },
+        "preset_id": {
+          "type": "number",
+          "description": "The decomp.me preset ID to use for the scratch.\nCompiler and flags in the config will take precedence over the preset, but the preset is useful for organizational purposes."
+        }
+      },
+      "required": [
+        "platform",
+        "compiler"
+      ]
+    },
+    "metadata": {
+      "type": "object",
+      "properties": {
+        "complete": {
+          "type": "boolean",
+          "description": "Marks the object as \"complete\" (linked) when `true` or \"incomplete\" when `false`."
+        },
+        "reverse_fn_order": {
+          "type": "boolean",
+          "description": "Displays function symbols in reversed order.\nUsed to support MWCC's -inline deferred option, which reverses the order of functions in the object file."
+        },
+        "source_path": {
+          "type": "string",
+          "description": "Path to the source file that generated the object."
+        },
+        "progress_categories": {
+          "type": "array",
+          "description": "Progress categories used for objdiff-cli report.",
+          "items": {
+            "type": "string",
+            "description": "Unique identifier for the category. (See progress_categories)"
+          }
+        },
+        "auto_generated": {
+          "type": "boolean",
+          "description": "Hides the object from the sidebar but includes it in progress reports."
+        }
+      }
+    },
+    "progress_category": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "Unique identifier for the category."
+        },
+        "name": {
+          "type": "string",
+          "description": "Human-readable name of the category."
+        }
+      }
+    }
+  }
+}

deny.toml

@@ -9,6 +9,11 @@
 # The values provided in this template are the default values that will be used
 # when any section or field is not specified in your own configuration
 
+# Root options
+
+# The graph table configures how the dependency graph is constructed and thus
+# which crates the checks are performed against
+[graph]
 # If 1 or more target triples (and optionally, target_features) are specified,
 # only the specified targets will be checked when running `cargo deny check`.
 # This means, if a particular package is only ever used as a target specific
@@ -20,88 +25,88 @@
 targets = [
     # The triple can be any string, but only the target triples built in to
     # rustc (as of 1.40) can be checked against actual config expressions
-    #{ triple = "x86_64-unknown-linux-musl" },
+    #"x86_64-unknown-linux-musl",
     # You can also specify which target_features you promise are enabled for a
     # particular target. target_features are currently not validated against
     # the actual valid features supported by the target architecture.
     #{ triple = "wasm32-unknown-unknown", features = ["atomics"] },
 ]
+# When creating the dependency graph used as the source of truth when checks are
+# executed, this field can be used to prune crates from the graph, removing them
+# from the view of cargo-deny. This is an extremely heavy hammer, as if a crate
+# is pruned from the graph, all of its dependencies will also be pruned unless
+# they are connected to another crate in the graph that hasn't been pruned,
+# so it should be used with care. The identifiers are [Package ID Specifications]
+# (https://doc.rust-lang.org/cargo/reference/pkgid-spec.html)
+#exclude = []
+# If true, metadata will be collected with `--all-features`. Note that this can't
+# be toggled off if true, if you want to conditionally enable `--all-features` it
+# is recommended to pass `--all-features` on the cmd line instead
+all-features = false
+# If true, metadata will be collected with `--no-default-features`. The same
+# caveat with `all-features` applies
+no-default-features = false
+# If set, these feature will be enabled when collecting metadata. If `--features`
+# is specified on the cmd line they will take precedence over this option.
+#features = []
+
+# The output table provides options for how/if diagnostics are outputted
+[output]
+# When outputting inclusion graphs in diagnostics that include features, this
+# option can be used to specify the depth at which feature edges will be added.
+# This option is included since the graphs can be quite large and the addition
+# of features from the crate(s) to all of the graph roots can be far too verbose.
+# This option can be overridden via `--feature-depth` on the cmd line
+feature-depth = 1
 
 # This section is considered when running `cargo deny check advisories`
 # More documentation for the advisories section can be found here:
 # https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html
 [advisories]
-# The path where the advisory database is cloned/fetched into
-db-path = "~/.cargo/advisory-db"
+# The path where the advisory databases are cloned/fetched into
+#db-path = "$CARGO_HOME/advisory-dbs"
 # The url(s) of the advisory databases to use
-db-urls = ["https://github.com/rustsec/advisory-db"]
-# The lint level for security vulnerabilities
-vulnerability = "deny"
-# The lint level for unmaintained crates
-unmaintained = "warn"
-# The lint level for crates that have been yanked from their source registry
-yanked = "warn"
-# The lint level for crates with security notices. Note that as of
-# 2019-12-17 there are no security notice advisories in
-# https://github.com/rustsec/advisory-db
-notice = "warn"
+#db-urls = ["https://github.com/rustsec/advisory-db"]
 # A list of advisory IDs to ignore. Note that ignored advisories will still
 # output a note when they are encountered.
 ignore = [
-    #"RUSTSEC-0000-0000",
+    #{ id = "RUSTSEC-0000-0000", reason = "you can specify a reason the advisory is ignored" },
+    #"a-crate-that-is-yanked@0.1.1", # you can also ignore yanked crate versions if you wish
+    #{ crate = "a-crate-that-is-yanked@0.1.1", reason = "you can specify why you are ignoring the yanked crate" },
+    { id = "RUSTSEC-2024-0436", reason = "Unmaintained paste crate is an indirect dependency" },
+    { id = "RUSTSEC-2025-0052", reason = "Unmaintained async-std crate is an indirect dependency" },
+    { id = "RUSTSEC-2025-0119", reason = "Unmaintained number_prefix crate is an indirect dependency" },
 ]
-# Threshold for security vulnerabilities, any vulnerability with a CVSS score
-# lower than the range specified will be ignored. Note that ignored advisories
-# will still output a note when they are encountered.
-# * None - CVSS Score 0.0
-# * Low - CVSS Score 0.1 - 3.9
-# * Medium - CVSS Score 4.0 - 6.9
-# * High - CVSS Score 7.0 - 8.9
-# * Critical - CVSS Score 9.0 - 10.0
-#severity-threshold =
+# If this is true, then cargo deny will use the git executable to fetch advisory database.
+# If this is false, then it uses a built-in git library.
+# Setting this to true can be helpful if you have special authentication requirements that cargo-deny does not support.
+# See Git Authentication for more information about setting up git authentication.
+#git-fetch-with-cli = true
 
 # This section is considered when running `cargo deny check licenses`
 # More documentation for the licenses section can be found here:
 # https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html
 [licenses]
-# The lint level for crates which do not have a detectable license
-unlicensed = "deny"
-# List of explictly allowed licenses
+# List of explicitly allowed licenses
 # See https://spdx.org/licenses/ for list of possible licenses
 # [possible values: any SPDX 3.11 short identifier (+ optional exception)].
 allow = [
     "MIT",
     "Apache-2.0",
+    "Apache-2.0 WITH LLVM-exception",
     "ISC",
     "BSD-2-Clause",
     "BSD-3-Clause",
     "BSL-1.0",
     "CC0-1.0",
     "MPL-2.0",
-    "Unicode-DFS-2016",
+    "Unicode-3.0",
     "Zlib",
     "0BSD",
+    "OFL-1.1",
+    "Ubuntu-font-1.0",
+    "CDLA-Permissive-2.0",
 ]
-# List of explictly disallowed licenses
-# See https://spdx.org/licenses/ for list of possible licenses
-# [possible values: any SPDX 3.11 short identifier (+ optional exception)].
-deny = [
-    #"Nokia",
-]
-# Lint level for licenses considered copyleft
-copyleft = "warn"
-# Blanket approval or denial for OSI-approved or FSF Free/Libre licenses
-# * both - The license will be approved if it is both OSI-approved *AND* FSF
-# * either - The license will be approved if it is either OSI-approved *OR* FSF
-# * osi-only - The license will be approved if is OSI-approved *AND NOT* FSF
-# * fsf-only - The license will be approved if is FSF *AND NOT* OSI-approved
-# * neither - This predicate is ignored and the default lint level is used
-allow-osi-fsf-free = "neither"
-# Lint level used when no other predicates are matched
-# 1. License isn't in the allow or deny lists
-# 2. License isn't copyleft
-# 3. License isn't OSI/FSF, or allow-osi-fsf-free = "neither"
-default = "deny"
 # The confidence threshold for detecting a license from license text.
 # The higher the value, the more closely the license text must be to the
 # canonical license text of a valid SPDX license file.
@@ -112,32 +117,32 @@ confidence-threshold = 0.8
 exceptions = [
     # Each entry is the crate and version constraint, and its specific allow
     # list
-    #{ allow = ["Zlib"], name = "adler32", version = "*" },
+    #{ allow = ["Zlib"], crate = "adler32" },
 ]
 
 # Some crates don't have (easily) machine readable licensing information,
 # adding a clarification entry for it allows you to manually specify the
 # licensing information
-#[[licenses.clarify]]
-# The name of the crate the clarification applies to
-#name = "ring"
-# The optional version constraint for the crate
-#version = "*"
+[[licenses.clarify]]
+# The package spec the clarification applies to
+crate = "ring"
 # The SPDX expression for the license requirements of the crate
-#expression = "MIT AND ISC AND OpenSSL"
+expression = "MIT AND ISC AND OpenSSL"
 # One or more files in the crate's source used as the "source of truth" for
 # the license expression. If the contents match, the clarification will be used
 # when running the license check, otherwise the clarification will be ignored
 # and the crate will be checked normally, which may produce warnings or errors
 # depending on the rest of your configuration
-#license-files = [
+license-files = [
     # Each entry is a crate relative path, and the (opaque) hash of its contents
-    #{ path = "LICENSE", hash = 0xbd0eed23 }
-#]
+    { path = "LICENSE", hash = 0xbd0eed23 }
+]
 
 [licenses.private]
 # If true, ignores workspace crates that aren't published, or are only
-# published to private registries
+# published to private registries.
+# To see how to mark a crate as unpublished (to the official registry),
+# visit https://doc.rust-lang.org/cargo/reference/manifest.html#the-publish-field.
 ignore = false
 # One or more private registries that you might publish crates to, if a crate
 # is only published to private registries, and ignore is true, the crate will
@@ -151,7 +156,7 @@ registries = [
 # https://embarkstudios.github.io/cargo-deny/checks/bans/cfg.html
 [bans]
 # Lint level for when multiple versions of the same crate are detected
-multiple-versions = "warn"
+multiple-versions = "allow"
 # Lint level for when a crate version requirement is `*`
 wildcards = "allow"
 # The graph highlighting used when creating dotgraphs for crates
@@ -160,30 +165,63 @@ wildcards = "allow"
 # * simplest-path - The path to the version with the fewest edges is highlighted
 # * all - Both lowest-version and simplest-path are used
 highlight = "all"
+# The default lint level for `default` features for crates that are members of
+# the workspace that is being checked. This can be overridden by allowing/denying
+# `default` on a crate-by-crate basis if desired.
+workspace-default-features = "allow"
+# The default lint level for `default` features for external crates that are not
+# members of the workspace. This can be overridden by allowing/denying `default`
+# on a crate-by-crate basis if desired.
+external-default-features = "allow"
 # List of crates that are allowed. Use with care!
 allow = [
-    #{ name = "ansi_term", version = "=0.11.0" },
+    #"ansi_term@0.11.0",
+    #{ crate = "ansi_term@0.11.0", reason = "you can specify a reason it is allowed" },
 ]
 # List of crates to deny
 deny = [
-    # Each entry the name of a crate and a version range. If version is
-    # not specified, all versions will be matched.
-    #{ name = "ansi_term", version = "=0.11.0" },
-    #
+    #"ansi_term@0.11.0",
+    #{ crate = "ansi_term@0.11.0", reason = "you can specify a reason it is banned" },
     # Wrapper crates can optionally be specified to allow the crate when it
     # is a direct dependency of the otherwise banned crate
-    #{ name = "ansi_term", version = "=0.11.0", wrappers = [] },
+    #{ crate = "ansi_term@0.11.0", wrappers = ["this-crate-directly-depends-on-ansi_term"] },
 ]
+
+# List of features to allow/deny
+# Each entry the name of a crate and a version range. If version is
+# not specified, all versions will be matched.
+#[[bans.features]]
+#crate = "reqwest"
+# Features to not allow
+#deny = ["json"]
+# Features to allow
+#allow = [
+#    "rustls",
+#    "__rustls",
+#    "__tls",
+#    "hyper-rustls",
+#    "rustls",
+#    "rustls-pemfile",
+#    "rustls-tls-webpki-roots",
+#    "tokio-rustls",
+#    "webpki-roots",
+#]
+# If true, the allowed features must exactly match the enabled feature set. If
+# this is set there is no point setting `deny`
+#exact = true
+
 # Certain crates/versions that will be skipped when doing duplicate detection.
 skip = [
-    #{ name = "ansi_term", version = "=0.11.0" },
+    #"ansi_term@0.11.0",
+    #{ crate = "ansi_term@0.11.0", reason = "you can specify a reason why it can't be updated/removed" },
 ]
 # Similarly to `skip` allows you to skip certain crates during duplicate
 # detection. Unlike skip, it also includes the entire tree of transitive
 # dependencies starting at the specified crate, up to a certain depth, which is
-# by default infinite
+# by default infinite.
 skip-tree = [
-    #{ name = "ansi_term", version = "=0.11.0", depth = 20 },
+    #"ansi_term@0.11.0", # will be skipped along with _all_ of its direct and transitive dependencies
+    #{ crate = "ansi_term@0.11.0", depth = 20 },
 ]
 
 # This section is considered when running `cargo deny check sources`.
@@ -203,9 +241,12 @@ allow-registry = ["https://github.com/rust-lang/crates.io-index"]
 allow-git = []
 
 [sources.allow-org]
-# 1 or more github.com organizations to allow git sources for
-github = ["encounter"]
-# 1 or more gitlab.com organizations to allow git sources for
-#gitlab = [""]
-# 1 or more bitbucket.org organizations to allow git sources for
-#bitbucket = [""]
+# github.com organizations to allow git sources for
+github = [
+    "encounter",
+    "gimli-rs",  # gimli
+]
+# gitlab.com organizations to allow git sources for
+gitlab = []
+# bitbucket.org organizations to allow git sources for
+bitbucket = []

objdiff-cli/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "objdiff-cli"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+readme = "../README.md"
+description = """
+A local diffing tool for decompilation projects.
+"""
+publish = false
+
+[dependencies]
+anyhow = "1.0"
+argp = "0.4"
+crossterm = "0.29"
+enable-ansi-support = "0.3"
+memmap2 = "0.9"
+objdiff-core = { path = "../objdiff-core", features = ["all"] }
+prost = "0.14"
+ratatui = "0.29"
+rayon = "1.11"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+supports-color = "3.0"
+time = { version = "0.3", features = ["formatting", "local-offset"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+typed-path = "0.12"
+
+[target.'cfg(target_env = "musl")'.dependencies]
+mimalloc = "0.1"

objdiff-cli/src/argp_version.rs

@@ -0,0 +1,63 @@
+// Originally from https://gist.github.com/suluke/e0c672492126be0a4f3b4f0e1115d77c
+//! Extend `argp` to be better integrated with the `cargo` ecosystem
+//!
+//! For now, this only adds a --version/-V option which causes early-exit.
+use std::ffi::OsStr;
+
+use argp::{EarlyExit, FromArgs, TopLevelCommand, parser::ParseGlobalOptions};
+
+struct ArgsOrVersion<T>(T)
+where T: FromArgs;
+
+impl<T> TopLevelCommand for ArgsOrVersion<T> where T: FromArgs {}
+
+impl<T> FromArgs for ArgsOrVersion<T>
+where T: FromArgs
+{
+    fn _from_args(
+        command_name: &[&str],
+        args: &[&OsStr],
+        parent: Option<&mut dyn ParseGlobalOptions>,
+    ) -> Result<Self, EarlyExit> {
+        /// Also use argp for catching `--version`-only invocations
+        #[derive(FromArgs)]
+        struct Version {
+            /// Print version information and exit.
+            #[argp(switch, short = 'V')]
+            pub version: bool,
+        }
+
+        match Version::from_args(command_name, args) {
+            Ok(v) => {
+                if v.version {
+                    println!(
+                        "{} {}",
+                        command_name.first().unwrap_or(&""),
+                        env!("CARGO_PKG_VERSION"),
+                    );
+                    std::process::exit(0);
+                } else {
+                    // Pass through empty arguments
+                    T::_from_args(command_name, args, parent).map(Self)
+                }
+            }
+            Err(exit) => match exit {
+                EarlyExit::Help(_help) => {
+                    // TODO: Chain help info from Version
+                    // For now, we just put the switch on T as well
+                    T::from_args(command_name, &["--help"]).map(Self)
+                }
+                EarlyExit::Err(_) => T::_from_args(command_name, args, parent).map(Self),
+            },
+        }
+    }
+}
+
+/// Create a `FromArgs` type from the current process’s `env::args`.
+///
+/// This function will exit early from the current process if argument parsing was unsuccessful or if information like `--help` was requested.
+/// Error messages will be printed to stderr, and `--help` output to stdout.
+pub fn from_env<T>() -> T
+where T: TopLevelCommand {
+    argp::parse_args_or_exit::<ArgsOrVersion<T>>(argp::DEFAULT).0
+}

objdiff-cli/src/cmd/diff.rs

@@ -0,0 +1,414 @@
+use std::{
+    io::stdout,
+    mem,
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+    task::{Wake, Waker},
+    time::Duration,
+};
+
+use anyhow::{Context, Result, anyhow, bail};
+use argp::FromArgs;
+use crossterm::{
+    event,
+    event::{DisableMouseCapture, EnableMouseCapture},
+    terminal::{
+        EnterAlternateScreen, LeaveAlternateScreen, SetTitle, disable_raw_mode, enable_raw_mode,
+    },
+};
+use objdiff_core::{
+    build::{
+        BuildConfig, BuildStatus,
+        watcher::{Watcher, create_watcher},
+    },
+    config::{
+        ProjectConfig, ProjectObject, ProjectObjectMetadata, ProjectOptions, apply_project_options,
+        build_globset,
+        path::{check_path_buf, platform_path, platform_path_serde_option},
+    },
+    diff::{DiffObjConfig, MappingConfig, ObjectDiff},
+    jobs::{
+        Job, JobQueue, JobResult,
+        objdiff::{ObjDiffConfig, start_build},
+    },
+    obj::{self, Object},
+};
+use ratatui::prelude::*;
+use typed_path::{Utf8PlatformPath, Utf8PlatformPathBuf};
+
+use crate::{
+    cmd::apply_config_args,
+    util::term::crossterm_panic_handler,
+    views::{EventControlFlow, EventResult, UiView, function_diff::FunctionDiffUi},
+};
+
+#[derive(FromArgs, PartialEq, Debug)]
+/// Diff two object files. (Interactive or one-shot mode)
+#[argp(subcommand, name = "diff")]
+pub struct Args {
+    #[argp(option, short = '1', from_str_fn(platform_path))]
+    /// Target object file
+    target: Option<Utf8PlatformPathBuf>,
+    #[argp(option, short = '2', from_str_fn(platform_path))]
+    /// Base object file
+    base: Option<Utf8PlatformPathBuf>,
+    #[argp(option, short = 'p', from_str_fn(platform_path))]
+    /// Project directory
+    project: Option<Utf8PlatformPathBuf>,
+    #[argp(option, short = 'u')]
+    /// Unit name within project
+    unit: Option<String>,
+    #[argp(positional)]
+    /// Function symbol to diff
+    symbol: Option<String>,
+    #[argp(option, short = 'c')]
+    /// Configuration property (key=value)
+    config: Vec<String>,
+}
+
+pub fn run(args: Args) -> Result<()> {
+    let (target_path, base_path, project_config, unit_options) =
+        match (&args.target, &args.base, &args.project, &args.unit) {
+            (Some(_), Some(_), None, None)
+            | (Some(_), None, None, None)
+            | (None, Some(_), None, None) => (args.target.clone(), args.base.clone(), None, None),
+            (None, None, p, u) => {
+                let project = match p {
+                    Some(project) => project.clone(),
+                    _ => check_path_buf(
+                        std::env::current_dir().context("Failed to get the current directory")?,
+                    )
+                    .context("Current directory is not valid UTF-8")?,
+                };
+                let Some((project_config, project_config_info)) =
+                    objdiff_core::config::try_project_config(project.as_ref())
+                else {
+                    bail!("Project config not found in {}", &project)
+                };
+                let project_config = project_config.with_context(|| {
+                    format!("Reading project config {}", project_config_info.path.display())
+                })?;
+                let target_obj_dir = project_config
+                    .target_dir
+                    .as_ref()
+                    .map(|p| project.join(p.with_platform_encoding()));
+                let base_obj_dir = project_config
+                    .base_dir
+                    .as_ref()
+                    .map(|p| project.join(p.with_platform_encoding()));
+                let units = project_config.units.as_deref().unwrap_or_default();
+                let objects = units
+                    .iter()
+                    .enumerate()
+                    .map(|(idx, o)| {
+                        (
+                            ObjectConfig::new(
+                                o,
+                                &project,
+                                target_obj_dir.as_deref(),
+                                base_obj_dir.as_deref(),
+                            ),
+                            idx,
+                        )
+                    })
+                    .collect::<Vec<_>>();
+                let (object, unit_idx) = if let Some(u) = u {
+                    objects
+                        .iter()
+                        .find(|(obj, _)| obj.name == *u)
+                        .map(|(obj, idx)| (obj, *idx))
+                        .ok_or_else(|| anyhow!("Unit not found: {}", u))?
+                } else if let Some(symbol_name) = &args.symbol {
+                    let mut idx = None;
+                    let mut count = 0usize;
+                    for (i, (obj, unit_idx)) in objects.iter().enumerate() {
+                        if obj
+                            .target_path
+                            .as_deref()
+                            .map(|o| obj::read::has_function(o.as_ref(), symbol_name))
+                            .transpose()?
+                            .unwrap_or(false)
+                        {
+                            idx = Some((i, *unit_idx));
+                            count += 1;
+                            if count > 1 {
+                                break;
+                            }
+                        }
+                    }
+                    match (count, idx) {
+                        (0, None) => bail!("Symbol not found: {}", symbol_name),
+                        (1, Some((i, unit_idx))) => (&objects[i].0, unit_idx),
+                        (2.., Some(_)) => bail!(
+                            "Multiple instances of {} were found, try specifying a unit",
+                            symbol_name
+                        ),
+                        _ => unreachable!(),
+                    }
+                } else {
+                    bail!("Must specify one of: symbol, project and unit, target and base objects")
+                };
+                let unit_options = units.get(unit_idx).and_then(|u| u.options().cloned());
+                let target_path = object.target_path.clone();
+                let base_path = object.base_path.clone();
+                (target_path, base_path, Some(project_config), unit_options)
+            }
+            _ => bail!("Either target and base or project and unit must be specified"),
+        };
+
+    run_interactive(args, target_path, base_path, project_config, unit_options)
+}
+
+fn build_config_from_args(
+    args: &Args,
+    project_config: Option<&ProjectConfig>,
+    unit_options: Option<&ProjectOptions>,
+) -> Result<(DiffObjConfig, MappingConfig)> {
+    let mut diff_config = DiffObjConfig::default();
+    if let Some(options) = project_config.and_then(|config| config.options.as_ref()) {
+        apply_project_options(&mut diff_config, options)?;
+    }
+    if let Some(options) = unit_options {
+        apply_project_options(&mut diff_config, options)?;
+    }
+    apply_config_args(&mut diff_config, &args.config)?;
+    Ok((diff_config, MappingConfig::default()))
+}
+
+pub struct AppState {
+    pub jobs: JobQueue,
+    pub waker: Arc<TermWaker>,
+    pub project_dir: Option<Utf8PlatformPathBuf>,
+    pub project_config: Option<ProjectConfig>,
+    pub target_path: Option<Utf8PlatformPathBuf>,
+    pub base_path: Option<Utf8PlatformPathBuf>,
+    pub left_status: Option<BuildStatus>,
+    pub right_status: Option<BuildStatus>,
+    pub left_obj: Option<(Object, ObjectDiff)>,
+    pub right_obj: Option<(Object, ObjectDiff)>,
+    pub prev_obj: Option<(Object, ObjectDiff)>,
+    pub reload_time: Option<time::OffsetDateTime>,
+    pub time_format: Vec<time::format_description::FormatItem<'static>>,
+    pub watcher: Option<Watcher>,
+    pub modified: Arc<AtomicBool>,
+    pub diff_obj_config: DiffObjConfig,
+    pub mapping_config: MappingConfig,
+}
+
+fn create_objdiff_config(state: &AppState) -> ObjDiffConfig {
+    ObjDiffConfig {
+        build_config: BuildConfig {
+            project_dir: state.project_dir.clone(),
+            custom_make: state
+                .project_config
+                .as_ref()
+                .and_then(|c| c.custom_make.as_ref())
+                .cloned(),
+            custom_args: state
+                .project_config
+                .as_ref()
+                .and_then(|c| c.custom_args.as_ref())
+                .cloned(),
+            selected_wsl_distro: None,
+        },
+        build_base: state.project_config.as_ref().is_some_and(|p| p.build_base.unwrap_or(true)),
+        build_target: state
+            .project_config
+            .as_ref()
+            .is_some_and(|p| p.build_target.unwrap_or(false)),
+        target_path: state.target_path.clone(),
+        base_path: state.base_path.clone(),
+        diff_obj_config: state.diff_obj_config.clone(),
+        mapping_config: state.mapping_config.clone(),
+    }
+}
+
+/// The configuration for a single object file.
+#[derive(Default, Clone, serde::Deserialize, serde::Serialize)]
+pub struct ObjectConfig {
+    pub name: String,
+    #[serde(default, with = "platform_path_serde_option")]
+    pub target_path: Option<Utf8PlatformPathBuf>,
+    #[serde(default, with = "platform_path_serde_option")]
+    pub base_path: Option<Utf8PlatformPathBuf>,
+    pub metadata: ProjectObjectMetadata,
+    pub complete: Option<bool>,
+}
+
+impl ObjectConfig {
+    pub fn new(
+        object: &ProjectObject,
+        project_dir: &Utf8PlatformPath,
+        target_obj_dir: Option<&Utf8PlatformPath>,
+        base_obj_dir: Option<&Utf8PlatformPath>,
+    ) -> Self {
+        let target_path = if let (Some(target_obj_dir), Some(path), None) =
+            (target_obj_dir, &object.path, &object.target_path)
+        {
+            Some(target_obj_dir.join(path.with_platform_encoding()))
+        } else {
+            object.target_path.as_ref().map(|path| project_dir.join(path.with_platform_encoding()))
+        };
+        let base_path = if let (Some(base_obj_dir), Some(path), None) =
+            (base_obj_dir, &object.path, &object.base_path)
+        {
+            Some(base_obj_dir.join(path.with_platform_encoding()))
+        } else {
+            object.base_path.as_ref().map(|path| project_dir.join(path.with_platform_encoding()))
+        };
+        Self {
+            name: object.name().to_string(),
+            target_path,
+            base_path,
+            metadata: object.metadata.clone().unwrap_or_default(),
+            complete: object.complete(),
+        }
+    }
+}
+
+impl AppState {
+    fn reload(&mut self) -> Result<()> {
+        let config = create_objdiff_config(self);
+        self.jobs.push_once(Job::ObjDiff, || start_build(Waker::from(self.waker.clone()), config));
+        Ok(())
+    }
+
+    fn check_jobs(&mut self) -> Result<bool> {
+        let mut redraw = false;
+        self.jobs.collect_results();
+        for result in mem::take(&mut self.jobs.results) {
+            match result {
+                JobResult::None => unreachable!("Unexpected JobResult::None"),
+                JobResult::ObjDiff(result) => {
+                    let result = result.unwrap();
+                    self.left_status = Some(result.first_status);
+                    self.right_status = Some(result.second_status);
+                    self.left_obj = result.first_obj;
+                    self.right_obj = result.second_obj;
+                    self.reload_time = Some(result.time);
+                    redraw = true;
+                }
+                JobResult::CheckUpdate(_) => todo!("CheckUpdate"),
+                JobResult::Update(_) => todo!("Update"),
+                JobResult::CreateScratch(_) => todo!("CreateScratch"),
+            }
+        }
+        Ok(redraw)
+    }
+}
+
+#[derive(Default)]
+pub struct TermWaker(pub AtomicBool);
+
+impl Wake for TermWaker {
+    fn wake(self: Arc<Self>) { self.0.store(true, Ordering::Relaxed); }
+
+    fn wake_by_ref(self: &Arc<Self>) { self.0.store(true, Ordering::Relaxed); }
+}
+
+fn run_interactive(
+    args: Args,
+    target_path: Option<Utf8PlatformPathBuf>,
+    base_path: Option<Utf8PlatformPathBuf>,
+    project_config: Option<ProjectConfig>,
+    unit_options: Option<ProjectOptions>,
+) -> Result<()> {
+    let Some(symbol_name) = &args.symbol else { bail!("Interactive mode requires a symbol name") };
+    let time_format = time::format_description::parse_borrowed::<2>("[hour]:[minute]:[second]")
+        .context("Failed to parse time format")?;
+    let (diff_obj_config, mapping_config) =
+        build_config_from_args(&args, project_config.as_ref(), unit_options.as_ref())?;
+    let mut state = AppState {
+        jobs: Default::default(),
+        waker: Default::default(),
+        project_dir: args.project.clone(),
+        project_config,
+        target_path,
+        base_path,
+        left_status: None,
+        right_status: None,
+        left_obj: None,
+        right_obj: None,
+        prev_obj: None,
+        reload_time: None,
+        time_format,
+        watcher: None,
+        modified: Default::default(),
+        diff_obj_config,
+        mapping_config,
+    };
+    if let (Some(project_dir), Some(project_config)) = (&state.project_dir, &state.project_config) {
+        let watch_patterns = project_config.build_watch_patterns()?;
+        let ignore_patterns = project_config.build_ignore_patterns()?;
+        state.watcher = Some(create_watcher(
+            state.modified.clone(),
+            project_dir.as_ref(),
+            build_globset(&watch_patterns)?,
+            build_globset(&ignore_patterns)?,
+            Waker::from(state.waker.clone()),
+        )?);
+    }
+    let mut view: Box<dyn UiView> =
+        Box::new(FunctionDiffUi { symbol_name: symbol_name.clone(), ..Default::default() });
+    state.reload()?;
+
+    crossterm_panic_handler();
+    enable_raw_mode()?;
+    crossterm::queue!(
+        stdout(),
+        EnterAlternateScreen,
+        EnableMouseCapture,
+        SetTitle(format!("{symbol_name} - objdiff")),
+    )?;
+    let backend = CrosstermBackend::new(stdout());
+    let mut terminal = Terminal::new(backend)?;
+
+    let mut result = EventResult { redraw: true, ..Default::default() };
+    'outer: loop {
+        if result.redraw {
+            terminal.draw(|f| {
+                loop {
+                    result.redraw = false;
+                    view.draw(&state, f, &mut result);
+                    result.click_xy = None;
+                    if !result.redraw {
+                        break;
+                    }
+                    // Clear buffer on redraw
+                    f.buffer_mut().reset();
+                }
+            })?;
+        }
+        loop {
+            if event::poll(Duration::from_millis(100))? {
+                match view.handle_event(&mut state, event::read()?) {
+                    EventControlFlow::Break => break 'outer,
+                    EventControlFlow::Continue(r) => result = r,
+                    EventControlFlow::Reload => {
+                        state.reload()?;
+                        result.redraw = true;
+                    }
+                }
+                break;
+            } else if state.waker.0.swap(false, Ordering::Relaxed) {
+                if state.modified.swap(false, Ordering::Relaxed) {
+                    state.reload()?;
+                }
+                result.redraw = true;
+                break;
+            }
+        }
+        if state.check_jobs()? {
+            result.redraw = true;
+            view.reload(&state)?;
+        }
+    }
+
+    // Reset terminal
+    disable_raw_mode()?;
+    crossterm::execute!(stdout(), LeaveAlternateScreen, DisableMouseCapture)?;
+    terminal.show_cursor()?;
+    Ok(())
+}

objdiff-cli/src/cmd/mod.rs

@@ -0,0 +1,33 @@
+pub mod diff;
+pub mod report;
+
+use std::str::FromStr;
+
+use anyhow::{Context, Result, anyhow};
+use objdiff_core::diff::{ConfigEnum, ConfigPropertyId, ConfigPropertyKind, DiffObjConfig};
+
+pub fn apply_config_args(diff_config: &mut DiffObjConfig, args: &[String]) -> Result<()> {
+    for config in args {
+        let (key, value) = config.split_once('=').context("--config expects \"key=value\"")?;
+        let property_id = ConfigPropertyId::from_str(key)
+            .map_err(|()| anyhow!("Invalid configuration property: {}", key))?;
+        diff_config.set_property_value_str(property_id, value).map_err(|()| {
+            let mut options = String::new();
+            match property_id.kind() {
+                ConfigPropertyKind::Boolean => {
+                    options = "true, false".to_string();
+                }
+                ConfigPropertyKind::Choice(variants) => {
+                    for (i, variant) in variants.iter().enumerate() {
+                        if i > 0 {
+                            options.push_str(", ");
+                        }
+                        options.push_str(variant.value);
+                    }
+                }
+            }
+            anyhow!("Invalid value for {}. Expected one of: {}", property_id.name(), options)
+        })?;
+    }
+    Ok(())
+}

objdiff-cli/src/cmd/report.rs

@@ -0,0 +1,478 @@
+use std::{collections::HashSet, fs::File, io::Read, time::Instant};
+
+use anyhow::{Context, Result, bail};
+use argp::FromArgs;
+use objdiff_core::{
+    bindings::report::{
+        ChangeItem, ChangeItemInfo, ChangeUnit, Changes, ChangesInput, Measures, REPORT_VERSION,
+        Report, ReportCategory, ReportItem, ReportItemMetadata, ReportUnit, ReportUnitMetadata,
+    },
+    config::{ProjectObject, ProjectOptions, apply_project_options, path::platform_path},
+    diff,
+    obj::{self, SectionKind, SymbolFlag, SymbolKind},
+};
+use prost::Message;
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+use tracing::{info, warn};
+use typed_path::{Utf8PlatformPath, Utf8PlatformPathBuf};
+
+use crate::{
+    cmd::{apply_config_args, diff::ObjectConfig},
+    util::output::{OutputFormat, write_output},
+};
+
+#[derive(FromArgs, PartialEq, Debug)]
+/// Generate a progress report for a project.
+#[argp(subcommand, name = "report")]
+pub struct Args {
+    #[argp(subcommand)]
+    command: SubCommand,
+}
+
+#[derive(FromArgs, PartialEq, Debug)]
+#[argp(subcommand)]
+pub enum SubCommand {
+    Generate(GenerateArgs),
+    Changes(ChangesArgs),
+}
+
+#[derive(FromArgs, PartialEq, Debug)]
+/// Generate a progress report for a project.
+#[argp(subcommand, name = "generate")]
+pub struct GenerateArgs {
+    #[argp(option, short = 'p', from_str_fn(platform_path))]
+    /// Project directory
+    project: Option<Utf8PlatformPathBuf>,
+    #[argp(option, short = 'o', from_str_fn(platform_path))]
+    /// Output file
+    output: Option<Utf8PlatformPathBuf>,
+    #[argp(switch, short = 'd')]
+    /// Deduplicate global and weak symbols (runs single-threaded)
+    deduplicate: bool,
+    #[argp(option, short = 'f')]
+    /// Output format (json, json-pretty, proto) (default: json)
+    format: Option<String>,
+    #[argp(option, short = 'c')]
+    /// Configuration property (key=value)
+    config: Vec<String>,
+}
+
+#[derive(FromArgs, PartialEq, Debug)]
+/// List any changes from a previous report.
+#[argp(subcommand, name = "changes")]
+pub struct ChangesArgs {
+    #[argp(positional, from_str_fn(platform_path))]
+    /// Previous report file
+    previous: Utf8PlatformPathBuf,
+    #[argp(positional, from_str_fn(platform_path))]
+    /// Current report file
+    current: Utf8PlatformPathBuf,
+    #[argp(option, short = 'o', from_str_fn(platform_path))]
+    /// Output file
+    output: Option<Utf8PlatformPathBuf>,
+    #[argp(option, short = 'f')]
+    /// Output format (json, json-pretty, proto) (default: json)
+    format: Option<String>,
+}
+
+pub fn run(args: Args) -> Result<()> {
+    match args.command {
+        SubCommand::Generate(args) => generate(args),
+        SubCommand::Changes(args) => changes(args),
+    }
+}
+
+fn generate(args: GenerateArgs) -> Result<()> {
+    let base_diff_config = diff::DiffObjConfig {
+        function_reloc_diffs: diff::FunctionRelocDiffs::None,
+        combine_data_sections: true,
+        combine_text_sections: true,
+        ppc_calculate_pool_relocations: false,
+        ..Default::default()
+    };
+
+    let output_format = OutputFormat::from_option(args.format.as_deref())?;
+    let project_dir = args.project.as_deref().unwrap_or_else(|| Utf8PlatformPath::new("."));
+    info!("Loading project {}", project_dir);
+
+    let project = match objdiff_core::config::try_project_config(project_dir.as_ref()) {
+        Some((Ok(config), _)) => config,
+        Some((Err(err), _)) => bail!("Failed to load project configuration: {}", err),
+        None => bail!("No project configuration found"),
+    };
+    let target_obj_dir =
+        project.target_dir.as_ref().map(|p| project_dir.join(p.with_platform_encoding()));
+    let base_obj_dir =
+        project.base_dir.as_ref().map(|p| project_dir.join(p.with_platform_encoding()));
+    let project_units = project.units.as_deref().unwrap_or_default();
+    let objects = project_units
+        .iter()
+        .enumerate()
+        .map(|(idx, o)| {
+            (
+                ObjectConfig::new(
+                    o,
+                    project_dir,
+                    target_obj_dir.as_deref(),
+                    base_obj_dir.as_deref(),
+                ),
+                idx,
+            )
+        })
+        .collect::<Vec<_>>();
+    info!(
+        "Generating report for {} units (using {} threads)",
+        objects.len(),
+        if args.deduplicate { 1 } else { rayon::current_num_threads() }
+    );
+
+    let start = Instant::now();
+    let mut units = vec![];
+    let mut existing_functions: HashSet<String> = HashSet::new();
+    if args.deduplicate {
+        // If deduplicating, we need to run single-threaded
+        for (object, unit_idx) in &objects {
+            let diff_config = build_unit_diff_config(
+                &base_diff_config,
+                project.options.as_ref(),
+                project_units.get(*unit_idx).and_then(ProjectObject::options),
+                &args.config,
+            )?;
+            if let Some(unit) = report_object(object, &diff_config, Some(&mut existing_functions))?
+            {
+                units.push(unit);
+            }
+        }
+    } else {
+        let vec = objects
+            .par_iter()
+            .map(|(object, unit_idx)| {
+                let diff_config = build_unit_diff_config(
+                    &base_diff_config,
+                    project.options.as_ref(),
+                    project_units.get(*unit_idx).and_then(ProjectObject::options),
+                    &args.config,
+                )?;
+                report_object(object, &diff_config, None)
+            })
+            .collect::<Result<Vec<Option<ReportUnit>>>>()?;
+        units = vec.into_iter().flatten().collect();
+    }
+    let measures = units.iter().flat_map(|u| u.measures.into_iter()).collect();
+    let mut categories = Vec::new();
+    for category in project.progress_categories() {
+        categories.push(ReportCategory {
+            id: category.id.clone(),
+            name: category.name.clone(),
+            measures: Some(Default::default()),
+        });
+    }
+    let mut report =
+        Report { measures: Some(measures), units, version: REPORT_VERSION, categories };
+    report.calculate_progress_categories();
+    let duration = start.elapsed();
+    info!("Report generated in {}.{:03}s", duration.as_secs(), duration.subsec_millis());
+    write_output(&report, args.output.as_deref(), output_format)?;
+    Ok(())
+}
+
+fn build_unit_diff_config(
+    base: &diff::DiffObjConfig,
+    project_options: Option<&ProjectOptions>,
+    unit_options: Option<&ProjectOptions>,
+    cli_args: &[String],
+) -> Result<diff::DiffObjConfig> {
+    let mut diff_config = base.clone();
+    if let Some(options) = project_options {
+        apply_project_options(&mut diff_config, options)?;
+    }
+    if let Some(options) = unit_options {
+        apply_project_options(&mut diff_config, options)?;
+    }
+    // CLI args override project and unit options
+    apply_config_args(&mut diff_config, cli_args)?;
+    Ok(diff_config)
+}
+
+fn report_object(
+    object: &ObjectConfig,
+    diff_config: &diff::DiffObjConfig,
+    mut existing_functions: Option<&mut HashSet<String>>,
+) -> Result<Option<ReportUnit>> {
+    match (&object.target_path, &object.base_path) {
+        (None, Some(_)) if !object.complete.unwrap_or(false) => {
+            warn!("Skipping object without target: {}", object.name);
+            return Ok(None);
+        }
+        (None, None) => {
+            warn!("Skipping object without target or base: {}", object.name);
+            return Ok(None);
+        }
+        _ => {}
+    }
+    let mapping_config = diff::MappingConfig::default();
+    let target = object
+        .target_path
+        .as_ref()
+        .map(|p| {
+            obj::read::read(p.as_ref(), diff_config, diff::DiffSide::Target)
+                .with_context(|| format!("Failed to open {p}"))
+        })
+        .transpose()?;
+    let base = object
+        .base_path
+        .as_ref()
+        .map(|p| {
+            obj::read::read(p.as_ref(), diff_config, diff::DiffSide::Base)
+                .with_context(|| format!("Failed to open {p}"))
+        })
+        .transpose()?;
+    let result =
+        diff::diff_objs(target.as_ref(), base.as_ref(), None, diff_config, &mapping_config)?;
+
+    let metadata = ReportUnitMetadata {
+        complete: object.metadata.complete,
+        module_name: target
+            .as_ref()
+            .and_then(|o| o.split_meta.as_ref())
+            .and_then(|m| m.module_name.clone()),
+        module_id: target.as_ref().and_then(|o| o.split_meta.as_ref()).and_then(|m| m.module_id),
+        source_path: object.metadata.source_path.as_ref().map(|p| p.to_string()),
+        progress_categories: object.metadata.progress_categories.clone().unwrap_or_default(),
+        auto_generated: object.metadata.auto_generated,
+    };
+    let mut measures = Measures { total_units: 1, ..Default::default() };
+    let mut sections = vec![];
+    let mut functions = vec![];
+
+    let obj = target.as_ref().or(base.as_ref()).unwrap();
+    let obj_diff = result.left.as_ref().or(result.right.as_ref()).unwrap();
+    for ((section_idx, section), section_diff) in
+        obj.sections.iter().enumerate().zip(&obj_diff.sections)
+    {
+        if section.kind == SectionKind::Unknown {
+            continue;
+        }
+        let section_match_percent = section_diff.match_percent.unwrap_or_else(|| {
+            // Support cases where we don't have a target object,
+            // assume complete means 100% match
+            if object.complete.unwrap_or(false) { 100.0 } else { 0.0 }
+        });
+        sections.push(ReportItem {
+            name: section.name.clone(),
+            fuzzy_match_percent: section_match_percent,
+            size: section.size,
+            metadata: Some(ReportItemMetadata {
+                demangled_name: None,
+                virtual_address: section.virtual_address,
+            }),
+            address: None,
+        });
+
+        match section.kind {
+            SectionKind::Data | SectionKind::Bss => {
+                measures.total_data += section.size;
+                if section_match_percent == 100.0 {
+                    measures.matched_data += section.size;
+                }
+                continue;
+            }
+            _ => {}
+        }
+
+        for (symbol, symbol_diff) in obj.symbols.iter().zip(&obj_diff.symbols) {
+            if symbol.section != Some(section_idx)
+                || symbol.size == 0
+                || symbol.flags.contains(SymbolFlag::Hidden)
+                || symbol.flags.contains(SymbolFlag::Ignored)
+                || symbol.kind == SymbolKind::Section
+            {
+                continue;
+            }
+            if let Some(existing_functions) = &mut existing_functions
+                && (symbol.flags.contains(SymbolFlag::Global)
+                    || symbol.flags.contains(SymbolFlag::Weak))
+                && !existing_functions.insert(symbol.name.clone())
+            {
+                continue;
+            }
+            let match_percent = symbol_diff.match_percent.unwrap_or_else(|| {
+                // Support cases where we don't have a target object,
+                // assume complete means 100% match
+                if object.complete.unwrap_or(false) { 100.0 } else { 0.0 }
+            });
+            measures.fuzzy_match_percent += match_percent * symbol.size as f32;
+            measures.total_code += symbol.size;
+            if match_percent == 100.0 {
+                measures.matched_code += symbol.size;
+            }
+            functions.push(ReportItem {
+                name: symbol.name.clone(),
+                size: symbol.size,
+                fuzzy_match_percent: match_percent,
+                metadata: Some(ReportItemMetadata {
+                    demangled_name: symbol.demangled_name.clone(),
+                    virtual_address: symbol.virtual_address,
+                }),
+                address: symbol.address.checked_sub(section.address),
+            });
+            if match_percent == 100.0 {
+                measures.matched_functions += 1;
+            }
+            measures.total_functions += 1;
+        }
+    }
+    sections.sort_by(|a, b| a.name.cmp(&b.name));
+    let reverse_fn_order = object.metadata.reverse_fn_order.unwrap_or(false);
+    functions.sort_by(|a, b| {
+        if reverse_fn_order {
+            b.address.unwrap_or(0).cmp(&a.address.unwrap_or(0))
+        } else {
+            a.address.unwrap_or(u64::MAX).cmp(&b.address.unwrap_or(u64::MAX))
+        }
+        .then_with(|| a.size.cmp(&b.size))
+    });
+    if metadata.complete.unwrap_or(false) {
+        measures.complete_code = measures.total_code;
+        measures.complete_data = measures.total_data;
+        measures.complete_units = 1;
+    }
+    measures.calc_fuzzy_match_percent();
+    measures.calc_matched_percent();
+    Ok(Some(ReportUnit {
+        name: object.name.clone(),
+        measures: Some(measures),
+        sections,
+        functions,
+        metadata: Some(metadata),
+    }))
+}
+
+fn changes(args: ChangesArgs) -> Result<()> {
+    let output_format = OutputFormat::from_option(args.format.as_deref())?;
+    let (previous, current) = if args.previous == "-" && args.current == "-" {
+        // Special case for comparing two reports from stdin
+        let mut data = vec![];
+        std::io::stdin().read_to_end(&mut data)?;
+        let input = ChangesInput::decode(data.as_slice())?;
+        (input.from.unwrap(), input.to.unwrap())
+    } else {
+        let previous = read_report(&args.previous)?;
+        let current = read_report(&args.current)?;
+        (previous, current)
+    };
+    let mut changes = Changes { from: previous.measures, to: current.measures, units: vec![] };
+    for prev_unit in &previous.units {
+        let curr_unit = current.units.iter().find(|u| u.name == prev_unit.name);
+        let sections = process_items(prev_unit, curr_unit, |u| &u.sections);
+        let functions = process_items(prev_unit, curr_unit, |u| &u.functions);
+
+        let prev_measures = prev_unit.measures;
+        let curr_measures = curr_unit.and_then(|u| u.measures);
+        if !functions.is_empty() || prev_measures != curr_measures {
+            changes.units.push(ChangeUnit {
+                name: prev_unit.name.clone(),
+                from: prev_measures,
+                to: curr_measures,
+                sections,
+                functions,
+                metadata: curr_unit
+                    .as_ref()
+                    .and_then(|u| u.metadata.clone())
+                    .or_else(|| prev_unit.metadata.clone()),
+            });
+        }
+    }
+    for curr_unit in &current.units {
+        if !previous.units.iter().any(|u| u.name == curr_unit.name) {
+            changes.units.push(ChangeUnit {
+                name: curr_unit.name.clone(),
+                from: None,
+                to: curr_unit.measures,
+                sections: process_new_items(&curr_unit.sections),
+                functions: process_new_items(&curr_unit.functions),
+                metadata: curr_unit.metadata.clone(),
+            });
+        }
+    }
+    write_output(&changes, args.output.as_deref(), output_format)?;
+    Ok(())
+}
+
+fn process_items<F: Fn(&ReportUnit) -> &Vec<ReportItem>>(
+    prev_unit: &ReportUnit,
+    curr_unit: Option<&ReportUnit>,
+    getter: F,
+) -> Vec<ChangeItem> {
+    let prev_items = getter(prev_unit);
+    let mut items = vec![];
+    if let Some(curr_unit) = curr_unit {
+        let curr_items = getter(curr_unit);
+        for prev_func in prev_items {
+            let prev_func_info = ChangeItemInfo::from(prev_func);
+            let curr_func = curr_items.iter().find(|f| f.name == prev_func.name);
+            let curr_func_info = curr_func.map(ChangeItemInfo::from);
+            if let Some(curr_func_info) = curr_func_info {
+                if prev_func_info != curr_func_info {
+                    items.push(ChangeItem {
+                        name: prev_func.name.clone(),
+                        from: Some(prev_func_info),
+                        to: Some(curr_func_info),
+                        metadata: curr_func.as_ref().unwrap().metadata.clone(),
+                    });
+                }
+            } else {
+                items.push(ChangeItem {
+                    name: prev_func.name.clone(),
+                    from: Some(prev_func_info),
+                    to: None,
+                    metadata: prev_func.metadata.clone(),
+                });
+            }
+        }
+        for curr_func in curr_items {
+            if !prev_items.iter().any(|f| f.name == curr_func.name) {
+                items.push(ChangeItem {
+                    name: curr_func.name.clone(),
+                    from: None,
+                    to: Some(ChangeItemInfo::from(curr_func)),
+                    metadata: curr_func.metadata.clone(),
+                });
+            }
+        }
+    } else {
+        for prev_func in prev_items {
+            items.push(ChangeItem {
+                name: prev_func.name.clone(),
+                from: Some(ChangeItemInfo::from(prev_func)),
+                to: None,
+                metadata: prev_func.metadata.clone(),
+            });
+        }
+    }
+    items
+}
+
+fn process_new_items(items: &[ReportItem]) -> Vec<ChangeItem> {
+    items
+        .iter()
+        .map(|item| ChangeItem {
+            name: item.name.clone(),
+            from: None,
+            to: Some(ChangeItemInfo::from(item)),
+            metadata: item.metadata.clone(),
+        })
+        .collect()
+}
+
+fn read_report(path: &Utf8PlatformPath) -> Result<Report> {
+    if path == Utf8PlatformPath::new("-") {
+        let mut data = vec![];
+        std::io::stdin().read_to_end(&mut data)?;
+        return Report::parse(&data).with_context(|| "Failed to load report from stdin");
+    }
+    let file = File::open(path).with_context(|| format!("Failed to open {path}"))?;
+    let mmap =
+        unsafe { memmap2::Mmap::map(&file) }.with_context(|| format!("Failed to map {path}"))?;
+    Report::parse(mmap.as_ref()).with_context(|| format!("Failed to load report {path}"))
+}

objdiff-cli/src/main.rs

@@ -0,0 +1,150 @@
+#![allow(clippy::too_many_arguments)]
+
+mod argp_version;
+mod cmd;
+mod util;
+mod views;
+
+// musl's allocator is very slow, so use mimalloc when targeting musl.
+// Otherwise, use the system allocator to avoid extra code size.
+#[cfg(target_env = "musl")]
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+use std::{env, ffi::OsStr, fmt::Display, path::PathBuf, str::FromStr};
+
+use anyhow::{Error, Result};
+use argp::{FromArgValue, FromArgs};
+use enable_ansi_support::enable_ansi_support;
+use supports_color::Stream;
+use tracing_subscriber::{EnvFilter, filter::LevelFilter};
+
+#[derive(Debug, Eq, PartialEq, Copy, Clone)]
+enum LogLevel {
+    Error,
+    Warn,
+    Info,
+    Debug,
+    Trace,
+}
+
+impl FromStr for LogLevel {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
+            "error" => Self::Error,
+            "warn" => Self::Warn,
+            "info" => Self::Info,
+            "debug" => Self::Debug,
+            "trace" => Self::Trace,
+            _ => return Err(()),
+        })
+    }
+}
+
+impl Display for LogLevel {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            LogLevel::Error => "error",
+            LogLevel::Warn => "warn",
+            LogLevel::Info => "info",
+            LogLevel::Debug => "debug",
+            LogLevel::Trace => "trace",
+        })
+    }
+}
+
+impl FromArgValue for LogLevel {
+    fn from_arg_value(value: &OsStr) -> Result<Self, String> {
+        String::from_arg_value(value)
+            .and_then(|s| Self::from_str(&s).map_err(|_| "Invalid log level".to_string()))
+    }
+}
+
+#[derive(FromArgs, PartialEq, Debug)]
+/// A local diffing tool for decompilation projects.
+struct TopLevel {
+    #[argp(subcommand)]
+    command: SubCommand,
+    #[argp(option, short = 'C')]
+    /// Change working directory.
+    chdir: Option<PathBuf>,
+    #[argp(option, short = 'L')]
+    /// Minimum logging level. (Default: info)
+    /// Possible values: error, warn, info, debug, trace
+    log_level: Option<LogLevel>,
+    /// Print version information and exit.
+    #[argp(switch, short = 'V')]
+    version: bool,
+    /// Disable color output. (env: NO_COLOR)
+    #[argp(switch)]
+    no_color: bool,
+}
+
+#[derive(FromArgs, PartialEq, Debug)]
+#[argp(subcommand)]
+enum SubCommand {
+    Diff(cmd::diff::Args),
+    Report(cmd::report::Args),
+}
+
+// Duplicated from supports-color so we can check early.
+fn env_no_color() -> bool {
+    match env::var("NO_COLOR").as_deref() {
+        Ok("") | Ok("0") | Err(_) => false,
+        Ok(_) => true,
+    }
+}
+
+fn main() {
+    let args: TopLevel = argp_version::from_env();
+    let use_colors = if args.no_color || env_no_color() {
+        false
+    } else {
+        // Try to enable ANSI support on Windows.
+        let _ = enable_ansi_support();
+        // Disable isatty check for supports-color. (e.g. when used with ninja)
+        unsafe { env::set_var("IGNORE_IS_TERMINAL", "1") };
+        supports_color::on(Stream::Stdout).is_some_and(|c| c.has_basic)
+    };
+
+    let format =
+        tracing_subscriber::fmt::format().with_ansi(use_colors).with_target(false).without_time();
+    let builder = tracing_subscriber::fmt().event_format(format).with_writer(std::io::stderr);
+    if let Some(level) = args.log_level {
+        builder
+            .with_max_level(match level {
+                LogLevel::Error => LevelFilter::ERROR,
+                LogLevel::Warn => LevelFilter::WARN,
+                LogLevel::Info => LevelFilter::INFO,
+                LogLevel::Debug => LevelFilter::DEBUG,
+                LogLevel::Trace => LevelFilter::TRACE,
+            })
+            .init();
+    } else {
+        builder
+            .with_env_filter(
+                EnvFilter::builder()
+                    .with_default_directive(LevelFilter::INFO.into())
+                    .from_env_lossy(),
+            )
+            .init();
+    }
+
+    let mut result = Ok(());
+    if let Some(dir) = &args.chdir {
+        result = env::set_current_dir(dir).map_err(|e| {
+            Error::new(e)
+                .context(format!("Failed to change working directory to '{}'", dir.display()))
+        });
+    }
+    result = result.and_then(|_| match args.command {
+        SubCommand::Diff(c_args) => cmd::diff::run(c_args),
+        SubCommand::Report(c_args) => cmd::report::run(c_args),
+    });
+    if let Err(e) = result {
+        eprintln!("Failed: {e:?}");
+        std::process::exit(1);
+    }
+}

objdiff-cli/src/util/mod.rs

@@ -0,0 +1,2 @@
+pub mod output;
+pub mod term;

objdiff-cli/src/util/output.rs

@@ -0,0 +1,87 @@
+use std::{
+    fs::File,
+    io::{BufWriter, Write},
+    ops::DerefMut,
+    path::Path,
+};
+
+use anyhow::{Context, Result, bail};
+use tracing::info;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
+pub enum OutputFormat {
+    #[default]
+    Json,
+    JsonPretty,
+    Proto,
+}
+
+impl OutputFormat {
+    pub fn from_str(s: &str) -> Result<Self> {
+        match s.to_ascii_lowercase().as_str() {
+            "json" => Ok(Self::Json),
+            "json-pretty" | "json_pretty" => Ok(Self::JsonPretty),
+            "binpb" | "pb" | "proto" | "protobuf" => Ok(Self::Proto),
+            _ => bail!("Invalid output format: {}", s),
+        }
+    }
+
+    pub fn from_option(s: Option<&str>) -> Result<Self> {
+        match s {
+            Some(s) => Self::from_str(s),
+            None => Ok(Self::default()),
+        }
+    }
+}
+
+pub fn write_output<T, P>(input: &T, output: Option<P>, format: OutputFormat) -> Result<()>
+where
+    T: serde::Serialize + prost::Message,
+    P: AsRef<Path>,
+{
+    match output.as_ref().map(|p| p.as_ref()) {
+        Some(output) if output != Path::new("-") => {
+            info!("Writing to {}", output.display());
+            let file = File::options()
+                .read(true)
+                .write(true)
+                .create(true)
+                .truncate(true)
+                .open(output)
+                .with_context(|| format!("Failed to create file {}", output.display()))?;
+            match format {
+                OutputFormat::Json => {
+                    let mut output = BufWriter::new(file);
+                    serde_json::to_writer(&mut output, input)
+                        .context("Failed to write output file")?;
+                    output.flush().context("Failed to flush output file")?;
+                }
+                OutputFormat::JsonPretty => {
+                    let mut output = BufWriter::new(file);
+                    serde_json::to_writer_pretty(&mut output, input)
+                        .context("Failed to write output file")?;
+                    output.flush().context("Failed to flush output file")?;
+                }
+                OutputFormat::Proto => {
+                    file.set_len(input.encoded_len() as u64)?;
+                    let map = unsafe { memmap2::Mmap::map(&file) }
+                        .context("Failed to map output file")?;
+                    let mut output = map.make_mut().context("Failed to remap output file")?;
+                    input.encode(&mut output.deref_mut()).context("Failed to encode output")?;
+                }
+            }
+        }
+        _ => match format {
+            OutputFormat::Json => {
+                serde_json::to_writer(std::io::stdout(), input)?;
+            }
+            OutputFormat::JsonPretty => {
+                serde_json::to_writer_pretty(std::io::stdout(), input)?;
+            }
+            OutputFormat::Proto => {
+                std::io::stdout().write_all(&input.encode_to_vec())?;
+            }
+        },
+    }
+    Ok(())
+}

objdiff-cli/src/util/term.rs

@@ -0,0 +1,16 @@
+use std::{io::stdout, panic};
+
+use crossterm::{
+    cursor::Show,
+    event::DisableMouseCapture,
+    terminal::{LeaveAlternateScreen, disable_raw_mode},
+};
+
+pub fn crossterm_panic_handler() {
+    let original_hook = panic::take_hook();
+    panic::set_hook(Box::new(move |panic_info| {
+        let _ = crossterm::execute!(stdout(), LeaveAlternateScreen, DisableMouseCapture, Show);
+        let _ = disable_raw_mode();
+        original_hook(panic_info);
+    }));
+}

objdiff-cli/src/views/function_diff.rs

@@ -0,0 +1,652 @@
+use core::cmp::Ordering;
+
+use anyhow::Result;
+use crossterm::event::{Event, KeyCode, KeyEventKind, KeyModifiers, MouseButton, MouseEventKind};
+use objdiff_core::{
+    build::BuildStatus,
+    diff::{
+        DiffObjConfig, FunctionRelocDiffs, InstructionDiffKind, ObjectDiff, SymbolDiff,
+        display::{DiffText, DiffTextColor, HighlightKind, display_row},
+    },
+    obj::Object,
+};
+use ratatui::{
+    Frame,
+    prelude::*,
+    widgets::{Block, Borders, Clear, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState},
+};
+
+use super::{EventControlFlow, EventResult, UiView};
+use crate::cmd::diff::AppState;
+
+#[allow(dead_code)]
+#[derive(Default)]
+pub struct FunctionDiffUi {
+    pub symbol_name: String,
+    pub left_highlight: HighlightKind,
+    pub right_highlight: HighlightKind,
+    pub scroll_x: usize,
+    pub scroll_state_x: ScrollbarState,
+    pub scroll_y: usize,
+    pub scroll_state_y: ScrollbarState,
+    pub per_page: usize,
+    pub num_rows: usize,
+    pub left_sym: Option<usize>,
+    pub right_sym: Option<usize>,
+    pub prev_sym: Option<usize>,
+    pub open_options: bool,
+    pub three_way: bool,
+}
+
+impl UiView for FunctionDiffUi {
+    fn draw(&mut self, state: &AppState, f: &mut Frame, result: &mut EventResult) {
+        let chunks = Layout::vertical([Constraint::Length(1), Constraint::Fill(1)]).split(f.area());
+        let header_chunks = Layout::horizontal([
+            Constraint::Fill(1),
+            Constraint::Length(3),
+            Constraint::Fill(1),
+            Constraint::Length(2),
+        ])
+        .split(chunks[0]);
+        let content_chunks = if self.three_way {
+            Layout::horizontal([
+                Constraint::Fill(1),
+                Constraint::Length(3),
+                Constraint::Fill(1),
+                Constraint::Length(3),
+                Constraint::Fill(1),
+                Constraint::Length(2),
+            ])
+            .split(chunks[1])
+        } else {
+            Layout::horizontal([
+                Constraint::Fill(1),
+                Constraint::Length(3),
+                Constraint::Fill(1),
+                Constraint::Length(2),
+            ])
+            .split(chunks[1])
+        };
+
+        self.per_page = chunks[1].height.saturating_sub(2) as usize;
+        let max_scroll_y = self.num_rows.saturating_sub(self.per_page);
+        if self.scroll_y > max_scroll_y {
+            self.scroll_y = max_scroll_y;
+        }
+        self.scroll_state_y =
+            self.scroll_state_y.content_length(max_scroll_y).position(self.scroll_y);
+
+        let mut line_l = Line::default();
+        line_l
+            .spans
+            .push(Span::styled(self.symbol_name.clone(), Style::new().fg(Color::White).bold()));
+        f.render_widget(line_l, header_chunks[0]);
+
+        let mut line_r = Line::default();
+        if let Some(percent) = get_symbol(state.right_obj.as_ref(), self.right_sym)
+            .and_then(|(_, _, d)| d.match_percent)
+        {
+            line_r.spans.push(Span::styled(
+                format!("{percent:.2}% "),
+                Style::new().fg(match_percent_color(percent)),
+            ));
+        }
+        let reload_time = state
+            .reload_time
+            .as_ref()
+            .and_then(|t| t.format(&state.time_format).ok())
+            .unwrap_or_else(|| "N/A".to_string());
+        line_r.spans.push(Span::styled(
+            format!("Last reload: {reload_time}"),
+            Style::new().fg(Color::White),
+        ));
+        line_r.spans.push(Span::styled(
+            format!(" ({} jobs)", state.jobs.jobs.len()),
+            Style::new().fg(Color::LightYellow),
+        ));
+        f.render_widget(line_r, header_chunks[2]);
+
+        let mut left_text = None;
+        let mut left_highlight = None;
+        let mut max_width = 0;
+        if let Some((obj, symbol_idx, symbol_diff)) =
+            get_symbol(state.left_obj.as_ref(), self.left_sym)
+        {
+            let mut text = Text::default();
+            let rect = content_chunks[0].inner(Margin::new(0, 1));
+            left_highlight = self.print_sym(
+                &mut text,
+                obj,
+                symbol_idx,
+                symbol_diff,
+                &state.diff_obj_config,
+                rect,
+                &self.left_highlight,
+                result,
+                false,
+            );
+            max_width = max_width.max(text.width());
+            left_text = Some(text);
+        } else if let Some(status) = &state.left_status {
+            let mut text = Text::default();
+            self.print_build_status(&mut text, status);
+            max_width = max_width.max(text.width());
+            left_text = Some(text);
+        }
+
+        let mut right_text = None;
+        let mut right_highlight = None;
+        let mut margin_text = None;
+        if let Some((obj, symbol_idx, symbol_diff)) =
+            get_symbol(state.right_obj.as_ref(), self.right_sym)
+        {
+            let mut text = Text::default();
+            let rect = content_chunks[2].inner(Margin::new(0, 1));
+            right_highlight = self.print_sym(
+                &mut text,
+                obj,
+                symbol_idx,
+                symbol_diff,
+                &state.diff_obj_config,
+                rect,
+                &self.right_highlight,
+                result,
+                false,
+            );
+            max_width = max_width.max(text.width());
+            right_text = Some(text);
+
+            // Render margin
+            let mut text = Text::default();
+            let rect = content_chunks[1].inner(Margin::new(1, 1));
+            self.print_margin(&mut text, symbol_diff, rect);
+            margin_text = Some(text);
+        } else if let Some(status) = &state.right_status {
+            let mut text = Text::default();
+            self.print_build_status(&mut text, status);
+            max_width = max_width.max(text.width());
+            right_text = Some(text);
+        }
+
+        let mut prev_text = None;
+        let mut prev_margin_text = None;
+        if self.three_way
+            && let Some((obj, symbol_idx, symbol_diff)) =
+                get_symbol(state.prev_obj.as_ref(), self.prev_sym)
+        {
+            let mut text = Text::default();
+            let rect = content_chunks[4].inner(Margin::new(0, 1));
+            self.print_sym(
+                &mut text,
+                obj,
+                symbol_idx,
+                symbol_diff,
+                &state.diff_obj_config,
+                rect,
+                &self.right_highlight,
+                result,
+                true,
+            );
+            max_width = max_width.max(text.width());
+            prev_text = Some(text);
+
+            // Render margin
+            let mut text = Text::default();
+            let rect = content_chunks[3].inner(Margin::new(1, 1));
+            self.print_margin(&mut text, symbol_diff, rect);
+            prev_margin_text = Some(text);
+        }
+
+        let max_scroll_x =
+            max_width.saturating_sub(content_chunks[0].width.min(content_chunks[2].width) as usize);
+        if self.scroll_x > max_scroll_x {
+            self.scroll_x = max_scroll_x;
+        }
+        self.scroll_state_x =
+            self.scroll_state_x.content_length(max_scroll_x).position(self.scroll_x);
+
+        if let Some(text) = left_text {
+            // Render left column
+            f.render_widget(
+                Paragraph::new(text)
+                    .block(
+                        Block::new()
+                            .borders(Borders::TOP)
+                            .border_style(Style::new().fg(Color::Gray))
+                            .title_style(Style::new().bold())
+                            .title("TARGET"),
+                    )
+                    .scroll((0, self.scroll_x as u16)),
+                content_chunks[0],
+            );
+        }
+        if let Some(text) = margin_text {
+            f.render_widget(text, content_chunks[1].inner(Margin::new(1, 1)));
+        }
+        if let Some(text) = right_text {
+            f.render_widget(
+                Paragraph::new(text)
+                    .block(
+                        Block::new()
+                            .borders(Borders::TOP)
+                            .border_style(Style::new().fg(Color::Gray))
+                            .title_style(Style::new().bold())
+                            .title("CURRENT"),
+                    )
+                    .scroll((0, self.scroll_x as u16)),
+                content_chunks[2],
+            );
+        }
+
+        if self.three_way {
+            if let Some(text) = prev_margin_text {
+                f.render_widget(text, content_chunks[3].inner(Margin::new(1, 1)));
+            }
+            let block = Block::new()
+                .borders(Borders::TOP)
+                .border_style(Style::new().fg(Color::Gray))
+                .title_style(Style::new().bold())
+                .title("SAVED");
+            if let Some(text) = prev_text {
+                f.render_widget(
+                    Paragraph::new(text).block(block.clone()).scroll((0, self.scroll_x as u16)),
+                    content_chunks[4],
+                );
+            } else {
+                f.render_widget(block, content_chunks[4]);
+            }
+        }
+
+        // Render scrollbars
+        f.render_stateful_widget(
+            Scrollbar::new(ScrollbarOrientation::VerticalRight).begin_symbol(None).end_symbol(None),
+            chunks[1].inner(Margin::new(0, 1)),
+            &mut self.scroll_state_y,
+        );
+        f.render_stateful_widget(
+            Scrollbar::new(ScrollbarOrientation::HorizontalBottom).thumb_symbol("■"),
+            content_chunks[0],
+            &mut self.scroll_state_x,
+        );
+        f.render_stateful_widget(
+            Scrollbar::new(ScrollbarOrientation::HorizontalBottom).thumb_symbol("■"),
+            content_chunks[2],
+            &mut self.scroll_state_x,
+        );
+        if self.three_way {
+            f.render_stateful_widget(
+                Scrollbar::new(ScrollbarOrientation::HorizontalBottom).thumb_symbol("■"),
+                content_chunks[4],
+                &mut self.scroll_state_x,
+            );
+        }
+
+        if let Some(new_highlight) = left_highlight {
+            if new_highlight == self.left_highlight {
+                if self.left_highlight != self.right_highlight {
+                    self.right_highlight = self.left_highlight.clone();
+                } else {
+                    self.left_highlight = HighlightKind::None;
+                    self.right_highlight = HighlightKind::None;
+                }
+            } else {
+                self.left_highlight = new_highlight;
+            }
+            result.redraw = true;
+        } else if let Some(new_highlight) = right_highlight {
+            if new_highlight == self.right_highlight {
+                if self.left_highlight != self.right_highlight {
+                    self.left_highlight = self.right_highlight.clone();
+                } else {
+                    self.left_highlight = HighlightKind::None;
+                    self.right_highlight = HighlightKind::None;
+                }
+            } else {
+                self.right_highlight = new_highlight;
+            }
+            result.redraw = true;
+        }
+
+        if self.open_options {
+            self.draw_options(f, result);
+        }
+    }
+
+    fn handle_event(&mut self, state: &mut AppState, event: Event) -> EventControlFlow {
+        let mut result = EventResult::default();
+        match event {
+            Event::Key(event)
+                if matches!(event.kind, KeyEventKind::Press | KeyEventKind::Repeat) =>
+            {
+                match event.code {
+                    // Quit
+                    KeyCode::Esc | KeyCode::Char('q') => return EventControlFlow::Break,
+                    // Page up
+                    KeyCode::PageUp => {
+                        self.page_up(false);
+                        result.redraw = true;
+                    }
+                    // Page up (shift + space)
+                    KeyCode::Char(' ') if event.modifiers.contains(KeyModifiers::SHIFT) => {
+                        self.page_up(false);
+                        result.redraw = true;
+                    }
+                    // Page down
+                    KeyCode::Char(' ') | KeyCode::PageDown => {
+                        self.page_down(false);
+                        result.redraw = true;
+                    }
+                    // Page down (ctrl + f)
+                    KeyCode::Char('f') if event.modifiers.contains(KeyModifiers::CONTROL) => {
+                        self.page_down(false);
+                        result.redraw = true;
+                    }
+                    // Page up (ctrl + b)
+                    KeyCode::Char('b') if event.modifiers.contains(KeyModifiers::CONTROL) => {
+                        self.page_up(false);
+                        result.redraw = true;
+                    }
+                    // Half page down (ctrl + d)
+                    KeyCode::Char('d') if event.modifiers.contains(KeyModifiers::CONTROL) => {
+                        self.page_down(true);
+                        result.redraw = true;
+                    }
+                    // Half page up (ctrl + u)
+                    KeyCode::Char('u') if event.modifiers.contains(KeyModifiers::CONTROL) => {
+                        self.page_up(true);
+                        result.redraw = true;
+                    }
+                    // Scroll down
+                    KeyCode::Down | KeyCode::Char('j') => {
+                        self.scroll_y += 1;
+                        result.redraw = true;
+                    }
+                    // Scroll up
+                    KeyCode::Up | KeyCode::Char('k') => {
+                        self.scroll_y = self.scroll_y.saturating_sub(1);
+                        result.redraw = true;
+                    }
+                    // Scroll to start
+                    KeyCode::Char('g') => {
+                        self.scroll_y = 0;
+                        result.redraw = true;
+                    }
+                    // Scroll to end
+                    KeyCode::Char('G') => {
+                        self.scroll_y = self.num_rows;
+                        result.redraw = true;
+                    }
+                    // Reload
+                    KeyCode::Char('r') => {
+                        return EventControlFlow::Reload;
+                    }
+                    // Scroll right
+                    KeyCode::Right | KeyCode::Char('l') => {
+                        self.scroll_x += 1;
+                        result.redraw = true;
+                    }
+                    // Scroll left
+                    KeyCode::Left | KeyCode::Char('h') => {
+                        self.scroll_x = self.scroll_x.saturating_sub(1);
+                        result.redraw = true;
+                    }
+                    // Cycle through function relocation diff mode
+                    KeyCode::Char('x') => {
+                        state.diff_obj_config.function_reloc_diffs =
+                            match state.diff_obj_config.function_reloc_diffs {
+                                FunctionRelocDiffs::None => FunctionRelocDiffs::NameAddress,
+                                FunctionRelocDiffs::NameAddress => FunctionRelocDiffs::DataValue,
+                                FunctionRelocDiffs::DataValue => FunctionRelocDiffs::All,
+                                FunctionRelocDiffs::All => FunctionRelocDiffs::None,
+                            };
+                        return EventControlFlow::Reload;
+                    }
+                    // Toggle three-way diff
+                    KeyCode::Char('3') => {
+                        self.three_way = !self.three_way;
+                        result.redraw = true;
+                    }
+                    // Toggle options
+                    KeyCode::Char('o') => {
+                        self.open_options = !self.open_options;
+                        result.redraw = true;
+                    }
+                    _ => {}
+                }
+            }
+            Event::Mouse(event) => match event.kind {
+                MouseEventKind::ScrollDown => {
+                    self.scroll_y += 3;
+                    result.redraw = true;
+                }
+                MouseEventKind::ScrollUp => {
+                    self.scroll_y = self.scroll_y.saturating_sub(3);
+                    result.redraw = true;
+                }
+                MouseEventKind::ScrollRight => {
+                    self.scroll_x += 3;
+                    result.redraw = true;
+                }
+                MouseEventKind::ScrollLeft => {
+                    self.scroll_x = self.scroll_x.saturating_sub(3);
+                    result.redraw = true;
+                }
+                MouseEventKind::Down(MouseButton::Left) => {
+                    result.click_xy = Some((event.column, event.row));
+                    result.redraw = true;
+                }
+                _ => {}
+            },
+            Event::Resize(_, _) => {
+                result.redraw = true;
+            }
+            _ => {}
+        }
+        EventControlFlow::Continue(result)
+    }
+
+    fn reload(&mut self, state: &AppState) -> Result<()> {
+        let left_sym =
+            state.left_obj.as_ref().and_then(|(o, _)| o.symbol_by_name(&self.symbol_name));
+        let right_sym =
+            state.right_obj.as_ref().and_then(|(o, _)| o.symbol_by_name(&self.symbol_name));
+        let prev_sym =
+            state.prev_obj.as_ref().and_then(|(o, _)| o.symbol_by_name(&self.symbol_name));
+        self.num_rows = match (
+            get_symbol(state.left_obj.as_ref(), left_sym),
+            get_symbol(state.right_obj.as_ref(), right_sym),
+        ) {
+            (Some((_l, _ls, ld)), Some((_r, _rs, rd))) => {
+                ld.instruction_rows.len().max(rd.instruction_rows.len())
+            }
+            (Some((_l, _ls, ld)), None) => ld.instruction_rows.len(),
+            (None, Some((_r, _rs, rd))) => rd.instruction_rows.len(),
+            (None, None) => 0,
+        };
+        self.left_sym = left_sym;
+        self.right_sym = right_sym;
+        self.prev_sym = prev_sym;
+        Ok(())
+    }
+}
+
+impl FunctionDiffUi {
+    pub fn draw_options(&mut self, f: &mut Frame, _result: &mut EventResult) {
+        let percent_x = 50;
+        let percent_y = 50;
+        let popup_rect = Layout::vertical([
+            Constraint::Percentage((100 - percent_y) / 2),
+            Constraint::Percentage(percent_y),
+            Constraint::Percentage((100 - percent_y) / 2),
+        ])
+        .split(f.area())[1];
+        let popup_rect = Layout::horizontal([
+            Constraint::Percentage((100 - percent_x) / 2),
+            Constraint::Percentage(percent_x),
+            Constraint::Percentage((100 - percent_x) / 2),
+        ])
+        .split(popup_rect)[1];
+
+        let popup = Block::default()
+            .borders(Borders::ALL)
+            .title("Options")
+            .title_style(Style::default().fg(Color::White).bg(Color::Black));
+        f.render_widget(Clear, popup_rect);
+        f.render_widget(popup, popup_rect);
+    }
+
+    fn page_up(&mut self, half: bool) {
+        self.scroll_y = self.scroll_y.saturating_sub(self.per_page / if half { 2 } else { 1 });
+    }
+
+    fn page_down(&mut self, half: bool) {
+        self.scroll_y += self.per_page / if half { 2 } else { 1 };
+    }
+
+    fn print_sym(
+        &self,
+        out: &mut Text<'static>,
+        obj: &Object,
+        symbol_index: usize,
+        symbol_diff: &SymbolDiff,
+        diff_config: &DiffObjConfig,
+        rect: Rect,
+        highlight: &HighlightKind,
+        result: &EventResult,
+        only_changed: bool,
+    ) -> Option<HighlightKind> {
+        let mut new_highlight = None;
+        for (y, ins_row) in symbol_diff
+            .instruction_rows
+            .iter()
+            .skip(self.scroll_y)
+            .take(rect.height as usize)
+            .enumerate()
+        {
+            if only_changed && ins_row.kind == InstructionDiffKind::None {
+                out.lines.push(Line::default());
+                continue;
+            }
+            let mut sx = rect.x;
+            let sy = rect.y + y as u16;
+            let mut line = Line::default();
+            display_row(obj, symbol_index, ins_row, diff_config, |segment| {
+                let highlight_kind = HighlightKind::from(&segment.text);
+                let label_text = match segment.text {
+                    DiffText::Basic(text) => text.to_string(),
+                    DiffText::Line(num) => format!("{num} "),
+                    DiffText::Address(addr) => format!("{addr:x}:"),
+                    DiffText::Opcode(mnemonic, _op) => format!("{mnemonic} "),
+                    DiffText::Argument(arg) => arg.to_string(),
+                    DiffText::BranchDest(addr) => format!("{addr:x}"),
+                    DiffText::Symbol(sym) => {
+                        sym.demangled_name.as_ref().unwrap_or(&sym.name).clone()
+                    }
+                    DiffText::Addend(addend) => match addend.cmp(&0i64) {
+                        Ordering::Greater => format!("+{addend:#x}"),
+                        Ordering::Less => format!("-{:#x}", -addend),
+                        _ => String::new(),
+                    },
+                    DiffText::Spacing(n) => {
+                        line.spans.push(Span::raw(" ".repeat(n as usize)));
+                        sx += n as u16;
+                        return Ok(());
+                    }
+                    DiffText::Eol => return Ok(()),
+                };
+
+                let len = label_text.len();
+                let highlighted =
+                    highlight_kind != HighlightKind::None && *highlight == highlight_kind;
+                if let Some((cx, cy)) = result.click_xy
+                    && cx >= sx
+                    && cx < sx + len as u16
+                    && cy == sy
+                {
+                    new_highlight = Some(highlight_kind);
+                }
+                let mut style = Style::new().fg(match segment.color {
+                    DiffTextColor::Normal => Color::Gray,
+                    DiffTextColor::Dim => Color::DarkGray,
+                    DiffTextColor::Bright => Color::White,
+                    DiffTextColor::DataFlow => Color::LightCyan,
+                    DiffTextColor::Replace => Color::Cyan,
+                    DiffTextColor::Delete => Color::Red,
+                    DiffTextColor::Insert => Color::Green,
+                    DiffTextColor::Rotating(i) => COLOR_ROTATION[i as usize % COLOR_ROTATION.len()],
+                });
+                if highlighted {
+                    style = style.bg(Color::DarkGray);
+                }
+                line.spans.push(Span::styled(label_text, style));
+                sx += len as u16;
+                if segment.pad_to as usize > len {
+                    let pad = (segment.pad_to as usize - len) as u16;
+                    line.spans.push(Span::raw(" ".repeat(pad as usize)));
+                    sx += pad;
+                }
+                Ok(())
+            })
+            .unwrap();
+            out.lines.push(line);
+        }
+        new_highlight
+    }
+
+    fn print_margin(&self, out: &mut Text, symbol: &SymbolDiff, rect: Rect) {
+        for ins_row in symbol.instruction_rows.iter().skip(self.scroll_y).take(rect.height as usize)
+        {
+            if ins_row.kind != InstructionDiffKind::None {
+                out.lines.push(Line::raw(match ins_row.kind {
+                    InstructionDiffKind::Delete => "<",
+                    InstructionDiffKind::Insert => ">",
+                    _ => "|",
+                }));
+            } else {
+                out.lines.push(Line::raw(" "));
+            }
+        }
+    }
+
+    fn print_build_status<'a>(&self, out: &mut Text<'a>, status: &'a BuildStatus) {
+        if !status.cmdline.is_empty() {
+            out.lines.push(Line::styled(status.cmdline.clone(), Style::new().fg(Color::LightBlue)));
+        }
+        for line in status.stdout.lines() {
+            out.lines.push(Line::styled(line, Style::new().fg(Color::White)));
+        }
+        for line in status.stderr.lines() {
+            out.lines.push(Line::styled(line, Style::new().fg(Color::Red)));
+        }
+    }
+}
+
+pub const COLOR_ROTATION: [Color; 7] = [
+    Color::Magenta,
+    Color::Cyan,
+    Color::Green,
+    Color::Red,
+    Color::Yellow,
+    Color::Blue,
+    Color::Green,
+];
+
+pub fn match_percent_color(match_percent: f32) -> Color {
+    if match_percent == 100.0 {
+        Color::Green
+    } else if match_percent >= 50.0 {
+        Color::LightBlue
+    } else {
+        Color::LightRed
+    }
+}
+
+#[inline]
+fn get_symbol(
+    obj: Option<&(Object, ObjectDiff)>,
+    sym: Option<usize>,
+) -> Option<(&Object, usize, &SymbolDiff)> {
+    let (obj, diff) = obj?;
+    let sym = sym?;
+    Some((obj, sym, &diff.symbols[sym]))
+}

objdiff-cli/src/views/mod.rs

@@ -0,0 +1,25 @@
+use anyhow::Result;
+use crossterm::event::Event;
+use ratatui::Frame;
+
+use crate::cmd::diff::AppState;
+
+pub mod function_diff;
+
+#[derive(Default)]
+pub struct EventResult {
+    pub redraw: bool,
+    pub click_xy: Option<(u16, u16)>,
+}
+
+pub enum EventControlFlow {
+    Break,
+    Continue(EventResult),
+    Reload,
+}
+
+pub trait UiView {
+    fn draw(&mut self, state: &AppState, f: &mut Frame, result: &mut EventResult);
+    fn handle_event(&mut self, state: &mut AppState, event: Event) -> EventControlFlow;
+    fn reload(&mut self, state: &AppState) -> Result<()>;
+}

objdiff-core/Cargo.toml

@@ -0,0 +1,212 @@
+[package]
+name = "objdiff-core"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+readme = "README.md"
+description = """
+A local diffing tool for decompilation projects.
+"""
+documentation = "https://docs.rs/objdiff-core"
+
+[features]
+default = ["std"]
+all = [
+    # Features
+    "bindings",
+    "build",
+    "config",
+    "dwarf",
+    "serde",
+    # Architectures
+    "arm",
+    "arm64",
+    "mips",
+    "ppc",
+    "x86",
+    "superh"
+]
+# Implicit, used to check if any arch is enabled
+any-arch = [
+    "dep:flagset",
+    "dep:heck",
+    "dep:log",
+    "dep:num-traits",
+    "dep:prettyplease",
+    "dep:proc-macro2",
+    "dep:quote",
+    "dep:regex",
+    "dep:similar",
+    "dep:syn",
+    "dep:encoding_rs",
+    "demangler",
+]
+bindings = [
+    "dep:prost",
+    "dep:prost-build",
+]
+build = [
+    "dep:notify",
+    "dep:notify-debouncer-full",
+    "dep:reqwest",
+    "dep:self_update",
+    "dep:shell-escape",
+    "dep:tempfile",
+    "dep:time",
+    "dep:winapi",
+]
+config = [
+    "dep:globset",
+    "dep:semver",
+    "dep:typed-path",
+]
+dwarf = [
+    "dep:gimli",
+    "dep:typed-arena",
+]
+serde = [
+    "dep:pbjson",
+    "dep:pbjson-build",
+    "dep:serde",
+    "dep:serde_json",
+]
+std = [
+    "anyhow/std",
+    "flagset?/std",
+    "log?/std",
+    "num-traits?/std",
+    "object/std",
+    "prost?/std",
+    "serde?/std",
+    "similar?/std",
+    "typed-arena?/std",
+    "typed-path?/std",
+    "dep:filetime",
+    "dep:memmap2",
+]
+mips = [
+    "any-arch",
+    "dep:rabbitizer",
+]
+ppc = [
+    "any-arch",
+    "dep:cwextab",
+    "dep:powerpc",
+    "dep:rlwinmdec",
+]
+x86 = [
+    "any-arch",
+    "dep:iced-x86",
+]
+arm = [
+    "any-arch",
+    "dep:arm-attr",
+    "dep:unarm",
+]
+arm64 = [
+    "any-arch",
+    "dep:yaxpeax-arch",
+    "dep:yaxpeax-arm",
+]
+superh = [
+    "any-arch",
+]
+demangler = [
+    "dep:cpp_demangle",
+    "dep:cwdemangle",
+    "dep:gnuv2_demangle",
+    "dep:msvc-demangler",
+]
+
+[package.metadata.docs.rs]
+features = ["all"]
+
+[dependencies]
+anyhow = { version = "1.0", default-features = false }
+filetime = { version = "0.2", optional = true }
+flagset = { version = "0.4", default-features = false, optional = true }
+itertools = { version = "0.14", default-features = false, features = ["use_alloc"] }
+log = { version = "0.4", default-features = false, optional = true }
+memmap2 = { version = "0.9", optional = true }
+num-traits = { version = "0.2", default-features = false, optional = true }
+object = { version = "0.37", default-features = false, features = ["read_core", "elf", "coff"] }
+pbjson = { version = "0.8", default-features = false, optional = true }
+prost = { version = "0.14", default-features = false, features = ["derive"], optional = true }
+regex = { version = "1.12", default-features = false, features = [], optional = true }
+serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
+similar = { git = "https://github.com/encounter/similar.git", branch = "no_std", default-features = false, features = ["hashbrown"], optional = true }
+typed-path = { version = "0.12", default-features = false, optional = true }
+
+# config
+globset = { version = "0.4", default-features = false, optional = true }
+semver = { version = "1.0", default-features = false, optional = true }
+serde_json = { version = "1.0", default-features = false, features = ["alloc"], optional = true }
+
+# dwarf
+gimli = { git = "https://github.com/gimli-rs/gimli", rev = "7335f00e7c39fd501511584fefb0ba974117c950", default-features = false, features = ["read"], optional = true }
+typed-arena = { version = "2.0", default-features = false, optional = true }
+
+# ppc
+cwextab = { version = "1.1", optional = true }
+powerpc = { version = "0.4", optional = true }
+rlwinmdec = { version = "1.1", optional = true }
+
+# mips
+rabbitizer = { version = "2.0.0-alpha.7", default-features = false, features = ["all_extensions"], optional = true }
+
+# x86
+iced-x86 = { version = "1.21", default-features = false, features = ["decoder", "intel", "gas", "masm", "nasm", "exhaustive_enums", "no_std"], optional = true }
+
+# arm
+unarm = { version = "2.1", optional = true }
+arm-attr = { version = "0.2", optional = true }
+
+# arm64
+yaxpeax-arch = { version = "0.3", default-features = false, optional = true }
+yaxpeax-arm = { version = "0.3", default-features = false, optional = true }
+
+# build
+notify = { version = "8.2.0", optional = true }
+notify-debouncer-full = { version = "0.6.0", optional = true }
+shell-escape = { version = "0.1", optional = true }
+tempfile = { version = "3.23", optional = true }
+time = { version = "0.3", optional = true }
+encoding_rs = { version = "0.8.35", optional = true }
+
+# demangler
+cpp_demangle = { version = "0.5", optional = true, default-features = false, features = ["alloc"] }
+cwdemangle = { version = "1.0", optional = true }
+gnuv2_demangle = { version = "0.4", optional = true }
+msvc-demangler = { version = "0.11", optional = true }
+
+[target.'cfg(windows)'.dependencies]
+winapi = { version = "0.3", optional = true, features = ["winbase"] }
+
+# For Linux static binaries, use rustls
+[target.'cfg(target_os = "linux")'.dependencies]
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "multipart", "rustls-tls"], optional = true }
+self_update = { version = "0.42", default-features = false, features = ["rustls"], optional = true }
+
+# For all other platforms, use native TLS
+[target.'cfg(not(target_os = "linux"))'.dependencies]
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "multipart", "default-tls"], optional = true }
+self_update = { version = "0.42", optional = true }
+
+[build-dependencies]
+heck = { version = "0.5", optional = true }
+pbjson-build = { version = "0.8", optional = true }
+prettyplease = { version = "0.2", optional = true }
+proc-macro2 = { version = "1.0", optional = true }
+prost-build = { version = "0.14", optional = true }
+quote = { version = "1.0", optional = true }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = { version = "1.0" }
+syn = { version = "2.0", optional = true }
+
+[dev-dependencies]
+# Enable all features for tests
+objdiff-core = { path = ".", features = ["all"] }
+insta = "1.43"

objdiff-core/README.md

@@ -0,0 +1,16 @@
+# objdiff-core
+
+objdiff-core contains the core functionality of [objdiff](https://github.com/encounter/objdiff), a tool for comparing object files in decompilation projects. See the main repository for more information.
+
+## Crate feature flags
+
+- **`all`**: Enables all main features.
+- **`bindings`**: Enables serialization and deserialization of objdiff data structures.
+- **`config`**: Enables objdiff configuration file support.
+- **`dwarf`**: Enables extraction of line number information from DWARF debug sections.
+- **`arm64`**: Enables the ARM64 backend powered by [yaxpeax-arm](https://github.com/iximeow/yaxpeax-arm).
+- **`arm`**: Enables the ARM backend powered by [unarm](https://github.com/AetiasHax/unarm).
+- **`mips`**: Enables the MIPS backend powered by [rabbitizer](https://github.com/Decompollaborate/rabbitizer).
+- **`ppc`**: Enables the PowerPC backend powered by [powerpc](https://github.com/encounter/powerpc-rs).
+- **`superh`**: Enables the SuperH backend powered by an included disassembler.
+- **`x86`**: Enables the x86 backend powered by [iced-x86](https://crates.io/crates/iced-x86).

objdiff-core/build.rs

@@ -0,0 +1,76 @@
+#[cfg(feature = "any-arch")]
+mod config_gen;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    #[cfg(feature = "bindings")]
+    compile_protos();
+    #[cfg(feature = "any-arch")]
+    config_gen::generate_diff_config();
+    Ok(())
+}
+
+#[cfg(feature = "bindings")]
+fn compile_protos() {
+    use std::path::{Path, PathBuf};
+    let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("protos");
+    let descriptor_path = root.join("proto_descriptor.bin");
+    println!("cargo:rerun-if-changed={}", descriptor_path.display());
+    let descriptor_mtime = std::fs::metadata(&descriptor_path)
+        .map(|m| m.modified().unwrap())
+        .unwrap_or(std::time::SystemTime::UNIX_EPOCH);
+    let mut run_protoc = false;
+    let proto_files = root
+        .read_dir()
+        .unwrap()
+        .filter_map(|e| {
+            let e = e.unwrap();
+            let path = e.path();
+            (path.extension() == Some(std::ffi::OsStr::new("proto"))).then_some(path)
+        })
+        .collect::<Vec<_>>();
+    for proto_file in &proto_files {
+        println!("cargo:rerun-if-changed={}", proto_file.display());
+        let mtime = match std::fs::metadata(proto_file) {
+            Ok(m) => m.modified().unwrap(),
+            Err(e) => panic!("Failed to stat proto file {}: {:?}", proto_file.display(), e),
+        };
+        if mtime > descriptor_mtime {
+            run_protoc = true;
+        }
+    }
+
+    fn prost_config(descriptor_path: &Path, run_protoc: bool) -> prost_build::Config {
+        let mut config = prost_build::Config::new();
+        config.file_descriptor_set_path(descriptor_path);
+        // If our cached descriptor is up-to-date, we don't need to run protoc.
+        // This is helpful so that users don't need to have protoc installed
+        // unless they're updating the protos.
+        if !run_protoc {
+            config.skip_protoc_run();
+        }
+        config
+    }
+    if let Err(e) =
+        prost_config(&descriptor_path, run_protoc).compile_protos(&proto_files, &[root.as_path()])
+    {
+        if e.kind() == std::io::ErrorKind::NotFound && e.to_string().contains("protoc") {
+            eprintln!("protoc not found, skipping protobuf compilation");
+            prost_config(&descriptor_path, false)
+                .compile_protos(&proto_files, &[root.as_path()])
+                .expect("Failed to compile protos");
+        } else {
+            panic!("Failed to compile protos: {e:?}");
+        }
+    }
+
+    #[cfg(feature = "serde")]
+    {
+        let descriptor_set = std::fs::read(descriptor_path).expect("Failed to read descriptor set");
+        pbjson_build::Builder::new()
+            .register_descriptors(&descriptor_set)
+            .expect("Failed to register descriptors")
+            .preserve_proto_field_names()
+            .build(&[".objdiff"])
+            .expect("Failed to build pbjson");
+    }
+}

objdiff-core/config-schema.json

@@ -0,0 +1,379 @@
+{
+  "properties": [
+    {
+      "id": "functionRelocDiffs",
+      "type": "choice",
+      "default": "name_address",
+      "name": "Function relocation diffs",
+      "description": "How relocation targets will be diffed in the function view.",
+      "items": [
+        {
+          "value": "none",
+          "name": "None"
+        },
+        {
+          "value": "name_address",
+          "name": "Name or address"
+        },
+        {
+          "value": "data_value",
+          "name": "Data value"
+        },
+        {
+          "value": "all",
+          "name": "Name or address, data value"
+        }
+      ]
+    },
+    {
+      "id": "demangler",
+      "type": "choice",
+      "default": "auto",
+      "name": "Demangler",
+      "description": "Which demangler should be used to demangle each symbol.",
+      "items": [
+        {
+          "value": "auto",
+          "name": "Auto",
+          "description": "Try to automatically guess the mangling format."
+        },
+        {
+          "value": "none",
+          "name": "None",
+          "description": "Disable demangling."
+        },
+        {
+          "value": "codewarrior",
+          "name": "CodeWarrior"
+        },
+        {
+          "value": "itanium",
+          "name": "Itanium"
+        },
+        {
+          "value": "msvc",
+          "name": "MSVC"
+        },
+        {
+          "value": "gnu_legacy",
+          "name": "GNU g++ (Legacy)",
+          "description": "Use the old GNU mangling ABI. Used up to g++ 2.9.x"
+        }
+      ]
+    },
+    {
+      "id": "analyzeDataFlow",
+      "type": "boolean",
+      "default": false,
+      "name": "(Experimental) Perform data flow analysis",
+      "description": "Use data flow analysis to display known information about register contents where possible"
+    },
+    {
+      "id": "showDataFlow",
+      "type": "boolean",
+      "default": true,
+      "name": "Show data flow",
+      "description": "Show data flow analysis results in place of register name where present"
+    },
+    {
+      "id": "spaceBetweenArgs",
+      "type": "boolean",
+      "default": true,
+      "name": "Space between args",
+      "description": "Adds a space between arguments in the diff output."
+    },
+    {
+      "id": "showSymbolSizes",
+      "type": "choice",
+      "default": "off",
+      "name": "Show symbol sizes",
+      "description": "Shows symbol sizes in the symbol view.",
+      "items": [
+        {
+          "value": "off",
+          "name": "Off"
+        },
+        {
+          "value": "hex",
+          "name": "Hex"
+        },
+        {
+          "value": "decimal",
+          "name": "Decimal"
+        }
+      ]
+    },
+    {
+      "id": "combineDataSections",
+      "type": "boolean",
+      "default": false,
+      "name": "Combine data sections",
+      "description": "Combines data sections with equal names."
+    },
+    {
+      "id": "combineTextSections",
+      "type": "boolean",
+      "default": false,
+      "name": "Combine text sections",
+      "description": "Combines all text sections into one."
+    },
+    {
+      "id": "arm.archVersion",
+      "type": "choice",
+      "default": "auto",
+      "name": "Architecture version",
+      "description": "ARM architecture version to use for disassembly.",
+      "items": [
+        {
+          "value": "auto",
+          "name": "Auto"
+        },
+        {
+          "value": "v4",
+          "name": "ARMv4"
+        },
+        {
+          "value": "v4t",
+          "name": "ARMv4T (GBA)"
+        },
+        {
+          "value": "v5t",
+          "name": "ARMv5T"
+        },
+        {
+          "value": "v5te",
+          "name": "ARMv5TE (DS)"
+        },
+        {
+          "value": "v5tej",
+          "name": "ARMv5TEJ"
+        },
+        {
+          "value": "v6",
+          "name": "ARMv6"
+        },
+        {
+          "value": "v6k",
+          "name": "ARMv6K (3DS)"
+        }
+      ]
+    },
+    {
+      "id": "arm.vfpV2",
+      "type": "boolean",
+      "default": true,
+      "name": "VFPv2 instructions",
+      "description": "Adds floating-point instructions from VFPv2."
+    },
+    {
+      "id": "arm.unifiedSyntax",
+      "type": "boolean",
+      "default": false,
+      "name": "Unified syntax",
+      "description": "Disassemble as unified assembly language (UAL)."
+    },
+    {
+      "id": "arm.avRegisters",
+      "type": "boolean",
+      "default": false,
+      "name": "Use A/V registers",
+      "description": "Display R0-R3 as A1-A4 and R4-R11 as V1-V8."
+    },
+    {
+      "id": "arm.r9Usage",
+      "type": "choice",
+      "default": "generalPurpose",
+      "name": "Display R9 as",
+      "items": [
+        {
+          "value": "generalPurpose",
+          "name": "R9 or V6",
+          "description": "Use R9 as a general-purpose register."
+        },
+        {
+          "value": "sb",
+          "name": "SB (static base)",
+          "description": "Used for position-independent data (PID)."
+        },
+        {
+          "value": "tr",
+          "name": "TR (TLS register)",
+          "description": "Used for thread-local storage."
+        }
+      ]
+    },
+    {
+      "id": "arm.slUsage",
+      "type": "boolean",
+      "default": false,
+      "name": "Display R10 as SL",
+      "description": "Used for explicit stack limits."
+    },
+    {
+      "id": "arm.fpUsage",
+      "type": "boolean",
+      "default": false,
+      "name": "Display R11 as FP",
+      "description": "Used for frame pointers."
+    },
+    {
+      "id": "arm.ipUsage",
+      "type": "boolean",
+      "default": false,
+      "name": "Display R12 as IP",
+      "description": "Used for interworking and long branches."
+    },
+    {
+      "id": "mips.abi",
+      "type": "choice",
+      "default": "auto",
+      "name": "ABI",
+      "description": "MIPS ABI to use for disassembly.",
+      "items": [
+        {
+          "value": "auto",
+          "name": "Auto"
+        },
+        {
+          "value": "o32",
+          "name": "O32"
+        },
+        {
+          "value": "o64",
+          "name": "O64"
+        },
+        {
+          "value": "n32",
+          "name": "N32"
+        },
+        {
+          "value": "n64",
+          "name": "N64"
+        },
+        {
+          "value": "eabi32",
+          "name": "eabi32"
+        },
+        {
+          "value": "eabi64",
+          "name": "eabi64"
+        }
+      ]
+    },
+    {
+      "id": "mips.instrCategory",
+      "type": "choice",
+      "default": "auto",
+      "name": "Instruction category",
+      "description": "MIPS instruction category to use for disassembly.",
+      "items": [
+        {
+          "value": "auto",
+          "name": "Auto"
+        },
+        {
+          "value": "cpu",
+          "name": "CPU"
+        },
+        {
+          "value": "rsp",
+          "name": "RSP (N64)"
+        },
+        {
+          "value": "r3000gte",
+          "name": "R3000 GTE (PS1)"
+        },
+        {
+          "value": "r4000allegrex",
+          "name": "R4000 ALLEGREX (PSP)"
+        },
+        {
+          "value": "r5900",
+          "name": "R5900 EE (PS2)"
+        }
+      ]
+    },
+    {
+      "id": "mips.registerPrefix",
+      "type": "boolean",
+      "default": false,
+      "name": "Register '$' prefix",
+      "description": "Display MIPS register names with a '$' prefix."
+    },
+    {
+      "id": "ppc.calculatePoolRelocations",
+      "type": "boolean",
+      "default": true,
+      "name": "Calculate pooled data references",
+      "description": "Display pooled data references in functions as fake relocations."
+    },
+    {
+      "id": "x86.formatter",
+      "type": "choice",
+      "default": "intel",
+      "name": "Format",
+      "description": "x86 disassembly syntax.",
+      "items": [
+        {
+          "value": "intel",
+          "name": "Intel"
+        },
+        {
+          "value": "gas",
+          "name": "AT&T"
+        },
+        {
+          "value": "nasm",
+          "name": "NASM"
+        },
+        {
+          "value": "masm",
+          "name": "MASM"
+        }
+      ]
+    }
+  ],
+  "groups": [
+    {
+      "id": "general",
+      "name": "General",
+      "properties": [
+        "functionRelocDiffs",
+        "demangler",
+        "showSymbolSizes",
+        "spaceBetweenArgs",
+        "combineDataSections",
+        "combineTextSections"
+      ]
+    },
+    {
+      "id": "arm",
+      "name": "ARM",
+      "properties": [
+        "arm.archVersion",
+        "arm.vfpV2",
+        "arm.unifiedSyntax",
+        "arm.avRegisters",
+        "arm.r9Usage",
+        "arm.slUsage",
+        "arm.fpUsage",
+        "arm.ipUsage"
+      ]
+    },
+    {
+      "id": "mips",
+      "name": "MIPS",
+      "properties": ["mips.abi", "mips.instrCategory", "mips.registerPrefix"]
+    },
+    {
+      "id": "ppc",
+      "name": "PowerPC",
+      "properties": ["ppc.calculatePoolRelocations", "analyzeDataFlow"]
+    },
+    {
+      "id": "x86",
+      "name": "x86",
+      "properties": ["x86.formatter"]
+    }
+  ]
+}

objdiff-core/config_gen.rs

@@ -0,0 +1,500 @@
+use std::{
+    fs::File,
+    path::{Path, PathBuf},
+};
+
+use heck::{ToShoutySnakeCase, ToSnakeCase, ToUpperCamelCase};
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote};
+
+#[derive(Debug, serde::Deserialize)]
+pub struct ConfigSchema {
+    pub properties: Vec<ConfigProperty>,
+    pub groups: Vec<ConfigGroup>,
+}
+
+#[derive(Debug, serde::Deserialize)]
+#[serde(tag = "type")]
+pub enum ConfigProperty {
+    #[serde(rename = "boolean")]
+    Boolean(ConfigPropertyBoolean),
+    #[serde(rename = "choice")]
+    Choice(ConfigPropertyChoice),
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct ConfigPropertyBase {
+    pub id: String,
+    pub name: String,
+    pub description: Option<String>,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct ConfigPropertyBoolean {
+    #[serde(flatten)]
+    pub base: ConfigPropertyBase,
+    pub default: bool,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct ConfigPropertyChoice {
+    #[serde(flatten)]
+    pub base: ConfigPropertyBase,
+    pub default: String,
+    pub items: Vec<ConfigPropertyChoiceItem>,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct ConfigPropertyChoiceItem {
+    pub value: String,
+    pub name: String,
+    pub description: Option<String>,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct ConfigGroup {
+    pub id: String,
+    pub name: String,
+    pub description: Option<String>,
+    pub properties: Vec<String>,
+}
+
+fn build_doc(name: &str, description: Option<&str>) -> TokenStream {
+    let mut doc = format!(" {name}");
+    let mut out = quote! { #[doc = #doc] };
+    if let Some(description) = description {
+        doc = format!(" {description}");
+        out.extend(quote! { #[doc = ""] });
+        out.extend(quote! { #[doc = #doc] });
+    }
+    out
+}
+
+pub fn generate_diff_config() {
+    let schema_path = Path::new(env!("CARGO_MANIFEST_DIR")).join("config-schema.json");
+    println!("cargo:rerun-if-changed={}", schema_path.display());
+    let schema_file = File::open(schema_path).expect("Failed to open config schema file");
+    let schema: ConfigSchema =
+        serde_json::from_reader(schema_file).expect("Failed to parse config schema");
+
+    let mut enums = TokenStream::new();
+    for property in &schema.properties {
+        let ConfigProperty::Choice(choice) = property else {
+            continue;
+        };
+        let enum_ident = format_ident!("{}", choice.base.id.to_upper_camel_case());
+        let mut variants = TokenStream::new();
+        let mut full_variants = TokenStream::new();
+        let mut variant_info = TokenStream::new();
+        let mut variant_to_str = TokenStream::new();
+        let mut variant_to_name = TokenStream::new();
+        let mut variant_to_description = TokenStream::new();
+        let mut variant_from_str = TokenStream::new();
+        for item in &choice.items {
+            let variant_name = item.value.to_upper_camel_case();
+            let variant_ident = format_ident!("{}", variant_name);
+            let is_default = item.value == choice.default;
+            variants.extend(build_doc(&item.name, item.description.as_deref()));
+            if is_default {
+                variants.extend(quote! { #[default] });
+            }
+            let value = &item.value;
+            variants.extend(quote! {
+                #[cfg_attr(feature = "serde", serde(rename = #value, alias = #variant_name))]
+                #variant_ident,
+            });
+            full_variants.extend(quote! { #enum_ident::#variant_ident, });
+            variant_to_str.extend(quote! { #enum_ident::#variant_ident => #value, });
+            let name = &item.name;
+            variant_to_name.extend(quote! { #enum_ident::#variant_ident => #name, });
+            if let Some(description) = &item.description {
+                variant_to_description.extend(quote! {
+                    #enum_ident::#variant_ident => Some(#description),
+                });
+            } else {
+                variant_to_description.extend(quote! {
+                    #enum_ident::#variant_ident => None,
+                });
+            }
+            let description = if let Some(description) = &item.description {
+                quote! { Some(#description) }
+            } else {
+                quote! { None }
+            };
+            variant_info.extend(quote! {
+                ConfigEnumVariantInfo {
+                    value: #value,
+                    name: #name,
+                    description: #description,
+                    is_default: #is_default,
+                },
+            });
+            variant_from_str.extend(quote! {
+                if s.eq_ignore_ascii_case(#value) { return Ok(#enum_ident::#variant_ident); }
+            });
+        }
+        enums.extend(quote! {
+            #[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Hash)]
+            #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+            pub enum #enum_ident {
+                #variants
+            }
+            impl ConfigEnum for #enum_ident {
+                #[inline]
+                fn variants() -> &'static [Self] {
+                    static VARIANTS: &[#enum_ident] = &[#full_variants];
+                    VARIANTS
+                }
+                #[inline]
+                fn variant_info() -> &'static [ConfigEnumVariantInfo] {
+                    static VARIANT_INFO: &[ConfigEnumVariantInfo] = &[
+                        #variant_info
+                    ];
+                    VARIANT_INFO
+                }
+                fn as_str(&self) -> &'static str {
+                    match self {
+                        #variant_to_str
+                    }
+                }
+                fn name(&self) -> &'static str {
+                    match self {
+                        #variant_to_name
+                    }
+                }
+                fn description(&self) -> Option<&'static str> {
+                    match self {
+                        #variant_to_description
+                    }
+                }
+            }
+            impl core::str::FromStr for #enum_ident {
+                type Err = ();
+                fn from_str(s: &str) -> Result<Self, Self::Err> {
+                    #variant_from_str
+                    Err(())
+                }
+            }
+        });
+    }
+
+    let mut groups = TokenStream::new();
+    let mut group_idents = Vec::new();
+    for group in &schema.groups {
+        let ident = format_ident!("CONFIG_GROUP_{}", group.id.to_shouty_snake_case());
+        let id = &group.id;
+        let name = &group.name;
+        let description = if let Some(description) = &group.description {
+            quote! { Some(#description) }
+        } else {
+            quote! { None }
+        };
+        let properties =
+            group.properties.iter().map(|p| format_ident!("{}", p.to_upper_camel_case()));
+        groups.extend(quote! {
+            ConfigPropertyGroup {
+                id: #id,
+                name: #name,
+                description: #description,
+                properties: &[#(ConfigPropertyId::#properties,)*],
+            },
+        });
+        group_idents.push(ident);
+    }
+
+    let mut property_idents = Vec::new();
+    let mut property_variants = TokenStream::new();
+    let mut variant_info = TokenStream::new();
+    let mut config_property_id_to_str = TokenStream::new();
+    let mut config_property_id_to_name = TokenStream::new();
+    let mut config_property_id_to_description = TokenStream::new();
+    let mut config_property_id_to_kind = TokenStream::new();
+    let mut property_fields = TokenStream::new();
+    let mut default_fields = TokenStream::new();
+    let mut get_property_value_variants = TokenStream::new();
+    let mut set_property_value_variants = TokenStream::new();
+    let mut set_property_value_str_variants = TokenStream::new();
+    let mut config_property_id_from_str = TokenStream::new();
+    for property in &schema.properties {
+        let base = match property {
+            ConfigProperty::Boolean(b) => &b.base,
+            ConfigProperty::Choice(c) => &c.base,
+        };
+        let id = &base.id;
+        let enum_ident = format_ident!("{}", id.to_upper_camel_case());
+        property_idents.push(enum_ident.clone());
+        config_property_id_to_str.extend(quote! { Self::#enum_ident => #id, });
+        let name = &base.name;
+        config_property_id_to_name.extend(quote! { Self::#enum_ident => #name, });
+        if let Some(description) = &base.description {
+            config_property_id_to_description.extend(quote! {
+                Self::#enum_ident => Some(#description),
+            });
+        } else {
+            config_property_id_to_description.extend(quote! {
+                Self::#enum_ident => None,
+            });
+        }
+        let doc = build_doc(name, base.description.as_deref());
+        property_variants.extend(quote! { #doc #enum_ident, });
+        property_fields.extend(doc);
+        let field_ident = format_ident!("{}", id.to_snake_case());
+        match property {
+            ConfigProperty::Boolean(b) => {
+                let default = b.default;
+                if default {
+                    property_fields.extend(quote! {
+                        #[cfg_attr(feature = "serde", serde(default = "default_true"))]
+                    });
+                }
+                property_fields.extend(quote! {
+                    pub #field_ident: bool,
+                });
+                default_fields.extend(quote! {
+                    #field_ident: #default,
+                });
+            }
+            ConfigProperty::Choice(_) => {
+                property_fields.extend(quote! {
+                    pub #field_ident: #enum_ident,
+                });
+                default_fields.extend(quote! {
+                    #field_ident: #enum_ident::default(),
+                });
+            }
+        }
+        let property_value = match property {
+            ConfigProperty::Boolean(_) => {
+                quote! { ConfigPropertyValue::Boolean(self.#field_ident) }
+            }
+            ConfigProperty::Choice(_) => {
+                quote! { ConfigPropertyValue::Choice(self.#field_ident.as_str()) }
+            }
+        };
+        get_property_value_variants.extend(quote! {
+            ConfigPropertyId::#enum_ident => #property_value,
+        });
+        match property {
+            ConfigProperty::Boolean(_) => {
+                set_property_value_variants.extend(quote! {
+                    ConfigPropertyId::#enum_ident => {
+                        if let ConfigPropertyValue::Boolean(value) = value {
+                            self.#field_ident = value;
+                            Ok(())
+                        } else {
+                            Err(())
+                        }
+                    },
+                });
+                set_property_value_str_variants.extend(quote! {
+                    ConfigPropertyId::#enum_ident => {
+                        if let Ok(value) = value.parse() {
+                            self.#field_ident = value;
+                            Ok(())
+                        } else {
+                            Err(())
+                        }
+                    },
+                });
+            }
+            ConfigProperty::Choice(_) => {
+                set_property_value_variants.extend(quote! {
+                    ConfigPropertyId::#enum_ident => {
+                        if let ConfigPropertyValue::Choice(value) = value {
+                            if let Ok(value) = value.parse() {
+                                self.#field_ident = value;
+                                Ok(())
+                            } else {
+                                Err(())
+                            }
+                        } else {
+                            Err(())
+                        }
+                    },
+                });
+                set_property_value_str_variants.extend(quote! {
+                    ConfigPropertyId::#enum_ident => {
+                        if let Ok(value) = value.parse() {
+                            self.#field_ident = value;
+                            Ok(())
+                        } else {
+                            Err(())
+                        }
+                    },
+                });
+            }
+        }
+        let description = if let Some(description) = &base.description {
+            quote! { Some(#description) }
+        } else {
+            quote! { None }
+        };
+        variant_info.extend(quote! {
+            ConfigEnumVariantInfo {
+                value: #id,
+                name: #name,
+                description: #description,
+                is_default: false,
+            },
+        });
+        match property {
+            ConfigProperty::Boolean(_) => {
+                config_property_id_to_kind.extend(quote! {
+                    Self::#enum_ident => ConfigPropertyKind::Boolean,
+                });
+            }
+            ConfigProperty::Choice(_) => {
+                config_property_id_to_kind.extend(quote! {
+                    Self::#enum_ident => ConfigPropertyKind::Choice(#enum_ident::variant_info()),
+                });
+            }
+        }
+        let snake_id = id.to_snake_case();
+        config_property_id_from_str.extend(quote! {
+            if s.eq_ignore_ascii_case(#id) || s.eq_ignore_ascii_case(#snake_id) {
+                return Ok(Self::#enum_ident);
+            }
+        });
+    }
+
+    let tokens = quote! {
+        pub trait ConfigEnum: Sized {
+            fn variants() -> &'static [Self];
+            fn variant_info() -> &'static [ConfigEnumVariantInfo];
+            fn as_str(&self) -> &'static str;
+            fn name(&self) -> &'static str;
+            fn description(&self) -> Option<&'static str>;
+        }
+        #[derive(Clone, Debug)]
+        pub struct ConfigEnumVariantInfo {
+            pub value: &'static str,
+            pub name: &'static str,
+            pub description: Option<&'static str>,
+            pub is_default: bool,
+        }
+        #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+        pub enum ConfigPropertyId {
+            #property_variants
+        }
+        impl ConfigEnum for ConfigPropertyId {
+            #[inline]
+            fn variants() -> &'static [Self] {
+                static VARIANTS: &[ConfigPropertyId] = &[#(ConfigPropertyId::#property_idents,)*];
+                VARIANTS
+            }
+            #[inline]
+            fn variant_info() -> &'static [ConfigEnumVariantInfo] {
+                static VARIANT_INFO: &[ConfigEnumVariantInfo] = &[
+                    #variant_info
+                ];
+                VARIANT_INFO
+            }
+            fn as_str(&self) -> &'static str {
+                match self {
+                    #config_property_id_to_str
+                }
+            }
+            fn name(&self) -> &'static str {
+                match self {
+                    #config_property_id_to_name
+                }
+            }
+            fn description(&self) -> Option<&'static str> {
+                match self {
+                    #config_property_id_to_description
+                }
+            }
+        }
+        impl ConfigPropertyId {
+            pub fn kind(&self) -> ConfigPropertyKind {
+                match self {
+                    #config_property_id_to_kind
+                }
+            }
+        }
+        impl core::str::FromStr for ConfigPropertyId {
+            type Err = ();
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                #config_property_id_from_str
+                Err(())
+            }
+        }
+        #[derive(Clone, Debug)]
+        pub struct ConfigPropertyGroup {
+            pub id: &'static str,
+            pub name: &'static str,
+            pub description: Option<&'static str>,
+            pub properties: &'static [ConfigPropertyId],
+        }
+        pub static CONFIG_GROUPS: &[ConfigPropertyGroup] = &[#groups];
+        #[derive(Clone, Debug, Eq, PartialEq, Hash)]
+        pub enum ConfigPropertyValue {
+            Boolean(bool),
+            Choice(&'static str),
+        }
+        impl ConfigPropertyValue {
+            #[cfg(feature = "serde")]
+            pub fn to_json(&self) -> serde_json::Value {
+                match self {
+                    ConfigPropertyValue::Boolean(value) => serde_json::Value::Bool(*value),
+                    ConfigPropertyValue::Choice(value) => serde_json::Value::String(value.to_string()),
+                }
+            }
+        }
+        impl core::fmt::Display for ConfigPropertyValue {
+            fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                match *self {
+                    ConfigPropertyValue::Boolean(value) => write!(f, "{value}"),
+                    ConfigPropertyValue::Choice(value) => f.write_str(value),
+                }
+            }
+        }
+        #[derive(Clone, Debug)]
+        pub enum ConfigPropertyKind {
+            Boolean,
+            Choice(&'static [ConfigEnumVariantInfo]),
+        }
+        #enums
+        #[cfg(feature = "serde")]
+        #[inline(always)]
+        fn default_true() -> bool { true }
+        #[derive(Clone, Debug)]
+        #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize), serde(default))]
+        pub struct DiffObjConfig {
+            #property_fields
+        }
+        impl Default for DiffObjConfig {
+            fn default() -> Self {
+                Self {
+                    #default_fields
+                }
+            }
+        }
+        impl DiffObjConfig {
+            pub fn get_property_value(&self, id: ConfigPropertyId) -> ConfigPropertyValue {
+                match id {
+                    #get_property_value_variants
+                }
+            }
+            #[allow(clippy::result_unit_err)]
+            pub fn set_property_value(&mut self, id: ConfigPropertyId, value: ConfigPropertyValue) -> Result<(), ()> {
+                match id {
+                    #set_property_value_variants
+                }
+            }
+            #[allow(clippy::result_unit_err)]
+            pub fn set_property_value_str(&mut self, id: ConfigPropertyId, value: &str) -> Result<(), ()> {
+                match id {
+                    #set_property_value_str_variants
+                }
+            }
+        }
+    };
+    let file = syn::parse2(tokens).unwrap();
+    let formatted = prettyplease::unparse(&file);
+    std::fs::write(
+        PathBuf::from(std::env::var_os("OUT_DIR").unwrap()).join("config.gen.rs"),
+        formatted,
+    )
+    .unwrap();
+}

objdiff-core/protos/changes.proto

@@ -0,0 +1,59 @@
+syntax = "proto3";
+
+import "report.proto";
+
+package objdiff.report;
+
+// A pair of reports to compare and generate changes
+message ChangesInput {
+  // The previous report
+  Report from = 1;
+  // The current report
+  Report to = 2;
+}
+
+// Changes between two reports
+message Changes {
+  // The progress info for the previous report
+  Measures from = 1;
+  // The progress info for the current report
+  Measures to = 2;
+  // Units that changed
+  repeated ChangeUnit units = 3;
+}
+
+// A changed unit
+message ChangeUnit {
+  // The name of the unit
+  string name = 1;
+  // The previous progress info (omitted if new)
+  optional Measures from = 2;
+  // The current progress info (omitted if removed)
+  optional Measures to = 3;
+  // Sections that changed
+  repeated ChangeItem sections = 4;
+  // Functions that changed
+  repeated ChangeItem functions = 5;
+  // Extra metadata for this unit
+  optional ReportUnitMetadata metadata = 6;
+}
+
+// A changed section or function
+message ChangeItem {
+  // The name of the item
+  string name = 1;
+  // The previous progress info (omitted if new)
+  optional ChangeItemInfo from = 2;
+  // The current progress info (omitted if removed)
+  optional ChangeItemInfo to = 3;
+  // Extra metadata for this item
+  optional ReportItemMetadata metadata = 4;
+}
+
+// Progress info for a section or function
+message ChangeItemInfo {
+  // The overall match percent for this item
+  float fuzzy_match_percent = 1;
+  // The size of the item in bytes
+  uint64 size = 2;
+}

objdiff-core/protos/report.proto

@@ -0,0 +1,112 @@
+syntax = "proto3";
+
+package objdiff.report;
+
+// Project progress report
+message Report {
+  // Overall progress info
+  Measures measures = 1;
+  // Units within this report
+  repeated ReportUnit units = 2;
+  // Report version
+  uint32 version = 3;
+  // Progress categories
+  repeated ReportCategory categories = 4;
+}
+
+// Progress info for a report or unit
+message Measures {
+  // Overall match percent, including partially matched functions and data
+  float fuzzy_match_percent = 1;
+  // Total size of code in bytes
+  uint64 total_code = 2;
+  // Fully matched code size in bytes
+  uint64 matched_code = 3;
+  // Fully matched code percent
+  float matched_code_percent = 4;
+  // Total size of data in bytes
+  uint64 total_data = 5;
+  // Fully matched data size in bytes
+  uint64 matched_data = 6;
+  // Fully matched data percent
+  float matched_data_percent = 7;
+  // Total number of functions
+  uint32 total_functions = 8;
+  // Fully matched functions
+  uint32 matched_functions = 9;
+  // Fully matched functions percent
+  float matched_functions_percent = 10;
+  // Completed (or "linked") code size in bytes
+  uint64 complete_code = 11;
+  // Completed (or "linked") code percent
+  float complete_code_percent = 12;
+  // Completed (or "linked") data size in bytes
+  uint64 complete_data = 13;
+  // Completed (or "linked") data percent
+  float complete_data_percent = 14;
+  // Total number of units
+  uint32 total_units = 15;
+  // Completed (or "linked") units
+  uint32 complete_units = 16;
+}
+
+message ReportCategory {
+  // The ID of the category
+  string id = 1;
+  // The name of the category
+  string name = 2;
+  // Progress info for this category
+  Measures measures = 3;
+}
+
+// A unit of the report (usually a translation unit)
+message ReportUnit {
+  // The name of the unit
+  string name = 1;
+  // Progress info for this unit
+  Measures measures = 2;
+  // Sections within this unit
+  repeated ReportItem sections = 3;
+  // Functions within this unit
+  repeated ReportItem functions = 4;
+  // Extra metadata for this unit
+  optional ReportUnitMetadata metadata = 5;
+}
+
+// Extra metadata for a unit
+message ReportUnitMetadata {
+  // Whether this unit is marked as complete (or "linked")
+  optional bool complete = 1;
+  // The name of the module this unit belongs to
+  optional string module_name = 2;
+  // The ID of the module this unit belongs to
+  optional uint32 module_id = 3;
+  // The path to the source file of this unit
+  optional string source_path = 4;
+  // Progress categories for this unit
+  repeated string progress_categories = 5;
+  // Whether this unit is automatically generated (not user-provided)
+  optional bool auto_generated = 6;
+}
+
+// A section or function within a unit
+message ReportItem {
+  // The name of the item
+  string name = 1;
+  // The size of the item in bytes
+  uint64 size = 2;
+  // The overall match percent for this item
+  float fuzzy_match_percent = 3;
+  // Extra metadata for this item
+  optional ReportItemMetadata metadata = 4;
+  // Address of the item (section-relative offset)
+  optional uint64 address = 5;
+}
+
+// Extra metadata for an item
+message ReportItemMetadata {
+  // The demangled name of the function
+  optional string demangled_name = 1;
+  // The virtual address of the function or section
+  optional uint64 virtual_address = 2;
+}

objdiff-core/src/arch/arm.rs

@@ -0,0 +1,606 @@
+use alloc::{borrow::Cow, collections::BTreeMap, vec::Vec};
+use core::fmt::Write;
+
+use anyhow::{Result, bail};
+use arm_attr::{BuildAttrs, enums::CpuArch, tag::Tag};
+use object::{Endian as _, Object as _, ObjectSection as _, ObjectSymbol as _, elf};
+use unarm::FormatValue as _;
+
+use crate::{
+    arch::{Arch, OPCODE_DATA, OPCODE_INVALID, RelocationOverride, RelocationOverrideTarget},
+    diff::{ArmArchVersion, ArmR9Usage, DiffObjConfig, display::InstructionPart},
+    obj::{
+        InstructionRef, Relocation, RelocationFlags, ResolvedInstructionRef, Section, SectionKind,
+        Symbol, SymbolFlag, SymbolFlagSet, SymbolKind,
+    },
+};
+
+#[derive(Debug)]
+pub struct ArchArm {
+    /// Maps section index, to list of disasm modes (arm, thumb or data) sorted by address
+    disasm_modes: BTreeMap<usize, Vec<DisasmMode>>,
+    detected_version: Option<unarm::Version>,
+    endianness: object::Endianness,
+}
+
+impl ArchArm {
+    pub fn new(file: &object::File) -> Result<Self> {
+        let endianness = file.endianness();
+        match file {
+            object::File::Elf32(_) => {
+                // The disasm_modes mapping is populated later in the post_init step so that we have access to merged sections.
+                let disasm_modes = BTreeMap::new();
+                let detected_version = Self::elf_detect_arm_version(file)?;
+                Ok(Self { disasm_modes, detected_version, endianness })
+            }
+            _ => bail!("Unsupported file format {:?}", file.format()),
+        }
+    }
+
+    fn elf_detect_arm_version(file: &object::File) -> Result<Option<unarm::Version>> {
+        // Check ARM attributes
+        if let Some(arm_attrs) = file.sections().find(|s| {
+            s.kind() == object::SectionKind::Elf(elf::SHT_ARM_ATTRIBUTES)
+                && s.name() == Ok(".ARM.attributes")
+        }) {
+            let attr_data = arm_attrs.uncompressed_data()?;
+            let build_attrs = BuildAttrs::new(&attr_data, match file.endianness() {
+                object::Endianness::Little => arm_attr::Endian::Little,
+                object::Endianness::Big => arm_attr::Endian::Big,
+            })?;
+            for subsection in build_attrs.subsections() {
+                let subsection = subsection?;
+                if !subsection.is_aeabi() {
+                    continue;
+                }
+                // Only checking first CpuArch tag. Others may exist, but that's very unlikely.
+                let cpu_arch = subsection.into_public_tag_iter()?.find_map(|(_, tag)| {
+                    if let Tag::CpuArch(cpu_arch) = tag { Some(cpu_arch) } else { None }
+                });
+                match cpu_arch {
+                    Some(CpuArch::V4) => return Ok(Some(unarm::Version::V4)),
+                    Some(CpuArch::V4T) => return Ok(Some(unarm::Version::V4T)),
+                    Some(CpuArch::V5TE) => return Ok(Some(unarm::Version::V5Te)),
+                    Some(CpuArch::V5TEJ) => return Ok(Some(unarm::Version::V5Tej)),
+                    Some(CpuArch::V6) => return Ok(Some(unarm::Version::V6)),
+                    Some(CpuArch::V6K) => return Ok(Some(unarm::Version::V6K)),
+                    Some(arch) => bail!("ARM arch {} not supported", arch),
+                    None => {}
+                };
+            }
+        }
+
+        Ok(None)
+    }
+
+    fn get_mapping_symbols(
+        sections: &[Section],
+        symbols: &[Symbol],
+    ) -> BTreeMap<usize, Vec<DisasmMode>> {
+        sections
+            .iter()
+            .enumerate()
+            .filter(|(_, section)| section.kind == SectionKind::Code)
+            .map(|(index, _)| {
+                let mut mapping_symbols: Vec<_> = symbols
+                    .iter()
+                    .filter(|s| s.section.map(|i| i == index).unwrap_or(false))
+                    .filter_map(DisasmMode::from_symbol)
+                    .collect();
+                mapping_symbols.sort_unstable_by_key(|x| x.address);
+                (index, mapping_symbols)
+            })
+            .collect()
+    }
+
+    fn unarm_options(&self, diff_config: &DiffObjConfig) -> unarm::Options {
+        let mut extensions = unarm::Extensions::none();
+        if diff_config.arm_vfp_v2 {
+            extensions = extensions.with(unarm::Extension::VfpV2);
+        }
+        unarm::Options {
+            version: match diff_config.arm_arch_version {
+                ArmArchVersion::Auto => self.detected_version.unwrap_or(unarm::Version::V5Te),
+                ArmArchVersion::V4 => unarm::Version::V4,
+                ArmArchVersion::V4t => unarm::Version::V4T,
+                ArmArchVersion::V5t => unarm::Version::V5T,
+                ArmArchVersion::V5te => unarm::Version::V5Te,
+                ArmArchVersion::V5tej => unarm::Version::V5Tej,
+                ArmArchVersion::V6 => unarm::Version::V6,
+                ArmArchVersion::V6k => unarm::Version::V6K,
+            },
+            extensions,
+            av: diff_config.arm_av_registers,
+            r9_use: match diff_config.arm_r9_usage {
+                ArmR9Usage::GeneralPurpose => unarm::R9Use::R9,
+                ArmR9Usage::Sb => unarm::R9Use::Sb,
+                ArmR9Usage::Tr => unarm::R9Use::Tr,
+            },
+            sl: diff_config.arm_sl_usage,
+            fp: diff_config.arm_fp_usage,
+            ip: diff_config.arm_ip_usage,
+            ual: diff_config.arm_unified_syntax,
+        }
+    }
+
+    fn parse_ins_ref(
+        &self,
+        ins_ref: InstructionRef,
+        code: &[u8],
+        diff_config: &DiffObjConfig,
+    ) -> Result<unarm::Ins> {
+        let code = match (self.endianness, ins_ref.size) {
+            (object::Endianness::Little, 2) => u16::from_le_bytes([code[0], code[1]]) as u32,
+            (object::Endianness::Little, 4) => {
+                u32::from_le_bytes([code[0], code[1], code[2], code[3]])
+            }
+            (object::Endianness::Big, 2) => u16::from_be_bytes([code[0], code[1]]) as u32,
+            (object::Endianness::Big, 4) => {
+                u32::from_be_bytes([code[0], code[1], code[2], code[3]])
+            }
+            _ => bail!("Invalid instruction size {}", ins_ref.size),
+        };
+
+        let thumb = ins_ref.opcode & (1 << 15) == 0;
+        let discriminant = ins_ref.opcode & !(1 << 15);
+        let pc = ins_ref.address as u32;
+        let options = self.unarm_options(diff_config);
+
+        let ins = if ins_ref.opcode == OPCODE_DATA {
+            match ins_ref.size {
+                4 => unarm::Ins::Word(code),
+                2 => unarm::Ins::HalfWord(code as u16),
+                _ => bail!("Invalid data size {}", ins_ref.size),
+            }
+        } else if thumb {
+            unarm::parse_thumb_with_discriminant(code, discriminant, pc, &options)
+        } else {
+            unarm::parse_arm_with_discriminant(code, discriminant, pc, &options)
+        };
+        Ok(ins)
+    }
+}
+
+impl Arch for ArchArm {
+    fn post_init(&mut self, sections: &[Section], symbols: &[Symbol]) {
+        self.disasm_modes = Self::get_mapping_symbols(sections, symbols);
+    }
+
+    fn scan_instructions_internal(
+        &self,
+        address: u64,
+        code: &[u8],
+        section_index: usize,
+        _relocations: &[Relocation],
+        diff_config: &DiffObjConfig,
+    ) -> Result<Vec<InstructionRef>> {
+        let start_addr = address as u32;
+        let end_addr = start_addr + code.len() as u32;
+
+        // Mapping symbols decide what kind of data comes after it. $a for ARM code, $t for Thumb code and $d for data.
+        let fallback_mappings =
+            [DisasmMode { address: start_addr, mapping: unarm::ParseMode::Arm }];
+        let mapping_symbols = self
+            .disasm_modes
+            .get(&section_index)
+            .map(|x| x.as_slice())
+            .unwrap_or(&fallback_mappings);
+        let first_mapping_idx = mapping_symbols
+            .binary_search_by_key(&start_addr, |x| x.address)
+            .unwrap_or_else(|idx| idx.saturating_sub(1));
+        let mut mode = mapping_symbols[first_mapping_idx].mapping;
+
+        let mut mappings_iter = mapping_symbols
+            .iter()
+            .copied()
+            .skip(first_mapping_idx + 1)
+            .take_while(|x| x.address < end_addr);
+        let mut next_mapping = mappings_iter.next();
+
+        let min_ins_size = if mode == unarm::ParseMode::Thumb { 2 } else { 4 };
+        let ins_count = code.len() / min_ins_size;
+        let mut ops = Vec::<InstructionRef>::with_capacity(ins_count);
+
+        let options = self.unarm_options(diff_config);
+
+        let mut address = start_addr;
+        while address < end_addr {
+            while let Some(next) = next_mapping.filter(|x| address >= x.address) {
+                // Change mapping
+                mode = next.mapping;
+                next_mapping = mappings_iter.next();
+            }
+
+            let data = &code[(address - start_addr) as usize..];
+            if data.len() < min_ins_size {
+                // Push the remainder as data
+                ops.push(InstructionRef {
+                    address: address as u64,
+                    size: data.len() as u8,
+                    opcode: OPCODE_DATA,
+                    branch_dest: None,
+                });
+                break;
+            }
+
+            // Check how many bytes we can/should read
+            let num_code_bytes = if data.len() >= 4 {
+                if mode == unarm::ParseMode::Data && address & 3 != 0 {
+                    // 32-bit .word value should be aligned on a 4-byte boundary, otherwise use .hword
+                    2
+                } else {
+                    // Read 4 bytes even for Thumb, as the parser will determine if it's a 2 or 4 byte instruction
+                    4
+                }
+            } else if mode != unarm::ParseMode::Arm {
+                2
+            } else {
+                // Invalid instruction size
+                ops.push(InstructionRef {
+                    address: address as u64,
+                    size: min_ins_size as u8,
+                    opcode: OPCODE_INVALID,
+                    branch_dest: None,
+                });
+                address += min_ins_size as u32;
+                continue;
+            };
+
+            let code = match num_code_bytes {
+                4 => match self.endianness {
+                    object::Endianness::Little => {
+                        u32::from_le_bytes([data[0], data[1], data[2], data[3]])
+                    }
+                    object::Endianness::Big => {
+                        if mode != unarm::ParseMode::Thumb {
+                            u32::from_be_bytes([data[0], data[1], data[2], data[3]])
+                        } else {
+                            // For 4-byte Thumb instructions, read two 16-bit halfwords in big endian
+                            u32::from_be_bytes([data[2], data[3], data[0], data[1]])
+                        }
+                    }
+                },
+                2 => match self.endianness {
+                    object::Endianness::Little => u16::from_le_bytes([data[0], data[1]]) as u32,
+                    object::Endianness::Big => u16::from_be_bytes([data[0], data[1]]) as u32,
+                },
+                _ => unreachable!(),
+            };
+
+            let (opcode, ins, ins_size) = match mode {
+                unarm::ParseMode::Arm => {
+                    let ins = unarm::parse_arm(code, address, &options);
+                    let opcode = ins.discriminant() | (1 << 15);
+                    (opcode, ins, 4)
+                }
+                unarm::ParseMode::Thumb => {
+                    let (ins, size) = unarm::parse_thumb(code, address, &options);
+                    let opcode = ins.discriminant();
+                    (opcode, ins, size)
+                }
+                unarm::ParseMode::Data => (
+                    OPCODE_DATA,
+                    if num_code_bytes == 4 {
+                        unarm::Ins::Word(code)
+                    } else {
+                        unarm::Ins::HalfWord(code as u16)
+                    },
+                    num_code_bytes,
+                ),
+            };
+
+            let branch_dest = match ins {
+                unarm::Ins::B { target, .. }
+                | unarm::Ins::Bl { target, .. }
+                | unarm::Ins::Blx { target: unarm::BlxTarget::Direct(target), .. } => {
+                    Some(target.addr)
+                }
+                _ => None,
+            };
+
+            ops.push(InstructionRef {
+                address: address as u64,
+                size: ins_size as u8,
+                opcode,
+                branch_dest: branch_dest.map(|x| x as u64),
+            });
+            address += ins_size;
+        }
+
+        Ok(ops)
+    }
+
+    fn display_instruction(
+        &self,
+        resolved: ResolvedInstructionRef,
+        diff_config: &DiffObjConfig,
+        cb: &mut dyn FnMut(InstructionPart) -> Result<()>,
+    ) -> Result<()> {
+        let ins = self.parse_ins_ref(resolved.ins_ref, resolved.code, diff_config)?;
+
+        let options = self.unarm_options(diff_config);
+        let mut string_fmt = unarm::StringFormatter::new(&options);
+        ins.write_opcode(&mut string_fmt)?;
+        let opcode = string_fmt.into_string();
+        cb(InstructionPart::opcode(opcode, resolved.ins_ref.opcode))?;
+
+        let mut args_formatter =
+            ArgsFormatter { options: &options, cb, resolved: &resolved, skip_leading_space: true };
+        ins.write_params(&mut args_formatter)?;
+        Ok(())
+    }
+
+    fn relocation_override(
+        &self,
+        _file: &object::File<'_>,
+        section: &object::Section,
+        address: u64,
+        relocation: &object::Relocation,
+    ) -> Result<Option<RelocationOverride>> {
+        match relocation.flags() {
+            // Handle ELF implicit relocations
+            object::RelocationFlags::Elf { r_type } => {
+                if relocation.has_implicit_addend() {
+                    let section_data = section.data()?;
+                    let address = address as usize;
+                    let addend = match r_type {
+                        // ARM calls
+                        elf::R_ARM_PC24 | elf::R_ARM_XPC25 | elf::R_ARM_CALL => {
+                            let data = section_data[address..address + 4].try_into()?;
+                            let addend = self.endianness.read_i32_bytes(data);
+                            let imm24 = addend & 0xffffff;
+                            (imm24 << 2) << 8 >> 8
+                        }
+
+                        // Thumb calls
+                        elf::R_ARM_THM_PC22 | elf::R_ARM_THM_XPC22 => {
+                            let data = section_data[address..address + 2].try_into()?;
+                            let high = self.endianness.read_i16_bytes(data) as i32;
+                            let data = section_data[address + 2..address + 4].try_into()?;
+                            let low = self.endianness.read_i16_bytes(data) as i32;
+
+                            let imm22 = ((high & 0x7ff) << 11) | (low & 0x7ff);
+                            (imm22 << 1) << 9 >> 9
+                        }
+
+                        // Data
+                        elf::R_ARM_ABS32 => {
+                            let data = section_data[address..address + 4].try_into()?;
+                            self.endianness.read_i32_bytes(data)
+                        }
+
+                        flags => bail!("Unsupported ARM implicit relocation {flags:?}"),
+                    };
+                    Ok(Some(RelocationOverride {
+                        target: RelocationOverrideTarget::Keep,
+                        addend: addend as i64,
+                    }))
+                } else {
+                    Ok(None)
+                }
+            }
+            _ => Ok(None),
+        }
+    }
+
+    fn reloc_name(&self, flags: RelocationFlags) -> Option<&'static str> {
+        match flags {
+            RelocationFlags::Elf(r_type) => match r_type {
+                elf::R_ARM_NONE => Some("R_ARM_NONE"),
+                elf::R_ARM_ABS32 => Some("R_ARM_ABS32"),
+                elf::R_ARM_REL32 => Some("R_ARM_REL32"),
+                elf::R_ARM_ABS16 => Some("R_ARM_ABS16"),
+                elf::R_ARM_ABS8 => Some("R_ARM_ABS8"),
+                elf::R_ARM_THM_PC22 => Some("R_ARM_THM_PC22"),
+                elf::R_ARM_THM_XPC22 => Some("R_ARM_THM_XPC22"),
+                elf::R_ARM_PC24 => Some("R_ARM_PC24"),
+                elf::R_ARM_XPC25 => Some("R_ARM_XPC25"),
+                elf::R_ARM_CALL => Some("R_ARM_CALL"),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+
+    fn data_reloc_size(&self, flags: RelocationFlags) -> usize {
+        match flags {
+            RelocationFlags::Elf(r_type) => match r_type {
+                elf::R_ARM_NONE => 0,
+                elf::R_ARM_ABS32 => 4,
+                elf::R_ARM_REL32 => 4,
+                elf::R_ARM_ABS16 => 2,
+                elf::R_ARM_ABS8 => 1,
+                elf::R_ARM_THM_PC22 => 4,
+                elf::R_ARM_THM_XPC22 => 4,
+                elf::R_ARM_PC24 => 4,
+                elf::R_ARM_XPC25 => 4,
+                elf::R_ARM_CALL => 4,
+                _ => 1,
+            },
+            _ => 1,
+        }
+    }
+
+    fn symbol_address(&self, address: u64, kind: SymbolKind) -> u64 {
+        if kind == SymbolKind::Function { address & !1 } else { address }
+    }
+
+    fn extra_symbol_flags(&self, symbol: &object::Symbol) -> SymbolFlagSet {
+        let mut flags = SymbolFlagSet::default();
+        if DisasmMode::from_object_symbol(symbol).is_some() {
+            flags |= SymbolFlag::Hidden;
+        }
+        flags
+    }
+
+    fn infer_function_size(
+        &self,
+        symbol: &Symbol,
+        section: &Section,
+        mut next_address: u64,
+    ) -> Result<u64> {
+        // TODO: This should probably check the disasm mode and trim accordingly,
+        // but self.disasm_modes isn't populated until post_init, so it needs a refactor.
+
+        // Trim any trailing 2-byte zeroes from the end (padding)
+        while next_address >= symbol.address + 2
+            && let Some(data) = section.data_range(next_address - 2, 2)
+            && data == [0u8; 2]
+            && section.relocation_at(next_address - 2, 2).is_none()
+        {
+            next_address -= 2;
+        }
+        Ok(next_address.saturating_sub(symbol.address))
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct DisasmMode {
+    address: u32,
+    mapping: unarm::ParseMode,
+}
+
+impl DisasmMode {
+    fn from_object_symbol<'a>(sym: &object::Symbol<'a, '_, &'a [u8]>) -> Option<Self> {
+        sym.name()
+            .ok()
+            .and_then(unarm::ParseMode::from_mapping_symbol)
+            .map(|mapping| DisasmMode { address: sym.address() as u32, mapping })
+    }
+
+    fn from_symbol(sym: &Symbol) -> Option<Self> {
+        unarm::ParseMode::from_mapping_symbol(&sym.name)
+            .map(|mapping| DisasmMode { address: sym.address as u32, mapping })
+    }
+}
+
+pub struct ArgsFormatter<'a> {
+    options: &'a unarm::Options,
+    cb: &'a mut dyn FnMut(InstructionPart) -> Result<()>,
+    resolved: &'a ResolvedInstructionRef<'a>,
+    skip_leading_space: bool,
+}
+
+impl ArgsFormatter<'_> {
+    fn write(&mut self, part: InstructionPart) -> core::fmt::Result {
+        (self.cb)(part).map_err(|_| core::fmt::Error)
+    }
+
+    fn write_opaque<F>(&mut self, value: F) -> core::fmt::Result
+    where F: unarm::FormatValue {
+        let mut string_fmt = unarm::StringFormatter::new(self.options);
+        value.write(&mut string_fmt)?;
+        self.write(InstructionPart::opaque(string_fmt.into_string()))?;
+        Ok(())
+    }
+}
+
+impl Write for ArgsFormatter<'_> {
+    fn write_str(&mut self, s: &str) -> core::fmt::Result { self.write(InstructionPart::basic(s)) }
+}
+
+impl unarm::FormatIns for ArgsFormatter<'_> {
+    fn options(&self) -> &unarm::Options { self.options }
+
+    fn write_ins(&mut self, ins: &unarm::Ins) -> core::fmt::Result {
+        let mut string_fmt = unarm::StringFormatter::new(self.options);
+        ins.write_opcode(&mut string_fmt)?;
+        let opcode = string_fmt.into_string();
+        self.write(InstructionPart::Opcode(Cow::Owned(opcode), self.resolved.ins_ref.opcode))?;
+        ins.write_params(self)
+    }
+
+    fn write_space(&mut self) -> core::fmt::Result {
+        if self.skip_leading_space {
+            self.skip_leading_space = false;
+            Ok(())
+        } else {
+            self.write_str(" ")
+        }
+    }
+
+    fn write_separator(&mut self) -> core::fmt::Result { self.write(InstructionPart::separator()) }
+
+    fn write_uimm(&mut self, uimm: u32) -> core::fmt::Result {
+        if let Some(resolved) = self.resolved.relocation
+            && let RelocationFlags::Elf(elf::R_ARM_ABS32) = resolved.relocation.flags
+        {
+            return self.write(InstructionPart::reloc());
+        }
+        self.write(InstructionPart::unsigned(uimm))
+    }
+
+    fn write_simm(&mut self, simm: i32) -> core::fmt::Result {
+        self.write(InstructionPart::signed(simm))
+    }
+
+    fn write_branch_target(&mut self, branch_target: unarm::BranchTarget) -> core::fmt::Result {
+        if let Some(resolved) = self.resolved.relocation {
+            match resolved.relocation.flags {
+                RelocationFlags::Elf(elf::R_ARM_THM_XPC22)
+                | RelocationFlags::Elf(elf::R_ARM_THM_PC22)
+                | RelocationFlags::Elf(elf::R_ARM_PC24)
+                | RelocationFlags::Elf(elf::R_ARM_XPC25)
+                | RelocationFlags::Elf(elf::R_ARM_CALL) => {
+                    return self.write(InstructionPart::reloc());
+                }
+                _ => {}
+            }
+        }
+        self.write(InstructionPart::branch_dest(branch_target.addr))
+    }
+
+    fn write_reg(&mut self, reg: unarm::Reg) -> core::fmt::Result { self.write_opaque(reg) }
+
+    fn write_status_reg(&mut self, status_reg: unarm::StatusReg) -> core::fmt::Result {
+        self.write_opaque(status_reg)
+    }
+
+    fn write_status_fields(&mut self, status_fields: unarm::StatusFields) -> core::fmt::Result {
+        self.write_opaque(status_fields)
+    }
+
+    fn write_shift_op(&mut self, shift_op: unarm::ShiftOp) -> core::fmt::Result {
+        self.write_opaque(shift_op)
+    }
+
+    fn write_coproc(&mut self, coproc: unarm::Coproc) -> core::fmt::Result {
+        self.write_opaque(coproc)
+    }
+
+    fn write_co_reg(&mut self, co_reg: unarm::CoReg) -> core::fmt::Result {
+        self.write_opaque(co_reg)
+    }
+
+    fn write_aif_flags(&mut self, aif_flags: unarm::AifFlags) -> core::fmt::Result {
+        self.write_opaque(aif_flags)
+    }
+
+    fn write_endianness(&mut self, endianness: unarm::Endianness) -> core::fmt::Result {
+        self.write_opaque(endianness)
+    }
+
+    fn write_sreg(&mut self, sreg: unarm::Sreg) -> core::fmt::Result { self.write_opaque(sreg) }
+
+    fn write_dreg(&mut self, dreg: unarm::Dreg) -> core::fmt::Result { self.write_opaque(dreg) }
+
+    fn write_fpscr(&mut self, fpscr: unarm::Fpscr) -> core::fmt::Result { self.write_opaque(fpscr) }
+
+    fn write_addr_ldr_str(&mut self, addr_ldr_str: unarm::AddrLdrStr) -> core::fmt::Result {
+        addr_ldr_str.write(self)?;
+        if let unarm::AddrLdrStr::Pre {
+            rn: unarm::Reg::Pc,
+            offset: unarm::LdrStrOffset::Imm(offset),
+            ..
+        } = addr_ldr_str
+        {
+            let thumb = self.resolved.ins_ref.opcode & (1 << 15) == 0;
+            let pc_offset = if thumb { 4 } else { 8 };
+            let pc = (self.resolved.ins_ref.address as u32 & !3) + pc_offset;
+            self.write(InstructionPart::basic(" (->"))?;
+            self.write(InstructionPart::branch_dest(pc.wrapping_add(offset as u32)))?;
+            self.write(InstructionPart::basic(")"))?;
+        }
+        Ok(())
+    }
+}

objdiff-core/src/arch/mips.rs

@@ -0,0 +1,501 @@
+use alloc::{
+    collections::{BTreeMap, BTreeSet},
+    string::ToString,
+    vec::Vec,
+};
+
+use anyhow::{Result, bail};
+use object::{Endian as _, Object as _, ObjectSection as _, ObjectSymbol as _, elf};
+use rabbitizer::{
+    IsaExtension, IsaVersion, Vram, abi::Abi, operands::ValuedOperand, registers_meta::Register,
+};
+
+use crate::{
+    arch::{Arch, RelocationOverride, RelocationOverrideTarget},
+    diff::{DiffObjConfig, DiffSide, MipsAbi, MipsInstrCategory, display::InstructionPart},
+    obj::{
+        InstructionArg, InstructionArgValue, InstructionRef, Relocation, RelocationFlags,
+        ResolvedInstructionRef, ResolvedRelocation, Section, Symbol, SymbolFlag, SymbolFlagSet,
+    },
+};
+
+#[derive(Debug)]
+pub struct ArchMips {
+    pub endianness: object::Endianness,
+    pub abi: Abi,
+    pub isa_extension: Option<IsaExtension>,
+    pub ri_gp_value: i32,
+    pub paired_relocations: Vec<BTreeMap<u64, i64>>,
+    pub ignored_symbols: BTreeSet<usize>,
+    pub diff_side: DiffSide,
+}
+
+const EF_MIPS_ABI: u32 = 0x0000F000;
+const EF_MIPS_MACH: u32 = 0x00FF0000;
+
+const EF_MIPS_MACH_ALLEGREX: u32 = 0x00840000;
+const EF_MIPS_MACH_5900: u32 = 0x00920000;
+
+const R_MIPS15_S3: u32 = 119;
+
+impl ArchMips {
+    pub fn new(object: &object::File, diff_side: DiffSide) -> Result<Self> {
+        let mut abi = Abi::O32;
+        let mut isa_extension = None;
+        match object.flags() {
+            object::FileFlags::None => {}
+            object::FileFlags::Elf { e_flags, .. } => {
+                abi = match e_flags & EF_MIPS_ABI {
+                    elf::EF_MIPS_ABI_O32 => Abi::O32,
+                    elf::EF_MIPS_ABI_O64 if e_flags & elf::EF_MIPS_ABI2 != 0 => Abi::N64,
+                    elf::EF_MIPS_ABI_O64 => Abi::O64,
+                    elf::EF_MIPS_ABI_EABI32 => Abi::EABI32,
+                    elf::EF_MIPS_ABI_EABI64 => Abi::EABI64,
+                    _ => {
+                        if e_flags & elf::EF_MIPS_ABI2 != 0 {
+                            Abi::N32
+                        } else {
+                            Abi::O32
+                        }
+                    }
+                };
+                isa_extension = match e_flags & EF_MIPS_MACH {
+                    EF_MIPS_MACH_ALLEGREX => Some(IsaExtension::R4000ALLEGREX),
+                    EF_MIPS_MACH_5900 => Some(IsaExtension::R5900EE),
+                    _ => None,
+                };
+            }
+            _ => bail!("Unsupported MIPS file flags"),
+        }
+
+        // Parse the ri_gp_value stored in .reginfo to be able to correctly
+        // calculate R_MIPS_GPREL16 relocations later. The value is stored
+        // 0x14 bytes into .reginfo (on 32-bit platforms)
+        let endianness = object.endianness();
+        let ri_gp_value = object
+            .section_by_name(".reginfo")
+            .and_then(|section| section.data().ok())
+            .and_then(|data| data.get(0x14..0x18))
+            .and_then(|s| s.try_into().ok())
+            .map(|bytes| endianness.read_i32_bytes(bytes))
+            .unwrap_or(0);
+
+        // Parse all relocations to pair R_MIPS_HI16 and R_MIPS_LO16. Since the instructions only
+        // have 16-bit immediate fields, the 32-bit addend is split across the two relocations.
+        // R_MIPS_LO16 relocations without an immediately preceding R_MIPS_HI16 use the last seen
+        // R_MIPS_HI16 addend.
+        // See https://refspecs.linuxfoundation.org/elf/mipsabi.pdf pages 4-17 and 4-18
+        let mut paired_relocations = Vec::with_capacity(object.sections().count() + 1);
+        for obj_section in object.sections() {
+            let data = obj_section.data()?;
+            let mut last_hi = None;
+            let mut last_hi_addend = 0;
+            let mut addends = BTreeMap::new();
+            for (addr, reloc) in obj_section.relocations() {
+                if !reloc.has_implicit_addend() {
+                    continue;
+                }
+                match reloc.flags() {
+                    object::RelocationFlags::Elf { r_type: elf::R_MIPS_HI16 } => {
+                        let code = data[addr as usize..addr as usize + 4].try_into()?;
+                        let addend = ((endianness.read_u32_bytes(code) & 0x0000FFFF) << 16) as i32;
+                        last_hi = Some(addr);
+                        last_hi_addend = addend;
+                    }
+                    object::RelocationFlags::Elf { r_type: elf::R_MIPS_LO16 } => {
+                        let code = data[addr as usize..addr as usize + 4].try_into()?;
+                        let addend = (endianness.read_u32_bytes(code) & 0x0000FFFF) as i16 as i32;
+                        let full_addend = (last_hi_addend + addend) as i64;
+                        if let Some(hi_addr) = last_hi.take() {
+                            addends.insert(hi_addr, full_addend);
+                        }
+                        addends.insert(addr, full_addend);
+                    }
+                    _ => {
+                        last_hi = None;
+                    }
+                }
+            }
+            let section_index = obj_section.index().0;
+            if section_index >= paired_relocations.len() {
+                paired_relocations.resize_with(section_index + 1, BTreeMap::new);
+            }
+            paired_relocations[section_index] = addends;
+        }
+
+        let mut ignored_symbols = BTreeSet::new();
+        for obj_symbol in object.symbols() {
+            let Ok(name) = obj_symbol.name() else { continue };
+            if let Some(prefix) = name.strip_suffix(".NON_MATCHING") {
+                ignored_symbols.insert(obj_symbol.index().0);
+                // Only remove the prefixless symbols if we are on the Base side of the diff,
+                // to allow diffing against target objects that contain `.NON_MATCHING` markers.
+                if diff_side == DiffSide::Base
+                    && let Some(target_symbol) = object.symbol_by_name(prefix)
+                {
+                    ignored_symbols.insert(target_symbol.index().0);
+                }
+            }
+        }
+
+        Ok(Self {
+            endianness,
+            abi,
+            isa_extension,
+            ri_gp_value,
+            paired_relocations,
+            ignored_symbols,
+            diff_side,
+        })
+    }
+
+    fn default_instruction_flags(&self) -> rabbitizer::InstructionFlags {
+        match self.isa_extension {
+            Some(extension) => rabbitizer::InstructionFlags::new_extension(extension),
+            None => rabbitizer::InstructionFlags::new(IsaVersion::MIPS_III),
+        }
+        .with_abi(self.abi)
+    }
+
+    fn instruction_flags(&self, diff_config: &DiffObjConfig) -> rabbitizer::InstructionFlags {
+        let isa_extension = match diff_config.mips_instr_category {
+            MipsInstrCategory::Auto => self.isa_extension,
+            MipsInstrCategory::Cpu => None,
+            MipsInstrCategory::Rsp => Some(IsaExtension::RSP),
+            MipsInstrCategory::R3000gte => Some(IsaExtension::R3000GTE),
+            MipsInstrCategory::R4000allegrex => Some(IsaExtension::R4000ALLEGREX),
+            MipsInstrCategory::R5900 => Some(IsaExtension::R5900EE),
+        };
+        match isa_extension {
+            Some(extension) => rabbitizer::InstructionFlags::new_extension(extension),
+            None => rabbitizer::InstructionFlags::new(IsaVersion::MIPS_III),
+        }
+        .with_abi(match diff_config.mips_abi {
+            MipsAbi::Auto => self.abi,
+            MipsAbi::O32 => Abi::O32,
+            MipsAbi::O64 => Abi::O64,
+            MipsAbi::N32 => Abi::N32,
+            MipsAbi::N64 => Abi::N64,
+            MipsAbi::Eabi32 => Abi::EABI32,
+            MipsAbi::Eabi64 => Abi::EABI64,
+        })
+    }
+
+    fn instruction_display_flags(
+        &self,
+        diff_config: &DiffObjConfig,
+    ) -> rabbitizer::InstructionDisplayFlags {
+        rabbitizer::InstructionDisplayFlags::default()
+            .with_unknown_instr_comment(false)
+            .with_use_dollar(diff_config.mips_register_prefix)
+    }
+
+    fn parse_ins_ref(
+        &self,
+        ins_ref: InstructionRef,
+        code: &[u8],
+        diff_config: &DiffObjConfig,
+    ) -> Result<rabbitizer::Instruction> {
+        Ok(rabbitizer::Instruction::new(
+            self.endianness.read_u32_bytes(code.try_into()?),
+            Vram::new(ins_ref.address as u32),
+            self.instruction_flags(diff_config),
+        ))
+    }
+}
+
+impl Arch for ArchMips {
+    fn scan_instructions_internal(
+        &self,
+        address: u64,
+        code: &[u8],
+        _section_index: usize,
+        _relocations: &[Relocation],
+        diff_config: &DiffObjConfig,
+    ) -> Result<Vec<InstructionRef>> {
+        let instruction_flags = self.instruction_flags(diff_config);
+        let mut ops = Vec::<InstructionRef>::with_capacity(code.len() / 4);
+        let mut cur_addr = address as u32;
+        for chunk in code.chunks_exact(4) {
+            let code = self.endianness.read_u32_bytes(chunk.try_into()?);
+            let instruction =
+                rabbitizer::Instruction::new(code, Vram::new(cur_addr), instruction_flags);
+            let opcode = instruction.opcode() as u16;
+            let branch_dest = instruction.get_branch_vram_generic().map(|v| v.inner() as u64);
+            ops.push(InstructionRef { address: cur_addr as u64, size: 4, opcode, branch_dest });
+            cur_addr += 4;
+        }
+        Ok(ops)
+    }
+
+    fn display_instruction(
+        &self,
+        resolved: ResolvedInstructionRef,
+        diff_config: &DiffObjConfig,
+        cb: &mut dyn FnMut(InstructionPart) -> Result<()>,
+    ) -> Result<()> {
+        let instruction = self.parse_ins_ref(resolved.ins_ref, resolved.code, diff_config)?;
+        let display_flags = self.instruction_display_flags(diff_config);
+        let opcode = instruction.opcode();
+        cb(InstructionPart::opcode(opcode.name(), opcode as u16))?;
+        push_args(&instruction, resolved.relocation, &display_flags, cb)?;
+        Ok(())
+    }
+
+    fn relocation_override(
+        &self,
+        file: &object::File<'_>,
+        section: &object::Section,
+        address: u64,
+        relocation: &object::Relocation,
+    ) -> Result<Option<RelocationOverride>> {
+        match relocation.flags() {
+            // Handle ELF implicit relocations
+            object::RelocationFlags::Elf { r_type } => {
+                if relocation.has_implicit_addend() {
+                    // Check for paired R_MIPS_HI16 and R_MIPS_LO16 relocations.
+                    if let elf::R_MIPS_HI16 | elf::R_MIPS_LO16 = r_type
+                        && let Some(addend) = self
+                            .paired_relocations
+                            .get(section.index().0)
+                            .and_then(|m| m.get(&address).copied())
+                    {
+                        return Ok(Some(RelocationOverride {
+                            target: RelocationOverrideTarget::Keep,
+                            addend,
+                        }));
+                    }
+
+                    let data = section.data()?;
+                    let code = self
+                        .endianness
+                        .read_u32_bytes(data[address as usize..address as usize + 4].try_into()?);
+                    let addend = match r_type {
+                        elf::R_MIPS_32 => code as i64,
+                        elf::R_MIPS_26 => ((code & 0x03FFFFFF) << 2) as i64,
+                        elf::R_MIPS_HI16 => ((code & 0x0000FFFF) << 16) as i32 as i64,
+                        elf::R_MIPS_LO16 | elf::R_MIPS_GOT16 | elf::R_MIPS_CALL16 => {
+                            (code & 0x0000FFFF) as i16 as i64
+                        }
+                        elf::R_MIPS_GPREL16 | elf::R_MIPS_LITERAL => {
+                            let object::RelocationTarget::Symbol(idx) = relocation.target() else {
+                                bail!("Unsupported R_MIPS_GPREL16 relocation against a non-symbol");
+                            };
+                            let sym = file.symbol_by_index(idx)?;
+
+                            // if the symbol we are relocating against is in a local section we need to add
+                            // the ri_gp_value from .reginfo to the addend.
+                            if sym.section().index().is_some() {
+                                ((code & 0x0000FFFF) as i16 as i64) + self.ri_gp_value as i64
+                            } else {
+                                (code & 0x0000FFFF) as i16 as i64
+                            }
+                        }
+                        elf::R_MIPS_PC16 => 0, // PC-relative relocation
+                        R_MIPS15_S3 => ((code & 0x001FFFC0) >> 3) as i64,
+                        elf::R_MIPS_GPREL32 => (code as i32 as i64) + self.ri_gp_value as i64,
+                        flags => bail!("Unsupported MIPS implicit relocation {flags:?}"),
+                    };
+                    Ok(Some(RelocationOverride { target: RelocationOverrideTarget::Keep, addend }))
+                } else {
+                    Ok(None)
+                }
+            }
+            _ => Ok(None),
+        }
+    }
+
+    fn reloc_name(&self, flags: RelocationFlags) -> Option<&'static str> {
+        match flags {
+            RelocationFlags::Elf(r_type) => match r_type {
+                elf::R_MIPS_NONE => Some("R_MIPS_NONE"),
+                elf::R_MIPS_16 => Some("R_MIPS_16"),
+                elf::R_MIPS_32 => Some("R_MIPS_32"),
+                elf::R_MIPS_26 => Some("R_MIPS_26"),
+                elf::R_MIPS_HI16 => Some("R_MIPS_HI16"),
+                elf::R_MIPS_LO16 => Some("R_MIPS_LO16"),
+                elf::R_MIPS_GPREL16 => Some("R_MIPS_GPREL16"),
+                elf::R_MIPS_LITERAL => Some("R_MIPS_LITERAL"),
+                elf::R_MIPS_GOT16 => Some("R_MIPS_GOT16"),
+                elf::R_MIPS_PC16 => Some("R_MIPS_PC16"),
+                elf::R_MIPS_CALL16 => Some("R_MIPS_CALL16"),
+                elf::R_MIPS_GPREL32 => Some("R_MIPS_GPREL32"),
+                R_MIPS15_S3 => Some("R_MIPS15_S3"),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+
+    fn data_reloc_size(&self, flags: RelocationFlags) -> usize {
+        match flags {
+            RelocationFlags::Elf(r_type) => match r_type {
+                elf::R_MIPS_16 => 2,
+                elf::R_MIPS_32 => 4,
+                _ => 1,
+            },
+            _ => 1,
+        }
+    }
+
+    fn extra_symbol_flags(&self, symbol: &object::Symbol) -> SymbolFlagSet {
+        let mut flags = SymbolFlagSet::default();
+        if self.ignored_symbols.contains(&symbol.index().0) {
+            flags |= SymbolFlag::Ignored;
+        }
+        flags
+    }
+
+    fn infer_function_size(
+        &self,
+        symbol: &Symbol,
+        section: &Section,
+        next_address: u64,
+    ) -> Result<u64> {
+        // Trim any trailing 4-byte zeroes from the end (nops)
+        let mut new_address = next_address;
+        while new_address >= symbol.address + 4
+            && let Some(data) = section.data_range(new_address - 4, 4)
+            && data == [0u8; 4]
+            && section.relocation_at(next_address - 4, 4).is_none()
+        {
+            new_address -= 4;
+        }
+        // Check if the last instruction has a delay slot, if so, include the delay slot nop
+        if new_address + 4 <= next_address
+            && new_address >= symbol.address + 4
+            && let Some(data) = section.data_range(new_address - 4, 4)
+            && let instruction = rabbitizer::Instruction::new(
+                self.endianness.read_u32_bytes(data.try_into().unwrap()),
+                Vram::new((new_address - 4) as u32),
+                self.default_instruction_flags(),
+            )
+            && instruction.opcode().has_delay_slot()
+        {
+            new_address += 4;
+        }
+        Ok(new_address.saturating_sub(symbol.address))
+    }
+}
+
+fn push_args(
+    instruction: &rabbitizer::Instruction,
+    relocation: Option<ResolvedRelocation>,
+    display_flags: &rabbitizer::InstructionDisplayFlags,
+    mut arg_cb: impl FnMut(InstructionPart) -> Result<()>,
+) -> Result<()> {
+    let operands = instruction.valued_operands_iter();
+    for (idx, op) in operands.enumerate() {
+        if idx > 0 {
+            arg_cb(InstructionPart::separator())?;
+        }
+
+        match op {
+            ValuedOperand::core_imm_i16(imm) => {
+                if let Some(resolved) = relocation {
+                    push_reloc(resolved.relocation, &mut arg_cb)?;
+                } else {
+                    arg_cb(InstructionPart::signed(imm))?;
+                }
+            }
+            ValuedOperand::core_imm_u16(imm) => {
+                if let Some(resolved) = relocation {
+                    push_reloc(resolved.relocation, &mut arg_cb)?;
+                } else {
+                    arg_cb(InstructionPart::unsigned(imm))?;
+                }
+            }
+            ValuedOperand::core_label(..) | ValuedOperand::core_branch_target_label(..) => {
+                if let Some(resolved) = relocation {
+                    push_reloc(resolved.relocation, &mut arg_cb)?;
+                } else if let Some(branch_dest) = instruction
+                    .get_branch_offset_generic()
+                    .map(|o| (instruction.vram() + o).inner() as u64)
+                {
+                    arg_cb(InstructionPart::branch_dest(branch_dest))?;
+                } else {
+                    arg_cb(InstructionPart::opaque(
+                        op.display(instruction, display_flags, None::<&str>).to_string(),
+                    ))?;
+                }
+            }
+            ValuedOperand::core_imm_rs(imm, base) => {
+                if let Some(resolved) = relocation {
+                    push_reloc(resolved.relocation, &mut arg_cb)?;
+                } else {
+                    arg_cb(InstructionPart::Arg(InstructionArg::Value(
+                        InstructionArgValue::Signed(imm as i64),
+                    )))?;
+                }
+                arg_cb(InstructionPart::basic("("))?;
+                arg_cb(InstructionPart::opaque(base.either_name(
+                    instruction.flags().abi(),
+                    display_flags.named_gpr(),
+                    !display_flags.use_dollar(),
+                )))?;
+                arg_cb(InstructionPart::basic(")"))?;
+            }
+            // ValuedOperand::r5900_immediate15(..) => match relocation {
+            //     Some(resolved)
+            //         if resolved.relocation.flags == RelocationFlags::Elf(R_MIPS15_S3) =>
+            //     {
+            //         push_reloc(&resolved.relocation, &mut arg_cb)?;
+            //     }
+            //     _ => {
+            //         arg_cb(InstructionPart::opaque(op.disassemble(&instruction, None)))?;
+            //     }
+            // },
+            _ => {
+                arg_cb(InstructionPart::opaque(
+                    op.display(instruction, display_flags, None::<&str>).to_string(),
+                ))?;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn push_reloc(
+    reloc: &Relocation,
+    mut arg_cb: impl FnMut(InstructionPart) -> Result<()>,
+) -> Result<()> {
+    match reloc.flags {
+        RelocationFlags::Elf(r_type) => match r_type {
+            elf::R_MIPS_HI16 => {
+                arg_cb(InstructionPart::basic("%hi("))?;
+                arg_cb(InstructionPart::reloc())?;
+                arg_cb(InstructionPart::basic(")"))?;
+            }
+            elf::R_MIPS_LO16 => {
+                arg_cb(InstructionPart::basic("%lo("))?;
+                arg_cb(InstructionPart::reloc())?;
+                arg_cb(InstructionPart::basic(")"))?;
+            }
+            elf::R_MIPS_GOT16 => {
+                arg_cb(InstructionPart::basic("%got("))?;
+                arg_cb(InstructionPart::reloc())?;
+                arg_cb(InstructionPart::basic(")"))?;
+            }
+            elf::R_MIPS_CALL16 => {
+                arg_cb(InstructionPart::basic("%call16("))?;
+                arg_cb(InstructionPart::reloc())?;
+                arg_cb(InstructionPart::basic(")"))?;
+            }
+            elf::R_MIPS_GPREL16 => {
+                arg_cb(InstructionPart::basic("%gp_rel("))?;
+                arg_cb(InstructionPart::reloc())?;
+                arg_cb(InstructionPart::basic(")"))?;
+            }
+            elf::R_MIPS_32
+            | elf::R_MIPS_26
+            | elf::R_MIPS_LITERAL
+            | elf::R_MIPS_PC16
+            | R_MIPS15_S3 => {
+                arg_cb(InstructionPart::reloc())?;
+            }
+            _ => bail!("Unsupported ELF MIPS relocation type {r_type}"),
+        },
+        flags => panic!("Unsupported MIPS relocation flags {flags:?}"),
+    }
+    Ok(())
+}

objdiff-core/src/arch/mod.rs

@@ -0,0 +1,501 @@
+use alloc::{
+    borrow::Cow,
+    boxed::Box,
+    format,
+    string::{String, ToString},
+    vec::Vec,
+};
+use core::{
+    any::Any,
+    fmt::{self, Debug},
+};
+
+use anyhow::{Result, bail};
+use object::Endian as _;
+
+use crate::{
+    diff::{
+        DiffObjConfig, DiffSide,
+        display::{ContextItem, HoverItem, InstructionPart},
+    },
+    obj::{
+        FlowAnalysisResult, InstructionArg, InstructionRef, Object, ParsedInstruction, Relocation,
+        RelocationFlags, ResolvedInstructionRef, ResolvedSymbol, Section, Symbol, SymbolFlagSet,
+        SymbolKind,
+    },
+    util::ReallySigned,
+};
+
+#[cfg(feature = "arm")]
+pub mod arm;
+#[cfg(feature = "arm64")]
+pub mod arm64;
+#[cfg(feature = "mips")]
+pub mod mips;
+#[cfg(feature = "ppc")]
+pub mod ppc;
+#[cfg(feature = "superh")]
+pub mod superh;
+#[cfg(feature = "x86")]
+pub mod x86;
+
+pub const OPCODE_INVALID: u16 = u16::MAX;
+pub const OPCODE_DATA: u16 = u16::MAX - 1;
+
+const SUPPORTED_ENCODINGS: [(&encoding_rs::Encoding, &str); 7] = [
+    (encoding_rs::UTF_8, "UTF-8"),
+    (encoding_rs::SHIFT_JIS, "Shift JIS"),
+    (encoding_rs::UTF_16BE, "UTF-16BE"),
+    (encoding_rs::UTF_16LE, "UTF-16LE"),
+    (encoding_rs::WINDOWS_1252, "Windows-1252"),
+    (encoding_rs::EUC_JP, "EUC-JP"),
+    (encoding_rs::BIG5, "Big5"),
+];
+
+/// Represents the type of data associated with an instruction
+#[derive(PartialEq)]
+pub enum DataType {
+    Int8,
+    Int16,
+    Int32,
+    Int64,
+    Float,
+    Double,
+    Bytes,
+    String,
+}
+
+impl fmt::Display for DataType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            DataType::Int8 => "Int8",
+            DataType::Int16 => "Int16",
+            DataType::Int32 => "Int32",
+            DataType::Int64 => "Int64",
+            DataType::Float => "Float",
+            DataType::Double => "Double",
+            DataType::Bytes => "Bytes",
+            DataType::String => "String",
+        })
+    }
+}
+
+impl DataType {
+    pub fn display_labels(&self, endian: object::Endianness, bytes: &[u8]) -> Vec<String> {
+        let mut strs = Vec::new();
+        for (literal, label_override) in self.display_literals(endian, bytes) {
+            let label = label_override.unwrap_or_else(|| self.to_string());
+            strs.push(format!("{label}: {literal:?}"))
+        }
+        strs
+    }
+
+    pub fn display_literals(
+        &self,
+        endian: object::Endianness,
+        bytes: &[u8],
+    ) -> Vec<(String, Option<String>)> {
+        let mut strs = Vec::new();
+        if self.required_len().is_some_and(|l| bytes.len() < l) {
+            log::warn!(
+                "Failed to display a symbol value for a symbol whose size is too small for instruction referencing it."
+            );
+            return strs;
+        }
+        let mut bytes = bytes;
+        if self.required_len().is_some_and(|l| bytes.len() > l) {
+            // If the symbol's size is larger a single instance of this data type, we take just the
+            // bytes necessary for one of them in order to display the first element of the array.
+            bytes = &bytes[0..self.required_len().unwrap()];
+            // TODO: Attempt to interpret large symbols as arrays of a smaller type and show all
+            // elements of the array instead. https://github.com/encounter/objdiff/issues/124
+            // However, note that the stride of an array can not always be determined just by the
+            // data type guessed by the single instruction accessing it. There can also be arrays of
+            // structs that contain multiple elements of different types, so if other elements after
+            // the first one were to be displayed in this manner, they may be inaccurate.
+        }
+
+        match self {
+            DataType::Int8 => {
+                let i = i8::from_ne_bytes(bytes.try_into().unwrap());
+                strs.push((format!("{i:#x}"), None));
+
+                if i < 0 {
+                    strs.push((format!("{:#x}", ReallySigned(i)), None));
+                }
+            }
+            DataType::Int16 => {
+                let i = endian.read_i16_bytes(bytes.try_into().unwrap());
+                strs.push((format!("{i:#x}"), None));
+
+                if i < 0 {
+                    strs.push((format!("{:#x}", ReallySigned(i)), None));
+                }
+            }
+            DataType::Int32 => {
+                let i = endian.read_i32_bytes(bytes.try_into().unwrap());
+                strs.push((format!("{i:#x}"), None));
+
+                if i < 0 {
+                    strs.push((format!("{:#x}", ReallySigned(i)), None));
+                }
+            }
+            DataType::Int64 => {
+                let i = endian.read_i64_bytes(bytes.try_into().unwrap());
+                strs.push((format!("{i:#x}"), None));
+
+                if i < 0 {
+                    strs.push((format!("{:#x}", ReallySigned(i)), None));
+                }
+            }
+            DataType::Float => {
+                let bytes: [u8; 4] = bytes.try_into().unwrap();
+                strs.push((
+                    format!("{:?}f", match endian {
+                        object::Endianness::Little => f32::from_le_bytes(bytes),
+                        object::Endianness::Big => f32::from_be_bytes(bytes),
+                    }),
+                    None,
+                ));
+            }
+            DataType::Double => {
+                let bytes: [u8; 8] = bytes.try_into().unwrap();
+                strs.push((
+                    format!("{:?}", match endian {
+                        object::Endianness::Little => f64::from_le_bytes(bytes),
+                        object::Endianness::Big => f64::from_be_bytes(bytes),
+                    }),
+                    None,
+                ));
+            }
+            DataType::Bytes => {
+                strs.push((format!("{bytes:#?}"), None));
+            }
+            DataType::String => {
+                if let Some(nul_idx) = bytes.iter().position(|&c| c == b'\0') {
+                    let str_bytes = &bytes[..nul_idx];
+                    // Special case to display (ASCII) as the label for ASCII-only strings.
+                    let (cow, _, had_errors) = encoding_rs::UTF_8.decode(str_bytes);
+                    if !had_errors && cow.is_ascii() {
+                        strs.push((format!("{cow}"), Some("ASCII".into())));
+                    }
+                    for (encoding, encoding_name) in SUPPORTED_ENCODINGS {
+                        let (cow, _, had_errors) = encoding.decode(str_bytes);
+                        // Avoid showing ASCII-only strings more than once if the encoding is ASCII-compatible.
+                        if !had_errors && (!encoding.is_ascii_compatible() || !cow.is_ascii()) {
+                            strs.push((format!("{cow}"), Some(encoding_name.into())));
+                        }
+                    }
+                }
+            }
+        }
+
+        strs
+    }
+
+    fn required_len(&self) -> Option<usize> {
+        match self {
+            DataType::Int8 => Some(1),
+            DataType::Int16 => Some(2),
+            DataType::Int32 => Some(4),
+            DataType::Int64 => Some(8),
+            DataType::Float => Some(4),
+            DataType::Double => Some(8),
+            DataType::Bytes => None,
+            DataType::String => None,
+        }
+    }
+}
+
+impl dyn Arch {
+    /// Generate a list of instructions references (offset, size, opcode) from the given code.
+    ///
+    /// See [`scan_instructions_internal`] for more details.
+    pub fn scan_instructions(
+        &self,
+        resolved: ResolvedSymbol,
+        diff_config: &DiffObjConfig,
+    ) -> Result<Vec<InstructionRef>> {
+        let mut result = self.scan_instructions_internal(
+            resolved.symbol.address,
+            resolved.data,
+            resolved.section_index,
+            &resolved.section.relocations,
+            diff_config,
+        )?;
+
+        let function_start = resolved.symbol.address;
+        let function_end = function_start + resolved.symbol.size;
+
+        // Remove any branch destinations that are outside the function range
+        for ins in result.iter_mut() {
+            if let Some(branch_dest) = ins.branch_dest
+                && (branch_dest < function_start || branch_dest >= function_end)
+            {
+                ins.branch_dest = None;
+            }
+        }
+
+        // Resolve relocation targets within the same function to branch destinations
+        let mut ins_iter = result.iter_mut().peekable();
+        'outer: for reloc in resolved
+            .section
+            .relocations
+            .iter()
+            .skip_while(|r| r.address < function_start)
+            .take_while(|r| r.address < function_end)
+        {
+            let ins = loop {
+                let Some(ins) = ins_iter.peek_mut() else {
+                    break 'outer;
+                };
+                if reloc.address < ins.address {
+                    continue 'outer;
+                }
+                let ins = ins_iter.next().unwrap();
+                if reloc.address >= ins.address && reloc.address < ins.address + ins.size as u64 {
+                    break ins;
+                }
+            };
+            // Clear existing branch destination for instructions with relocations
+            ins.branch_dest = None;
+            let Some(target) = resolved.obj.symbols.get(reloc.target_symbol) else {
+                continue;
+            };
+            if target.section != Some(resolved.section_index) {
+                continue;
+            }
+            let Some(target_address) = target.address.checked_add_signed(reloc.addend) else {
+                continue;
+            };
+            // If the target address is within the function range, set it as a branch destination
+            if target_address >= function_start && target_address < function_end {
+                ins.branch_dest = Some(target_address);
+            }
+        }
+
+        Ok(result)
+    }
+
+    /// Parse an instruction to gather its mnemonic and arguments for more detailed comparison.
+    ///
+    /// This is called only when we need to compare the arguments of an instruction.
+    pub fn process_instruction(
+        &self,
+        resolved: ResolvedInstructionRef,
+        diff_config: &DiffObjConfig,
+    ) -> Result<ParsedInstruction> {
+        let mut mnemonic = None;
+        let mut args = Vec::with_capacity(8);
+        let mut relocation_emitted = false;
+        self.display_instruction(resolved, diff_config, &mut |part| {
+            match part {
+                InstructionPart::Opcode(m, _) => mnemonic = Some(Cow::Owned(m.into_owned())),
+                InstructionPart::Arg(arg) => {
+                    if arg == InstructionArg::Reloc {
+                        relocation_emitted = true;
+                        // If the relocation was resolved to a branch destination, emit that instead.
+                        if let Some(dest) = resolved.ins_ref.branch_dest {
+                            args.push(InstructionArg::BranchDest(dest));
+                            return Ok(());
+                        }
+                    }
+                    args.push(arg.into_static());
+                }
+                _ => {}
+            }
+            Ok(())
+        })?;
+        // If the instruction has a relocation, but we didn't format it in the display, add it to
+        // the end of the arguments list.
+        if resolved.relocation.is_some() && !relocation_emitted {
+            args.push(InstructionArg::Reloc);
+        }
+        Ok(ParsedInstruction {
+            ins_ref: resolved.ins_ref,
+            mnemonic: mnemonic.unwrap_or_default(),
+            args,
+        })
+    }
+}
+
+pub trait Arch: Any + Debug + Send + Sync {
+    /// Finishes arch-specific initialization that must be done after sections have been combined.
+    fn post_init(&mut self, _sections: &[Section], _symbols: &[Symbol]) {}
+
+    /// Generate a list of instructions references (offset, size, opcode) from the given code.
+    ///
+    /// The opcode IDs are used to generate the initial diff. Implementations should do as little
+    /// parsing as possible here: just enough to identify the base instruction opcode, size, and
+    /// possible branch destination (for visual representation). As needed, instructions are parsed
+    /// via `process_instruction` to compare their arguments.
+    fn scan_instructions_internal(
+        &self,
+        address: u64,
+        code: &[u8],
+        section_index: usize,
+        relocations: &[Relocation],
+        diff_config: &DiffObjConfig,
+    ) -> Result<Vec<InstructionRef>>;
+
+    /// Format an instruction for display.
+    ///
+    /// Implementations should call the callback for each part of the instruction: usually the
+    /// mnemonic and arguments, plus any separators and visual formatting.
+    fn display_instruction(
+        &self,
+        resolved: ResolvedInstructionRef,
+        diff_config: &DiffObjConfig,
+        cb: &mut dyn FnMut(InstructionPart) -> Result<()>,
+    ) -> Result<()>;
+
+    /// Generate a list of fake relocations from the given code that represent pooled data accesses.
+    fn generate_pooled_relocations(
+        &self,
+        _address: u64,
+        _code: &[u8],
+        _relocations: &[Relocation],
+        _symbols: &[Symbol],
+    ) -> Vec<Relocation> {
+        Vec::new()
+    }
+
+    // Perform detailed data flow analysis
+    fn data_flow_analysis(
+        &self,
+        _obj: &Object,
+        _symbol: &Symbol,
+        _code: &[u8],
+        _relocations: &[Relocation],
+    ) -> Option<Box<dyn FlowAnalysisResult>> {
+        None
+    }
+
+    fn relocation_override(
+        &self,
+        _file: &object::File<'_>,
+        _section: &object::Section,
+        _address: u64,
+        _relocation: &object::Relocation,
+    ) -> Result<Option<RelocationOverride>> {
+        Ok(None)
+    }
+
+    fn reloc_name(&self, _flags: RelocationFlags) -> Option<&'static str> { None }
+
+    fn data_reloc_size(&self, flags: RelocationFlags) -> usize;
+
+    fn symbol_address(&self, address: u64, _kind: SymbolKind) -> u64 { address }
+
+    fn extra_symbol_flags(&self, _symbol: &object::Symbol) -> SymbolFlagSet {
+        SymbolFlagSet::default()
+    }
+
+    fn guess_data_type(
+        &self,
+        _resolved: ResolvedInstructionRef,
+        _bytes: &[u8],
+    ) -> Option<DataType> {
+        None
+    }
+
+    fn symbol_hover(&self, _obj: &Object, _symbol_index: usize) -> Vec<HoverItem> { Vec::new() }
+
+    fn symbol_context(&self, _obj: &Object, _symbol_index: usize) -> Vec<ContextItem> { Vec::new() }
+
+    fn instruction_hover(
+        &self,
+        _obj: &Object,
+        _resolved: ResolvedInstructionRef,
+    ) -> Vec<HoverItem> {
+        Vec::new()
+    }
+
+    fn instruction_context(
+        &self,
+        _obj: &Object,
+        _resolved: ResolvedInstructionRef,
+    ) -> Vec<ContextItem> {
+        Vec::new()
+    }
+
+    fn infer_function_size(
+        &self,
+        symbol: &Symbol,
+        _section: &Section,
+        next_address: u64,
+    ) -> Result<u64> {
+        Ok(next_address.saturating_sub(symbol.address))
+    }
+}
+
+pub fn new_arch(object: &object::File, diff_side: DiffSide) -> Result<Box<dyn Arch>> {
+    use object::Object as _;
+    // Avoid unused warnings on non-mips builds
+    let _ = diff_side;
+
+    Ok(match object.architecture() {
+        #[cfg(feature = "ppc")]
+        object::Architecture::PowerPc | object::Architecture::PowerPc64 => {
+            Box::new(ppc::ArchPpc::new(object)?)
+        }
+        #[cfg(feature = "mips")]
+        object::Architecture::Mips => Box::new(mips::ArchMips::new(object, diff_side)?),
+        #[cfg(feature = "x86")]
+        object::Architecture::I386 | object::Architecture::X86_64 => {
+            Box::new(x86::ArchX86::new(object)?)
+        }
+        #[cfg(feature = "arm")]
+        object::Architecture::Arm => Box::new(arm::ArchArm::new(object)?),
+        #[cfg(feature = "arm64")]
+        object::Architecture::Aarch64 => Box::new(arm64::ArchArm64::new(object)?),
+        #[cfg(feature = "superh")]
+        object::Architecture::SuperH => Box::new(superh::ArchSuperH::new(object)?),
+        arch => bail!("Unsupported architecture: {arch:?}"),
+    })
+}
+
+#[derive(Debug, Default)]
+pub struct ArchDummy {}
+
+impl ArchDummy {
+    pub fn new() -> Box<Self> { Box::new(Self {}) }
+}
+
+impl Arch for ArchDummy {
+    fn scan_instructions_internal(
+        &self,
+        _address: u64,
+        _code: &[u8],
+        _section_index: usize,
+        _relocations: &[Relocation],
+        _diff_config: &DiffObjConfig,
+    ) -> Result<Vec<InstructionRef>> {
+        Ok(Vec::new())
+    }
+
+    fn display_instruction(
+        &self,
+        _resolved: ResolvedInstructionRef,
+        _diff_config: &DiffObjConfig,
+        _cb: &mut dyn FnMut(InstructionPart) -> Result<()>,
+    ) -> Result<()> {
+        Ok(())
+    }
+
+    fn data_reloc_size(&self, _flags: RelocationFlags) -> usize { 0 }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RelocationOverrideTarget {
+    Keep,
+    Skip,
+    Symbol(object::SymbolIndex),
+    Section(object::SectionIndex),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct RelocationOverride {
+    pub target: RelocationOverrideTarget,
+    pub addend: i64,
+}

objdiff-core/src/arch/ppc/flow_analysis.rs

@@ -0,0 +1,649 @@
+use alloc::{
+    boxed::Box,
+    collections::{BTreeMap, BTreeSet},
+    format,
+    string::{String, ToString},
+    vec::Vec,
+};
+use core::{
+    ffi::CStr,
+    ops::{Index, IndexMut},
+};
+
+use itertools::Itertools;
+use powerpc::{Extensions, Simm};
+
+use crate::{
+    arch::DataType,
+    obj::{FlowAnalysisResult, FlowAnalysisValue, Object, Relocation, Symbol},
+    util::{RawDouble, RawFloat},
+};
+
+fn is_store_instruction(op: powerpc::Opcode) -> bool {
+    use powerpc::Opcode;
+    matches!(
+        op,
+        Opcode::Stbux
+            | Opcode::Stbx
+            | Opcode::Stfdux
+            | Opcode::Stfdx
+            | Opcode::Stfiwx
+            | Opcode::Stfsux
+            | Opcode::Stfsx
+            | Opcode::Sthbrx
+            | Opcode::Sthux
+            | Opcode::Sthx
+            | Opcode::Stswi
+            | Opcode::Stswx
+            | Opcode::Stwbrx
+            | Opcode::Stwcx_
+            | Opcode::Stwux
+            | Opcode::Stwx
+            | Opcode::Stwu
+            | Opcode::Stb
+            | Opcode::Stbu
+            | Opcode::Sth
+            | Opcode::Sthu
+            | Opcode::Stmw
+            | Opcode::Stfs
+            | Opcode::Stfsu
+            | Opcode::Stfd
+            | Opcode::Stfdu
+    )
+}
+
+pub fn guess_data_type_from_load_store_inst_op(inst_op: powerpc::Opcode) -> Option<DataType> {
+    use powerpc::Opcode;
+    match inst_op {
+        Opcode::Lbz | Opcode::Lbzu | Opcode::Lbzux | Opcode::Lbzx => Some(DataType::Int8),
+        Opcode::Lhz | Opcode::Lhzu | Opcode::Lhzux | Opcode::Lhzx => Some(DataType::Int16),
+        Opcode::Lha | Opcode::Lhau | Opcode::Lhaux | Opcode::Lhax => Some(DataType::Int16),
+        Opcode::Lwz | Opcode::Lwzu | Opcode::Lwzux | Opcode::Lwzx => Some(DataType::Int32),
+        Opcode::Lfs | Opcode::Lfsu | Opcode::Lfsux | Opcode::Lfsx => Some(DataType::Float),
+        Opcode::Lfd | Opcode::Lfdu | Opcode::Lfdux | Opcode::Lfdx => Some(DataType::Double),
+
+        Opcode::Stb | Opcode::Stbu | Opcode::Stbux | Opcode::Stbx => Some(DataType::Int8),
+        Opcode::Sth | Opcode::Sthu | Opcode::Sthux | Opcode::Sthx => Some(DataType::Int16),
+        Opcode::Stw | Opcode::Stwu | Opcode::Stwux | Opcode::Stwx => Some(DataType::Int32),
+        Opcode::Stfs | Opcode::Stfsu | Opcode::Stfsux | Opcode::Stfsx => Some(DataType::Float),
+        Opcode::Stfd | Opcode::Stfdu | Opcode::Stfdux | Opcode::Stfdx => Some(DataType::Double),
+        _ => None,
+    }
+}
+
+#[derive(Default, PartialEq, Eq, Copy, Clone, Debug, PartialOrd, Ord)]
+enum RegisterContent {
+    #[default]
+    Unknown,
+    Variable, // Multiple potential values
+    FloatConstant(RawFloat),
+    DoubleConstant(RawDouble),
+    IntConstant(i32),
+    InputRegister(u8),
+    Symbol(usize),
+}
+
+impl core::fmt::Display for RegisterContent {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            RegisterContent::Unknown => write!(f, "unknown"),
+            RegisterContent::Variable => write!(f, "variable"),
+            RegisterContent::IntConstant(i) =>
+            // -i is safe because it's at most a 16 bit constant in the i32
+            {
+                if *i >= 0 {
+                    write!(f, "0x{i:x}")
+                } else {
+                    write!(f, "-0x{:x}", -i)
+                }
+            }
+            RegisterContent::FloatConstant(RawFloat(fp)) => write!(f, "{fp:?}f"),
+            RegisterContent::DoubleConstant(RawDouble(fp)) => write!(f, "{fp:?}d"),
+            RegisterContent::InputRegister(p) => write!(f, "input{p}"),
+            RegisterContent::Symbol(_u) => write!(f, "relocation"),
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Ord, PartialOrd)]
+struct RegisterState {
+    gpr: [RegisterContent; 32],
+    fpr: [RegisterContent; 32],
+}
+
+impl RegisterState {
+    fn new() -> Self {
+        RegisterState { gpr: [RegisterContent::Unknown; 32], fpr: [RegisterContent::Unknown; 32] }
+    }
+
+    // During a function call, these registers must be assumed trashed.
+    fn clear_volatile(&mut self) {
+        self[powerpc::GPR(0)] = RegisterContent::Unknown;
+        for i in 0..=13 {
+            self[powerpc::GPR(i)] = RegisterContent::Unknown;
+        }
+        for i in 0..=13 {
+            self[powerpc::FPR(i)] = RegisterContent::Unknown;
+        }
+    }
+
+    // Mark potential input values.
+    // Subsequent flow analysis will "realize" that they are not actually inputs if
+    // they get overwritten with another value before getting read.
+    fn set_potential_inputs(&mut self) {
+        for g_reg in 3..=13 {
+            self[powerpc::GPR(g_reg)] = RegisterContent::InputRegister(g_reg);
+        }
+        for f_reg in 1..=13 {
+            self[powerpc::FPR(f_reg)] = RegisterContent::InputRegister(f_reg);
+        }
+    }
+
+    // If the there is no value, we can take the new known value.
+    // If there's a known value different than the new value, the content
+    // must is variable.
+    // Returns whether the current value was updated.
+    fn unify_values(current: &mut RegisterContent, new: &RegisterContent) -> bool {
+        if *current == *new {
+            false
+        } else if *current == RegisterContent::Unknown {
+            *current = *new;
+            true
+        } else if *current == RegisterContent::Variable {
+            // Already variable
+            false
+        } else {
+            *current = RegisterContent::Variable;
+            true
+        }
+    }
+
+    // Unify currently known register contents in a give situation with new
+    // information about the register contents in that situation.
+    // Currently unknown register contents can be filled, but if there are
+    // conflicting contents, we go back to unknown.
+    fn unify(&mut self, other: &RegisterState) -> bool {
+        let mut updated = false;
+        for i in 0..32 {
+            updated |= Self::unify_values(&mut self.gpr[i], &other.gpr[i]);
+            updated |= Self::unify_values(&mut self.fpr[i], &other.fpr[i]);
+        }
+        updated
+    }
+}
+
+impl Index<powerpc::GPR> for RegisterState {
+    type Output = RegisterContent;
+
+    fn index(&self, gpr: powerpc::GPR) -> &Self::Output { &self.gpr[gpr.0 as usize] }
+}
+impl IndexMut<powerpc::GPR> for RegisterState {
+    fn index_mut(&mut self, gpr: powerpc::GPR) -> &mut Self::Output {
+        &mut self.gpr[gpr.0 as usize]
+    }
+}
+
+impl Index<powerpc::FPR> for RegisterState {
+    type Output = RegisterContent;
+
+    fn index(&self, fpr: powerpc::FPR) -> &Self::Output { &self.fpr[fpr.0 as usize] }
+}
+impl IndexMut<powerpc::FPR> for RegisterState {
+    fn index_mut(&mut self, fpr: powerpc::FPR) -> &mut Self::Output {
+        &mut self.fpr[fpr.0 as usize]
+    }
+}
+
+fn execute_instruction(
+    registers: &mut RegisterState,
+    op: &powerpc::Opcode,
+    args: &powerpc::Arguments,
+) {
+    use powerpc::{Argument, GPR, Opcode};
+    match (op, args[0], args[1], args[2]) {
+        (Opcode::Or, Argument::GPR(a), Argument::GPR(b), Argument::GPR(c)) => {
+            // Move is implemented as or with self for ints
+            if b == c {
+                registers[a] = registers[b];
+            } else {
+                registers[a] = RegisterContent::Unknown;
+            }
+        }
+        (Opcode::Fmr, Argument::FPR(a), Argument::FPR(b), _) => {
+            registers[a] = registers[b];
+        }
+        (Opcode::Addi, Argument::GPR(a), Argument::GPR(GPR(0)), Argument::Simm(c)) => {
+            // Load immidiate implemented as addi with addend = r0
+            // Let Addi with other addends fall through to the case which
+            // overwrites the destination
+            registers[a] = RegisterContent::IntConstant(c.0 as i32);
+        }
+        (Opcode::Bcctr, _, _, _) => {
+            // Called a function pointer, may have erased volatile registers
+            registers.clear_volatile();
+        }
+        (Opcode::B, _, _, _) => {
+            if get_branch_offset(args) == 0 {
+                // Call to another function
+                registers.clear_volatile();
+            }
+        }
+        (
+            Opcode::Stbu | Opcode::Sthu | Opcode::Stwu | Opcode::Stfsu | Opcode::Stfdu,
+            _,
+            _,
+            Argument::GPR(rel),
+        ) => {
+            // Storing with update, clear updated register (third arg)
+            registers[rel] = RegisterContent::Unknown;
+        }
+        (
+            Opcode::Stbux | Opcode::Sthux | Opcode::Stwux | Opcode::Stfsux | Opcode::Stfdux,
+            _,
+            Argument::GPR(rel),
+            _,
+        ) => {
+            // Storing indexed with update, clear updated register (second arg)
+            registers[rel] = RegisterContent::Unknown;
+        }
+        (Opcode::Lmw, Argument::GPR(target), _, _) => {
+            // `lmw` overwrites all registers from rd to r31.
+            for reg in target.0..31 {
+                registers[GPR(reg)] = RegisterContent::Unknown;
+            }
+        }
+        (_, Argument::GPR(a), _, _) => {
+            // Store instructions don't modify the GPR
+            if !is_store_instruction(*op) {
+                // Other operations which write to GPR a
+                registers[a] = RegisterContent::Unknown;
+            }
+        }
+        (_, Argument::FPR(a), _, _) => {
+            // Store instructions don't modify the FPR
+            if !is_store_instruction(*op) {
+                // Other operations which write to FPR a
+                registers[a] = RegisterContent::Unknown;
+            }
+        }
+        (_, _, _, _) => {}
+    }
+}
+
+fn get_branch_offset(args: &powerpc::Arguments) -> i32 {
+    for arg in args.iter() {
+        match arg {
+            powerpc::Argument::BranchDest(dest) => return dest.0 / 4,
+            powerpc::Argument::None => break,
+            _ => {}
+        }
+    }
+    0
+}
+
+#[derive(Debug, Default)]
+struct PPCFlowAnalysisResult {
+    argument_contents: BTreeMap<(u64, u8), FlowAnalysisValue>,
+}
+
+impl PPCFlowAnalysisResult {
+    fn set_argument_value_at_address(
+        &mut self,
+        address: u64,
+        argument: u8,
+        value: FlowAnalysisValue,
+    ) {
+        self.argument_contents.insert((address, argument), value);
+    }
+
+    fn new() -> Self { PPCFlowAnalysisResult { argument_contents: Default::default() } }
+}
+
+impl FlowAnalysisResult for PPCFlowAnalysisResult {
+    fn get_argument_value_at_address(
+        &self,
+        address: u64,
+        argument: u8,
+    ) -> Option<&FlowAnalysisValue> {
+        self.argument_contents.get(&(address, argument))
+    }
+}
+
+fn clamp_text_length(s: String, max: usize) -> String {
+    if s.len() <= max { s } else { format!("{}…", s.chars().take(max - 3).collect::<String>()) }
+}
+
+fn get_register_content_from_reloc(
+    reloc: &Relocation,
+    obj: &Object,
+    op: powerpc::Opcode,
+) -> RegisterContent {
+    if let Some(bytes) = obj.symbol_data(reloc.target_symbol) {
+        match guess_data_type_from_load_store_inst_op(op) {
+            Some(DataType::Float) => {
+                RegisterContent::FloatConstant(RawFloat(match obj.endianness {
+                    object::Endianness::Little => {
+                        f32::from_le_bytes(bytes.try_into().unwrap_or([0; 4]))
+                    }
+                    object::Endianness::Big => {
+                        f32::from_be_bytes(bytes.try_into().unwrap_or([0; 4]))
+                    }
+                }))
+            }
+            Some(DataType::Double) => {
+                RegisterContent::DoubleConstant(RawDouble(match obj.endianness {
+                    object::Endianness::Little => {
+                        f64::from_le_bytes(bytes.try_into().unwrap_or([0; 8]))
+                    }
+                    object::Endianness::Big => {
+                        f64::from_be_bytes(bytes.try_into().unwrap_or([0; 8]))
+                    }
+                }))
+            }
+            _ => RegisterContent::Symbol(reloc.target_symbol),
+        }
+    } else {
+        RegisterContent::Symbol(reloc.target_symbol)
+    }
+}
+
+// Executing op with args at cur_address, update current_state with symbols that
+// come from relocations. That is, references to globals, floating point
+// constants, string constants, etc.
+fn fill_registers_from_relocation(
+    reloc: &Relocation,
+    current_state: &mut RegisterState,
+    obj: &Object,
+    op: powerpc::Opcode,
+    args: &powerpc::Arguments,
+) {
+    // Only update the register state for loads. We may store to a reloc
+    // address but that doesn't update register contents.
+    if !is_store_instruction(op) {
+        match (op, args[0]) {
+            // Everything else is a load of some sort
+            (_, powerpc::Argument::GPR(gpr)) => {
+                current_state[gpr] = get_register_content_from_reloc(reloc, obj, op);
+            }
+            (_, powerpc::Argument::FPR(fpr)) => {
+                current_state[fpr] = get_register_content_from_reloc(reloc, obj, op);
+            }
+            _ => {}
+        }
+    }
+}
+
+// Special helper fragments generated by MWCC.
+// See: https://github.com/encounter/decomp-toolkit/blob/main/src/analysis/pass.rs
+const SLEDS: [&str; 6] = ["_savefpr_", "_restfpr_", "_savegpr_", "_restgpr_", "_savev", "_restv"];
+
+fn is_sled_function(name: &str) -> bool { SLEDS.iter().any(|sled| name.starts_with(sled)) }
+
+pub fn ppc_data_flow_analysis(
+    obj: &Object,
+    func_symbol: &Symbol,
+    code: &[u8],
+    relocations: &[Relocation],
+    extensions: Extensions,
+) -> Box<dyn FlowAnalysisResult> {
+    use alloc::collections::VecDeque;
+
+    use powerpc::InsIter;
+    let instructions = InsIter::new(code, func_symbol.address as u32, extensions)
+        .map(|(_addr, ins)| (ins.op, ins.basic().args))
+        .collect_vec();
+
+    let func_address = func_symbol.address;
+
+    // Get initial register values from function parameters
+    let mut initial_register_state = RegisterState::new();
+    initial_register_state.set_potential_inputs();
+
+    let mut execution_queue = VecDeque::<(usize, RegisterState)>::new();
+    execution_queue.push_back((0, initial_register_state));
+
+    // Execute the instructions against abstract data
+    let mut failsafe_counter = 0;
+    let mut taken_branches = BTreeSet::<(usize, RegisterState)>::new();
+    let mut register_state_at = Vec::<RegisterState>::new();
+    let mut completed_first_pass = false;
+    register_state_at.resize_with(instructions.len(), RegisterState::new);
+    while let Some((mut index, mut current_state)) = execution_queue.pop_front() {
+        while let Some((op, args)) = instructions.get(index) {
+            // Record the state at this index
+            // If recording does not result in any changes to the known values
+            // we're done, because the subsequent values are a function of the
+            // current values so we'll get the same result as the last time
+            // we went down this path.
+            // Don't break out if we haven't even completed the first pass
+            // through the function though.
+            if !register_state_at[index].unify(&current_state) && completed_first_pass {
+                break;
+            }
+
+            // Get symbol used in this instruction
+            let cur_addr = (func_address as u32) + ((index * 4) as u32);
+            let reloc = relocations.iter().find(|r| (r.address as u32 & !3) == cur_addr);
+
+            // Is this a branch to a compiler generated helper? These helpers
+            // do not trash registers like normal function calls, so we don't
+            // want to treat this as normal execution.
+            let symbol = reloc.and_then(|r| obj.symbols.get(r.target_symbol));
+            let is_sled_invocation = symbol.is_some_and(|x| is_sled_function(&x.name));
+
+            // Execute the instruction to update the state
+            // Since sled invocations are only used to save / restore registers
+            // as part of prelude / cleanup in a function call we don't have to
+            // do any execution for them.
+            if !is_sled_invocation {
+                execute_instruction(&mut current_state, op, args);
+            }
+
+            // Fill in register state coming from relocations at this line. This
+            // handles references to global variables, floating point constants,
+            // etc.
+            if let Some(reloc) = reloc {
+                fill_registers_from_relocation(reloc, &mut current_state, obj, *op, args);
+            }
+
+            // Add conditional branches to execution queue
+            // Only take a given (address, register state) combination once. If
+            // the known register state is different we have to take the branch
+            // again to stabilize the known values for backwards branches.
+            if op == &powerpc::Opcode::Bc {
+                let branch_state = (index, current_state.clone());
+                if !taken_branches.contains(&branch_state) {
+                    let offset = get_branch_offset(args);
+                    let target_index = ((index as i32) + offset) as usize;
+                    execution_queue.push_back((target_index, current_state.clone()));
+                    taken_branches.insert(branch_state);
+
+                    // We should never hit this case, but avoid getting stuck in
+                    // an infinite loop if we hit some kind of bad behavior.
+                    failsafe_counter += 1;
+                    if failsafe_counter > 256 {
+                        //println!("Analysis of {} failed to stabilize", func_symbol.name);
+                        return Box::new(PPCFlowAnalysisResult::new());
+                    }
+                }
+            }
+
+            // Update index
+            if op == &powerpc::Opcode::B {
+                // Unconditional branch
+                let offset = get_branch_offset(args);
+                if offset > 0 {
+                    // Jump table or branch to over else clause.
+                    index += offset as usize;
+                } else if offset == 0 {
+                    // Function call with relocation. We'll return to
+                    // the next instruction.
+                    index += 1;
+                } else {
+                    // Unconditional branch (E.g.: loop { ... })
+                    // Also some compilations of loops put the conditional at
+                    // the end and B to it for the check of the first iteration.
+                    let branch_state = (index, current_state.clone());
+                    if taken_branches.contains(&branch_state) {
+                        break;
+                    }
+                    taken_branches.insert(branch_state);
+                    index = ((index as i32) + offset) as usize;
+                }
+            } else {
+                // Normal execution of next instruction
+                index += 1;
+            }
+        }
+
+        // Mark that we've completed at least one pass over the function, at
+        // this point we can break out if the code we're running doesn't change
+        // any register outcomes.
+        completed_first_pass = true;
+    }
+
+    // Store the relevant data flow values for simplified instructions
+    generate_flow_analysis_result(
+        obj,
+        func_address,
+        code,
+        register_state_at,
+        relocations,
+        extensions,
+    )
+}
+
+fn get_string_data(obj: &Object, symbol_index: usize, offset: Simm) -> Option<&str> {
+    if let Some(sym) = obj.symbols.get(symbol_index)
+        && sym.name.starts_with("@stringBase")
+        && offset.0 != 0
+        && let Some(data) = obj.symbol_data(symbol_index)
+    {
+        let bytes = &data[offset.0 as usize..];
+        if let Ok(Ok(str)) = CStr::from_bytes_until_nul(bytes).map(|x| x.to_str()) {
+            return Some(str);
+        }
+    }
+    None
+}
+
+// Write the relevant part of the flow analysis out into the FlowAnalysisResult
+// the rest of the application will use to query results of the flow analysis.
+// Flow analysis will compute the known contents of every register at every
+// line, but we only need to record the values of registers that are actually
+// referenced at each line.
+fn generate_flow_analysis_result(
+    obj: &Object,
+    base_address: u64,
+    code: &[u8],
+    register_state_at: Vec<RegisterState>,
+    relocations: &[Relocation],
+    extensions: Extensions,
+) -> Box<PPCFlowAnalysisResult> {
+    use powerpc::{Argument, InsIter};
+    let mut analysis_result = PPCFlowAnalysisResult::new();
+    let default_register_state = RegisterState::new();
+    for (addr, ins) in InsIter::new(code, 0, extensions) {
+        let ins_address = base_address + (addr as u64);
+        let index = addr / 4;
+        let powerpc::ParsedIns { mnemonic: _, args } = ins.simplified();
+
+        // If we're already showing relocations on a line don't also show data flow
+        let reloc = relocations.iter().find(|r| (r.address & !3) == ins_address);
+
+        // Special case to show float and double constants on the line where
+        // they are being loaded.
+        // We need to do this before we break out on showing relocations in the
+        // subsequent if statement.
+        if let (powerpc::Opcode::Lfs | powerpc::Opcode::Lfd, Some(reloc)) = (ins.op, reloc) {
+            let content = get_register_content_from_reloc(reloc, obj, ins.op);
+            if matches!(
+                content,
+                RegisterContent::FloatConstant(_) | RegisterContent::DoubleConstant(_)
+            ) {
+                analysis_result.set_argument_value_at_address(
+                    ins_address,
+                    1,
+                    FlowAnalysisValue::Text(content.to_string()),
+                );
+
+                // Don't need to show any other data flow if we're showing that
+                continue;
+            }
+        }
+
+        // Special case to show string constants on the line where they are
+        // being indexed to. This will typically be "addi t, stringbase, offset"
+        let registers = register_state_at.get(index as usize).unwrap_or(&default_register_state);
+        if let (powerpc::Opcode::Addi, Argument::GPR(rel), Argument::Simm(offset)) =
+            (ins.op, args[1], args[2])
+            && let RegisterContent::Symbol(sym_index) = registers[rel]
+            && let Some(str) = get_string_data(obj, sym_index, offset)
+        {
+            // Show the string constant in the analysis result
+            let formatted = format!("\"{str}\"");
+            analysis_result.set_argument_value_at_address(
+                ins_address,
+                2,
+                FlowAnalysisValue::Text(clamp_text_length(formatted, 20)),
+            );
+            // Don't continue, we want to show the stringbase value as well
+        }
+
+        let is_store = is_store_instruction(ins.op);
+        for (arg_index, arg) in args.into_iter().enumerate() {
+            // Hacky shorthand for determining which arguments are sources,
+            // We only want to show data flow for source registers, not target
+            // registers. Technically there are some non-"st_" operations which
+            // read from their first argument but they're rare.
+            if (arg_index == 0) && !is_store {
+                continue;
+            }
+
+            let content = match arg {
+                Argument::GPR(gpr) => Some(registers[gpr]),
+                Argument::FPR(fpr) => Some(registers[fpr]),
+                _ => None,
+            };
+            let analysis_value = match content {
+                Some(RegisterContent::Symbol(s)) => {
+                    if reloc.is_none() {
+                        // Only symbols if there isn't already a relocation, because
+                        // code other than the data flow analysis will be showing
+                        // the symbol for a relocation on the line it is for. If we
+                        // also showed it as data flow analysis value we would be
+                        // showing redundant information.
+                        obj.symbols.get(s).map(|sym| {
+                            FlowAnalysisValue::Text(clamp_text_length(
+                                sym.demangled_name.as_ref().unwrap_or(&sym.name).clone(),
+                                20,
+                            ))
+                        })
+                    } else {
+                        None
+                    }
+                }
+                Some(RegisterContent::InputRegister(reg)) => {
+                    let reg_name = match arg {
+                        Argument::GPR(_) => format!("in_r{reg}"),
+                        Argument::FPR(_) => format!("in_f{reg}"),
+                        _ => panic!("Register content should only be in a register"),
+                    };
+                    Some(FlowAnalysisValue::Text(reg_name))
+                }
+                Some(RegisterContent::Unknown) | Some(RegisterContent::Variable) => None,
+                Some(value) => Some(FlowAnalysisValue::Text(value.to_string())),
+                None => None,
+            };
+            if let Some(analysis_value) = analysis_value {
+                analysis_result.set_argument_value_at_address(
+                    ins_address,
+                    arg_index as u8,
+                    analysis_value,
+                );
+            }
+        }
+    }
+
+    Box::new(analysis_result)
+}

objdiff-core/src/arch/superh/mod.rs

@@ -0,0 +1,804 @@
+use alloc::{collections::BTreeMap, format, vec, vec::Vec};
+
+use anyhow::Result;
+use object::elf;
+
+use crate::{
+    arch::{Arch, superh::disasm::sh2_disasm},
+    diff::{DiffObjConfig, display::InstructionPart},
+    obj::{InstructionRef, Relocation, RelocationFlags, ResolvedInstructionRef},
+};
+
+pub mod disasm;
+
+#[derive(Debug)]
+pub struct ArchSuperH {}
+
+impl ArchSuperH {
+    pub fn new(_file: &object::File) -> Result<Self> { Ok(Self {}) }
+}
+
+struct DataInfo {
+    address: u64,
+    size: u32,
+}
+
+impl Arch for ArchSuperH {
+    fn scan_instructions_internal(
+        &self,
+        address: u64,
+        code: &[u8],
+        _section_index: usize,
+        _relocations: &[Relocation],
+        _diff_config: &DiffObjConfig,
+    ) -> Result<Vec<InstructionRef>> {
+        let mut ops = Vec::<InstructionRef>::with_capacity(code.len() / 2);
+        let mut offset = address;
+
+        for chunk in code.chunks_exact(2) {
+            let opcode = u16::from_be_bytes(chunk.try_into().unwrap());
+            let mut parts: Vec<InstructionPart> = vec![];
+            let resolved: ResolvedInstructionRef = Default::default();
+            let mut branch_dest: Option<u64> = None;
+            sh2_disasm(
+                offset.try_into().unwrap(),
+                opcode,
+                true,
+                &mut parts,
+                &resolved,
+                &mut branch_dest,
+            );
+
+            let opcode_enum: u16 = match parts.first() {
+                Some(InstructionPart::Opcode(_, val)) => *val,
+                _ => 0,
+            };
+            ops.push(InstructionRef { address: offset, size: 2, opcode: opcode_enum, branch_dest });
+            offset += 2;
+        }
+
+        Ok(ops)
+    }
+
+    fn display_instruction(
+        &self,
+        resolved: ResolvedInstructionRef,
+        _diff_config: &DiffObjConfig,
+        cb: &mut dyn FnMut(InstructionPart) -> Result<()>,
+    ) -> Result<()> {
+        let opcode = u16::from_be_bytes(resolved.code.try_into().unwrap());
+        let mut parts: Vec<InstructionPart> = vec![];
+        let mut branch_dest: Option<u64> = None;
+
+        sh2_disasm(0, opcode, true, &mut parts, &resolved, &mut branch_dest);
+
+        if let Some(symbol_data) =
+            resolved.section.data_range(resolved.symbol.address, resolved.symbol.size as usize)
+        {
+            // scan for data
+            // map of instruction offsets to data target offsets
+            let mut data_offsets = BTreeMap::<u64, DataInfo>::new();
+
+            let mut pos: u64 = 0;
+            for chunk in symbol_data.chunks_exact(2) {
+                let opcode = u16::from_be_bytes(chunk.try_into().unwrap());
+                // mov.w
+                if (opcode & 0xf000) == 0x9000 {
+                    let target = (opcode as u64 & 0xff) * 2 + 4 + pos;
+                    let data_info = DataInfo { address: target, size: 2 };
+                    data_offsets.insert(pos, data_info);
+                }
+                // mov.l
+                else if (opcode & 0xf000) == 0xd000 {
+                    let target = ((opcode as u64 & 0xff) * 4 + 4 + pos) & 0xfffffffc;
+                    let data_info = DataInfo { address: target, size: 4 };
+                    data_offsets.insert(pos, data_info);
+                }
+                pos += 2;
+            }
+
+            let pos = resolved.ins_ref.address - resolved.symbol.address;
+
+            // add the data info
+            if let Some(value) = data_offsets.get(&pos) {
+                if value.size == 2 && value.address as usize + 1 < symbol_data.len() {
+                    let data = u16::from_be_bytes(
+                        symbol_data[value.address as usize..value.address as usize + 2]
+                            .try_into()
+                            .unwrap(),
+                    );
+                    parts.push(InstructionPart::basic(" /* "));
+                    parts.push(InstructionPart::basic("0x"));
+                    parts.push(InstructionPart::basic(format!("{data:04X}")));
+                    parts.push(InstructionPart::basic(" */"));
+                } else if value.size == 4 && value.address as usize + 3 < symbol_data.len() {
+                    let data = u32::from_be_bytes(
+                        symbol_data[value.address as usize..value.address as usize + 4]
+                            .try_into()
+                            .unwrap(),
+                    );
+                    parts.push(InstructionPart::basic(" /* "));
+                    parts.push(InstructionPart::basic("0x"));
+                    parts.push(InstructionPart::basic(format!("{data:08X}")));
+                    parts.push(InstructionPart::basic(" */"));
+                }
+            }
+        }
+
+        for part in parts {
+            cb(part)?;
+        }
+
+        Ok(())
+    }
+
+    fn reloc_name(&self, flags: RelocationFlags) -> Option<&'static str> {
+        match flags {
+            RelocationFlags::Elf(r_type) => match r_type {
+                elf::R_SH_NONE => Some("R_SH_NONE"),
+                elf::R_SH_DIR32 => Some("R_SH_DIR32"),
+                elf::R_SH_REL32 => Some("R_SH_REL32"),
+                elf::R_SH_DIR8WPN => Some("R_SH_DIR8WPN"),
+                elf::R_SH_IND12W => Some("R_SH_IND12W"),
+                elf::R_SH_DIR8WPL => Some("R_SH_DIR8WPL"),
+                elf::R_SH_DIR8WPZ => Some("R_SH_DIR8WPZ"),
+                elf::R_SH_DIR8BP => Some("R_SH_DIR8BP"),
+                elf::R_SH_DIR8W => Some("R_SH_DIR8W"),
+                elf::R_SH_DIR8L => Some("R_SH_DIR8L"),
+                elf::R_SH_SWITCH16 => Some("R_SH_SWITCH16"),
+                elf::R_SH_SWITCH32 => Some("R_SH_SWITCH32"),
+                elf::R_SH_USES => Some("R_SH_USES"),
+                elf::R_SH_COUNT => Some("R_SH_COUNT"),
+                elf::R_SH_ALIGN => Some("R_SH_ALIGN"),
+                elf::R_SH_CODE => Some("R_SH_CODE"),
+                elf::R_SH_DATA => Some("R_SH_DATA"),
+                elf::R_SH_LABEL => Some("R_SH_LABEL"),
+                elf::R_SH_SWITCH8 => Some("R_SH_SWITCH8"),
+                elf::R_SH_GNU_VTINHERIT => Some("R_SH_GNU_VTINHERIT"),
+                elf::R_SH_GNU_VTENTRY => Some("R_SH_GNU_VTENTRY"),
+                elf::R_SH_TLS_GD_32 => Some("R_SH_TLS_GD_32"),
+                elf::R_SH_TLS_LD_32 => Some("R_SH_TLS_LD_32"),
+                elf::R_SH_TLS_LDO_32 => Some("R_SH_TLS_LDO_32"),
+                elf::R_SH_TLS_IE_32 => Some("R_SH_TLS_IE_32"),
+                elf::R_SH_TLS_LE_32 => Some("R_SH_TLS_LE_32"),
+                elf::R_SH_TLS_DTPMOD32 => Some("R_SH_TLS_DTPMOD32"),
+                elf::R_SH_TLS_DTPOFF32 => Some("R_SH_TLS_DTPOFF32"),
+                elf::R_SH_TLS_TPOFF32 => Some("R_SH_TLS_TPOFF32"),
+                elf::R_SH_GOT32 => Some("R_SH_GOT32"),
+                elf::R_SH_PLT32 => Some("R_SH_PLT32"),
+                elf::R_SH_COPY => Some("R_SH_COPY"),
+                elf::R_SH_GLOB_DAT => Some("R_SH_GLOB_DAT"),
+                elf::R_SH_JMP_SLOT => Some("R_SH_JMP_SLOT"),
+                elf::R_SH_RELATIVE => Some("R_SH_RELATIVE"),
+                elf::R_SH_GOTOFF => Some("R_SH_GOTOFF"),
+                elf::R_SH_GOTPC => Some("R_SH_GOTPC"),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+
+    fn data_reloc_size(&self, flags: RelocationFlags) -> usize {
+        match flags {
+            RelocationFlags::Elf(elf::R_SH_DIR32) => 4,
+            RelocationFlags::Elf(_) => 1,
+            _ => 1,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::fmt::{self, Display};
+
+    use super::*;
+    use crate::obj::{InstructionArg, Section, SectionData, Symbol};
+
+    impl Display for InstructionPart<'_> {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            match self {
+                InstructionPart::Basic(s) => f.write_str(s),
+                InstructionPart::Opcode(s, _o) => write!(f, "{s} "),
+                InstructionPart::Arg(arg) => write!(f, "{arg}"),
+                InstructionPart::Separator => f.write_str(", "),
+            }
+        }
+    }
+
+    impl Display for InstructionArg<'_> {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            match self {
+                InstructionArg::Value(v) => write!(f, "{v}"),
+                InstructionArg::BranchDest(v) => write!(f, "{v}"),
+                InstructionArg::Reloc => f.write_str("reloc"),
+            }
+        }
+    }
+
+    #[test]
+    fn test_sh2_display_instruction_basic_ops() {
+        let arch = ArchSuperH {};
+        let ops: [(u16, &str); 8] = [
+            (0x0008, "clrt "),
+            (0x0028, "clrmac "),
+            (0x0019, "div0u "),
+            (0x0009, "nop "),
+            (0x002b, "rte "),
+            (0x000b, "rts "),
+            (0x0018, "sett "),
+            (0x001b, "sleep "),
+        ];
+
+        for (opcode, expected_str) in ops {
+            let code = opcode.to_be_bytes();
+            let mut parts = Vec::new();
+
+            arch.display_instruction(
+                ResolvedInstructionRef {
+                    ins_ref: InstructionRef { address: 0x1000, size: 2, opcode, branch_dest: None },
+                    code: &code,
+                    ..Default::default()
+                },
+                &DiffObjConfig::default(),
+                &mut |part| {
+                    parts.push(part.into_static());
+                    Ok(())
+                },
+            )
+            .unwrap();
+
+            let joined_str: String = parts.iter().map(<_>::to_string).collect();
+            assert_eq!(joined_str, expected_str.to_string());
+        }
+    }
+
+    #[test]
+    fn test_sh2_display_instruction_f0ff_ops() {
+        let arch = ArchSuperH {};
+        let ops: [(u16, &str); 49] = [
+            (0x4015, "cmp/pl r0"),
+            (0x4115, "cmp/pl r1"),
+            (0x4215, "cmp/pl r2"),
+            (0x4315, "cmp/pl r3"),
+            (0x4011, "cmp/pz r0"),
+            (0x4010, "dt r0"),
+            (0x0029, "movt r0"),
+            (0x4004, "rotl r0"),
+            (0x4005, "rotr r0"),
+            (0x4024, "rotcl r0"),
+            (0x4025, "rotcr r0"),
+            (0x4020, "shal r0"),
+            (0x4021, "shar r0"),
+            (0x4000, "shll r0"),
+            (0x4001, "shlr r0"),
+            (0x4008, "shll2 r0"),
+            (0x4009, "shlr2 r0"),
+            (0x4018, "shll8 r0"),
+            (0x4019, "shlr8 r0"),
+            (0x4028, "shll16 r0"),
+            (0x4029, "shlr16 r0"),
+            (0x0002, "stc sr, r0"),
+            (0x0012, "stc gbr, r0"),
+            (0x0022, "stc vbr, r0"),
+            (0x000a, "sts mach, r0"),
+            (0x001a, "sts macl, r0"),
+            (0x402a, "lds r0, pr"),
+            (0x401b, "tas.b r0"),
+            (0x4003, "stc.l sr, @-r0"),
+            (0x4013, "stc.l gbr, @-r0"),
+            (0x4023, "stc.l vbr, @-r0"),
+            (0x4002, "sts.l mach, @-r0"),
+            (0x4012, "sts.l macl, @-r0"),
+            (0x4022, "sts.l pr, @-r0"),
+            (0x400e, "ldc r0, sr"),
+            (0x401e, "ldc r0, gbr"),
+            (0x402e, "ldc r0, vbr"),
+            (0x400a, "lds r0, mach"),
+            (0x401a, "lds r0, macl"),
+            (0x402b, "jmp @r0"),
+            (0x400b, "jsr @r0"),
+            (0x4007, "ldc.l @r0+, sr"),
+            (0x4017, "ldc.l @r0+, gbr"),
+            (0x4027, "ldc.l @r0+, vbr"),
+            (0x4006, "lds.l @r0+, mach"),
+            (0x4016, "lds.l @r0+, macl"),
+            (0x4026, "lds.l @r0+, pr"),
+            (0x0023, "braf r0"),
+            (0x0003, "bsrf r0"),
+        ];
+
+        for (opcode, expected_str) in ops {
+            let code = opcode.to_be_bytes();
+            let mut parts = Vec::new();
+
+            arch.display_instruction(
+                ResolvedInstructionRef {
+                    ins_ref: InstructionRef { address: 0x1000, size: 2, opcode, branch_dest: None },
+                    code: &code,
+                    ..Default::default()
+                },
+                &DiffObjConfig::default(),
+                &mut |part| {
+                    parts.push(part.into_static());
+                    Ok(())
+                },
+            )
+            .unwrap();
+
+            let joined_str: String = parts.iter().map(<_>::to_string).collect();
+            assert_eq!(joined_str, expected_str.to_string());
+        }
+    }
+
+    #[test]
+    fn test_sh2_display_instructions_f00f() {
+        let arch = ArchSuperH {};
+        let ops: [(u16, &str); 54] = [
+            (0x300c, "add r0, r0"),
+            (0x300e, "addc r0, r0"),
+            (0x300f, "addv r0, r0"),
+            (0x2009, "and r0, r0"),
+            (0x3000, "cmp/eq r0, r0"),
+            (0x3002, "cmp/hs r0, r0"),
+            (0x3003, "cmp/ge r0, r0"),
+            (0x3006, "cmp/hi r0, r0"),
+            (0x3007, "cmp/gt r0, r0"),
+            (0x200c, "cmp/str r0, r0"),
+            (0x3004, "div1 r0, r0"),
+            (0x2007, "div0s r0, r0"),
+            (0x300d, "dmuls.l r0, r0"),
+            (0x3005, "dmulu.l r0, r0"),
+            (0x600e, "exts.b r0, r0"),
+            (0x600f, "exts.w r0, r0"),
+            (0x600c, "extu.b r0, r0"),
+            (0x600d, "extu.w r0, r0"),
+            (0x6003, "mov r0, r0"),
+            (0x0007, "mul.l r0, r0"),
+            (0x200f, "muls r0, r0"),
+            (0x200e, "mulu r0, r0"),
+            (0x600b, "neg r0, r0"),
+            (0x600a, "negc r0, r0"),
+            (0x6007, "not r0, r0"),
+            (0x200b, "or r0, r0"),
+            (0x3008, "sub r0, r0"),
+            (0x300a, "subc r0, r0"),
+            (0x300b, "subv r0, r0"),
+            (0x6008, "swap.b r0, r0"),
+            (0x6009, "swap.w r0, r0"),
+            (0x2008, "tst r0, r0"),
+            (0x200a, "xor r0, r0"),
+            (0x200d, "xtrct r0, r0"),
+            (0x2000, "mov.b r0, @r0"),
+            (0x2001, "mov.w r0, @r0"),
+            (0x2002, "mov.l r0, @r0"),
+            (0x6000, "mov.b @r0, r0"),
+            (0x6001, "mov.w @r0, r0"),
+            (0x6002, "mov.l @r0, r0"),
+            (0x000f, "mac.l @r0+, @r0+"),
+            (0x400f, "mac.w @r0+, @r0+"),
+            (0x6004, "mov.b @r0+, r0"),
+            (0x6005, "mov.w @r0+, r0"),
+            (0x6006, "mov.l @r0+, r0"),
+            (0x2004, "mov.b r0, @-r0"),
+            (0x2005, "mov.w r0, @-r0"),
+            (0x2006, "mov.l r0, @-r0"),
+            (0x0004, "mov.b r0, @(r0, r0)"),
+            (0x0005, "mov.w r0, @(r0, r0)"),
+            (0x0006, "mov.l r0, @(r0, r0)"),
+            (0x000c, "mov.b @(r0, r0), r0"),
+            (0x000d, "mov.w @(r0, r0), r0"),
+            (0x000e, "mov.l @(r0, r0), r0"),
+        ];
+
+        for (opcode, expected_str) in ops {
+            let code = opcode.to_be_bytes();
+            let mut parts = Vec::new();
+
+            arch.display_instruction(
+                ResolvedInstructionRef {
+                    ins_ref: InstructionRef { address: 0x1000, size: 2, opcode, branch_dest: None },
+                    code: &code,
+                    ..Default::default()
+                },
+                &DiffObjConfig::default(),
+                &mut |part| {
+                    parts.push(part.into_static());
+                    Ok(())
+                },
+            )
+            .unwrap();
+
+            let joined_str: String = parts.iter().map(<_>::to_string).collect();
+            assert_eq!(joined_str, expected_str.to_string());
+        }
+    }
+
+    #[test]
+    fn test_sh2_display_instruction_mov_immediate_offset() {
+        let arch = ArchSuperH {};
+        let ops: [(u16, &str); 8] = [
+            (0x8000, "mov.b r0, @(0x0, r0)"),
+            (0x8011, "mov.b r0, @(0x1, r1)"),
+            (0x8102, "mov.w r0, @(0x4, r0)"),
+            (0x8113, "mov.w r0, @(0x6, r1)"),
+            (0x8404, "mov.b @(0x4, r0), r0"),
+            (0x8415, "mov.b @(0x5, r1), r0"),
+            (0x8506, "mov.w @(0xc, r0), r0"),
+            (0x8517, "mov.w @(0xe, r1), r0"),
+        ];
+
+        for (opcode, expected_str) in ops {
+            let code = opcode.to_be_bytes();
+            let mut parts = Vec::new();
+
+            arch.display_instruction(
+                ResolvedInstructionRef {
+                    ins_ref: InstructionRef { address: 0x1000, size: 2, opcode, branch_dest: None },
+                    code: &code,
+                    ..Default::default()
+                },
+                &DiffObjConfig::default(),
+                &mut |part| {
+                    parts.push(part.into_static());
+                    Ok(())
+                },
+            )
+            .unwrap();
+
+            let joined_str: String = parts.iter().map(<_>::to_string).collect();
+            assert_eq!(joined_str, expected_str.to_string());
+        }
+    }
+
+    #[test]
+    fn test_sh2_display_instruction_gbr_and_branches() {
+        let arch = ArchSuperH {};
+        let ops: &[(u16, u32, &str)] = &[
+            (0xc000, 0x0000, "mov.b r0, @(0x0, gbr)"),
+            (0xc07f, 0x0000, "mov.b r0, @(0x7f, gbr)"),
+            (0xc100, 0x0000, "mov.w r0, @(0x0, gbr)"),
+            (0xc17f, 0x0000, "mov.w r0, @(0xfe, gbr)"),
+            (0xc200, 0x0000, "mov.l r0, @(0x0, gbr)"),
+            (0xc27f, 0x0000, "mov.l r0, @(0x1fc, gbr)"),
+            (0xc400, 0x0000, "mov.b @(0x0, gbr), r0"),
+            (0xc47f, 0x0000, "mov.b @(0x7f, gbr), r0"),
+            (0xc500, 0x0000, "mov.w @(0x0, gbr), r0"),
+            (0xc57f, 0x0000, "mov.w @(0xfe, gbr), r0"),
+            (0xc600, 0x0000, "mov.l @(0x0, gbr), r0"),
+            (0xc67f, 0x0000, "mov.l @(0x1fc, gbr), r0"),
+            (0x8b20, 0x1000, "bf 0x44"),
+            (0x8b80, 0x1000, "bf 0xffffff04"),
+            (0x8f10, 0x2000, "bf.s 0x24"),
+            (0x8f90, 0x2000, "bf.s 0xffffff24"),
+            (0x8904, 0x3000, "bt 0xc"),
+            (0x8980, 0x3000, "bt 0xffffff04"),
+            (0x8d04, 0x4000, "bt.s 0xc"),
+            (0x8d80, 0x4000, "bt.s 0xffffff04"),
+        ];
+
+        for &(opcode, addr, expected_str) in ops {
+            let code = opcode.to_be_bytes();
+            let mut parts = Vec::new();
+
+            arch.display_instruction(
+                ResolvedInstructionRef {
+                    ins_ref: InstructionRef {
+                        address: addr as u64,
+                        size: 2,
+                        opcode,
+                        branch_dest: None,
+                    },
+                    code: &code,
+                    ..Default::default()
+                },
+                &DiffObjConfig::default(),
+                &mut |part| {
+                    parts.push(part.into_static());
+                    Ok(())
+                },
+            )
+            .unwrap();
+
+            let joined_str: String = parts.iter().map(<_>::to_string).collect();
+            assert_eq!(joined_str, expected_str.to_string());
+        }
+    }
+
+    #[test]
+    fn test_sh2_display_instruction_mov_l() {
+        let arch = ArchSuperH {};
+        let ops: &[(u16, u32, &str)] = &[
+            // mov.l rX, @(0xXXX, rY)
+            (0x1000, 0x0000, "mov.l r0, @(0x0, r0)"),
+            (0x1001, 0x0000, "mov.l r0, @(0x4, r0)"),
+            (0x100f, 0x0000, "mov.l r0, @(0x3c, r0)"),
+            (0x101f, 0x0000, "mov.l r1, @(0x3c, r0)"),
+            // mov.l @(0xXXX, rY), rX
+            (0x5000, 0x0000, "mov.l @(0x0, r0), r0"),
+        ];
+
+        for &(opcode, addr, expected_str) in ops {
+            let code = opcode.to_be_bytes();
+            let mut parts = Vec::new();
+
+            arch.display_instruction(
+                ResolvedInstructionRef {
+                    ins_ref: InstructionRef {
+                        address: addr as u64,
+                        size: 2,
+                        opcode,
+                        branch_dest: None,
+                    },
+                    code: &code,
+                    ..Default::default()
+                },
+                &DiffObjConfig::default(),
+                &mut |part| {
+                    parts.push(part.into_static());
+                    Ok(())
+                },
+            )
+            .unwrap();
+
+            let joined_str: String = parts.iter().map(<_>::to_string).collect();
+            assert_eq!(joined_str, expected_str.to_string());
+        }
+    }
+
+    #[test]
+    fn test_sh2_display_instruction_bra_bsr() {
+        let arch: ArchSuperH = ArchSuperH {};
+        let ops: &[(u16, u32, &str)] = &[
+            // bra
+            (0xa000, 0x0000, "bra 0x4"),
+            (0xa001, 0x0000, "bra 0x6"),
+            (0xa800, 0x0000, "bra 0xfffff004"),
+            (0xa801, 0x0000, "bra 0xfffff006"),
+            // bsr
+            (0xb000, 0x0000, "bsr 0x4"),
+            (0xb001, 0x0000, "bsr 0x6"),
+            (0xb800, 0x0000, "bsr 0xfffff004"),
+            (0xb801, 0x0000, "bsr 0xfffff006"),
+        ];
+
+        for &(opcode, addr, expected_str) in ops {
+            let code = opcode.to_be_bytes();
+            let mut parts = Vec::new();
+
+            arch.display_instruction(
+                ResolvedInstructionRef {
+                    ins_ref: InstructionRef {
+                        address: addr as u64,
+                        size: 2,
+                        opcode,
+                        branch_dest: None,
+                    },
+                    code: &code,
+                    ..Default::default()
+                },
+                &DiffObjConfig::default(),
+                &mut |part| {
+                    parts.push(part.into_static());
+                    Ok(())
+                },
+            )
+            .unwrap();
+
+            let joined_str: String = parts.iter().map(<_>::to_string).collect();
+            assert_eq!(joined_str, expected_str.to_string());
+        }
+    }
+
+    #[test]
+    fn test_sh2_display_instruction_operations() {
+        let arch = ArchSuperH {};
+        let ops: &[(u16, u32, &str)] = &[
+            (0xcdff, 0x0000, "and.b #0xff, @(r0, gbr)"),
+            (0xcfff, 0x0000, "or.b #0xff, @(r0, gbr)"),
+            (0xccff, 0x0000, "tst.b #0xff, @(r0, gbr)"),
+            (0xceff, 0x0000, "xor.b #0xff, @(r0, gbr)"),
+            (0xc9ff, 0x0000, "and #0xff, r0"),
+            (0x88ff, 0x0000, "cmp/eq #0xff, r0"),
+            (0xcbff, 0x0000, "or #0xff, r0"),
+            (0xc8ff, 0x0000, "tst #0xff, r0"),
+            (0xcaff, 0x0000, "xor #0xff, r0"),
+            (0xc3ff, 0x0000, "trapa #0xff"),
+        ];
+
+        for &(opcode, addr, expected_str) in ops {
+            let code = opcode.to_be_bytes();
+            let mut parts = Vec::new();
+
+            arch.display_instruction(
+                ResolvedInstructionRef {
+                    ins_ref: InstructionRef {
+                        address: addr as u64,
+                        size: 2,
+                        opcode,
+                        branch_dest: None,
+                    },
+                    code: &code,
+                    ..Default::default()
+                },
+                &DiffObjConfig::default(),
+                &mut |part| {
+                    parts.push(part.into_static());
+                    Ok(())
+                },
+            )
+            .unwrap();
+
+            let joined_str: String = parts.iter().map(<_>::to_string).collect();
+            assert_eq!(joined_str, expected_str.to_string());
+        }
+    }
+
+    #[test]
+    fn test_sh2_add_mov_unknown_instructions() {
+        let arch = ArchSuperH {};
+        let ops: &[(u16, u32, &str)] = &[
+            (0x70FF, 0x0000, "add #0xff, r0"),
+            (0xE0FF, 0x0000, "mov #0xff, r0"),
+            (0x0000, 0x0000, ".word 0x0000 /* unknown instruction */"),
+        ];
+
+        for &(opcode, addr, expected_str) in ops {
+            let code = opcode.to_be_bytes();
+            let mut parts = Vec::new();
+
+            arch.display_instruction(
+                ResolvedInstructionRef {
+                    ins_ref: InstructionRef {
+                        address: addr as u64,
+                        size: 2,
+                        opcode,
+                        branch_dest: None,
+                    },
+                    code: &code,
+                    ..Default::default()
+                },
+                &DiffObjConfig::default(),
+                &mut |part| {
+                    parts.push(part.into_static());
+                    Ok(())
+                },
+            )
+            .unwrap();
+
+            let joined_str: String = parts.iter().map(<_>::to_string).collect();
+            assert_eq!(joined_str, expected_str.to_string());
+        }
+    }
+
+    #[test]
+    fn test_sh2_mov_instructions_with_labels() {
+        let arch = ArchSuperH {};
+        let ops: &[(u16, u32, &str)] =
+            &[(0x9000, 0x0000, "mov.w @(0x4, pc), r0"), (0xd000, 0x0000, "mov.l @(0x4, pc), r0")];
+
+        for &(opcode, addr, expected_str) in ops {
+            let code = opcode.to_be_bytes();
+            let mut parts = Vec::new();
+
+            arch.display_instruction(
+                ResolvedInstructionRef {
+                    ins_ref: InstructionRef {
+                        address: addr as u64,
+                        size: 2,
+                        opcode,
+                        branch_dest: None,
+                    },
+                    code: &code,
+                    ..Default::default()
+                },
+                &DiffObjConfig::default(),
+                &mut |part| {
+                    parts.push(part.into_static());
+                    Ok(())
+                },
+            )
+            .unwrap();
+
+            let joined_str: String = parts.iter().map(<_>::to_string).collect();
+            assert_eq!(joined_str, expected_str.to_string());
+        }
+    }
+
+    #[test]
+    fn test_func_0606_f378_mov_w_data_labeling() {
+        let arch = ArchSuperH {};
+        let ops: &[(u16, u32, &str)] = &[(0x9000, 0x0606F378, "mov.w @(0x4, pc), r0 /* 0x00B0 */")];
+
+        let mut code = Vec::new();
+        code.extend_from_slice(&0x9000_u16.to_be_bytes());
+        code.extend_from_slice(&0x0009_u16.to_be_bytes());
+        code.extend_from_slice(&0x00B0_u16.to_be_bytes());
+
+        for &(opcode, addr, expected_str) in ops {
+            let mut parts = Vec::new();
+
+            arch.display_instruction(
+                ResolvedInstructionRef {
+                    ins_ref: InstructionRef {
+                        address: addr as u64,
+                        size: 2,
+                        opcode,
+                        branch_dest: None,
+                    },
+                    code: &opcode.to_be_bytes(),
+                    symbol: &Symbol {
+                        address: 0x0606F378, // func base address
+                        size: code.len() as u64,
+                        ..Default::default()
+                    },
+                    section: &Section {
+                        address: 0x0606F378,
+                        size: code.len() as u64,
+                        data: SectionData(code.clone()),
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+                &DiffObjConfig::default(),
+                &mut |part| {
+                    parts.push(part.into_static());
+                    Ok(())
+                },
+            )
+            .unwrap();
+
+            let joined_str: String = parts.iter().map(<_>::to_string).collect();
+            assert_eq!(joined_str, expected_str.to_string());
+        }
+    }
+
+    #[test]
+    fn test_func_0606_f378_mov_l_data_labeling() {
+        let arch = ArchSuperH {};
+        let ops: &[(u16, u32, &str)] =
+            &[(0xd000, 0x0606F378, "mov.l @(0x4, pc), r0 /* 0x00B000B0 */")];
+
+        let mut code = Vec::new();
+        code.extend_from_slice(&0xd000_u16.to_be_bytes());
+        code.extend_from_slice(&0x0009_u16.to_be_bytes());
+        code.extend_from_slice(&0x00B0_u16.to_be_bytes());
+        code.extend_from_slice(&0x00B0_u16.to_be_bytes());
+
+        for &(opcode, addr, expected_str) in ops {
+            let mut parts = Vec::new();
+
+            arch.display_instruction(
+                ResolvedInstructionRef {
+                    ins_ref: InstructionRef {
+                        address: addr as u64,
+                        size: 2,
+                        opcode,
+                        branch_dest: None,
+                    },
+                    code: &opcode.to_be_bytes(),
+                    symbol: &Symbol {
+                        address: 0x0606F378, // func base address
+                        size: code.len() as u64,
+                        ..Default::default()
+                    },
+                    section: &Section {
+                        address: 0x0606F378,
+                        size: code.len() as u64,
+                        data: SectionData(code.clone()),
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+                &DiffObjConfig::default(),
+                &mut |part| {
+                    parts.push(part.into_static());
+                    Ok(())
+                },
+            )
+            .unwrap();
+
+            let joined_str: String = parts.iter().map(<_>::to_string).collect();
+            assert_eq!(joined_str, expected_str.to_string());
+        }
+    }
+}

objdiff-core/src/arch/x86.rs

@@ -0,0 +1,845 @@
+use alloc::{boxed::Box, format, vec::Vec};
+use core::cmp::Ordering;
+
+use anyhow::{Context, Result, anyhow, bail};
+use iced_x86::{
+    Decoder, DecoderOptions, DecoratorKind, FormatterOutput, FormatterTextKind, GasFormatter,
+    Instruction, IntelFormatter, MasmFormatter, NasmFormatter, NumberKind, OpKind, Register,
+};
+use object::{Endian as _, Object as _, ObjectSection as _, elf, pe};
+
+use crate::{
+    arch::{Arch, OPCODE_DATA, RelocationOverride, RelocationOverrideTarget},
+    diff::{DiffObjConfig, X86Formatter, display::InstructionPart},
+    obj::{InstructionRef, Relocation, RelocationFlags, ResolvedInstructionRef, Section, Symbol},
+};
+
+#[derive(Debug)]
+pub struct ArchX86 {
+    arch: Architecture,
+    endianness: object::Endianness,
+}
+
+#[derive(Debug)]
+enum Architecture {
+    X86,
+    X86_64,
+}
+
+impl ArchX86 {
+    pub fn new(object: &object::File) -> Result<Self> {
+        let arch = match object.architecture() {
+            object::Architecture::I386 => Architecture::X86,
+            object::Architecture::X86_64 => Architecture::X86_64,
+            _ => bail!("Unsupported architecture for ArchX86: {:?}", object.architecture()),
+        };
+        Ok(Self { arch, endianness: object.endianness() })
+    }
+
+    fn decoder<'a>(&self, code: &'a [u8], address: u64) -> Decoder<'a> {
+        Decoder::with_ip(
+            match self.arch {
+                Architecture::X86 => 32,
+                Architecture::X86_64 => 64,
+            },
+            code,
+            address,
+            DecoderOptions::NONE,
+        )
+    }
+
+    fn formatter(&self, diff_config: &DiffObjConfig) -> Box<dyn iced_x86::Formatter> {
+        let mut formatter: Box<dyn iced_x86::Formatter> = match diff_config.x86_formatter {
+            X86Formatter::Intel => Box::new(IntelFormatter::new()),
+            X86Formatter::Gas => Box::new(GasFormatter::new()),
+            X86Formatter::Nasm => Box::new(NasmFormatter::new()),
+            X86Formatter::Masm => Box::new(MasmFormatter::new()),
+        };
+        formatter.options_mut().set_space_after_operand_separator(diff_config.space_between_args);
+        formatter
+    }
+
+    fn reloc_size(&self, flags: RelocationFlags) -> Option<usize> {
+        match self.arch {
+            Architecture::X86 => match flags {
+                RelocationFlags::Coff(typ) => match typ {
+                    pe::IMAGE_REL_I386_DIR16 | pe::IMAGE_REL_I386_REL16 => Some(2),
+                    pe::IMAGE_REL_I386_DIR32 | pe::IMAGE_REL_I386_REL32 => Some(4),
+                    _ => None,
+                },
+                RelocationFlags::Elf(typ) => match typ {
+                    elf::R_386_32 | elf::R_386_PC32 => Some(4),
+                    elf::R_386_16 => Some(2),
+                    _ => None,
+                },
+            },
+            Architecture::X86_64 => match flags {
+                RelocationFlags::Coff(typ) => match typ {
+                    pe::IMAGE_REL_AMD64_ADDR32NB | pe::IMAGE_REL_AMD64_REL32 => Some(4),
+                    pe::IMAGE_REL_AMD64_ADDR64 => Some(8),
+                    _ => None,
+                },
+                RelocationFlags::Elf(typ) => match typ {
+                    elf::R_X86_64_PC32 => Some(4),
+                    elf::R_X86_64_64 => Some(8),
+                    _ => None,
+                },
+            },
+        }
+    }
+}
+
+impl Arch for ArchX86 {
+    fn scan_instructions_internal(
+        &self,
+        address: u64,
+        code: &[u8],
+        _section_index: usize,
+        relocations: &[Relocation],
+        _diff_config: &DiffObjConfig,
+    ) -> Result<Vec<InstructionRef>> {
+        let mut out = Vec::with_capacity(code.len() / 2);
+        let mut decoder = self.decoder(code, address);
+        let mut instruction = Instruction::default();
+        let mut reloc_iter = relocations.iter().peekable();
+        'outer: while decoder.can_decode() {
+            let address = decoder.ip();
+            while let Some(reloc) = reloc_iter.peek() {
+                match reloc.address.cmp(&address) {
+                    Ordering::Less => {
+                        reloc_iter.next();
+                    }
+                    Ordering::Equal => {
+                        // If the instruction starts at a relocation, it's inline data
+                        let size = self.reloc_size(reloc.flags).with_context(|| {
+                            format!("Unsupported inline x86 relocation {:?}", reloc.flags)
+                        })?;
+                        if decoder.set_position(decoder.position() + size).is_ok() {
+                            decoder.set_ip(address + size as u64);
+                            out.push(InstructionRef {
+                                address,
+                                size: size as u8,
+                                opcode: OPCODE_DATA,
+                                branch_dest: None,
+                            });
+
+                            reloc_iter.next();
+
+                            // support .byte arrays after jump tables (they're typically known as indirect tables)
+
+                            let indirect_array_address = address.wrapping_add(size as u64);
+                            let indirect_array_pos = decoder.position();
+
+                            let max_size = code.len().saturating_sub(indirect_array_pos);
+
+                            let indirect_array_size = reloc_iter
+                                .peek()
+                                .map(|next_reloc| {
+                                    next_reloc.address.saturating_sub(indirect_array_address)
+                                        as usize
+                                })
+                                .unwrap_or(max_size)
+                                .min(max_size);
+
+                            if indirect_array_size > 0 {
+                                for i in 0..indirect_array_size {
+                                    out.push(InstructionRef {
+                                        address: indirect_array_address + i as u64,
+                                        size: 1,
+                                        opcode: OPCODE_DATA,
+                                        branch_dest: None,
+                                    });
+                                }
+                                // move decoder to after the array (there can be multiple jump+indirect tables in one function)
+                                let _ =
+                                    decoder.set_position(indirect_array_pos + indirect_array_size);
+                                decoder.set_ip(indirect_array_address + indirect_array_size as u64);
+                            }
+
+                            continue 'outer;
+                        }
+                    }
+                    Ordering::Greater => break,
+                }
+            }
+            decoder.decode_out(&mut instruction);
+            let branch_dest = match instruction.op0_kind() {
+                OpKind::NearBranch16 => Some(instruction.near_branch16() as u64),
+                OpKind::NearBranch32 => Some(instruction.near_branch32() as u64),
+                OpKind::NearBranch64 => Some(instruction.near_branch64()),
+                _ => None,
+            };
+            out.push(InstructionRef {
+                address,
+                size: instruction.len() as u8,
+                opcode: instruction.mnemonic() as u16,
+                branch_dest,
+            });
+        }
+        Ok(out)
+    }
+
+    fn display_instruction(
+        &self,
+        resolved: ResolvedInstructionRef,
+        diff_config: &DiffObjConfig,
+        cb: &mut dyn FnMut(InstructionPart) -> Result<()>,
+    ) -> Result<()> {
+        if resolved.ins_ref.opcode == OPCODE_DATA {
+            let (mnemonic, imm) = match resolved.ins_ref.size {
+                1 => (".byte", resolved.code[0] as u64),
+                2 => (".word", self.endianness.read_u16_bytes(resolved.code.try_into()?) as u64),
+                4 => (".dword", self.endianness.read_u32_bytes(resolved.code.try_into()?) as u64),
+                _ => bail!("Unsupported x86 inline data size {}", resolved.ins_ref.size),
+            };
+            cb(InstructionPart::opcode(mnemonic, OPCODE_DATA))?;
+            if resolved.relocation.is_some() {
+                cb(InstructionPart::reloc())?;
+            } else {
+                cb(InstructionPart::unsigned(imm))?;
+            }
+            return Ok(());
+        }
+
+        let mut decoder = self.decoder(resolved.code, resolved.ins_ref.address);
+        let mut formatter = self.formatter(diff_config);
+        let mut instruction = Instruction::default();
+        decoder.decode_out(&mut instruction);
+
+        // Determine where to insert relocation in instruction output.
+        // We replace the immediate or displacement with a placeholder value since the formatter
+        // doesn't provide enough information to know which number is the displacement inside a
+        // memory operand.
+        let mut reloc_replace = None;
+        if let Some(reloc) = resolved.relocation {
+            const PLACEHOLDER: u64 = 0x7BDE3E7D; // chosen by fair dice roll. guaranteed to be random.
+            let reloc_offset = reloc.relocation.address - resolved.ins_ref.address;
+            let reloc_size = self.reloc_size(reloc.relocation.flags).unwrap_or(usize::MAX);
+            let offsets = decoder.get_constant_offsets(&instruction);
+            if reloc_offset == offsets.displacement_offset() as u64
+                && reloc_size == offsets.displacement_size()
+            {
+                instruction.set_memory_displacement64(PLACEHOLDER);
+                // Formatter always writes the displacement as Int32
+                reloc_replace = Some((OpKind::Memory, 4, PLACEHOLDER));
+            } else if reloc_offset == offsets.immediate_offset() as u64
+                && reloc_size == offsets.immediate_size()
+            {
+                let is_branch = matches!(
+                    instruction.op0_kind(),
+                    OpKind::NearBranch16 | OpKind::NearBranch32 | OpKind::NearBranch64
+                );
+                let op_kind = if is_branch {
+                    instruction.op0_kind()
+                } else {
+                    match reloc_size {
+                        2 => OpKind::Immediate16,
+                        4 => OpKind::Immediate32,
+                        8 => OpKind::Immediate64,
+                        _ => OpKind::default(),
+                    }
+                };
+                if is_branch {
+                    instruction.set_near_branch64(PLACEHOLDER);
+                } else {
+                    instruction.set_immediate32(PLACEHOLDER as u32);
+                }
+                reloc_replace = Some((op_kind, reloc_size, PLACEHOLDER));
+            }
+        }
+
+        let mut output =
+            InstructionFormatterOutput { cb, reloc_replace, error: None, skip_next: false };
+        formatter.format(&instruction, &mut output);
+        if let Some(error) = output.error.take() {
+            return Err(error);
+        }
+        Ok(())
+    }
+
+    fn relocation_override(
+        &self,
+        _file: &object::File<'_>,
+        section: &object::Section,
+        address: u64,
+        relocation: &object::Relocation,
+    ) -> Result<Option<RelocationOverride>> {
+        if !relocation.has_implicit_addend() {
+            return Ok(None);
+        }
+        let addend = match self.arch {
+            Architecture::X86 => match relocation.flags() {
+                object::RelocationFlags::Coff {
+                    typ: pe::IMAGE_REL_I386_DIR32 | pe::IMAGE_REL_I386_REL32,
+                }
+                | object::RelocationFlags::Elf { r_type: elf::R_386_32 | elf::R_386_PC32 } => {
+                    let data =
+                        section.data()?[address as usize..address as usize + 4].try_into()?;
+                    self.endianness.read_i32_bytes(data) as i64
+                }
+                flags => bail!("Unsupported x86 implicit relocation {flags:?}"),
+            },
+            Architecture::X86_64 => match relocation.flags() {
+                object::RelocationFlags::Coff {
+                    typ: pe::IMAGE_REL_AMD64_ADDR32NB | pe::IMAGE_REL_AMD64_REL32,
+                }
+                | object::RelocationFlags::Elf { r_type: elf::R_X86_64_32 | elf::R_X86_64_PC32 } => {
+                    let data =
+                        section.data()?[address as usize..address as usize + 4].try_into()?;
+                    self.endianness.read_i32_bytes(data) as i64
+                }
+                object::RelocationFlags::Coff { typ: pe::IMAGE_REL_AMD64_ADDR64 }
+                | object::RelocationFlags::Elf { r_type: elf::R_X86_64_64 } => {
+                    let data =
+                        section.data()?[address as usize..address as usize + 8].try_into()?;
+                    self.endianness.read_i64_bytes(data)
+                }
+                flags => bail!("Unsupported x86-64 implicit relocation {flags:?}"),
+            },
+        };
+        Ok(Some(RelocationOverride { target: RelocationOverrideTarget::Keep, addend }))
+    }
+
+    fn reloc_name(&self, flags: RelocationFlags) -> Option<&'static str> {
+        match self.arch {
+            Architecture::X86 => match flags {
+                RelocationFlags::Coff(typ) => match typ {
+                    pe::IMAGE_REL_I386_DIR32 => Some("IMAGE_REL_I386_DIR32"),
+                    pe::IMAGE_REL_I386_REL32 => Some("IMAGE_REL_I386_REL32"),
+                    _ => None,
+                },
+                _ => None,
+            },
+            Architecture::X86_64 => match flags {
+                RelocationFlags::Coff(typ) => match typ {
+                    pe::IMAGE_REL_AMD64_ADDR64 => Some("IMAGE_REL_AMD64_ADDR64"),
+                    pe::IMAGE_REL_AMD64_ADDR32NB => Some("IMAGE_REL_AMD64_ADDR32NB"),
+                    pe::IMAGE_REL_AMD64_REL32 => Some("IMAGE_REL_AMD64_REL32"),
+                    _ => None,
+                },
+                _ => None,
+            },
+        }
+    }
+
+    fn data_reloc_size(&self, flags: RelocationFlags) -> usize {
+        self.reloc_size(flags).unwrap_or(1)
+    }
+
+    fn infer_function_size(
+        &self,
+        symbol: &Symbol,
+        section: &Section,
+        next_address: u64,
+    ) -> Result<u64> {
+        let Ok(size) = (next_address - symbol.address).try_into() else {
+            return Ok(next_address.saturating_sub(symbol.address));
+        };
+        let Some(code) = section.data_range(symbol.address, size) else {
+            return Ok(0);
+        };
+        // Decode instructions to find the last non-NOP instruction
+        let mut decoder = self.decoder(code, symbol.address);
+        let mut instruction = Instruction::default();
+        let mut new_address = 0;
+        let mut reloc_iter = section.relocations.iter().peekable();
+        'outer: while decoder.can_decode() {
+            let address = decoder.ip();
+            while let Some(reloc) = reloc_iter.peek() {
+                match reloc.address.cmp(&address) {
+                    Ordering::Less => {
+                        reloc_iter.next();
+                    }
+                    Ordering::Equal => {
+                        // If the instruction starts at a relocation, it's inline data
+                        let reloc_size = self.reloc_size(reloc.flags).with_context(|| {
+                            format!("Unsupported inline x86 relocation {:?}", reloc.flags)
+                        })?;
+                        if decoder.set_position(decoder.position() + reloc_size).is_ok() {
+                            new_address = address + reloc_size as u64;
+                            decoder.set_ip(new_address);
+                            continue 'outer;
+                        }
+                    }
+                    Ordering::Greater => break,
+                }
+            }
+            decoder.decode_out(&mut instruction);
+            if instruction.mnemonic() != iced_x86::Mnemonic::Nop {
+                new_address = instruction.next_ip();
+            }
+        }
+        Ok(new_address.saturating_sub(symbol.address))
+    }
+}
+
+struct InstructionFormatterOutput<'a> {
+    cb: &'a mut dyn FnMut(InstructionPart<'_>) -> Result<()>,
+    reloc_replace: Option<(OpKind, usize, u64)>,
+    error: Option<anyhow::Error>,
+    skip_next: bool,
+}
+
+impl InstructionFormatterOutput<'_> {
+    fn push_signed(&mut self, mut value: i64) {
+        if self.error.is_some() {
+            return;
+        }
+        // The formatter writes the '-' operator and then gives us a negative value,
+        // so convert it to a positive value to avoid double negatives
+        if value < 0 {
+            value = value.wrapping_abs();
+        }
+        if let Err(e) = (self.cb)(InstructionPart::signed(value)) {
+            self.error = Some(e);
+        }
+    }
+}
+
+impl FormatterOutput for InstructionFormatterOutput<'_> {
+    fn write(&mut self, text: &str, kind: FormatterTextKind) {
+        if self.error.is_some() {
+            return;
+        }
+        // Skip whitespace after the mnemonic
+        if self.skip_next {
+            self.skip_next = false;
+            if kind == FormatterTextKind::Text && text == " " {
+                return;
+            }
+        }
+        match kind {
+            FormatterTextKind::Text | FormatterTextKind::Punctuation => {
+                if let Err(e) = (self.cb)(InstructionPart::basic(text)) {
+                    self.error = Some(e);
+                }
+            }
+            FormatterTextKind::Prefix
+            | FormatterTextKind::Keyword
+            | FormatterTextKind::Operator => {
+                if let Err(e) = (self.cb)(InstructionPart::opaque(text)) {
+                    self.error = Some(e);
+                }
+            }
+            _ => self.error = Some(anyhow!("x86: Unsupported FormatterTextKind {:?}", kind)),
+        }
+    }
+
+    fn write_mnemonic(&mut self, instruction: &Instruction, text: &str) {
+        if self.error.is_some() {
+            return;
+        }
+        if let Err(e) = (self.cb)(InstructionPart::opcode(text, instruction.mnemonic() as u16)) {
+            self.error = Some(e);
+        }
+        // Skip whitespace after the mnemonic
+        self.skip_next = true;
+    }
+
+    fn write_number(
+        &mut self,
+        instruction: &Instruction,
+        _operand: u32,
+        instruction_operand: Option<u32>,
+        _text: &str,
+        value: u64,
+        number_kind: NumberKind,
+        kind: FormatterTextKind,
+    ) {
+        if self.error.is_some() {
+            return;
+        }
+
+        if let (Some(operand), Some((target_op_kind, reloc_size, target_value))) =
+            (instruction_operand, self.reloc_replace)
+        {
+            #[allow(clippy::match_like_matches_macro)]
+            if instruction.op_kind(operand) == target_op_kind
+                && match (number_kind, reloc_size) {
+                    (NumberKind::Int8 | NumberKind::UInt8, 1)
+                    | (NumberKind::Int16 | NumberKind::UInt16, 2)
+                    | (NumberKind::Int32 | NumberKind::UInt32, 4)
+                    | (NumberKind::Int64 | NumberKind::UInt64, 4) // x86_64
+                    | (NumberKind::Int64 | NumberKind::UInt64, 8) => true,
+                    _ => false,
+                }
+                && value == target_value
+            {
+                if let Err(e) = (self.cb)(InstructionPart::reloc()) {
+                    self.error = Some(e);
+                }
+                return;
+            }
+        }
+
+        if let FormatterTextKind::LabelAddress | FormatterTextKind::FunctionAddress = kind {
+            if let Err(e) = (self.cb)(InstructionPart::branch_dest(value)) {
+                self.error = Some(e);
+            }
+            return;
+        }
+
+        match number_kind {
+            NumberKind::Int8 => self.push_signed(value as i8 as i64),
+            NumberKind::Int16 => self.push_signed(value as i16 as i64),
+            NumberKind::Int32 => self.push_signed(value as i32 as i64),
+            NumberKind::Int64 => self.push_signed(value as i64),
+            NumberKind::UInt8 | NumberKind::UInt16 | NumberKind::UInt32 | NumberKind::UInt64 => {
+                if let Err(e) = (self.cb)(InstructionPart::unsigned(value)) {
+                    self.error = Some(e);
+                }
+            }
+        }
+    }
+
+    fn write_decorator(
+        &mut self,
+        _instruction: &Instruction,
+        _operand: u32,
+        _instruction_operand: Option<u32>,
+        text: &str,
+        _decorator: DecoratorKind,
+    ) {
+        if self.error.is_some() {
+            return;
+        }
+        if let Err(e) = (self.cb)(InstructionPart::basic(text)) {
+            self.error = Some(e);
+        }
+    }
+
+    fn write_register(
+        &mut self,
+        _instruction: &Instruction,
+        _operand: u32,
+        _instruction_operand: Option<u32>,
+        text: &str,
+        _register: Register,
+    ) {
+        if self.error.is_some() {
+            return;
+        }
+        if let Err(e) = (self.cb)(InstructionPart::opaque(text)) {
+            self.error = Some(e);
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::obj::{Relocation, ResolvedRelocation};
+
+    #[test]
+    fn test_scan_instructions() {
+        let arch = ArchX86 { arch: Architecture::X86, endianness: object::Endianness::Little };
+        let code = [
+            0xc7, 0x85, 0x68, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x8b, 0x04, 0x85, 0x00,
+            0x00, 0x00, 0x00,
+        ];
+        let scanned =
+            arch.scan_instructions_internal(0, &code, 0, &[], &DiffObjConfig::default()).unwrap();
+        assert_eq!(scanned.len(), 2);
+        assert_eq!(scanned[0].address, 0);
+        assert_eq!(scanned[0].size, 10);
+        assert_eq!(scanned[0].opcode, iced_x86::Mnemonic::Mov as u16);
+        assert_eq!(scanned[0].branch_dest, None);
+        assert_eq!(scanned[1].address, 10);
+        assert_eq!(scanned[1].size, 7);
+        assert_eq!(scanned[1].opcode, iced_x86::Mnemonic::Mov as u16);
+        assert_eq!(scanned[1].branch_dest, None);
+    }
+
+    #[test]
+    fn test_process_instruction() {
+        let arch = ArchX86 { arch: Architecture::X86, endianness: object::Endianness::Little };
+        let code = [0xc7, 0x85, 0x68, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00];
+        let opcode = iced_x86::Mnemonic::Mov as u16;
+        let mut parts = Vec::new();
+        arch.display_instruction(
+            ResolvedInstructionRef {
+                ins_ref: InstructionRef { address: 0x1234, size: 10, opcode, branch_dest: None },
+                code: &code,
+                ..Default::default()
+            },
+            &DiffObjConfig::default(),
+            &mut |part| {
+                parts.push(part.into_static());
+                Ok(())
+            },
+        )
+        .unwrap();
+        assert_eq!(parts, &[
+            InstructionPart::opcode("mov", opcode),
+            InstructionPart::opaque("dword"),
+            InstructionPart::basic(" "),
+            InstructionPart::opaque("ptr"),
+            InstructionPart::basic(" "),
+            InstructionPart::basic("["),
+            InstructionPart::opaque("ebp"),
+            InstructionPart::opaque("-"),
+            InstructionPart::signed(152i64),
+            InstructionPart::basic("]"),
+            InstructionPart::basic(","),
+            InstructionPart::basic(" "),
+            InstructionPart::unsigned(0u64),
+        ]);
+    }
+
+    #[test]
+    fn test_process_instruction_with_reloc_1() {
+        let arch = ArchX86 { arch: Architecture::X86, endianness: object::Endianness::Little };
+        let code = [0xc7, 0x85, 0x68, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00];
+        let opcode = iced_x86::Mnemonic::Mov as u16;
+        let mut parts = Vec::new();
+        arch.display_instruction(
+            ResolvedInstructionRef {
+                ins_ref: InstructionRef { address: 0x1234, size: 10, opcode, branch_dest: None },
+                code: &code,
+                relocation: Some(ResolvedRelocation {
+                    relocation: &Relocation {
+                        flags: RelocationFlags::Coff(pe::IMAGE_REL_I386_DIR32),
+                        address: 0x1234 + 6,
+                        target_symbol: 0,
+                        addend: 0,
+                    },
+                    symbol: &Default::default(),
+                }),
+                ..Default::default()
+            },
+            &DiffObjConfig::default(),
+            &mut |part| {
+                parts.push(part.into_static());
+                Ok(())
+            },
+        )
+        .unwrap();
+        assert_eq!(parts, &[
+            InstructionPart::opcode("mov", opcode),
+            InstructionPart::opaque("dword"),
+            InstructionPart::basic(" "),
+            InstructionPart::opaque("ptr"),
+            InstructionPart::basic(" "),
+            InstructionPart::basic("["),
+            InstructionPart::opaque("ebp"),
+            InstructionPart::opaque("-"),
+            InstructionPart::signed(152i64),
+            InstructionPart::basic("]"),
+            InstructionPart::basic(","),
+            InstructionPart::basic(" "),
+            InstructionPart::reloc(),
+        ]);
+    }
+
+    #[test]
+    fn test_process_instruction_with_reloc_2() {
+        let arch = ArchX86 { arch: Architecture::X86, endianness: object::Endianness::Little };
+        let code = [0x8b, 0x04, 0x85, 0x00, 0x00, 0x00, 0x00];
+        let opcode = iced_x86::Mnemonic::Mov as u16;
+        let mut parts = Vec::new();
+        arch.display_instruction(
+            ResolvedInstructionRef {
+                ins_ref: InstructionRef { address: 0x1234, size: 7, opcode, branch_dest: None },
+                code: &code,
+                relocation: Some(ResolvedRelocation {
+                    relocation: &Relocation {
+                        flags: RelocationFlags::Coff(pe::IMAGE_REL_I386_DIR32),
+                        address: 0x1234 + 3,
+                        target_symbol: 0,
+                        addend: 0,
+                    },
+                    symbol: &Default::default(),
+                }),
+                ..Default::default()
+            },
+            &DiffObjConfig::default(),
+            &mut |part| {
+                parts.push(part.into_static());
+                Ok(())
+            },
+        )
+        .unwrap();
+        assert_eq!(parts, &[
+            InstructionPart::opcode("mov", opcode),
+            InstructionPart::opaque("eax"),
+            InstructionPart::basic(","),
+            InstructionPart::basic(" "),
+            InstructionPart::basic("["),
+            InstructionPart::opaque("eax"),
+            InstructionPart::opaque("*"),
+            InstructionPart::signed(4),
+            InstructionPart::opaque("+"),
+            InstructionPart::reloc(),
+            InstructionPart::basic("]"),
+        ]);
+    }
+
+    #[test]
+    fn test_process_instruction_with_reloc_3() {
+        let arch = ArchX86 { arch: Architecture::X86, endianness: object::Endianness::Little };
+        let code = [0xe8, 0x00, 0x00, 0x00, 0x00];
+        let opcode = iced_x86::Mnemonic::Call as u16;
+        let mut parts = Vec::new();
+        arch.display_instruction(
+            ResolvedInstructionRef {
+                ins_ref: InstructionRef { address: 0x1234, size: 5, opcode, branch_dest: None },
+                code: &code,
+                relocation: Some(ResolvedRelocation {
+                    relocation: &Relocation {
+                        flags: RelocationFlags::Coff(pe::IMAGE_REL_I386_REL32),
+                        address: 0x1234 + 1,
+                        target_symbol: 0,
+                        addend: 0,
+                    },
+                    symbol: &Default::default(),
+                }),
+                ..Default::default()
+            },
+            &DiffObjConfig::default(),
+            &mut |part| {
+                parts.push(part.into_static());
+                Ok(())
+            },
+        )
+        .unwrap();
+        assert_eq!(parts, &[InstructionPart::opcode("call", opcode), InstructionPart::reloc()]);
+    }
+
+    #[test]
+    fn test_process_instruction_with_reloc_4() {
+        let arch = ArchX86 { arch: Architecture::X86, endianness: object::Endianness::Little };
+        let code = [0x8b, 0x15, 0xa4, 0x21, 0x7e, 0x00];
+        let opcode = iced_x86::Mnemonic::Mov as u16;
+        let mut parts = Vec::new();
+        arch.display_instruction(
+            ResolvedInstructionRef {
+                ins_ref: InstructionRef { address: 0x1234, size: 6, opcode, branch_dest: None },
+                code: &code,
+                relocation: Some(ResolvedRelocation {
+                    relocation: &Relocation {
+                        flags: RelocationFlags::Coff(pe::IMAGE_REL_I386_DIR32),
+                        address: 0x1234 + 2,
+                        target_symbol: 0,
+                        addend: 0,
+                    },
+                    symbol: &Default::default(),
+                }),
+                ..Default::default()
+            },
+            &DiffObjConfig::default(),
+            &mut |part| {
+                parts.push(part.into_static());
+                Ok(())
+            },
+        )
+        .unwrap();
+        assert_eq!(parts, &[
+            InstructionPart::opcode("mov", opcode),
+            InstructionPart::opaque("edx"),
+            InstructionPart::basic(","),
+            InstructionPart::basic(" "),
+            InstructionPart::basic("["),
+            InstructionPart::reloc(),
+            InstructionPart::basic("]"),
+        ]);
+    }
+
+    #[test]
+    fn test_process_x86_64_instruction_with_reloc_1() {
+        let arch = ArchX86 { arch: Architecture::X86_64, endianness: object::Endianness::Little };
+        let code = [0x48, 0x8b, 0x05, 0x00, 0x00, 0x00, 0x00];
+        let opcode = iced_x86::Mnemonic::Mov as u16;
+        let mut parts = Vec::new();
+        arch.display_instruction(
+            ResolvedInstructionRef {
+                ins_ref: InstructionRef { address: 0x1234, size: 7, opcode, branch_dest: None },
+                code: &code,
+                relocation: Some(ResolvedRelocation {
+                    relocation: &Relocation {
+                        flags: RelocationFlags::Coff(pe::IMAGE_REL_AMD64_REL32),
+                        address: 0x1234 + 3,
+                        target_symbol: 0,
+                        addend: 0,
+                    },
+                    symbol: &Default::default(),
+                }),
+                ..Default::default()
+            },
+            &DiffObjConfig::default(),
+            &mut |part| {
+                parts.push(part.into_static());
+                Ok(())
+            },
+        )
+        .unwrap();
+        assert_eq!(parts, &[
+            InstructionPart::opcode("mov", opcode),
+            InstructionPart::opaque("rax"),
+            InstructionPart::basic(","),
+            InstructionPart::basic(" "),
+            InstructionPart::basic("["),
+            InstructionPart::reloc(),
+            InstructionPart::basic("]"),
+        ]);
+    }
+
+    #[test]
+    fn test_process_x86_64_instruction_with_reloc_2() {
+        let arch = ArchX86 { arch: Architecture::X86_64, endianness: object::Endianness::Little };
+        let code = [0xe8, 0x00, 0x00, 0x00, 0x00];
+        let opcode = iced_x86::Mnemonic::Call as u16;
+        let mut parts = Vec::new();
+        arch.display_instruction(
+            ResolvedInstructionRef {
+                ins_ref: InstructionRef { address: 0x1234, size: 5, opcode, branch_dest: None },
+                code: &code,
+                relocation: Some(ResolvedRelocation {
+                    relocation: &Relocation {
+                        flags: RelocationFlags::Coff(pe::IMAGE_REL_AMD64_REL32),
+                        address: 0x1234 + 1,
+                        target_symbol: 0,
+                        addend: 0,
+                    },
+                    symbol: &Default::default(),
+                }),
+                ..Default::default()
+            },
+            &DiffObjConfig::default(),
+            &mut |part| {
+                parts.push(part.into_static());
+                Ok(())
+            },
+        )
+        .unwrap();
+        assert_eq!(parts, &[InstructionPart::opcode("call", opcode), InstructionPart::reloc()]);
+    }
+
+    #[test]
+    fn test_display_1_byte_inline_data() {
+        let arch = ArchX86 { arch: Architecture::X86, endianness: object::Endianness::Little };
+        let code = [0xAB];
+        let mut parts = Vec::new();
+        arch.display_instruction(
+            ResolvedInstructionRef {
+                ins_ref: InstructionRef {
+                    address: 0x1234,
+                    size: 1,
+                    opcode: OPCODE_DATA,
+                    branch_dest: None,
+                },
+                code: &code,
+                ..Default::default()
+            },
+            &DiffObjConfig::default(),
+            &mut |part| {
+                parts.push(part.into_static());
+                Ok(())
+            },
+        )
+        .unwrap();
+        assert_eq!(parts, &[
+            InstructionPart::opcode(".byte", OPCODE_DATA),
+            InstructionPart::unsigned(0xABu64),
+        ]);
+    }
+}

objdiff-core/src/bindings/mod.rs

@@ -0,0 +1 @@
+pub mod report;

objdiff-core/src/bindings/report.rs

@@ -0,0 +1,460 @@
+#![allow(clippy::needless_lifetimes)] // Generated serde code
+
+use alloc::{
+    string::{String, ToString},
+    vec,
+    vec::Vec,
+};
+use core::ops::AddAssign;
+
+use anyhow::{Result, bail};
+use prost::Message;
+
+// Protobuf report types
+include!(concat!(env!("OUT_DIR"), "/objdiff.report.rs"));
+#[cfg(feature = "serde")]
+include!(concat!(env!("OUT_DIR"), "/objdiff.report.serde.rs"));
+
+pub const REPORT_VERSION: u32 = 2;
+
+impl Report {
+    /// Attempts to parse the report as binary protobuf or JSON.
+    pub fn parse(data: &[u8]) -> Result<Self> {
+        if data.is_empty() {
+            bail!("Empty data");
+        }
+        let report = if data[0] == b'{' {
+            // Load as JSON
+            #[cfg(feature = "serde")]
+            {
+                Self::from_json(data)?
+            }
+            #[cfg(not(feature = "serde"))]
+            bail!("JSON report parsing requires the `serde` feature")
+        } else {
+            // Load as binary protobuf
+            Self::decode(data).map_err(|e| anyhow::Error::msg(e.to_string()))?
+        };
+        Ok(report)
+    }
+
+    #[cfg(feature = "serde")]
+    /// Attempts to parse the report as JSON, migrating from the legacy report format if necessary.
+    fn from_json(bytes: &[u8]) -> Result<Self, serde_json::Error> {
+        match serde_json::from_slice::<Self>(bytes) {
+            Ok(report) => Ok(report),
+            Err(e) => {
+                use serde_json::error::Category;
+                match e.classify() {
+                    Category::Io | Category::Eof | Category::Syntax => Err(e),
+                    Category::Data => {
+                        // Try to load as legacy report
+                        match serde_json::from_slice::<LegacyReport>(bytes) {
+                            Ok(legacy_report) => Ok(Report::from(legacy_report)),
+                            Err(_) => Err(e),
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// Migrates the report to the latest version.
+    /// Fails if the report version is newer than supported.
+    pub fn migrate(&mut self) -> Result<()> {
+        if self.version == 0 {
+            self.migrate_v0()?;
+        }
+        if self.version == 1 {
+            self.migrate_v1()?;
+        }
+        if self.version != REPORT_VERSION {
+            bail!("Unsupported report version: {}", self.version);
+        }
+        Ok(())
+    }
+
+    /// Adds `complete_code`, `complete_data`, `complete_code_percent`, and `complete_data_percent`
+    /// to measures, and sets `progress_categories` in unit metadata.
+    fn migrate_v0(&mut self) -> Result<()> {
+        let Some(measures) = &mut self.measures else {
+            bail!("Missing measures in report");
+        };
+        for unit in &mut self.units {
+            let Some(unit_measures) = &mut unit.measures else {
+                bail!("Missing measures in report unit");
+            };
+            let mut complete = false;
+            if let Some(metadata) = &mut unit.metadata {
+                if metadata.module_name.is_some() || metadata.module_id.is_some() {
+                    metadata.progress_categories = vec!["modules".to_string()];
+                } else {
+                    metadata.progress_categories = vec!["dol".to_string()];
+                }
+                complete = metadata.complete.unwrap_or(false);
+            };
+            if complete {
+                unit_measures.complete_code = unit_measures.total_code;
+                unit_measures.complete_data = unit_measures.total_data;
+                unit_measures.complete_code_percent = 100.0;
+                unit_measures.complete_data_percent = 100.0;
+            } else {
+                unit_measures.complete_code = 0;
+                unit_measures.complete_data = 0;
+                unit_measures.complete_code_percent = 0.0;
+                unit_measures.complete_data_percent = 0.0;
+            }
+            measures.complete_code += unit_measures.complete_code;
+            measures.complete_data += unit_measures.complete_data;
+        }
+        measures.calc_matched_percent();
+        self.calculate_progress_categories();
+        self.version = 1;
+        Ok(())
+    }
+
+    /// Adds `total_units` and `complete_units` to measures.
+    fn migrate_v1(&mut self) -> Result<()> {
+        let Some(total_measures) = &mut self.measures else {
+            bail!("Missing measures in report");
+        };
+        for unit in &mut self.units {
+            let Some(measures) = &mut unit.measures else {
+                bail!("Missing measures in report unit");
+            };
+            let complete = unit.metadata.as_ref().and_then(|m| m.complete).unwrap_or(false) as u32;
+            let progress_categories =
+                unit.metadata.as_ref().map(|m| m.progress_categories.as_slice()).unwrap_or(&[]);
+            measures.total_units = 1;
+            measures.complete_units = complete;
+            total_measures.total_units += 1;
+            total_measures.complete_units += complete;
+            for id in progress_categories {
+                if let Some(category) = self.categories.iter_mut().find(|c| &c.id == id) {
+                    let Some(measures) = &mut category.measures else {
+                        bail!("Missing measures in category");
+                    };
+                    measures.total_units += 1;
+                    measures.complete_units += complete;
+                }
+            }
+        }
+        self.version = 2;
+        Ok(())
+    }
+
+    /// Calculate progress categories based on unit metadata.
+    pub fn calculate_progress_categories(&mut self) {
+        for unit in &self.units {
+            let Some(metadata) = unit.metadata.as_ref() else {
+                continue;
+            };
+            let Some(measures) = unit.measures.as_ref() else {
+                continue;
+            };
+            for category_id in &metadata.progress_categories {
+                let category = match self.categories.iter_mut().find(|c| &c.id == category_id) {
+                    Some(category) => category,
+                    None => {
+                        self.categories.push(ReportCategory {
+                            id: category_id.clone(),
+                            name: String::new(),
+                            measures: Some(Default::default()),
+                        });
+                        self.categories.last_mut().unwrap()
+                    }
+                };
+                *category.measures.get_or_insert_with(Default::default) += *measures;
+            }
+        }
+        for category in &mut self.categories {
+            let measures = category.measures.get_or_insert_with(Default::default);
+            measures.calc_fuzzy_match_percent();
+            measures.calc_matched_percent();
+        }
+    }
+
+    /// Split the report into multiple reports based on progress categories.
+    /// Assumes progress categories are in the format `version`, `version.category`.
+    /// This is a hack for projects that generate all versions in a single report.
+    pub fn split(self) -> Vec<(String, Report)> {
+        let mut reports = Vec::new();
+        // Map units to Option to allow taking ownership
+        let mut units = self.units.into_iter().map(Some).collect::<Vec<_>>();
+        for category in &self.categories {
+            if category.id.contains(".") {
+                // Skip subcategories
+                continue;
+            }
+            fn is_sub_category(id: &str, parent: &str, sep: char) -> bool {
+                id.starts_with(parent) && id.get(parent.len()..).is_some_and(|s| s.starts_with(sep))
+            }
+            let mut sub_categories = self
+                .categories
+                .iter()
+                .filter(|c| is_sub_category(&c.id, &category.id, '.'))
+                .cloned()
+                .collect::<Vec<_>>();
+            // Remove category prefix
+            for sub_category in &mut sub_categories {
+                sub_category.id = sub_category.id[category.id.len() + 1..].to_string();
+            }
+            let mut sub_units = units
+                .iter_mut()
+                .filter_map(|opt| {
+                    let unit = opt.as_mut()?;
+                    let metadata = unit.metadata.as_ref()?;
+                    if metadata.progress_categories.contains(&category.id) {
+                        opt.take()
+                    } else {
+                        None
+                    }
+                })
+                .collect::<Vec<_>>();
+            for sub_unit in &mut sub_units {
+                // Remove leading version/ from unit name
+                if let Some(name) =
+                    sub_unit.name.strip_prefix(&category.id).and_then(|s| s.strip_prefix('/'))
+                {
+                    sub_unit.name = name.to_string();
+                }
+                // Filter progress categories
+                let Some(metadata) = sub_unit.metadata.as_mut() else {
+                    continue;
+                };
+                metadata.progress_categories = metadata
+                    .progress_categories
+                    .iter()
+                    .filter(|c| is_sub_category(c, &category.id, '.'))
+                    .map(|c| c[category.id.len() + 1..].to_string())
+                    .collect();
+            }
+            reports.push((category.id.clone(), Report {
+                measures: category.measures,
+                units: sub_units,
+                version: self.version,
+                categories: sub_categories,
+            }));
+        }
+        reports
+    }
+}
+
+impl Measures {
+    /// Average the fuzzy match percentage over total code bytes.
+    pub fn calc_fuzzy_match_percent(&mut self) {
+        if self.total_code == 0 {
+            self.fuzzy_match_percent = 100.0;
+        } else {
+            self.fuzzy_match_percent /= self.total_code as f32;
+        }
+    }
+
+    /// Calculate the percentage of matched code, data, and functions.
+    pub fn calc_matched_percent(&mut self) {
+        self.matched_code_percent = if self.total_code == 0 {
+            100.0
+        } else {
+            self.matched_code as f32 / self.total_code as f32 * 100.0
+        };
+        self.matched_data_percent = if self.total_data == 0 {
+            100.0
+        } else {
+            self.matched_data as f32 / self.total_data as f32 * 100.0
+        };
+        self.matched_functions_percent = if self.total_functions == 0 {
+            100.0
+        } else {
+            self.matched_functions as f32 / self.total_functions as f32 * 100.0
+        };
+        self.complete_code_percent = if self.total_code == 0 {
+            100.0
+        } else {
+            self.complete_code as f32 / self.total_code as f32 * 100.0
+        };
+        self.complete_data_percent = if self.total_data == 0 {
+            100.0
+        } else {
+            self.complete_data as f32 / self.total_data as f32 * 100.0
+        };
+    }
+}
+
+impl From<&ReportItem> for ChangeItemInfo {
+    fn from(value: &ReportItem) -> Self {
+        Self { fuzzy_match_percent: value.fuzzy_match_percent, size: value.size }
+    }
+}
+
+impl AddAssign for Measures {
+    fn add_assign(&mut self, other: Self) {
+        self.fuzzy_match_percent += other.fuzzy_match_percent * other.total_code as f32;
+        self.total_code += other.total_code;
+        self.matched_code += other.matched_code;
+        self.total_data += other.total_data;
+        self.matched_data += other.matched_data;
+        self.total_functions += other.total_functions;
+        self.matched_functions += other.matched_functions;
+        self.complete_code += other.complete_code;
+        self.complete_data += other.complete_data;
+        self.total_units += other.total_units;
+        self.complete_units += other.complete_units;
+    }
+}
+
+/// Allows [collect](Iterator::collect) to be used on an iterator of [Measures].
+impl FromIterator<Measures> for Measures {
+    fn from_iter<T>(iter: T) -> Self
+    where T: IntoIterator<Item = Measures> {
+        let mut measures = Measures::default();
+        for other in iter {
+            measures += other;
+        }
+        measures.calc_fuzzy_match_percent();
+        measures.calc_matched_percent();
+        measures
+    }
+}
+
+// Older JSON report types
+#[derive(Debug, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+struct LegacyReport {
+    fuzzy_match_percent: f32,
+    total_code: u64,
+    matched_code: u64,
+    matched_code_percent: f32,
+    total_data: u64,
+    matched_data: u64,
+    matched_data_percent: f32,
+    total_functions: u32,
+    matched_functions: u32,
+    matched_functions_percent: f32,
+    units: Vec<LegacyReportUnit>,
+}
+
+impl From<LegacyReport> for Report {
+    fn from(value: LegacyReport) -> Self {
+        Self {
+            measures: Some(Measures {
+                fuzzy_match_percent: value.fuzzy_match_percent,
+                total_code: value.total_code,
+                matched_code: value.matched_code,
+                matched_code_percent: value.matched_code_percent,
+                total_data: value.total_data,
+                matched_data: value.matched_data,
+                matched_data_percent: value.matched_data_percent,
+                total_functions: value.total_functions,
+                matched_functions: value.matched_functions,
+                matched_functions_percent: value.matched_functions_percent,
+                ..Default::default()
+            }),
+            units: value.units.into_iter().map(ReportUnit::from).collect::<Vec<_>>(),
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+struct LegacyReportUnit {
+    name: String,
+    fuzzy_match_percent: f32,
+    total_code: u64,
+    matched_code: u64,
+    total_data: u64,
+    matched_data: u64,
+    total_functions: u32,
+    matched_functions: u32,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    complete: Option<bool>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    module_name: Option<String>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    module_id: Option<u32>,
+    sections: Vec<LegacyReportItem>,
+    functions: Vec<LegacyReportItem>,
+}
+
+impl From<LegacyReportUnit> for ReportUnit {
+    fn from(value: LegacyReportUnit) -> Self {
+        let mut measures = Measures {
+            fuzzy_match_percent: value.fuzzy_match_percent,
+            total_code: value.total_code,
+            matched_code: value.matched_code,
+            total_data: value.total_data,
+            matched_data: value.matched_data,
+            total_functions: value.total_functions,
+            matched_functions: value.matched_functions,
+            ..Default::default()
+        };
+        measures.calc_matched_percent();
+        Self {
+            name: value.name.clone(),
+            measures: Some(measures),
+            sections: value.sections.into_iter().map(ReportItem::from).collect(),
+            functions: value.functions.into_iter().map(ReportItem::from).collect(),
+            metadata: Some(ReportUnitMetadata {
+                complete: value.complete,
+                module_name: value.module_name.clone(),
+                module_id: value.module_id,
+                ..Default::default()
+            }),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+struct LegacyReportItem {
+    name: String,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    demangled_name: Option<String>,
+    #[cfg_attr(
+        feature = "serde",
+        serde(
+            default,
+            skip_serializing_if = "Option::is_none",
+            serialize_with = "serialize_hex",
+            deserialize_with = "deserialize_hex"
+        )
+    )]
+    address: Option<u64>,
+    size: u64,
+    fuzzy_match_percent: f32,
+}
+
+impl From<LegacyReportItem> for ReportItem {
+    fn from(value: LegacyReportItem) -> Self {
+        Self {
+            name: value.name,
+            size: value.size,
+            fuzzy_match_percent: value.fuzzy_match_percent,
+            metadata: Some(ReportItemMetadata {
+                demangled_name: value.demangled_name,
+                virtual_address: value.address,
+            }),
+            address: None,
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+fn serialize_hex<S>(x: &Option<u64>, s: S) -> Result<S::Ok, S::Error>
+where S: serde::Serializer {
+    if let Some(x) = x { s.serialize_str(&format!("{x:#x}")) } else { s.serialize_none() }
+}
+
+#[cfg(feature = "serde")]
+fn deserialize_hex<'de, D>(d: D) -> Result<Option<u64>, D::Error>
+where D: serde::Deserializer<'de> {
+    use serde::Deserialize;
+    let s = String::deserialize(d)?;
+    if s.is_empty() {
+        Ok(None)
+    } else if !s.starts_with("0x") {
+        Err(serde::de::Error::custom("expected hex string"))
+    } else {
+        u64::from_str_radix(&s[2..], 16).map(Some).map_err(serde::de::Error::custom)
+    }
+}

objdiff-core/src/build/mod.rs

@@ -0,0 +1,109 @@
+pub mod watcher;
+
+use std::process::Command;
+
+use typed_path::{Utf8PlatformPathBuf, Utf8UnixPath};
+
+pub struct BuildStatus {
+    pub success: bool,
+    pub cmdline: String,
+    pub stdout: String,
+    pub stderr: String,
+}
+
+impl Default for BuildStatus {
+    fn default() -> Self {
+        BuildStatus {
+            success: true,
+            cmdline: String::new(),
+            stdout: String::new(),
+            stderr: String::new(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct BuildConfig {
+    pub project_dir: Option<Utf8PlatformPathBuf>,
+    pub custom_make: Option<String>,
+    pub custom_args: Option<Vec<String>>,
+    #[allow(unused)]
+    pub selected_wsl_distro: Option<String>,
+}
+
+pub fn run_make(config: &BuildConfig, arg: &Utf8UnixPath) -> BuildStatus {
+    let Some(cwd) = &config.project_dir else {
+        return BuildStatus {
+            success: false,
+            stderr: "Missing project dir".to_string(),
+            ..Default::default()
+        };
+    };
+    let make = config.custom_make.as_deref().unwrap_or("make");
+    let make_args = config.custom_args.as_deref().unwrap_or(&[]);
+    #[cfg(not(windows))]
+    let mut command = {
+        let mut command = Command::new(make);
+        command.current_dir(cwd).args(make_args).arg(arg);
+        command
+    };
+    #[cfg(windows)]
+    let mut command = {
+        use alloc::borrow::Cow;
+        use std::os::windows::process::CommandExt;
+
+        let mut command = if config.selected_wsl_distro.is_some() {
+            Command::new("wsl")
+        } else {
+            Command::new(make)
+        };
+        if let Some(distro) = &config.selected_wsl_distro {
+            // Strip distro root prefix \\wsl.localhost\{distro}
+            let wsl_path_prefix = format!("\\\\wsl.localhost\\{}", distro);
+            let cwd = match cwd.strip_prefix(wsl_path_prefix) {
+                // Convert to absolute Unix path
+                Ok(new_cwd) => Cow::Owned(
+                    Utf8UnixPath::new("/").join(new_cwd.with_unix_encoding()).into_string(),
+                ),
+                // Otherwise, use the Windows path as is
+                Err(_) => Cow::Borrowed(cwd.as_str()),
+            };
+
+            command
+                .arg("--cd")
+                .arg::<&str>(cwd.as_ref())
+                .arg("-d")
+                .arg(distro)
+                .arg("--")
+                .arg(make)
+                .args(make_args)
+                .arg(arg.as_str());
+        } else {
+            command.current_dir(cwd).args(make_args).arg(arg.as_str());
+        }
+        command.creation_flags(winapi::um::winbase::CREATE_NO_WINDOW);
+        command
+    };
+    let mut cmdline = shell_escape::escape(command.get_program().to_string_lossy()).into_owned();
+    for arg in command.get_args() {
+        cmdline.push(' ');
+        cmdline.push_str(shell_escape::escape(arg.to_string_lossy()).as_ref());
+    }
+    let output = match command.output() {
+        Ok(output) => output,
+        Err(e) => {
+            return BuildStatus {
+                success: false,
+                cmdline,
+                stdout: Default::default(),
+                stderr: e.to_string(),
+            };
+        }
+    };
+    // Try from_utf8 first to avoid copying the buffer if it's valid, then fall back to from_utf8_lossy
+    let stdout = String::from_utf8(output.stdout)
+        .unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned());
+    let stderr = String::from_utf8(output.stderr)
+        .unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned());
+    BuildStatus { success: output.status.success(), cmdline, stdout, stderr }
+}

objdiff-core/src/build/watcher.rs

@@ -0,0 +1,76 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+    task::Waker,
+    time::Duration,
+};
+
+use globset::GlobSet;
+use notify::RecursiveMode;
+use notify_debouncer_full::{DebounceEventResult, new_debouncer_opt};
+
+pub type Watcher = notify_debouncer_full::Debouncer<
+    notify::RecommendedWatcher,
+    notify_debouncer_full::RecommendedCache,
+>;
+
+pub struct WatcherState {
+    pub config_path: Option<PathBuf>,
+    pub left_obj_path: Option<PathBuf>,
+    pub right_obj_path: Option<PathBuf>,
+    pub patterns: GlobSet,
+}
+
+pub fn create_watcher(
+    modified: Arc<AtomicBool>,
+    project_dir: &Path,
+    patterns: GlobSet,
+    ignore_patterns: GlobSet,
+    waker: Waker,
+) -> notify::Result<Watcher> {
+    let base_dir = fs::canonicalize(project_dir)?;
+    let base_dir_clone = base_dir.clone();
+    let timeout = Duration::from_millis(200);
+    let config = notify::Config::default().with_poll_interval(Duration::from_secs(2));
+    let mut debouncer = new_debouncer_opt(
+        timeout,
+        None,
+        move |result: DebounceEventResult| match result {
+            Ok(events) => {
+                let mut any_match = false;
+                for event in events.iter() {
+                    if !matches!(
+                        event.kind,
+                        notify::EventKind::Modify(..)
+                            | notify::EventKind::Create(..)
+                            | notify::EventKind::Remove(..)
+                    ) {
+                        continue;
+                    }
+                    for path in &event.paths {
+                        let Ok(path) = path.strip_prefix(&base_dir_clone) else {
+                            continue;
+                        };
+                        if patterns.is_match(path) && !ignore_patterns.is_match(path) {
+                            log::debug!("File modified: {}", path.display());
+                            any_match = true;
+                        }
+                    }
+                }
+                if any_match {
+                    modified.store(true, Ordering::Relaxed);
+                    waker.wake_by_ref();
+                }
+            }
+            Err(errors) => errors.iter().for_each(|e| log::error!("Watch error: {e:?}")),
+        },
+        notify_debouncer_full::RecommendedCache::new(),
+        config,
+    )?;
+    debouncer.watch(base_dir, RecursiveMode::Recursive)?;
+    Ok(debouncer)
+}

objdiff-core/src/config/mod.rs

@@ -0,0 +1,372 @@
+pub mod path;
+
+use alloc::{
+    borrow::Cow,
+    collections::BTreeMap,
+    string::{String, ToString},
+    vec::Vec,
+};
+
+use anyhow::{Context, Result, anyhow};
+use globset::{Glob, GlobSet, GlobSetBuilder};
+use path::unix_path_serde_option;
+use typed_path::Utf8UnixPathBuf;
+
+#[derive(Default, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize), serde(default))]
+pub struct ProjectConfig {
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub min_version: Option<String>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub custom_make: Option<String>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub custom_args: Option<Vec<String>>,
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "unix_path_serde_option", skip_serializing_if = "Option::is_none")
+    )]
+    pub target_dir: Option<Utf8UnixPathBuf>,
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "unix_path_serde_option", skip_serializing_if = "Option::is_none")
+    )]
+    pub base_dir: Option<Utf8UnixPathBuf>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub build_base: Option<bool>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub build_target: Option<bool>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub watch_patterns: Option<Vec<String>>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub ignore_patterns: Option<Vec<String>>,
+    #[cfg_attr(
+        feature = "serde",
+        serde(alias = "objects", skip_serializing_if = "Option::is_none")
+    )]
+    pub units: Option<Vec<ProjectObject>>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub progress_categories: Option<Vec<ProjectProgressCategory>>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub options: Option<ProjectOptions>,
+}
+
+impl ProjectConfig {
+    #[inline]
+    pub fn units(&self) -> &[ProjectObject] { self.units.as_deref().unwrap_or_default() }
+
+    #[inline]
+    pub fn progress_categories(&self) -> &[ProjectProgressCategory] {
+        self.progress_categories.as_deref().unwrap_or_default()
+    }
+
+    #[inline]
+    pub fn progress_categories_mut(&mut self) -> &mut Vec<ProjectProgressCategory> {
+        self.progress_categories.get_or_insert_with(Vec::new)
+    }
+
+    pub fn build_watch_patterns(&self) -> Result<Vec<Glob>, globset::Error> {
+        Ok(if let Some(watch_patterns) = &self.watch_patterns {
+            watch_patterns
+                .iter()
+                .map(|s| Glob::new(s))
+                .collect::<Result<Vec<Glob>, globset::Error>>()?
+        } else {
+            default_watch_patterns()
+        })
+    }
+
+    pub fn build_ignore_patterns(&self) -> Result<Vec<Glob>, globset::Error> {
+        Ok(if let Some(ignore_patterns) = &self.ignore_patterns {
+            ignore_patterns
+                .iter()
+                .map(|s| Glob::new(s))
+                .collect::<Result<Vec<Glob>, globset::Error>>()?
+        } else {
+            default_ignore_patterns()
+        })
+    }
+}
+
+#[derive(Default, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize), serde(default))]
+pub struct ProjectObject {
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub name: Option<String>,
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "unix_path_serde_option", skip_serializing_if = "Option::is_none")
+    )]
+    pub path: Option<Utf8UnixPathBuf>,
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "unix_path_serde_option", skip_serializing_if = "Option::is_none")
+    )]
+    pub target_path: Option<Utf8UnixPathBuf>,
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "unix_path_serde_option", skip_serializing_if = "Option::is_none")
+    )]
+    pub base_path: Option<Utf8UnixPathBuf>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    #[deprecated(note = "Use metadata.reverse_fn_order")]
+    pub reverse_fn_order: Option<bool>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    #[deprecated(note = "Use metadata.complete")]
+    pub complete: Option<bool>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub scratch: Option<ScratchConfig>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub metadata: Option<ProjectObjectMetadata>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub symbol_mappings: Option<BTreeMap<String, String>>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub options: Option<ProjectOptions>,
+}
+
+#[derive(Default, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize), serde(default))]
+pub struct ProjectObjectMetadata {
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub complete: Option<bool>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub reverse_fn_order: Option<bool>,
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "unix_path_serde_option", skip_serializing_if = "Option::is_none")
+    )]
+    pub source_path: Option<Utf8UnixPathBuf>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub progress_categories: Option<Vec<String>>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub auto_generated: Option<bool>,
+}
+
+#[derive(Default, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize), serde(default))]
+pub struct ProjectProgressCategory {
+    pub id: String,
+    pub name: String,
+}
+
+pub type ProjectOptions = BTreeMap<String, ProjectOptionValue>;
+
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize), serde(untagged))]
+pub enum ProjectOptionValue {
+    Bool(bool),
+    String(String),
+}
+
+impl ProjectObject {
+    pub fn name(&self) -> &str {
+        if let Some(name) = &self.name {
+            name
+        } else if let Some(path) = &self.path {
+            path.as_str()
+        } else {
+            "[unknown]"
+        }
+    }
+
+    pub fn complete(&self) -> Option<bool> {
+        #[expect(deprecated)]
+        self.metadata.as_ref().and_then(|m| m.complete).or(self.complete)
+    }
+
+    pub fn reverse_fn_order(&self) -> Option<bool> {
+        #[expect(deprecated)]
+        self.metadata.as_ref().and_then(|m| m.reverse_fn_order).or(self.reverse_fn_order)
+    }
+
+    pub fn hidden(&self) -> bool {
+        self.metadata.as_ref().and_then(|m| m.auto_generated).unwrap_or(false)
+    }
+
+    pub fn source_path(&self) -> Option<&Utf8UnixPathBuf> {
+        self.metadata.as_ref().and_then(|m| m.source_path.as_ref())
+    }
+
+    pub fn progress_categories(&self) -> &[String] {
+        self.metadata.as_ref().and_then(|m| m.progress_categories.as_deref()).unwrap_or_default()
+    }
+
+    pub fn auto_generated(&self) -> Option<bool> {
+        self.metadata.as_ref().and_then(|m| m.auto_generated)
+    }
+
+    pub fn options(&self) -> Option<&ProjectOptions> { self.options.as_ref() }
+}
+
+#[derive(Default, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize), serde(default))]
+pub struct ScratchConfig {
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub platform: Option<String>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub compiler: Option<String>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub c_flags: Option<String>,
+    #[cfg_attr(
+        feature = "serde",
+        serde(with = "unix_path_serde_option", skip_serializing_if = "Option::is_none")
+    )]
+    pub ctx_path: Option<Utf8UnixPathBuf>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub build_ctx: Option<bool>,
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
+    pub preset_id: Option<u32>,
+}
+
+pub const CONFIG_FILENAMES: [&str; 3] = ["objdiff.json", "objdiff.yml", "objdiff.yaml"];
+
+pub const DEFAULT_WATCH_PATTERNS: &[&str] = &[
+    "*.c", "*.cc", "*.cp", "*.cpp", "*.cxx", "*.c++", "*.h", "*.hh", "*.hp", "*.hpp", "*.hxx",
+    "*.h++", "*.pch", "*.pch++", "*.inc", "*.s", "*.S", "*.asm", "*.py", "*.yml", "*.txt",
+    "*.json",
+];
+
+pub const DEFAULT_IGNORE_PATTERNS: &[&str] = &["build/**/*"];
+
+pub fn default_watch_patterns() -> Vec<Glob> {
+    DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect()
+}
+
+pub fn default_ignore_patterns() -> Vec<Glob> {
+    DEFAULT_IGNORE_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect()
+}
+
+#[cfg(feature = "std")]
+#[derive(Clone, Eq, PartialEq)]
+pub struct ProjectConfigInfo {
+    pub path: std::path::PathBuf,
+    pub timestamp: Option<filetime::FileTime>,
+}
+
+#[cfg(feature = "std")]
+pub fn try_project_config(
+    dir: &std::path::Path,
+) -> Option<(Result<ProjectConfig>, ProjectConfigInfo)> {
+    for filename in CONFIG_FILENAMES.iter() {
+        let config_path = dir.join(filename);
+        let Ok(file) = std::fs::File::open(&config_path) else {
+            continue;
+        };
+        let metadata = file.metadata();
+        if let Ok(metadata) = metadata {
+            if !metadata.is_file() {
+                continue;
+            }
+            let ts = filetime::FileTime::from_last_modification_time(&metadata);
+            let mut reader = std::io::BufReader::new(file);
+            let mut result = read_json_config(&mut reader);
+            if let Ok(config) = &result {
+                // Validate min_version if present
+                if let Err(e) = validate_min_version(config) {
+                    result = Err(e);
+                }
+            }
+            return Some((result, ProjectConfigInfo { path: config_path, timestamp: Some(ts) }));
+        }
+    }
+    None
+}
+
+#[cfg(feature = "std")]
+pub fn save_project_config(
+    config: &ProjectConfig,
+    info: &ProjectConfigInfo,
+) -> Result<ProjectConfigInfo> {
+    if let Some(last_ts) = info.timestamp {
+        // Check if the file has changed since we last read it
+        if let Ok(metadata) = std::fs::metadata(&info.path) {
+            let ts = filetime::FileTime::from_last_modification_time(&metadata);
+            if ts != last_ts {
+                return Err(anyhow!("Config file has changed since last read"));
+            }
+        }
+    }
+    let mut writer = std::io::BufWriter::new(
+        std::fs::File::create(&info.path).context("Failed to create config file")?,
+    );
+    let ext = info.path.extension().and_then(|ext| ext.to_str()).unwrap_or("json");
+    match ext {
+        "json" => serde_json::to_writer_pretty(&mut writer, config).context("Failed to write JSON"),
+        _ => Err(anyhow!("Unknown config file extension: {ext}")),
+    }?;
+    let file = writer.into_inner().context("Failed to flush file")?;
+    let metadata = file.metadata().context("Failed to get file metadata")?;
+    let ts = filetime::FileTime::from_last_modification_time(&metadata);
+    Ok(ProjectConfigInfo { path: info.path.clone(), timestamp: Some(ts) })
+}
+
+fn validate_min_version(config: &ProjectConfig) -> Result<()> {
+    let Some(min_version) = &config.min_version else { return Ok(()) };
+    let version = semver::Version::parse(env!("CARGO_PKG_VERSION"))
+        .map_err(|e| anyhow::Error::msg(e.to_string()))
+        .context("Failed to parse package version")?;
+    let min_version = semver::Version::parse(min_version)
+        .map_err(|e| anyhow::Error::msg(e.to_string()))
+        .context("Failed to parse min_version")?;
+    if version >= min_version {
+        Ok(())
+    } else {
+        Err(anyhow!("Project requires objdiff version {min_version} or higher"))
+    }
+}
+
+#[cfg(feature = "std")]
+fn read_json_config<R: std::io::Read>(reader: &mut R) -> Result<ProjectConfig> {
+    Ok(serde_json::from_reader(reader)?)
+}
+
+pub fn build_globset(vec: &[Glob]) -> Result<GlobSet, globset::Error> {
+    let mut builder = GlobSetBuilder::new();
+    for glob in vec {
+        builder.add(glob.clone());
+    }
+    builder.build()
+}
+
+#[cfg(feature = "any-arch")]
+pub fn apply_project_options(
+    diff_config: &mut crate::diff::DiffObjConfig,
+    options: &ProjectOptions,
+) -> Result<()> {
+    use core::str::FromStr;
+
+    use crate::diff::{ConfigEnum, ConfigPropertyId, ConfigPropertyKind};
+
+    let mut result = Ok(());
+    for (key, value) in options.iter() {
+        let property_id = ConfigPropertyId::from_str(key)
+            .map_err(|()| anyhow!("Invalid configuration property: {key}"))?;
+        let value = match value {
+            ProjectOptionValue::Bool(value) => Cow::Borrowed(if *value { "true" } else { "false" }),
+            ProjectOptionValue::String(value) => Cow::Borrowed(value.as_str()),
+        };
+        if diff_config.set_property_value_str(property_id, &value).is_err() {
+            if result.is_err() {
+                // Already returning an error, skip further errors
+                continue;
+            }
+            let mut expected = String::new();
+            match property_id.kind() {
+                ConfigPropertyKind::Boolean => expected.push_str("true, false"),
+                ConfigPropertyKind::Choice(variants) => {
+                    for (idx, variant) in variants.iter().enumerate() {
+                        if idx > 0 {
+                            expected.push_str(", ");
+                        }
+                        expected.push_str(variant.value);
+                    }
+                }
+            }
+            result = Err(anyhow!(
+                "Invalid value for {}. Expected one of: {}",
+                property_id.name(),
+                expected
+            ));
+        }
+    }
+    result
+}

objdiff-core/src/config/path.rs

@@ -0,0 +1,57 @@
+// For argp::FromArgs
+#[cfg(feature = "std")]
+pub fn platform_path(value: &str) -> Result<typed_path::Utf8PlatformPathBuf, String> {
+    Ok(typed_path::Utf8PlatformPathBuf::from(value))
+}
+
+/// Checks if the path is valid UTF-8 and returns it as a [`Utf8PlatformPath`].
+#[cfg(feature = "std")]
+pub fn check_path(
+    path: &std::path::Path,
+) -> Result<&typed_path::Utf8PlatformPath, core::str::Utf8Error> {
+    typed_path::Utf8PlatformPath::from_bytes_path(typed_path::PlatformPath::new(
+        path.as_os_str().as_encoded_bytes(),
+    ))
+}
+
+/// Checks if the path is valid UTF-8 and returns it as a [`Utf8NativePathBuf`].
+#[cfg(feature = "std")]
+pub fn check_path_buf(
+    path: std::path::PathBuf,
+) -> Result<typed_path::Utf8PlatformPathBuf, alloc::string::FromUtf8Error> {
+    typed_path::Utf8PlatformPathBuf::from_bytes_path_buf(typed_path::PlatformPathBuf::from(
+        path.into_os_string().into_encoded_bytes(),
+    ))
+}
+
+#[cfg(feature = "serde")]
+pub mod unix_path_serde_option {
+    use serde::{Deserialize, Deserializer, Serializer};
+    use typed_path::Utf8UnixPathBuf;
+
+    pub fn serialize<S>(path: &Option<Utf8UnixPathBuf>, s: S) -> Result<S::Ok, S::Error>
+    where S: Serializer {
+        if let Some(path) = path { s.serialize_some(path.as_str()) } else { s.serialize_none() }
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Utf8UnixPathBuf>, D::Error>
+    where D: Deserializer<'de> {
+        Ok(Option::<String>::deserialize(deserializer)?.map(Utf8UnixPathBuf::from))
+    }
+}
+
+#[cfg(all(feature = "serde", feature = "std"))]
+pub mod platform_path_serde_option {
+    use serde::{Deserialize, Deserializer, Serializer};
+    use typed_path::Utf8PlatformPathBuf;
+
+    pub fn serialize<S>(path: &Option<Utf8PlatformPathBuf>, s: S) -> Result<S::Ok, S::Error>
+    where S: Serializer {
+        if let Some(path) = path { s.serialize_some(path.as_str()) } else { s.serialize_none() }
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Utf8PlatformPathBuf>, D::Error>
+    where D: Deserializer<'de> {
+        Ok(Option::<String>::deserialize(deserializer)?.map(Utf8PlatformPathBuf::from))
+    }
+}

objdiff-core/src/diff/code.rs

@@ -0,0 +1,515 @@
+use alloc::{
+    collections::{BTreeMap, btree_map},
+    string::{String, ToString},
+    vec,
+    vec::Vec,
+};
+
+use anyhow::{Context, Result, anyhow, ensure};
+
+use super::{
+    DiffObjConfig, FunctionRelocDiffs, InstructionArgDiffIndex, InstructionBranchFrom,
+    InstructionBranchTo, InstructionDiffKind, InstructionDiffRow, SymbolDiff,
+    display::display_ins_data_literals,
+};
+use crate::obj::{
+    InstructionArg, InstructionArgValue, InstructionRef, Object, ResolvedInstructionRef,
+    ResolvedRelocation, ResolvedSymbol, SymbolKind,
+};
+
+pub fn no_diff_code(
+    obj: &Object,
+    symbol_index: usize,
+    diff_config: &DiffObjConfig,
+) -> Result<SymbolDiff> {
+    let symbol = &obj.symbols[symbol_index];
+    let section_index = symbol.section.ok_or_else(|| anyhow!("Missing section for symbol"))?;
+    let section = &obj.sections[section_index];
+    let data = section.data_range(symbol.address, symbol.size as usize).ok_or_else(|| {
+        anyhow!(
+            "Symbol data out of bounds: {:#x}..{:#x}",
+            symbol.address,
+            symbol.address + symbol.size
+        )
+    })?;
+    let ops = obj.arch.scan_instructions(
+        ResolvedSymbol { obj, symbol_index, symbol, section_index, section, data },
+        diff_config,
+    )?;
+    let mut instruction_rows = Vec::<InstructionDiffRow>::new();
+    for i in &ops {
+        instruction_rows.push(InstructionDiffRow { ins_ref: Some(*i), ..Default::default() });
+    }
+    resolve_branches(&ops, &mut instruction_rows);
+    Ok(SymbolDiff {
+        target_symbol: None,
+        match_percent: None,
+        diff_score: None,
+        instruction_rows,
+        ..Default::default()
+    })
+}
+
+const PENALTY_IMM_DIFF: u64 = 1;
+const PENALTY_REG_DIFF: u64 = 5;
+const PENALTY_REPLACE: u64 = 60;
+const PENALTY_INSERT_DELETE: u64 = 100;
+
+pub fn diff_code(
+    left_obj: &Object,
+    right_obj: &Object,
+    left_symbol_idx: usize,
+    right_symbol_idx: usize,
+    diff_config: &DiffObjConfig,
+) -> Result<(SymbolDiff, SymbolDiff)> {
+    let left_symbol = &left_obj.symbols[left_symbol_idx];
+    let right_symbol = &right_obj.symbols[right_symbol_idx];
+    let left_section = left_symbol
+        .section
+        .and_then(|i| left_obj.sections.get(i))
+        .ok_or_else(|| anyhow!("Missing section for symbol"))?;
+    let right_section = right_symbol
+        .section
+        .and_then(|i| right_obj.sections.get(i))
+        .ok_or_else(|| anyhow!("Missing section for symbol"))?;
+    let left_data = left_section
+        .data_range(left_symbol.address, left_symbol.size as usize)
+        .ok_or_else(|| {
+            anyhow!(
+                "Symbol data out of bounds: {:#x}..{:#x}",
+                left_symbol.address,
+                left_symbol.address + left_symbol.size
+            )
+        })?;
+    let right_data = right_section
+        .data_range(right_symbol.address, right_symbol.size as usize)
+        .ok_or_else(|| {
+            anyhow!(
+                "Symbol data out of bounds: {:#x}..{:#x}",
+                right_symbol.address,
+                right_symbol.address + right_symbol.size
+            )
+        })?;
+
+    let left_section_idx = left_symbol.section.unwrap();
+    let right_section_idx = right_symbol.section.unwrap();
+    let left_ops = left_obj.arch.scan_instructions(
+        ResolvedSymbol {
+            obj: left_obj,
+            symbol_index: left_symbol_idx,
+            symbol: left_symbol,
+            section_index: left_section_idx,
+            section: left_section,
+            data: left_data,
+        },
+        diff_config,
+    )?;
+    let right_ops = right_obj.arch.scan_instructions(
+        ResolvedSymbol {
+            obj: right_obj,
+            symbol_index: right_symbol_idx,
+            symbol: right_symbol,
+            section_index: right_section_idx,
+            section: right_section,
+            data: right_data,
+        },
+        diff_config,
+    )?;
+    let (mut left_rows, mut right_rows) = diff_instructions(&left_ops, &right_ops)?;
+    resolve_branches(&left_ops, &mut left_rows);
+    resolve_branches(&right_ops, &mut right_rows);
+
+    let mut diff_state = InstructionDiffState::default();
+    for (left_row, right_row) in left_rows.iter_mut().zip(right_rows.iter_mut()) {
+        let result = diff_instruction(
+            left_obj,
+            right_obj,
+            left_symbol_idx,
+            right_symbol_idx,
+            left_row.ins_ref,
+            right_row.ins_ref,
+            left_row,
+            right_row,
+            diff_config,
+            &mut diff_state,
+        )?;
+        left_row.kind = result.kind;
+        right_row.kind = result.kind;
+        left_row.arg_diff = result.left_args_diff;
+        right_row.arg_diff = result.right_args_diff;
+    }
+
+    let max_score = left_ops.len() as u64 * PENALTY_INSERT_DELETE;
+    let diff_score = diff_state.diff_score.min(max_score);
+    let match_percent = if max_score == 0 {
+        100.0
+    } else {
+        ((1.0 - (diff_score as f64 / max_score as f64)) * 100.0) as f32
+    };
+
+    Ok((
+        SymbolDiff {
+            target_symbol: Some(right_symbol_idx),
+            match_percent: Some(match_percent),
+            diff_score: Some((diff_score, max_score)),
+            instruction_rows: left_rows,
+            ..Default::default()
+        },
+        SymbolDiff {
+            target_symbol: Some(left_symbol_idx),
+            match_percent: Some(match_percent),
+            diff_score: Some((diff_score, max_score)),
+            instruction_rows: right_rows,
+            ..Default::default()
+        },
+    ))
+}
+
+fn diff_instructions(
+    left_insts: &[InstructionRef],
+    right_insts: &[InstructionRef],
+) -> Result<(Vec<InstructionDiffRow>, Vec<InstructionDiffRow>)> {
+    let left_ops = left_insts.iter().map(|i| i.opcode).collect::<Vec<_>>();
+    let right_ops = right_insts.iter().map(|i| i.opcode).collect::<Vec<_>>();
+    let ops = similar::capture_diff_slices(similar::Algorithm::Patience, &left_ops, &right_ops);
+    if ops.is_empty() {
+        ensure!(left_insts.len() == right_insts.len());
+        let left_diff = left_insts
+            .iter()
+            .map(|i| InstructionDiffRow { ins_ref: Some(*i), ..Default::default() })
+            .collect();
+        let right_diff = right_insts
+            .iter()
+            .map(|i| InstructionDiffRow { ins_ref: Some(*i), ..Default::default() })
+            .collect();
+        return Ok((left_diff, right_diff));
+    }
+
+    let row_count = ops
+        .iter()
+        .map(|op| match *op {
+            similar::DiffOp::Equal { len, .. } => len,
+            similar::DiffOp::Delete { old_len, .. } => old_len,
+            similar::DiffOp::Insert { new_len, .. } => new_len,
+            similar::DiffOp::Replace { old_len, new_len, .. } => old_len.max(new_len),
+        })
+        .sum();
+    let mut left_diff = Vec::<InstructionDiffRow>::with_capacity(row_count);
+    let mut right_diff = Vec::<InstructionDiffRow>::with_capacity(row_count);
+    for op in ops {
+        let (_tag, left_range, right_range) = op.as_tag_tuple();
+        let len = left_range.len().max(right_range.len());
+        left_diff.extend(
+            left_range
+                .clone()
+                .map(|i| InstructionDiffRow { ins_ref: Some(left_insts[i]), ..Default::default() }),
+        );
+        right_diff.extend(
+            right_range.clone().map(|i| InstructionDiffRow {
+                ins_ref: Some(right_insts[i]),
+                ..Default::default()
+            }),
+        );
+        if left_range.len() < len {
+            left_diff.extend((left_range.len()..len).map(|_| InstructionDiffRow::default()));
+        }
+        if right_range.len() < len {
+            right_diff.extend((right_range.len()..len).map(|_| InstructionDiffRow::default()));
+        }
+    }
+    Ok((left_diff, right_diff))
+}
+
+fn arg_to_string(arg: &InstructionArg, reloc: Option<ResolvedRelocation>) -> String {
+    match arg {
+        InstructionArg::Value(arg) => arg.to_string(),
+        InstructionArg::Reloc => {
+            reloc.as_ref().map_or_else(|| "<unknown>".to_string(), |r| r.symbol.name.clone())
+        }
+        InstructionArg::BranchDest(arg) => arg.to_string(),
+    }
+}
+
+fn resolve_branches(ops: &[InstructionRef], rows: &mut [InstructionDiffRow]) {
+    let mut branch_idx = 0u32;
+    // Map addresses to indices
+    let mut addr_map = BTreeMap::<u64, u32>::new();
+    for (i, ins_diff) in rows.iter().enumerate() {
+        if let Some(ins) = ins_diff.ins_ref {
+            addr_map.insert(ins.address, i as u32);
+        }
+    }
+    // Generate branches
+    let mut branches = BTreeMap::<u32, InstructionBranchFrom>::new();
+    for ((i, ins_diff), ins) in
+        rows.iter_mut().enumerate().filter(|(_, row)| row.ins_ref.is_some()).zip(ops)
+    {
+        if let Some(ins_idx) = ins.branch_dest.and_then(|a| addr_map.get(&a).copied()) {
+            match branches.entry(ins_idx) {
+                btree_map::Entry::Vacant(e) => {
+                    ins_diff.branch_to = Some(InstructionBranchTo { ins_idx, branch_idx });
+                    e.insert(InstructionBranchFrom { ins_idx: vec![i as u32], branch_idx });
+                    branch_idx += 1;
+                }
+                btree_map::Entry::Occupied(e) => {
+                    let branch = e.into_mut();
+                    ins_diff.branch_to =
+                        Some(InstructionBranchTo { ins_idx, branch_idx: branch.branch_idx });
+                    branch.ins_idx.push(i as u32);
+                }
+            }
+        }
+    }
+    // Store branch from
+    for (i, branch) in branches {
+        rows[i as usize].branch_from = Some(branch);
+    }
+}
+
+pub(crate) fn address_eq(left: ResolvedRelocation, right: ResolvedRelocation) -> bool {
+    if right.symbol.size == 0 && left.symbol.size != 0 {
+        // The base relocation is against a pool but the target relocation isn't.
+        // This can happen in rare cases where the compiler will generate a pool+addend relocation
+        // in the base's data, but the one detected in the target is direct with no addend.
+        // Just check that the final address is the same so these count as a match.
+        left.symbol.address as i64 + left.relocation.addend
+            == right.symbol.address as i64 + right.relocation.addend
+    } else {
+        // But otherwise, if the compiler isn't using a pool, we're more strict and check that the
+        // target symbol address and relocation addend both match exactly.
+        left.symbol.address == right.symbol.address
+            && left.relocation.addend == right.relocation.addend
+    }
+}
+
+pub(crate) fn section_name_eq(
+    left_obj: &Object,
+    right_obj: &Object,
+    left_section_index: usize,
+    right_section_index: usize,
+) -> bool {
+    left_obj.sections.get(left_section_index).is_some_and(|left_section| {
+        right_obj
+            .sections
+            .get(right_section_index)
+            .is_some_and(|right_section| left_section.name == right_section.name)
+    })
+}
+
+fn reloc_eq(
+    left_obj: &Object,
+    right_obj: &Object,
+    left_ins: ResolvedInstructionRef,
+    right_ins: ResolvedInstructionRef,
+    diff_config: &DiffObjConfig,
+) -> bool {
+    let relax_reloc_diffs = diff_config.function_reloc_diffs == FunctionRelocDiffs::None;
+    let (left_reloc, right_reloc) = match (left_ins.relocation, right_ins.relocation) {
+        (Some(left_reloc), Some(right_reloc)) => (left_reloc, right_reloc),
+        // If relocations are relaxed, match if left is missing a reloc
+        (None, Some(_)) => return relax_reloc_diffs,
+        (None, None) => return true,
+        _ => return false,
+    };
+    if left_reloc.relocation.flags != right_reloc.relocation.flags {
+        return false;
+    }
+    if relax_reloc_diffs {
+        return true;
+    }
+
+    let symbol_name_addend_matches = left_reloc.symbol.name == right_reloc.symbol.name
+        && left_reloc.relocation.addend == right_reloc.relocation.addend;
+    match (&left_reloc.symbol.section, &right_reloc.symbol.section) {
+        (Some(sl), Some(sr)) => {
+            // Match if section and name or address match
+            section_name_eq(left_obj, right_obj, *sl, *sr)
+                && (diff_config.function_reloc_diffs == FunctionRelocDiffs::DataValue
+                    || symbol_name_addend_matches
+                    || address_eq(left_reloc, right_reloc))
+                && (diff_config.function_reloc_diffs == FunctionRelocDiffs::NameAddress
+                    || left_reloc.symbol.kind != SymbolKind::Object
+                    || right_reloc.symbol.size == 0 // Likely a pool symbol like ...data, don't treat this as a diff
+                    || display_ins_data_literals(left_obj, left_ins)
+                        == display_ins_data_literals(right_obj, right_ins))
+        }
+        (Some(_), None) | (None, Some(_)) | (None, None) => symbol_name_addend_matches,
+    }
+}
+
+fn arg_eq(
+    left_obj: &Object,
+    right_obj: &Object,
+    left_row: &InstructionDiffRow,
+    right_row: &InstructionDiffRow,
+    left_arg: &InstructionArg,
+    right_arg: &InstructionArg,
+    left_ins: ResolvedInstructionRef,
+    right_ins: ResolvedInstructionRef,
+    diff_config: &DiffObjConfig,
+) -> bool {
+    match left_arg {
+        InstructionArg::Value(l) => match right_arg {
+            InstructionArg::Value(r) => l.loose_eq(r),
+            // If relocations are relaxed, match if left is a constant and right is a reloc
+            // Useful for instances where the target object is created without relocations
+            InstructionArg::Reloc => diff_config.function_reloc_diffs == FunctionRelocDiffs::None,
+            _ => false,
+        },
+        InstructionArg::Reloc => {
+            matches!(right_arg, InstructionArg::Reloc)
+                && reloc_eq(left_obj, right_obj, left_ins, right_ins, diff_config)
+        }
+        InstructionArg::BranchDest(_) => match right_arg {
+            // Compare dest instruction idx after diffing
+            InstructionArg::BranchDest(_) => {
+                left_row.branch_to.as_ref().map(|b| b.ins_idx)
+                    == right_row.branch_to.as_ref().map(|b| b.ins_idx)
+            }
+            // If relocations are relaxed, match if left is a constant and right is a reloc
+            // Useful for instances where the target object is created without relocations
+            InstructionArg::Reloc => diff_config.function_reloc_diffs == FunctionRelocDiffs::None,
+            _ => false,
+        },
+    }
+}
+
+#[derive(Default)]
+struct InstructionDiffState {
+    diff_score: u64,
+    left_arg_idx: u32,
+    right_arg_idx: u32,
+    left_args_idx: BTreeMap<String, u32>,
+    right_args_idx: BTreeMap<String, u32>,
+}
+
+#[derive(Default)]
+struct InstructionDiffResult {
+    kind: InstructionDiffKind,
+    left_args_diff: Vec<InstructionArgDiffIndex>,
+    right_args_diff: Vec<InstructionArgDiffIndex>,
+}
+
+impl InstructionDiffResult {
+    #[inline]
+    const fn new(kind: InstructionDiffKind) -> Self {
+        Self { kind, left_args_diff: Vec::new(), right_args_diff: Vec::new() }
+    }
+}
+
+fn diff_instruction(
+    left_obj: &Object,
+    right_obj: &Object,
+    left_symbol_idx: usize,
+    right_symbol_idx: usize,
+    l: Option<InstructionRef>,
+    r: Option<InstructionRef>,
+    left_row: &InstructionDiffRow,
+    right_row: &InstructionDiffRow,
+    diff_config: &DiffObjConfig,
+    state: &mut InstructionDiffState,
+) -> Result<InstructionDiffResult> {
+    let (l, r) = match (l, r) {
+        (Some(l), Some(r)) => (l, r),
+        (Some(_), None) => {
+            state.diff_score += PENALTY_INSERT_DELETE;
+            return Ok(InstructionDiffResult::new(InstructionDiffKind::Delete));
+        }
+        (None, Some(_)) => {
+            state.diff_score += PENALTY_INSERT_DELETE;
+            return Ok(InstructionDiffResult::new(InstructionDiffKind::Insert));
+        }
+        (None, None) => return Ok(InstructionDiffResult::new(InstructionDiffKind::None)),
+    };
+
+    // If opcodes don't match, replace
+    if l.opcode != r.opcode {
+        state.diff_score += PENALTY_REPLACE;
+        return Ok(InstructionDiffResult::new(InstructionDiffKind::Replace));
+    }
+
+    let left_resolved = left_obj
+        .resolve_instruction_ref(left_symbol_idx, l)
+        .context("Failed to resolve left instruction")?;
+    let right_resolved = right_obj
+        .resolve_instruction_ref(right_symbol_idx, r)
+        .context("Failed to resolve right instruction")?;
+
+    if left_resolved.code != right_resolved.code
+        || !reloc_eq(left_obj, right_obj, left_resolved, right_resolved, diff_config)
+    {
+        // If either the raw code bytes or relocations don't match, process instructions and compare args
+        let left_ins = left_obj.arch.process_instruction(left_resolved, diff_config)?;
+        let right_ins = right_obj.arch.process_instruction(right_resolved, diff_config)?;
+        if left_ins.args.len() != right_ins.args.len() {
+            state.diff_score += PENALTY_REPLACE;
+            return Ok(InstructionDiffResult::new(InstructionDiffKind::Replace));
+        }
+        let mut result = InstructionDiffResult::new(InstructionDiffKind::None);
+        if left_ins.mnemonic != right_ins.mnemonic {
+            state.diff_score += PENALTY_REG_DIFF;
+            result.kind = InstructionDiffKind::OpMismatch;
+        }
+        for (a, b) in left_ins.args.iter().zip(right_ins.args.iter()) {
+            if arg_eq(
+                left_obj,
+                right_obj,
+                left_row,
+                right_row,
+                a,
+                b,
+                left_resolved,
+                right_resolved,
+                diff_config,
+            ) {
+                result.left_args_diff.push(InstructionArgDiffIndex::NONE);
+                result.right_args_diff.push(InstructionArgDiffIndex::NONE);
+            } else {
+                state.diff_score += if let InstructionArg::Value(
+                    InstructionArgValue::Signed(_) | InstructionArgValue::Unsigned(_),
+                ) = a
+                {
+                    PENALTY_IMM_DIFF
+                } else {
+                    PENALTY_REG_DIFF
+                };
+                if result.kind == InstructionDiffKind::None {
+                    result.kind = InstructionDiffKind::ArgMismatch;
+                }
+                let a_str = arg_to_string(a, left_resolved.relocation);
+                let a_diff = match state.left_args_idx.entry(a_str) {
+                    btree_map::Entry::Vacant(e) => {
+                        let idx = state.left_arg_idx;
+                        state.left_arg_idx = idx + 1;
+                        e.insert(idx);
+                        idx
+                    }
+                    btree_map::Entry::Occupied(e) => *e.get(),
+                };
+                let b_str = arg_to_string(b, right_resolved.relocation);
+                let b_diff = match state.right_args_idx.entry(b_str) {
+                    btree_map::Entry::Vacant(e) => {
+                        let idx = state.right_arg_idx;
+                        state.right_arg_idx = idx + 1;
+                        e.insert(idx);
+                        idx
+                    }
+                    btree_map::Entry::Occupied(e) => *e.get(),
+                };
+                result.left_args_diff.push(InstructionArgDiffIndex::new(a_diff));
+                result.right_args_diff.push(InstructionArgDiffIndex::new(b_diff));
+            }
+        }
+        if result.kind == InstructionDiffKind::None
+            && left_resolved.code.len() != right_resolved.code.len()
+        {
+            // If everything else matches but the raw code length differs (e.g. x86 instructions
+            // with same disassembly but different encoding), mark as op mismatch
+            result.kind = InstructionDiffKind::OpMismatch;
+            state.diff_score += PENALTY_REG_DIFF;
+        }
+        return Ok(result);
+    }
+
+    Ok(InstructionDiffResult::new(InstructionDiffKind::None))
+}

objdiff-core/src/diff/data.rs

@@ -0,0 +1,659 @@
+use alloc::{vec, vec::Vec};
+use core::{cmp::Ordering, ops::Range};
+
+use anyhow::{Result, anyhow};
+use similar::{Algorithm, capture_diff_slices, get_diff_ratio};
+
+use super::{
+    DataDiff, DataDiffKind, DataDiffRow, DataRelocationDiff, ObjectDiff, SectionDiff, SymbolDiff,
+    code::{address_eq, section_name_eq},
+};
+use crate::obj::{Object, Relocation, ResolvedRelocation, Symbol, SymbolFlag, SymbolKind};
+
+pub fn diff_bss_symbol(
+    left_obj: &Object,
+    right_obj: &Object,
+    left_symbol_ref: usize,
+    right_symbol_ref: usize,
+) -> Result<(SymbolDiff, SymbolDiff)> {
+    let left_symbol = &left_obj.symbols[left_symbol_ref];
+    let right_symbol = &right_obj.symbols[right_symbol_ref];
+    let percent = if left_symbol.size == right_symbol.size { 100.0 } else { 50.0 };
+    Ok((
+        SymbolDiff {
+            target_symbol: Some(right_symbol_ref),
+            match_percent: Some(percent),
+            diff_score: None,
+            ..Default::default()
+        },
+        SymbolDiff {
+            target_symbol: Some(left_symbol_ref),
+            match_percent: Some(percent),
+            diff_score: None,
+            ..Default::default()
+        },
+    ))
+}
+
+pub fn symbol_name_matches(left_name: &str, right_name: &str) -> bool {
+    // Match Metrowerks symbol$1234 against symbol$2345
+    // and GCC symbol.1234 against symbol.2345
+    if let Some((prefix, suffix)) = left_name.split_once(['$', '.']) {
+        if !suffix.chars().all(char::is_numeric) {
+            return false;
+        }
+        right_name
+            .split_once(['$', '.'])
+            .is_some_and(|(p, s)| p == prefix && s.chars().all(char::is_numeric))
+    } else {
+        left_name == right_name
+    }
+}
+
+fn reloc_eq(
+    left_obj: &Object,
+    right_obj: &Object,
+    left: ResolvedRelocation,
+    right: ResolvedRelocation,
+) -> bool {
+    if left.relocation.flags != right.relocation.flags {
+        return false;
+    }
+
+    let symbol_name_addend_matches = symbol_name_matches(&left.symbol.name, &right.symbol.name)
+        && left.relocation.addend == right.relocation.addend;
+    match (left.symbol.section, right.symbol.section) {
+        (Some(sl), Some(sr)) => {
+            // Match if section and name+addend or address match
+            section_name_eq(left_obj, right_obj, sl, sr)
+                && (symbol_name_addend_matches || address_eq(left, right))
+        }
+        (Some(_), None) | (None, Some(_)) | (None, None) => symbol_name_addend_matches,
+    }
+}
+
+#[inline]
+pub fn resolve_relocation<'obj>(
+    symbols: &'obj [Symbol],
+    reloc: &'obj Relocation,
+) -> ResolvedRelocation<'obj> {
+    let symbol = &symbols[reloc.target_symbol];
+    ResolvedRelocation { relocation: reloc, symbol }
+}
+
+/// Compares the bytes within a certain data range.
+fn diff_data_range(left_data: &[u8], right_data: &[u8]) -> (f32, Vec<DataDiff>, Vec<DataDiff>) {
+    let ops = capture_diff_slices(Algorithm::Patience, left_data, right_data);
+    let bytes_match_ratio = get_diff_ratio(&ops, left_data.len(), right_data.len());
+
+    let mut left_data_diff = Vec::<DataDiff>::new();
+    let mut right_data_diff = Vec::<DataDiff>::new();
+    for op in ops {
+        let (tag, left_range, right_range) = op.as_tag_tuple();
+        let left_len = left_range.len();
+        let right_len = right_range.len();
+        let mut len = left_len.max(right_len);
+        let kind = match tag {
+            similar::DiffTag::Equal => DataDiffKind::None,
+            similar::DiffTag::Delete => DataDiffKind::Delete,
+            similar::DiffTag::Insert => DataDiffKind::Insert,
+            similar::DiffTag::Replace => {
+                // Ensure replacements are equal length
+                len = left_len.min(right_len);
+                DataDiffKind::Replace
+            }
+        };
+        let left_data = &left_data[left_range];
+        let right_data = &right_data[right_range];
+        left_data_diff.push(DataDiff {
+            data: left_data[..len.min(left_data.len())].to_vec(),
+            kind,
+            size: len,
+        });
+        right_data_diff.push(DataDiff {
+            data: right_data[..len.min(right_data.len())].to_vec(),
+            kind,
+            size: len,
+        });
+        if kind == DataDiffKind::Replace {
+            match left_len.cmp(&right_len) {
+                Ordering::Less => {
+                    let len = right_len - left_len;
+                    left_data_diff.push(DataDiff {
+                        data: vec![],
+                        kind: DataDiffKind::Insert,
+                        size: len,
+                    });
+                    right_data_diff.push(DataDiff {
+                        data: right_data[left_len..right_len].to_vec(),
+                        kind: DataDiffKind::Insert,
+                        size: len,
+                    });
+                }
+                Ordering::Greater => {
+                    let len = left_len - right_len;
+                    left_data_diff.push(DataDiff {
+                        data: left_data[right_len..left_len].to_vec(),
+                        kind: DataDiffKind::Delete,
+                        size: len,
+                    });
+                    right_data_diff.push(DataDiff {
+                        data: vec![],
+                        kind: DataDiffKind::Delete,
+                        size: len,
+                    });
+                }
+                Ordering::Equal => {}
+            }
+        }
+    }
+
+    (bytes_match_ratio, left_data_diff, right_data_diff)
+}
+
+/// Compares relocations contained within a certain data range.
+fn diff_data_relocs_for_range<'left, 'right>(
+    left_obj: &'left Object,
+    right_obj: &'right Object,
+    left_section_idx: usize,
+    right_section_idx: usize,
+    left_range: Range<usize>,
+    right_range: Range<usize>,
+) -> Vec<(DataDiffKind, Option<ResolvedRelocation<'left>>, Option<ResolvedRelocation<'right>>)> {
+    let left_section = &left_obj.sections[left_section_idx];
+    let right_section = &right_obj.sections[right_section_idx];
+    let mut diffs = Vec::new();
+    for left_reloc in left_section.relocations.iter() {
+        if !left_range.contains(&(left_reloc.address as usize)) {
+            continue;
+        }
+        let left_offset = left_reloc.address as usize - left_range.start;
+        let left_reloc = resolve_relocation(&left_obj.symbols, left_reloc);
+        let Some(right_reloc) = right_section.relocations.iter().find(|r| {
+            if !right_range.contains(&(r.address as usize)) {
+                return false;
+            }
+            let right_offset = r.address as usize - right_range.start;
+            right_offset == left_offset
+        }) else {
+            diffs.push((DataDiffKind::Delete, Some(left_reloc), None));
+            continue;
+        };
+        let right_reloc = resolve_relocation(&right_obj.symbols, right_reloc);
+        if reloc_eq(left_obj, right_obj, left_reloc, right_reloc) {
+            diffs.push((DataDiffKind::None, Some(left_reloc), Some(right_reloc)));
+        } else {
+            diffs.push((DataDiffKind::Replace, Some(left_reloc), Some(right_reloc)));
+        }
+    }
+    for right_reloc in right_section.relocations.iter() {
+        if !right_range.contains(&(right_reloc.address as usize)) {
+            continue;
+        }
+        let right_offset = right_reloc.address as usize - right_range.start;
+        let right_reloc = resolve_relocation(&right_obj.symbols, right_reloc);
+        let Some(_) = left_section.relocations.iter().find(|r| {
+            if !left_range.contains(&(r.address as usize)) {
+                return false;
+            }
+            let left_offset = r.address as usize - left_range.start;
+            left_offset == right_offset
+        }) else {
+            diffs.push((DataDiffKind::Insert, None, Some(right_reloc)));
+            continue;
+        };
+        // No need to check the cases for relocations being deleted or matching again.
+        // They were already handled in the loop over the left relocs.
+    }
+    diffs
+}
+
+pub fn no_diff_data_section(obj: &Object, section_idx: usize) -> Result<SectionDiff> {
+    let section = &obj.sections[section_idx];
+
+    let data_diff = vec![DataDiff {
+        data: section.data.0.clone(),
+        kind: DataDiffKind::None,
+        size: section.data.len(),
+    }];
+
+    let mut reloc_diffs = Vec::new();
+    for reloc in section.relocations.iter() {
+        let reloc_len = obj.arch.data_reloc_size(reloc.flags);
+        let range = reloc.address..reloc.address + reloc_len as u64;
+        reloc_diffs.push(DataRelocationDiff {
+            reloc: reloc.clone(),
+            kind: DataDiffKind::None,
+            range,
+        });
+    }
+
+    Ok(SectionDiff { match_percent: Some(0.0), data_diff, reloc_diff: reloc_diffs })
+}
+
+/// Compare the data sections of two object files.
+pub fn diff_data_section(
+    left_obj: &Object,
+    right_obj: &Object,
+    left_diff: &ObjectDiff,
+    right_diff: &ObjectDiff,
+    left_section_idx: usize,
+    right_section_idx: usize,
+) -> Result<(SectionDiff, SectionDiff)> {
+    let left_section = &left_obj.sections[left_section_idx];
+    let right_section = &right_obj.sections[right_section_idx];
+    let left_max = symbols_matching_section(&left_obj.symbols, left_section_idx)
+        .filter_map(|(_, s)| s.address.checked_sub(left_section.address).map(|a| a + s.size))
+        .max()
+        .unwrap_or(0)
+        .min(left_section.size);
+    let right_max = symbols_matching_section(&right_obj.symbols, right_section_idx)
+        .filter_map(|(_, s)| s.address.checked_sub(right_section.address).map(|a| a + s.size))
+        .max()
+        .unwrap_or(0)
+        .min(right_section.size);
+    let left_data = &left_section.data[..left_max as usize];
+    let right_data = &right_section.data[..right_max as usize];
+
+    let (bytes_match_ratio, left_data_diff, right_data_diff) =
+        diff_data_range(left_data, right_data);
+    let match_percent = bytes_match_ratio * 100.0;
+
+    let mut left_reloc_diffs = Vec::new();
+    let mut right_reloc_diffs = Vec::new();
+    for (diff_kind, left_reloc, right_reloc) in diff_data_relocs_for_range(
+        left_obj,
+        right_obj,
+        left_section_idx,
+        right_section_idx,
+        0..left_max as usize,
+        0..right_max as usize,
+    ) {
+        if let Some(left_reloc) = left_reloc {
+            let len = left_obj.arch.data_reloc_size(left_reloc.relocation.flags);
+            let range = left_reloc.relocation.address..left_reloc.relocation.address + len as u64;
+            left_reloc_diffs.push(DataRelocationDiff {
+                reloc: left_reloc.relocation.clone(),
+                kind: diff_kind,
+                range,
+            });
+        }
+        if let Some(right_reloc) = right_reloc {
+            let len = right_obj.arch.data_reloc_size(right_reloc.relocation.flags);
+            let range = right_reloc.relocation.address..right_reloc.relocation.address + len as u64;
+            right_reloc_diffs.push(DataRelocationDiff {
+                reloc: right_reloc.relocation.clone(),
+                kind: diff_kind,
+                range,
+            });
+        }
+    }
+
+    let (mut left_section_diff, mut right_section_diff) = diff_generic_section(
+        left_obj,
+        right_obj,
+        left_diff,
+        right_diff,
+        left_section_idx,
+        right_section_idx,
+    )?;
+    let all_left_relocs_match = left_reloc_diffs.iter().all(|d| d.kind == DataDiffKind::None);
+    left_section_diff.data_diff = left_data_diff;
+    right_section_diff.data_diff = right_data_diff;
+    left_section_diff.reloc_diff = left_reloc_diffs;
+    right_section_diff.reloc_diff = right_reloc_diffs;
+    if all_left_relocs_match {
+        // Use the highest match percent between two options:
+        // - Left symbols matching right symbols by name
+        // - Diff of the data itself
+        // We only do this when all relocations on the left side match.
+        if left_section_diff.match_percent.unwrap_or(-1.0) < match_percent {
+            left_section_diff.match_percent = Some(match_percent);
+        }
+    }
+    Ok((left_section_diff, right_section_diff))
+}
+
+pub fn no_diff_data_symbol(obj: &Object, symbol_index: usize) -> Result<SymbolDiff> {
+    let symbol = &obj.symbols[symbol_index];
+    let section_idx = symbol.section.ok_or_else(|| anyhow!("Data symbol section not found"))?;
+    let section = &obj.sections[section_idx];
+
+    let start = symbol
+        .address
+        .checked_sub(section.address)
+        .ok_or_else(|| anyhow!("Symbol address out of section bounds"))?;
+    let end = start + symbol.size;
+    if end > section.size {
+        return Err(anyhow!(
+            "Symbol {} size out of section bounds ({} > {})",
+            symbol.name,
+            end,
+            section.size
+        ));
+    }
+    let range = start as usize..end as usize;
+    let data = &section.data[range.clone()];
+
+    let data_diff = vec![DataDiff {
+        data: data.to_vec(),
+        kind: DataDiffKind::None,
+        size: symbol.size as usize,
+    }];
+
+    let mut reloc_diffs = Vec::new();
+    for reloc in section.relocations.iter() {
+        if !range.contains(&(reloc.address as usize)) {
+            continue;
+        }
+        let reloc_len = obj.arch.data_reloc_size(reloc.flags);
+        let range = reloc.address..reloc.address + reloc_len as u64;
+        reloc_diffs.push(DataRelocationDiff {
+            reloc: reloc.clone(),
+            kind: DataDiffKind::None,
+            range,
+        });
+    }
+
+    let data_rows = build_data_diff_rows(&data_diff, &reloc_diffs, symbol.address);
+    Ok(SymbolDiff {
+        target_symbol: None,
+        match_percent: None,
+        diff_score: None,
+        data_rows,
+        ..Default::default()
+    })
+}
+
+pub fn diff_data_symbol(
+    left_obj: &Object,
+    right_obj: &Object,
+    left_symbol_idx: usize,
+    right_symbol_idx: usize,
+) -> Result<(SymbolDiff, SymbolDiff)> {
+    let left_symbol = &left_obj.symbols[left_symbol_idx];
+    let right_symbol = &right_obj.symbols[right_symbol_idx];
+
+    let left_section_idx =
+        left_symbol.section.ok_or_else(|| anyhow!("Data symbol section not found"))?;
+    let right_section_idx =
+        right_symbol.section.ok_or_else(|| anyhow!("Data symbol section not found"))?;
+
+    let left_section = &left_obj.sections[left_section_idx];
+    let right_section = &right_obj.sections[right_section_idx];
+
+    let left_start = left_symbol
+        .address
+        .checked_sub(left_section.address)
+        .ok_or_else(|| anyhow!("Symbol address out of section bounds"))?;
+    let right_start = right_symbol
+        .address
+        .checked_sub(right_section.address)
+        .ok_or_else(|| anyhow!("Symbol address out of section bounds"))?;
+    let left_end = left_start + left_symbol.size;
+    if left_end > left_section.size {
+        return Err(anyhow!(
+            "Symbol {} size out of section bounds ({} > {})",
+            left_symbol.name,
+            left_end,
+            left_section.size
+        ));
+    }
+    let right_end = right_start + right_symbol.size;
+    if right_end > right_section.size {
+        return Err(anyhow!(
+            "Symbol {} size out of section bounds ({} > {})",
+            right_symbol.name,
+            right_end,
+            right_section.size
+        ));
+    }
+    let left_range = left_start as usize..left_end as usize;
+    let right_range = right_start as usize..right_end as usize;
+    let left_data = &left_section.data[left_range.clone()];
+    let right_data = &right_section.data[right_range.clone()];
+
+    let (bytes_match_ratio, left_data_diff, right_data_diff) =
+        diff_data_range(left_data, right_data);
+
+    let reloc_diffs = diff_data_relocs_for_range(
+        left_obj,
+        right_obj,
+        left_section_idx,
+        right_section_idx,
+        left_range,
+        right_range,
+    );
+
+    let mut match_ratio = bytes_match_ratio;
+    let mut left_reloc_diffs = Vec::new();
+    let mut right_reloc_diffs = Vec::new();
+    if !reloc_diffs.is_empty() {
+        let mut total_reloc_bytes = 0;
+        let mut matching_reloc_bytes = 0;
+        for (diff_kind, left_reloc, right_reloc) in reloc_diffs {
+            let reloc_diff_len = match (left_reloc, right_reloc) {
+                (None, None) => unreachable!(),
+                (None, Some(right_reloc)) => {
+                    right_obj.arch.data_reloc_size(right_reloc.relocation.flags)
+                }
+                (Some(left_reloc), _) => left_obj.arch.data_reloc_size(left_reloc.relocation.flags),
+            };
+            total_reloc_bytes += reloc_diff_len;
+            if diff_kind == DataDiffKind::None {
+                matching_reloc_bytes += reloc_diff_len;
+            }
+
+            if let Some(left_reloc) = left_reloc {
+                let len = left_obj.arch.data_reloc_size(left_reloc.relocation.flags);
+                let range =
+                    left_reloc.relocation.address..left_reloc.relocation.address + len as u64;
+                left_reloc_diffs.push(DataRelocationDiff {
+                    reloc: left_reloc.relocation.clone(),
+                    kind: diff_kind,
+                    range,
+                });
+            }
+            if let Some(right_reloc) = right_reloc {
+                let len = right_obj.arch.data_reloc_size(right_reloc.relocation.flags);
+                let range =
+                    right_reloc.relocation.address..right_reloc.relocation.address + len as u64;
+                right_reloc_diffs.push(DataRelocationDiff {
+                    reloc: right_reloc.relocation.clone(),
+                    kind: diff_kind,
+                    range,
+                });
+            }
+        }
+        if total_reloc_bytes > 0 {
+            let relocs_match_ratio = matching_reloc_bytes as f32 / total_reloc_bytes as f32;
+            // Adjust the overall match ratio to include relocation differences.
+            // We calculate it so that bytes that contain a relocation are counted twice: once for the
+            // byte's raw value, and once for its relocation.
+            // e.g. An 8 byte symbol that has 8 matching raw bytes and a single 4 byte relocation that
+            // doesn't match would show as 66% (weighted average of 100% and 0%).
+            match_ratio = ((bytes_match_ratio * (left_data.len() as f32))
+                + (relocs_match_ratio * total_reloc_bytes as f32))
+                / (left_data.len() + total_reloc_bytes) as f32;
+        }
+    }
+
+    left_reloc_diffs
+        .sort_by(|a, b| a.range.start.cmp(&b.range.start).then(a.range.end.cmp(&b.range.end)));
+    right_reloc_diffs
+        .sort_by(|a, b| a.range.start.cmp(&b.range.start).then(a.range.end.cmp(&b.range.end)));
+
+    let match_percent = match_ratio * 100.0;
+    let left_rows = build_data_diff_rows(&left_data_diff, &left_reloc_diffs, left_symbol.address);
+    let right_rows =
+        build_data_diff_rows(&right_data_diff, &right_reloc_diffs, right_symbol.address);
+
+    Ok((
+        SymbolDiff {
+            target_symbol: Some(right_symbol_idx),
+            match_percent: Some(match_percent),
+            diff_score: None,
+            data_rows: left_rows,
+            ..Default::default()
+        },
+        SymbolDiff {
+            target_symbol: Some(left_symbol_idx),
+            match_percent: Some(match_percent),
+            diff_score: None,
+            data_rows: right_rows,
+            ..Default::default()
+        },
+    ))
+}
+
+/// Compares a section of two object files.
+/// This essentially adds up the match percentage of each symbol in the section.
+pub fn diff_generic_section(
+    left_obj: &Object,
+    _right_obj: &Object,
+    left_diff: &ObjectDiff,
+    _right_diff: &ObjectDiff,
+    left_section_idx: usize,
+    _right_section_idx: usize,
+) -> Result<(SectionDiff, SectionDiff)> {
+    let match_percent = if symbols_matching_section(&left_obj.symbols, left_section_idx)
+        .map(|(i, _)| &left_diff.symbols[i])
+        .all(|d| d.match_percent == Some(100.0))
+    {
+        100.0 // Avoid fp precision issues
+    } else {
+        let (matched, total) = symbols_matching_section(&left_obj.symbols, left_section_idx)
+            .map(|(i, s)| (s, &left_diff.symbols[i]))
+            .fold((0.0, 0.0), |(matched, total), (s, d)| {
+                (matched + d.match_percent.unwrap_or(0.0) * s.size as f32, total + s.size as f32)
+            });
+        if total == 0.0 { 100.0 } else { matched / total }
+    };
+    Ok((
+        SectionDiff { match_percent: Some(match_percent), data_diff: vec![], reloc_diff: vec![] },
+        SectionDiff { match_percent: None, data_diff: vec![], reloc_diff: vec![] },
+    ))
+}
+
+pub fn no_diff_bss_section() -> Result<SectionDiff> {
+    Ok(SectionDiff { match_percent: Some(0.0), data_diff: vec![], reloc_diff: vec![] })
+}
+
+/// Compare the addresses and sizes of each symbol in the BSS sections.
+pub fn diff_bss_section(
+    left_obj: &Object,
+    right_obj: &Object,
+    left_diff: &ObjectDiff,
+    right_diff: &ObjectDiff,
+    left_section_idx: usize,
+    right_section_idx: usize,
+) -> Result<(SectionDiff, SectionDiff)> {
+    let left_section = &left_obj.sections[left_section_idx];
+    let left_sizes = symbols_matching_section(&left_obj.symbols, left_section_idx)
+        .filter_map(|(_, s)| s.address.checked_sub(left_section.address).map(|a| (a, s.size)))
+        .collect::<Vec<_>>();
+    let right_section = &right_obj.sections[right_section_idx];
+    let right_sizes = symbols_matching_section(&right_obj.symbols, right_section_idx)
+        .filter_map(|(_, s)| s.address.checked_sub(right_section.address).map(|a| (a, s.size)))
+        .collect::<Vec<_>>();
+    let ops = capture_diff_slices(Algorithm::Patience, &left_sizes, &right_sizes);
+    let mut match_percent = get_diff_ratio(&ops, left_sizes.len(), right_sizes.len()) * 100.0;
+
+    // Use the highest match percent between two options:
+    // - Left symbols matching right symbols by name
+    // - Diff of the addresses and sizes of each symbol
+    let (generic_diff, _) = diff_generic_section(
+        left_obj,
+        right_obj,
+        left_diff,
+        right_diff,
+        left_section_idx,
+        right_section_idx,
+    )?;
+    if generic_diff.match_percent.unwrap_or(-1.0) > match_percent {
+        match_percent = generic_diff.match_percent.unwrap();
+    }
+
+    Ok((
+        SectionDiff { match_percent: Some(match_percent), data_diff: vec![], reloc_diff: vec![] },
+        SectionDiff { match_percent: None, data_diff: vec![], reloc_diff: vec![] },
+    ))
+}
+
+fn symbols_matching_section(
+    symbols: &[Symbol],
+    section_idx: usize,
+) -> impl Iterator<Item = (usize, &Symbol)> + '_ {
+    symbols.iter().enumerate().filter(move |(_, s)| {
+        s.section == Some(section_idx)
+            && s.kind != SymbolKind::Section
+            && s.size > 0
+            && !s.flags.contains(SymbolFlag::Hidden)
+            && !s.flags.contains(SymbolFlag::Ignored)
+    })
+}
+
+pub const BYTES_PER_ROW: usize = 16;
+
+fn build_data_diff_row(
+    data_diffs: &[DataDiff],
+    reloc_diffs: &[DataRelocationDiff],
+    symbol_address: u64,
+    row_index: usize,
+) -> DataDiffRow {
+    let row_start = row_index * BYTES_PER_ROW;
+    let row_end = row_start + BYTES_PER_ROW;
+    let mut row_diff = DataDiffRow {
+        address: symbol_address + row_start as u64,
+        segments: Vec::new(),
+        relocations: Vec::new(),
+    };
+
+    // Collect all segments that overlap with this row
+    let mut current_offset = 0;
+    for diff in data_diffs {
+        let diff_end = current_offset + diff.size;
+        if current_offset < row_end && diff_end > row_start {
+            let start_in_diff = row_start.saturating_sub(current_offset);
+            let end_in_diff = row_end.min(diff_end) - current_offset;
+            if start_in_diff < end_in_diff {
+                let data_slice = if diff.data.is_empty() {
+                    Vec::new()
+                } else {
+                    diff.data[start_in_diff..end_in_diff.min(diff.data.len())].to_vec()
+                };
+                row_diff.segments.push(DataDiff {
+                    data: data_slice,
+                    kind: diff.kind,
+                    size: end_in_diff - start_in_diff,
+                });
+            }
+        }
+        current_offset = diff_end;
+        if current_offset >= row_start + BYTES_PER_ROW {
+            break;
+        }
+    }
+
+    // Collect all relocations that overlap with this row
+    let row_end_absolute = row_diff.address + BYTES_PER_ROW as u64;
+    row_diff.relocations = reloc_diffs
+        .iter()
+        .filter(|rd| rd.range.start < row_end_absolute && rd.range.end > row_diff.address)
+        .cloned()
+        .collect();
+
+    row_diff
+}
+
+fn build_data_diff_rows(
+    segments: &[DataDiff],
+    relocations: &[DataRelocationDiff],
+    symbol_address: u64,
+) -> Vec<DataDiffRow> {
+    let total_len = segments.iter().map(|s| s.size as u64).sum::<u64>();
+    let num_rows = total_len.div_ceil(BYTES_PER_ROW as u64) as usize;
+    (0..num_rows)
+        .map(|row_index| build_data_diff_row(segments, relocations, symbol_address, row_index))
+        .collect()
+}

objdiff-core/src/diff/demangler.rs

@@ -0,0 +1,49 @@
+use alloc::string::String;
+
+use crate::diff::Demangler;
+
+#[cfg(feature = "demangler")]
+impl Demangler {
+    pub fn demangle(&self, name: &str) -> Option<String> {
+        match self {
+            Demangler::None => None,
+            Demangler::Codewarrior => Self::demangle_codewarrior(name),
+            Demangler::Msvc => Self::demangle_msvc(name),
+            Demangler::Itanium => Self::demangle_itanium(name),
+            Demangler::GnuLegacy => Self::demangle_gnu_legacy(name),
+            Demangler::Auto => {
+                // Try to guess
+                if name.starts_with('?') {
+                    Self::demangle_msvc(name)
+                } else {
+                    Self::demangle_codewarrior(name)
+                        .or_else(|| Self::demangle_gnu_legacy(name))
+                        .or_else(|| Self::demangle_itanium(name))
+                }
+            }
+        }
+    }
+
+    fn demangle_codewarrior(name: &str) -> Option<String> {
+        cwdemangle::demangle(name, &cwdemangle::DemangleOptions::default())
+    }
+
+    fn demangle_msvc(name: &str) -> Option<String> {
+        msvc_demangler::demangle(name, msvc_demangler::DemangleFlags::llvm()).ok()
+    }
+
+    fn demangle_itanium(name: &str) -> Option<String> {
+        let name = name.trim_start_matches('.');
+        cpp_demangle::Symbol::new(name).ok().and_then(|s| s.demangle().ok())
+    }
+
+    fn demangle_gnu_legacy(name: &str) -> Option<String> {
+        let name = name.trim_start_matches('.');
+        gnuv2_demangle::demangle(name, &gnuv2_demangle::DemangleConfig::new()).ok()
+    }
+}
+
+#[cfg(not(feature = "demangler"))]
+impl Demangler {
+    pub fn demangle(&self, _name: &str) -> Option<String> { None }
+}

objdiff-core/src/diff/display.rs

@@ -0,0 +1,877 @@
+use alloc::{
+    borrow::Cow,
+    collections::BTreeSet,
+    format,
+    string::{String, ToString},
+    vec::Vec,
+};
+use core::cmp::Ordering;
+
+use anyhow::Result;
+use itertools::Itertools;
+use regex::Regex;
+
+use crate::{
+    diff::{
+        DataDiffKind, DataDiffRow, DiffObjConfig, InstructionDiffKind, InstructionDiffRow,
+        ObjectDiff, SymbolDiff, data::resolve_relocation,
+    },
+    obj::{
+        FlowAnalysisValue, InstructionArg, InstructionArgValue, Object, ParsedInstruction,
+        ResolvedInstructionRef, ResolvedRelocation, SectionFlag, SectionKind, Symbol, SymbolFlag,
+        SymbolKind,
+    },
+};
+
+#[derive(Debug, Clone)]
+pub enum DiffText<'a> {
+    /// Basic text
+    Basic(&'a str),
+    /// Line number
+    Line(u32),
+    /// Instruction address
+    Address(u64),
+    /// Instruction mnemonic
+    Opcode(&'a str, u16),
+    /// Instruction argument
+    Argument(InstructionArgValue<'a>),
+    /// Branch destination
+    BranchDest(u64),
+    /// Symbol name
+    Symbol(&'a Symbol),
+    /// Relocation addend
+    Addend(i64),
+    /// Number of spaces
+    Spacing(u8),
+    /// End of line
+    Eol,
+}
+
+#[derive(Debug, Copy, Clone, Default, PartialEq, Eq, Hash)]
+pub enum DiffTextColor {
+    #[default]
+    Normal, // Grey
+    Dim,      // Dark grey
+    Bright,   // White
+    DataFlow, // Light blue
+    Replace,  // Blue
+    Delete,   // Red
+    Insert,   // Green
+    Rotating(u8),
+}
+
+#[derive(Debug, Clone)]
+pub struct DiffTextSegment<'a> {
+    pub text: DiffText<'a>,
+    pub color: DiffTextColor,
+    pub pad_to: u8,
+}
+
+impl<'a> DiffTextSegment<'a> {
+    #[inline(always)]
+    pub fn basic(text: &'a str, color: DiffTextColor) -> Self {
+        Self { text: DiffText::Basic(text), color, pad_to: 0 }
+    }
+
+    #[inline(always)]
+    pub fn spacing(spaces: u8) -> Self {
+        Self { text: DiffText::Spacing(spaces), color: DiffTextColor::Normal, pad_to: 0 }
+    }
+}
+
+const EOL_SEGMENT: DiffTextSegment<'static> =
+    DiffTextSegment { text: DiffText::Eol, color: DiffTextColor::Normal, pad_to: 0 };
+
+#[derive(Debug, Default, Clone)]
+pub enum HighlightKind {
+    #[default]
+    None,
+    Opcode(u16),
+    Argument(InstructionArgValue<'static>),
+    Symbol(String),
+    Address(u64),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum InstructionPart<'a> {
+    Basic(Cow<'a, str>),
+    Opcode(Cow<'a, str>, u16),
+    Arg(InstructionArg<'a>),
+    Separator,
+}
+
+impl<'a> InstructionPart<'a> {
+    #[inline(always)]
+    pub fn basic<T>(s: T) -> Self
+    where T: Into<Cow<'a, str>> {
+        InstructionPart::Basic(s.into())
+    }
+
+    #[inline(always)]
+    pub fn opcode<T>(s: T, o: u16) -> Self
+    where T: Into<Cow<'a, str>> {
+        InstructionPart::Opcode(s.into(), o)
+    }
+
+    #[inline(always)]
+    pub fn opaque<T>(s: T) -> Self
+    where T: Into<Cow<'a, str>> {
+        InstructionPart::Arg(InstructionArg::Value(InstructionArgValue::Opaque(s.into())))
+    }
+
+    #[inline(always)]
+    pub fn signed<T>(v: T) -> InstructionPart<'static>
+    where T: Into<i64> {
+        InstructionPart::Arg(InstructionArg::Value(InstructionArgValue::Signed(v.into())))
+    }
+
+    #[inline(always)]
+    pub fn unsigned<T>(v: T) -> InstructionPart<'static>
+    where T: Into<u64> {
+        InstructionPart::Arg(InstructionArg::Value(InstructionArgValue::Unsigned(v.into())))
+    }
+
+    #[inline(always)]
+    pub fn branch_dest<T>(v: T) -> InstructionPart<'static>
+    where T: Into<u64> {
+        InstructionPart::Arg(InstructionArg::BranchDest(v.into()))
+    }
+
+    #[inline(always)]
+    pub fn reloc() -> InstructionPart<'static> { InstructionPart::Arg(InstructionArg::Reloc) }
+
+    #[inline(always)]
+    pub fn separator() -> InstructionPart<'static> { InstructionPart::Separator }
+
+    pub fn into_static(self) -> InstructionPart<'static> {
+        match self {
+            InstructionPart::Basic(s) => InstructionPart::Basic(Cow::Owned(s.into_owned())),
+            InstructionPart::Opcode(s, o) => InstructionPart::Opcode(Cow::Owned(s.into_owned()), o),
+            InstructionPart::Arg(a) => InstructionPart::Arg(a.into_static()),
+            InstructionPart::Separator => InstructionPart::Separator,
+        }
+    }
+}
+
+pub fn display_row(
+    obj: &Object,
+    symbol_index: usize,
+    ins_row: &InstructionDiffRow,
+    diff_config: &DiffObjConfig,
+    mut cb: impl FnMut(DiffTextSegment) -> Result<()>,
+) -> Result<()> {
+    let Some(ins_ref) = ins_row.ins_ref else {
+        cb(EOL_SEGMENT)?;
+        return Ok(());
+    };
+    let Some(resolved) = obj.resolve_instruction_ref(symbol_index, ins_ref) else {
+        cb(DiffTextSegment::basic("<invalid>", DiffTextColor::Delete))?;
+        cb(EOL_SEGMENT)?;
+        return Ok(());
+    };
+    let base_color = match ins_row.kind {
+        InstructionDiffKind::Replace => DiffTextColor::Replace,
+        InstructionDiffKind::Delete => DiffTextColor::Delete,
+        InstructionDiffKind::Insert => DiffTextColor::Insert,
+        _ => DiffTextColor::Normal,
+    };
+    if let Some(line) = resolved.section.line_info.range(..=ins_ref.address).last().map(|(_, &b)| b)
+    {
+        cb(DiffTextSegment { text: DiffText::Line(line), color: DiffTextColor::Dim, pad_to: 5 })?;
+    }
+    cb(DiffTextSegment {
+        text: DiffText::Address(ins_ref.address.saturating_sub(resolved.symbol.address)),
+        color: DiffTextColor::Dim,
+        pad_to: 5,
+    })?;
+    if let Some(branch) = &ins_row.branch_from {
+        cb(DiffTextSegment::basic(" ~> ", DiffTextColor::Rotating(branch.branch_idx as u8)))?;
+    } else {
+        cb(DiffTextSegment::spacing(4))?;
+    }
+    let mut arg_idx = 0;
+    let mut displayed_relocation = false;
+    let analysis_result = if diff_config.show_data_flow {
+        obj.get_flow_analysis_result(resolved.symbol)
+    } else {
+        None
+    };
+    obj.arch.display_instruction(resolved, diff_config, &mut |part| match part {
+        InstructionPart::Basic(text) => {
+            if text.chars().all(|c| c == ' ') {
+                cb(DiffTextSegment::spacing(text.len() as u8))
+            } else {
+                cb(DiffTextSegment::basic(&text, base_color))
+            }
+        }
+        InstructionPart::Opcode(mnemonic, opcode) => cb(DiffTextSegment {
+            text: DiffText::Opcode(mnemonic.as_ref(), opcode),
+            color: match ins_row.kind {
+                InstructionDiffKind::OpMismatch => DiffTextColor::Replace,
+                _ => base_color,
+            },
+            pad_to: 10,
+        }),
+        InstructionPart::Arg(arg) => {
+            let diff_index = ins_row.arg_diff.get(arg_idx).copied().unwrap_or_default();
+            arg_idx += 1;
+            if arg == InstructionArg::Reloc {
+                displayed_relocation = true;
+            }
+            let data_flow_value =
+            analysis_result.and_then(|result|
+                result.get_argument_value_at_address(
+                    ins_ref.address, (arg_idx - 1) as u8));
+            match (arg, data_flow_value, resolved.ins_ref.branch_dest) {
+                // If we have a flow analysis result, always use that over anything else.
+                (InstructionArg::Value(_) | InstructionArg::Reloc, Some(FlowAnalysisValue::Text(text)), _) => {
+                    cb(DiffTextSegment {
+                        text: DiffText::Argument(InstructionArgValue::Opaque(Cow::Borrowed(text))),
+                        color: DiffTextColor::DataFlow,
+                        pad_to: 0,
+                    })
+                },
+                (InstructionArg::Value(value), None, _) => {
+                    let color = diff_index
+                        .get()
+                        .map_or(base_color, |i| DiffTextColor::Rotating(i as u8));
+                    cb(DiffTextSegment {
+                        text: DiffText::Argument(value),
+                        color,
+                        pad_to: 0,
+                    })
+                },
+                (InstructionArg::Reloc, _, None) => {
+                    let resolved = resolved.relocation.unwrap();
+                    let color = diff_index
+                        .get()
+                        .map_or(DiffTextColor::Bright, |i| DiffTextColor::Rotating(i as u8));
+                    cb(DiffTextSegment {
+                        text: DiffText::Symbol(resolved.symbol),
+                        color,
+                        pad_to: 0,
+                    })?;
+                    if resolved.relocation.addend != 0 {
+                        cb(DiffTextSegment {
+                            text: DiffText::Addend(resolved.relocation.addend),
+                            color,
+                            pad_to: 0,
+                        })?;
+                    }
+                    Ok(())
+                }
+                (InstructionArg::BranchDest(dest), _, _) |
+                // If the relocation was resolved to a branch destination, emit that instead.
+                (InstructionArg::Reloc, _, Some(dest))  => {
+                    if let Some(addr) = dest.checked_sub(resolved.symbol.address) {
+                        cb(DiffTextSegment {
+                            text: DiffText::BranchDest(addr),
+                            color: diff_index
+                                .get()
+                                .map_or(base_color, |i| DiffTextColor::Rotating(i as u8)),
+                            pad_to: 0,
+                        })
+                    } else {
+                        cb(DiffTextSegment {
+                            text: DiffText::Argument(InstructionArgValue::Opaque(Cow::Borrowed(
+                                "<invalid>",
+                            ))),
+                            color: diff_index
+                                .get()
+                                .map_or(base_color, |i| DiffTextColor::Rotating(i as u8)),
+                            pad_to: 0,
+                        })
+                    }
+                }
+            }
+        }
+        InstructionPart::Separator => {
+            cb(DiffTextSegment::basic(diff_config.separator(), base_color))
+        }
+    })?;
+    // Fallback for relocation that wasn't displayed
+    if resolved.relocation.is_some() && !displayed_relocation {
+        cb(DiffTextSegment::basic(" <", base_color))?;
+        let resolved = resolved.relocation.unwrap();
+        let diff_index = ins_row.arg_diff.get(arg_idx).copied().unwrap_or_default();
+        let color =
+            diff_index.get().map_or(DiffTextColor::Bright, |i| DiffTextColor::Rotating(i as u8));
+        cb(DiffTextSegment { text: DiffText::Symbol(resolved.symbol), color, pad_to: 0 })?;
+        if resolved.relocation.addend != 0 {
+            cb(DiffTextSegment {
+                text: DiffText::Addend(resolved.relocation.addend),
+                color,
+                pad_to: 0,
+            })?;
+        }
+        cb(DiffTextSegment::basic(">", base_color))?;
+    }
+    if let Some(branch) = &ins_row.branch_to {
+        cb(DiffTextSegment::basic(" ~>", DiffTextColor::Rotating(branch.branch_idx as u8)))?;
+    }
+    cb(EOL_SEGMENT)?;
+    Ok(())
+}
+
+impl PartialEq<HighlightKind> for HighlightKind {
+    fn eq(&self, other: &HighlightKind) -> bool {
+        match (self, other) {
+            (HighlightKind::Opcode(a), HighlightKind::Opcode(b)) => a == b,
+            (HighlightKind::Argument(a), HighlightKind::Argument(b)) => a.loose_eq(b),
+            (HighlightKind::Symbol(a), HighlightKind::Symbol(b)) => a == b,
+            (HighlightKind::Address(a), HighlightKind::Address(b)) => a == b,
+            _ => false,
+        }
+    }
+}
+
+impl PartialEq<DiffText<'_>> for HighlightKind {
+    fn eq(&self, other: &DiffText) -> bool {
+        match (self, other) {
+            (HighlightKind::Opcode(a), DiffText::Opcode(_, b)) => a == b,
+            (HighlightKind::Argument(a), DiffText::Argument(b)) => a.loose_eq(b),
+            (HighlightKind::Symbol(a), DiffText::Symbol(b)) => a == &b.name,
+            (HighlightKind::Address(a), DiffText::Address(b) | DiffText::BranchDest(b)) => a == b,
+            _ => false,
+        }
+    }
+}
+
+impl PartialEq<HighlightKind> for DiffText<'_> {
+    fn eq(&self, other: &HighlightKind) -> bool { other.eq(self) }
+}
+
+impl From<&DiffText<'_>> for HighlightKind {
+    fn from(value: &DiffText<'_>) -> Self {
+        match value {
+            DiffText::Opcode(_, op) => HighlightKind::Opcode(*op),
+            DiffText::Argument(arg) => HighlightKind::Argument(arg.to_static()),
+            DiffText::Symbol(sym) => HighlightKind::Symbol(sym.name.to_string()),
+            DiffText::Address(addr) | DiffText::BranchDest(addr) => HighlightKind::Address(*addr),
+            _ => HighlightKind::None,
+        }
+    }
+}
+
+pub enum ContextItem {
+    Copy { value: String, label: Option<String> },
+    Navigate { label: String, symbol_index: usize, kind: SymbolNavigationKind },
+    Separator,
+}
+
+#[derive(Debug, Clone, Default, Eq, PartialEq)]
+pub enum SymbolNavigationKind {
+    #[default]
+    Normal,
+    Extab,
+}
+
+#[derive(Debug, Clone, Default, Eq, PartialEq)]
+pub enum HoverItemColor {
+    #[default]
+    Normal, // Gray
+    Emphasized, // White
+    Special,    // Blue
+    Delete,     // Red
+    Insert,     // Green
+}
+
+pub enum HoverItem {
+    Text { label: String, value: String, color: HoverItemColor },
+    Separator,
+}
+
+pub fn symbol_context(obj: &Object, symbol_index: usize) -> Vec<ContextItem> {
+    let Some(symbol) = obj.symbols.get(symbol_index) else {
+        return Vec::new();
+    };
+    let mut out = Vec::new();
+    out.push(ContextItem::Copy { value: symbol.name.clone(), label: None });
+    if let Some(name) = &symbol.demangled_name {
+        out.push(ContextItem::Copy { value: name.clone(), label: None });
+    }
+    if symbol.section.is_some()
+        && let Some(address) = symbol.virtual_address
+    {
+        out.push(ContextItem::Copy {
+            value: format!("{address:x}"),
+            label: Some("virtual address".to_string()),
+        });
+    }
+    out.append(&mut obj.arch.symbol_context(obj, symbol_index));
+    out
+}
+
+pub fn symbol_hover(
+    obj: &Object,
+    symbol_index: usize,
+    addend: i64,
+    override_color: Option<HoverItemColor>,
+) -> Vec<HoverItem> {
+    let Some(symbol) = obj.symbols.get(symbol_index) else {
+        return Vec::new();
+    };
+    let addend_str = match addend.cmp(&0i64) {
+        Ordering::Greater => format!("+{addend:x}"),
+        Ordering::Less => format!("-{:x}", -addend),
+        _ => String::new(),
+    };
+    let mut out = Vec::new();
+    out.push(HoverItem::Text {
+        label: "Name".into(),
+        value: format!("{}{}", symbol.name, addend_str),
+        color: override_color.clone().unwrap_or_default(),
+    });
+    if let Some(demangled_name) = &symbol.demangled_name {
+        out.push(HoverItem::Text {
+            label: "Demangled".into(),
+            value: demangled_name.into(),
+            color: override_color.clone().unwrap_or_default(),
+        });
+    }
+    if let Some(section) = symbol.section {
+        out.push(HoverItem::Text {
+            label: "Section".into(),
+            value: obj.sections[section].name.clone(),
+            color: override_color.clone().unwrap_or_default(),
+        });
+        out.push(HoverItem::Text {
+            label: "Address".into(),
+            value: format!("{:x}{}", symbol.address, addend_str),
+            color: override_color.clone().unwrap_or_default(),
+        });
+        if symbol.flags.contains(SymbolFlag::SizeInferred) {
+            out.push(HoverItem::Text {
+                label: "Size".into(),
+                value: format!("{:x} (inferred)", symbol.size),
+                color: override_color.clone().unwrap_or_default(),
+            });
+        } else {
+            out.push(HoverItem::Text {
+                label: "Size".into(),
+                value: format!("{:x}", symbol.size),
+                color: override_color.clone().unwrap_or_default(),
+            });
+        }
+        if let Some(align) = symbol.align {
+            out.push(HoverItem::Text {
+                label: "Alignment".into(),
+                value: align.get().to_string(),
+                color: override_color.clone().unwrap_or_default(),
+            });
+        }
+        if let Some(address) = symbol.virtual_address {
+            out.push(HoverItem::Text {
+                label: "Virtual address".into(),
+                value: format!("{address:x}"),
+                color: override_color.clone().unwrap_or(HoverItemColor::Special),
+            });
+        }
+    } else {
+        out.push(HoverItem::Text {
+            label: Default::default(),
+            value: "Extern".into(),
+            color: HoverItemColor::Emphasized,
+        });
+    }
+    out.append(&mut obj.arch.symbol_hover(obj, symbol_index));
+    out
+}
+
+pub fn relocation_context(
+    obj: &Object,
+    reloc: ResolvedRelocation,
+    ins: Option<ResolvedInstructionRef>,
+) -> Vec<ContextItem> {
+    let mut out = Vec::new();
+    out.append(&mut symbol_context(obj, reloc.relocation.target_symbol));
+    if let Some(ins) = ins {
+        let literals = display_ins_data_literals(obj, ins);
+        if !literals.is_empty() {
+            out.push(ContextItem::Separator);
+            for (literal, label_override) in literals {
+                out.push(ContextItem::Copy { value: literal, label: label_override });
+            }
+        }
+    }
+    out
+}
+
+pub fn data_row_hover(obj: &Object, diff_row: &DataDiffRow) -> Vec<HoverItem> {
+    let mut out = Vec::new();
+    let mut prev_reloc = None;
+    let mut first = true;
+    for reloc_diff in diff_row.relocations.iter() {
+        let reloc = &reloc_diff.reloc;
+        if prev_reloc == Some(reloc) {
+            // Avoid showing consecutive duplicate relocations.
+            // We do this because a single relocation can span across multiple diffs if the
+            // bytes in the relocation changed (e.g. first byte is added, second is unchanged).
+            continue;
+        }
+        prev_reloc = Some(reloc);
+
+        if first {
+            first = false;
+        } else {
+            out.push(HoverItem::Separator);
+        }
+
+        let reloc = resolve_relocation(&obj.symbols, reloc);
+        let color = match reloc_diff.kind {
+            DataDiffKind::None => HoverItemColor::Normal,
+            DataDiffKind::Replace => HoverItemColor::Special,
+            DataDiffKind::Delete => HoverItemColor::Delete,
+            DataDiffKind::Insert => HoverItemColor::Insert,
+        };
+        out.append(&mut relocation_hover(obj, reloc, Some(color)));
+    }
+    out
+}
+
+pub fn data_row_context(obj: &Object, diff_row: &DataDiffRow) -> Vec<ContextItem> {
+    let mut out = Vec::new();
+    let mut prev_reloc = None;
+    for reloc_diff in diff_row.relocations.iter() {
+        let reloc = &reloc_diff.reloc;
+        if prev_reloc == Some(reloc) {
+            // Avoid showing consecutive duplicate relocations.
+            // We do this because a single relocation can span across multiple diffs if the
+            // bytes in the relocation changed (e.g. first byte is added, second is unchanged).
+            continue;
+        }
+        prev_reloc = Some(reloc);
+
+        let reloc = resolve_relocation(&obj.symbols, reloc);
+        out.append(&mut relocation_context(obj, reloc, None));
+    }
+    out
+}
+
+pub fn relocation_hover(
+    obj: &Object,
+    reloc: ResolvedRelocation,
+    override_color: Option<HoverItemColor>,
+) -> Vec<HoverItem> {
+    let mut out = Vec::new();
+    if let Some(name) = obj.arch.reloc_name(reloc.relocation.flags) {
+        out.push(HoverItem::Text {
+            label: "Relocation".into(),
+            value: name.to_string(),
+            color: override_color.clone().unwrap_or_default(),
+        });
+    } else {
+        out.push(HoverItem::Text {
+            label: "Relocation".into(),
+            value: format!("<{:?}>", reloc.relocation.flags),
+            color: override_color.clone().unwrap_or_default(),
+        });
+    }
+    out.append(&mut symbol_hover(
+        obj,
+        reloc.relocation.target_symbol,
+        reloc.relocation.addend,
+        override_color,
+    ));
+    out
+}
+
+pub fn instruction_context(
+    obj: &Object,
+    resolved: ResolvedInstructionRef,
+    ins: &ParsedInstruction,
+) -> Vec<ContextItem> {
+    let mut out = Vec::new();
+    let mut hex_string = String::new();
+    for byte in resolved.code {
+        hex_string.push_str(&format!("{byte:02x}"));
+    }
+    out.push(ContextItem::Copy { value: hex_string, label: Some("instruction bytes".to_string()) });
+    out.append(&mut obj.arch.instruction_context(obj, resolved));
+    if let Some(virtual_address) = resolved.symbol.virtual_address {
+        let offset = resolved.ins_ref.address - resolved.symbol.address;
+        out.push(ContextItem::Copy {
+            value: format!("{:x}", virtual_address + offset),
+            label: Some("virtual address".to_string()),
+        });
+    }
+    for arg in &ins.args {
+        if let InstructionArg::Value(arg) = arg {
+            out.push(ContextItem::Copy { value: arg.to_string(), label: None });
+            match arg {
+                InstructionArgValue::Signed(v) => {
+                    out.push(ContextItem::Copy { value: v.to_string(), label: None });
+                }
+                InstructionArgValue::Unsigned(v) => {
+                    out.push(ContextItem::Copy { value: v.to_string(), label: None });
+                }
+                _ => {}
+            }
+        }
+    }
+    if let Some(reloc) = resolved.relocation {
+        out.push(ContextItem::Separator);
+        out.append(&mut relocation_context(obj, reloc, Some(resolved)));
+    }
+    out
+}
+
+pub fn instruction_hover(
+    obj: &Object,
+    resolved: ResolvedInstructionRef,
+    ins: &ParsedInstruction,
+) -> Vec<HoverItem> {
+    let mut out = Vec::new();
+    out.push(HoverItem::Text {
+        label: Default::default(),
+        value: format!("{:02x?}", resolved.code),
+        color: HoverItemColor::Normal,
+    });
+    out.append(&mut obj.arch.instruction_hover(obj, resolved));
+    if let Some(virtual_address) = resolved.symbol.virtual_address {
+        let offset = resolved.ins_ref.address - resolved.symbol.address;
+        out.push(HoverItem::Text {
+            label: "Virtual address".into(),
+            value: format!("{:x}", virtual_address + offset),
+            color: HoverItemColor::Special,
+        });
+    }
+    for arg in &ins.args {
+        if let InstructionArg::Value(arg) = arg {
+            match arg {
+                InstructionArgValue::Signed(v) => {
+                    out.push(HoverItem::Text {
+                        label: Default::default(),
+                        value: format!("{arg} == {v}"),
+                        color: HoverItemColor::Normal,
+                    });
+                }
+                InstructionArgValue::Unsigned(v) => {
+                    out.push(HoverItem::Text {
+                        label: Default::default(),
+                        value: format!("{arg} == {v}"),
+                        color: HoverItemColor::Normal,
+                    });
+                }
+                _ => {}
+            }
+        }
+    }
+    if let Some(reloc) = resolved.relocation {
+        out.push(HoverItem::Separator);
+        out.append(&mut relocation_hover(obj, reloc, None));
+        let bytes = obj.symbol_data(reloc.relocation.target_symbol).unwrap_or(&[]);
+        if let Some(ty) = obj.arch.guess_data_type(resolved, bytes) {
+            let literals = display_ins_data_literals(obj, resolved);
+            if !literals.is_empty() {
+                out.push(HoverItem::Separator);
+                for (literal, label_override) in literals {
+                    out.push(HoverItem::Text {
+                        label: label_override.unwrap_or_else(|| ty.to_string()),
+                        value: format!("{literal:?}"),
+                        color: HoverItemColor::Normal,
+                    });
+                }
+            }
+        }
+    }
+    out
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum SymbolFilter<'a> {
+    None,
+    Search(&'a Regex),
+    Mapping(usize, Option<&'a Regex>),
+}
+
+fn symbol_matches_filter(
+    symbol: &Symbol,
+    diff: &SymbolDiff,
+    filter: SymbolFilter<'_>,
+    show_hidden_symbols: bool,
+) -> bool {
+    // Ignore absolute symbols
+    if symbol.section.is_none() && !symbol.flags.contains(SymbolFlag::Common) {
+        return false;
+    }
+    if !show_hidden_symbols
+        && (symbol.size == 0
+            || symbol.flags.contains(SymbolFlag::Hidden)
+            || symbol.flags.contains(SymbolFlag::Ignored))
+    {
+        return false;
+    }
+    match filter {
+        SymbolFilter::None => true,
+        SymbolFilter::Search(regex) => {
+            regex.is_match(&symbol.name)
+                || symbol.demangled_name.as_deref().is_some_and(|s| regex.is_match(s))
+        }
+        SymbolFilter::Mapping(symbol_ref, regex) => {
+            diff.target_symbol == Some(symbol_ref)
+                && regex.is_none_or(|r| {
+                    r.is_match(&symbol.name)
+                        || symbol.demangled_name.as_deref().is_some_and(|s| r.is_match(s))
+                })
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct SectionDisplaySymbol {
+    pub symbol: usize,
+    pub is_mapping_symbol: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct SectionDisplay {
+    pub id: String,
+    pub name: String,
+    pub size: u64,
+    pub match_percent: Option<f32>,
+    pub symbols: Vec<SectionDisplaySymbol>,
+    pub kind: SectionKind,
+}
+
+pub fn display_sections(
+    obj: &Object,
+    diff: &ObjectDiff,
+    filter: SymbolFilter<'_>,
+    show_hidden_symbols: bool,
+    show_mapped_symbols: bool,
+    reverse_fn_order: bool,
+) -> Vec<SectionDisplay> {
+    let mut mapping = BTreeSet::new();
+    let is_mapping_symbol = if let SymbolFilter::Mapping(_, _) = filter {
+        for mapping_diff in &diff.mapping_symbols {
+            let symbol = &obj.symbols[mapping_diff.symbol_index];
+            if !symbol_matches_filter(
+                symbol,
+                &mapping_diff.symbol_diff,
+                filter,
+                show_hidden_symbols,
+            ) {
+                continue;
+            }
+            if !show_mapped_symbols {
+                let symbol_diff = &diff.symbols[mapping_diff.symbol_index];
+                if symbol_diff.target_symbol.is_some() {
+                    continue;
+                }
+            }
+            mapping.insert((symbol.section, mapping_diff.symbol_index));
+        }
+        true
+    } else {
+        for (symbol_idx, (symbol, symbol_diff)) in obj.symbols.iter().zip(&diff.symbols).enumerate()
+        {
+            if !symbol_matches_filter(symbol, symbol_diff, filter, show_hidden_symbols) {
+                continue;
+            }
+            mapping.insert((symbol.section, symbol_idx));
+        }
+        false
+    };
+    let num_sections = mapping.iter().map(|(section_idx, _)| *section_idx).dedup().count();
+    let mut sections = Vec::with_capacity(num_sections);
+    for (section_idx, group) in &mapping.iter().chunk_by(|(section_idx, _)| *section_idx) {
+        let mut symbols = group
+            .map(|&(_, symbol)| SectionDisplaySymbol { symbol, is_mapping_symbol })
+            .collect::<Vec<_>>();
+        if let Some(section_idx) = section_idx {
+            let section = &obj.sections[section_idx];
+            if section.kind == SectionKind::Unknown {
+                // Skip unknown and hidden sections
+                continue;
+            }
+            let section_diff = &diff.sections[section_idx];
+            let reverse_fn_order = section.kind == SectionKind::Code && reverse_fn_order;
+            symbols.sort_by(|a, b| {
+                let a = &obj.symbols[a.symbol];
+                let b = &obj.symbols[b.symbol];
+                section_symbol_sort(a, b)
+                    .then_with(|| {
+                        if reverse_fn_order {
+                            b.address.cmp(&a.address)
+                        } else {
+                            a.address.cmp(&b.address)
+                        }
+                    })
+                    .then_with(|| a.size.cmp(&b.size))
+            });
+            sections.push(SectionDisplay {
+                id: section.id.clone(),
+                name: if section.flags.contains(SectionFlag::Combined) {
+                    format!("{} [combined]", section.name)
+                } else {
+                    section.name.clone()
+                },
+                size: section.size,
+                match_percent: section_diff.match_percent,
+                symbols,
+                kind: section.kind,
+            });
+        } else {
+            // Don't sort, preserve order of absolute symbols
+            sections.push(SectionDisplay {
+                id: ".comm".to_string(),
+                name: ".comm".to_string(),
+                size: 0,
+                match_percent: None,
+                symbols,
+                kind: SectionKind::Common,
+            });
+        }
+    }
+    sections.sort_by(|a, b| a.name.cmp(&b.name));
+    sections
+}
+
+fn section_symbol_sort(a: &Symbol, b: &Symbol) -> Ordering {
+    if a.kind == SymbolKind::Section {
+        if b.kind != SymbolKind::Section {
+            return Ordering::Less;
+        }
+    } else if b.kind == SymbolKind::Section {
+        return Ordering::Greater;
+    }
+    Ordering::Equal
+}
+
+pub fn display_ins_data_labels(obj: &Object, resolved: ResolvedInstructionRef) -> Vec<String> {
+    let Some(reloc) = resolved.relocation else {
+        return Vec::new();
+    };
+    if reloc.relocation.addend < 0 || reloc.relocation.addend as u64 >= reloc.symbol.size {
+        return Vec::new();
+    }
+    let Some(data) = obj.symbol_data(reloc.relocation.target_symbol) else {
+        return Vec::new();
+    };
+    let bytes = &data[reloc.relocation.addend as usize..];
+    obj.arch
+        .guess_data_type(resolved, bytes)
+        .map(|ty| ty.display_labels(obj.endianness, bytes))
+        .unwrap_or_default()
+}
+
+pub fn display_ins_data_literals(
+    obj: &Object,
+    resolved: ResolvedInstructionRef,
+) -> Vec<(String, Option<String>)> {
+    let Some(reloc) = resolved.relocation else {
+        return Vec::new();
+    };
+    if reloc.relocation.addend < 0 || reloc.relocation.addend as u64 >= reloc.symbol.size {
+        return Vec::new();
+    }
+    let Some(data) = obj.symbol_data(reloc.relocation.target_symbol) else {
+        return Vec::new();
+    };
+    let bytes = &data[reloc.relocation.addend as usize..];
+    obj.arch
+        .guess_data_type(resolved, bytes)
+        .map(|ty| ty.display_literals(obj.endianness, bytes))
+        .unwrap_or_default()
+}

objdiff-core/src/diff/mod.rs

@@ -0,0 +1,834 @@
+use alloc::{
+    collections::{BTreeMap, BTreeSet},
+    string::String,
+    vec,
+    vec::Vec,
+};
+use core::{num::NonZeroU32, ops::Range};
+
+use anyhow::Result;
+
+use crate::{
+    diff::{
+        code::{diff_code, no_diff_code},
+        data::{
+            diff_bss_section, diff_bss_symbol, diff_data_section, diff_data_symbol,
+            diff_generic_section, no_diff_bss_section, no_diff_data_section, no_diff_data_symbol,
+            symbol_name_matches,
+        },
+    },
+    obj::{InstructionRef, Object, Relocation, SectionKind, Symbol, SymbolFlag},
+};
+
+pub mod code;
+pub mod data;
+pub mod demangler;
+pub mod display;
+
+include!(concat!(env!("OUT_DIR"), "/config.gen.rs"));
+
+impl DiffObjConfig {
+    pub fn separator(&self) -> &'static str { if self.space_between_args { ", " } else { "," } }
+}
+
+#[derive(Debug, Clone)]
+pub struct SectionDiff {
+    // pub target_section: Option<usize>,
+    pub match_percent: Option<f32>,
+    pub data_diff: Vec<DataDiff>,
+    pub reloc_diff: Vec<DataRelocationDiff>,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct SymbolDiff {
+    /// The symbol index in the _other_ object that this symbol was diffed against
+    pub target_symbol: Option<usize>,
+    pub match_percent: Option<f32>,
+    pub diff_score: Option<(u64, u64)>,
+    pub instruction_rows: Vec<InstructionDiffRow>,
+    pub data_rows: Vec<DataDiffRow>,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct MappingSymbolDiff {
+    pub symbol_index: usize,
+    pub symbol_diff: SymbolDiff,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct InstructionDiffRow {
+    /// Instruction reference
+    pub ins_ref: Option<InstructionRef>,
+    /// Diff kind
+    pub kind: InstructionDiffKind,
+    /// Branches from instruction(s)
+    pub branch_from: Option<InstructionBranchFrom>,
+    /// Branches to instruction
+    pub branch_to: Option<InstructionBranchTo>,
+    /// Arg diffs
+    pub arg_diff: Vec<InstructionArgDiffIndex>,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
+pub enum InstructionDiffKind {
+    #[default]
+    None,
+    OpMismatch,
+    ArgMismatch,
+    Replace,
+    Delete,
+    Insert,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct DataDiff {
+    pub data: Vec<u8>,
+    pub size: usize,
+    pub kind: DataDiffKind,
+}
+
+#[derive(Debug, Clone)]
+pub struct DataRelocationDiff {
+    pub reloc: Relocation,
+    pub range: Range<u64>,
+    pub kind: DataDiffKind,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
+pub enum DataDiffKind {
+    #[default]
+    None,
+    Replace,
+    Delete,
+    Insert,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct DataDiffRow {
+    pub address: u64,
+    pub segments: Vec<DataDiff>,
+    pub relocations: Vec<DataRelocationDiff>,
+}
+
+/// Index of the argument diff for coloring.
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Default)]
+pub struct InstructionArgDiffIndex(pub Option<NonZeroU32>);
+
+impl InstructionArgDiffIndex {
+    pub const NONE: Self = Self(None);
+
+    #[inline(always)]
+    pub fn new(idx: u32) -> Self {
+        Self(Some(unsafe { NonZeroU32::new_unchecked(idx.saturating_add(1)) }))
+    }
+
+    #[inline(always)]
+    pub fn get(&self) -> Option<u32> { self.0.map(|idx| idx.get() - 1) }
+
+    #[inline(always)]
+    pub fn is_some(&self) -> bool { self.0.is_some() }
+
+    #[inline(always)]
+    pub fn is_none(&self) -> bool { self.0.is_none() }
+}
+
+#[derive(Debug, Clone)]
+pub struct InstructionBranchFrom {
+    /// Source instruction indices
+    pub ins_idx: Vec<u32>,
+    /// Incrementing index for coloring
+    pub branch_idx: u32,
+}
+
+#[derive(Debug, Clone)]
+pub struct InstructionBranchTo {
+    /// Target instruction index
+    pub ins_idx: u32,
+    /// Incrementing index for coloring
+    pub branch_idx: u32,
+}
+
+#[derive(Debug, Default)]
+pub struct ObjectDiff {
+    /// A list of all symbol diffs in the object.
+    pub symbols: Vec<SymbolDiff>,
+    /// A list of all section diffs in the object.
+    pub sections: Vec<SectionDiff>,
+    /// If `selecting_left` or `selecting_right` is set, this is the list of symbols
+    /// that are being mapped to the other object.
+    pub mapping_symbols: Vec<MappingSymbolDiff>,
+}
+
+impl ObjectDiff {
+    pub fn new_from_obj(obj: &Object) -> Self {
+        let mut result = Self {
+            symbols: Vec::with_capacity(obj.symbols.len()),
+            sections: Vec::with_capacity(obj.sections.len()),
+            mapping_symbols: vec![],
+        };
+        for _ in obj.symbols.iter() {
+            result.symbols.push(SymbolDiff {
+                target_symbol: None,
+                match_percent: None,
+                diff_score: None,
+                ..Default::default()
+            });
+        }
+        for _ in obj.sections.iter() {
+            result.sections.push(SectionDiff {
+                // target_section: None,
+                match_percent: None,
+                data_diff: vec![],
+                reloc_diff: vec![],
+            });
+        }
+        result
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct DiffObjsResult {
+    pub left: Option<ObjectDiff>,
+    pub right: Option<ObjectDiff>,
+    pub prev: Option<ObjectDiff>,
+}
+
+pub fn diff_objs(
+    left: Option<&Object>,
+    right: Option<&Object>,
+    prev: Option<&Object>,
+    diff_config: &DiffObjConfig,
+    mapping_config: &MappingConfig,
+) -> Result<DiffObjsResult> {
+    let symbol_matches = matching_symbols(left, right, prev, mapping_config)?;
+    let section_matches = matching_sections(left, right)?;
+    let mut left = left.map(|p| (p, ObjectDiff::new_from_obj(p)));
+    let mut right = right.map(|p| (p, ObjectDiff::new_from_obj(p)));
+    let mut prev = prev.map(|p| (p, ObjectDiff::new_from_obj(p)));
+
+    for symbol_match in symbol_matches {
+        match symbol_match {
+            SymbolMatch {
+                left: Some(left_symbol_ref),
+                right: Some(right_symbol_ref),
+                prev: prev_symbol_ref,
+                section_kind,
+            } => {
+                let (left_obj, left_out) = left.as_mut().unwrap();
+                let (right_obj, right_out) = right.as_mut().unwrap();
+                match section_kind {
+                    SectionKind::Code => {
+                        let (left_diff, right_diff) = diff_code(
+                            left_obj,
+                            right_obj,
+                            left_symbol_ref,
+                            right_symbol_ref,
+                            diff_config,
+                        )?;
+                        left_out.symbols[left_symbol_ref] = left_diff;
+                        right_out.symbols[right_symbol_ref] = right_diff;
+
+                        if let Some(prev_symbol_ref) = prev_symbol_ref {
+                            let (_prev_obj, prev_out) = prev.as_mut().unwrap();
+                            let (_, prev_diff) = diff_code(
+                                left_obj,
+                                right_obj,
+                                right_symbol_ref,
+                                prev_symbol_ref,
+                                diff_config,
+                            )?;
+                            prev_out.symbols[prev_symbol_ref] = prev_diff;
+                        }
+                    }
+                    SectionKind::Data => {
+                        let (left_diff, right_diff) = diff_data_symbol(
+                            left_obj,
+                            right_obj,
+                            left_symbol_ref,
+                            right_symbol_ref,
+                        )?;
+                        left_out.symbols[left_symbol_ref] = left_diff;
+                        right_out.symbols[right_symbol_ref] = right_diff;
+                    }
+                    SectionKind::Bss | SectionKind::Common => {
+                        let (left_diff, right_diff) = diff_bss_symbol(
+                            left_obj,
+                            right_obj,
+                            left_symbol_ref,
+                            right_symbol_ref,
+                        )?;
+                        left_out.symbols[left_symbol_ref] = left_diff;
+                        right_out.symbols[right_symbol_ref] = right_diff;
+                    }
+                    SectionKind::Unknown => unreachable!(),
+                }
+            }
+            SymbolMatch { left: Some(left_symbol_ref), right: None, prev: _, section_kind } => {
+                let (left_obj, left_out) = left.as_mut().unwrap();
+                match section_kind {
+                    SectionKind::Code => {
+                        left_out.symbols[left_symbol_ref] =
+                            no_diff_code(left_obj, left_symbol_ref, diff_config)?;
+                    }
+                    SectionKind::Data => {
+                        left_out.symbols[left_symbol_ref] =
+                            no_diff_data_symbol(left_obj, left_symbol_ref)?;
+                    }
+                    SectionKind::Bss | SectionKind::Common => {
+                        // Nothing needs to be done
+                    }
+                    SectionKind::Unknown => unreachable!(),
+                }
+            }
+            SymbolMatch { left: None, right: Some(right_symbol_ref), prev: _, section_kind } => {
+                let (right_obj, right_out) = right.as_mut().unwrap();
+                match section_kind {
+                    SectionKind::Code => {
+                        right_out.symbols[right_symbol_ref] =
+                            no_diff_code(right_obj, right_symbol_ref, diff_config)?;
+                    }
+                    SectionKind::Data => {
+                        right_out.symbols[right_symbol_ref] =
+                            no_diff_data_symbol(right_obj, right_symbol_ref)?;
+                    }
+                    SectionKind::Bss | SectionKind::Common => {
+                        // Nothing needs to be done
+                    }
+                    SectionKind::Unknown => unreachable!(),
+                }
+            }
+            SymbolMatch { left: None, right: None, .. } => {
+                // Should not happen
+            }
+        }
+    }
+
+    for section_match in section_matches {
+        match section_match {
+            SectionMatch {
+                left: Some(left_section_idx),
+                right: Some(right_section_idx),
+                section_kind,
+            } => {
+                let (left_obj, left_out) = left.as_mut().unwrap();
+                let (right_obj, right_out) = right.as_mut().unwrap();
+                match section_kind {
+                    SectionKind::Code => {
+                        let (left_diff, right_diff) = diff_generic_section(
+                            left_obj,
+                            right_obj,
+                            left_out,
+                            right_out,
+                            left_section_idx,
+                            right_section_idx,
+                        )?;
+                        left_out.sections[left_section_idx] = left_diff;
+                        right_out.sections[right_section_idx] = right_diff;
+                    }
+                    SectionKind::Data => {
+                        let (left_diff, right_diff) = diff_data_section(
+                            left_obj,
+                            right_obj,
+                            left_out,
+                            right_out,
+                            left_section_idx,
+                            right_section_idx,
+                        )?;
+                        left_out.sections[left_section_idx] = left_diff;
+                        right_out.sections[right_section_idx] = right_diff;
+                    }
+                    SectionKind::Bss | SectionKind::Common => {
+                        let (left_diff, right_diff) = diff_bss_section(
+                            left_obj,
+                            right_obj,
+                            left_out,
+                            right_out,
+                            left_section_idx,
+                            right_section_idx,
+                        )?;
+                        left_out.sections[left_section_idx] = left_diff;
+                        right_out.sections[right_section_idx] = right_diff;
+                    }
+                    SectionKind::Unknown => unreachable!(),
+                }
+            }
+            SectionMatch { left: Some(left_section_idx), right: None, section_kind } => {
+                let (left_obj, left_out) = left.as_mut().unwrap();
+                match section_kind {
+                    SectionKind::Code => {}
+                    SectionKind::Data => {
+                        left_out.sections[left_section_idx] =
+                            no_diff_data_section(left_obj, left_section_idx)?;
+                    }
+                    SectionKind::Bss | SectionKind::Common => {
+                        left_out.sections[left_section_idx] = no_diff_bss_section()?;
+                    }
+                    SectionKind::Unknown => unreachable!(),
+                }
+            }
+            SectionMatch { left: None, right: Some(right_section_idx), section_kind } => {
+                let (right_obj, right_out) = right.as_mut().unwrap();
+                match section_kind {
+                    SectionKind::Code => {}
+                    SectionKind::Data => {
+                        right_out.sections[right_section_idx] =
+                            no_diff_data_section(right_obj, right_section_idx)?;
+                    }
+                    SectionKind::Bss | SectionKind::Common => {
+                        right_out.sections[right_section_idx] = no_diff_bss_section()?;
+                    }
+                    SectionKind::Unknown => unreachable!(),
+                }
+            }
+            SectionMatch { left: None, right: None, .. } => {
+                // Should not happen
+            }
+        }
+    }
+
+    if let (Some((right_obj, right_out)), Some((left_obj, left_out))) =
+        (right.as_mut(), left.as_mut())
+    {
+        if let Some(right_name) = mapping_config.selecting_left.as_deref() {
+            generate_mapping_symbols(
+                left_obj,
+                left_out,
+                right_obj,
+                right_out,
+                MappingSymbol::Right(right_name),
+                diff_config,
+            )?;
+        }
+        if let Some(left_name) = mapping_config.selecting_right.as_deref() {
+            generate_mapping_symbols(
+                left_obj,
+                left_out,
+                right_obj,
+                right_out,
+                MappingSymbol::Left(left_name),
+                diff_config,
+            )?;
+        }
+    }
+
+    Ok(DiffObjsResult {
+        left: left.map(|(_, o)| o),
+        right: right.map(|(_, o)| o),
+        prev: prev.map(|(_, o)| o),
+    })
+}
+
+#[derive(Clone, Copy)]
+enum MappingSymbol<'a> {
+    Left(&'a str),
+    Right(&'a str),
+}
+
+/// When we're selecting a symbol to use as a comparison, we'll create comparisons for all
+/// symbols in the other object that match the selected symbol's section and kind. This allows
+/// us to display match percentages for all symbols in the other object that could be selected.
+fn generate_mapping_symbols(
+    left_obj: &Object,
+    left_out: &mut ObjectDiff,
+    right_obj: &Object,
+    right_out: &mut ObjectDiff,
+    mapping_symbol: MappingSymbol,
+    config: &DiffObjConfig,
+) -> Result<()> {
+    let (base_obj, base_name, target_obj) = match mapping_symbol {
+        MappingSymbol::Left(name) => (left_obj, name, right_obj),
+        MappingSymbol::Right(name) => (right_obj, name, left_obj),
+    };
+    let Some(base_symbol_ref) = base_obj.symbol_by_name(base_name) else {
+        return Ok(());
+    };
+    let base_section_kind = symbol_section_kind(base_obj, &base_obj.symbols[base_symbol_ref]);
+    for (target_symbol_index, target_symbol) in target_obj.symbols.iter().enumerate() {
+        if target_symbol.size == 0
+            || target_symbol.flags.contains(SymbolFlag::Ignored)
+            || symbol_section_kind(target_obj, target_symbol) != base_section_kind
+        {
+            continue;
+        }
+        let (left_symbol_idx, right_symbol_idx) = match mapping_symbol {
+            MappingSymbol::Left(_) => (base_symbol_ref, target_symbol_index),
+            MappingSymbol::Right(_) => (target_symbol_index, base_symbol_ref),
+        };
+        let (left_diff, right_diff) = match base_section_kind {
+            SectionKind::Code => {
+                diff_code(left_obj, right_obj, left_symbol_idx, right_symbol_idx, config)
+            }
+            SectionKind::Data => {
+                diff_data_symbol(left_obj, right_obj, left_symbol_idx, right_symbol_idx)
+            }
+            SectionKind::Bss | SectionKind::Common => {
+                diff_bss_symbol(left_obj, right_obj, left_symbol_idx, right_symbol_idx)
+            }
+            SectionKind::Unknown => continue,
+        }?;
+        match mapping_symbol {
+            MappingSymbol::Left(_) => right_out.mapping_symbols.push(MappingSymbolDiff {
+                symbol_index: right_symbol_idx,
+                symbol_diff: right_diff,
+            }),
+            MappingSymbol::Right(_) => left_out
+                .mapping_symbols
+                .push(MappingSymbolDiff { symbol_index: left_symbol_idx, symbol_diff: left_diff }),
+        }
+    }
+    Ok(())
+}
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+struct SymbolMatch {
+    left: Option<usize>,
+    right: Option<usize>,
+    prev: Option<usize>,
+    section_kind: SectionKind,
+}
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+struct SectionMatch {
+    left: Option<usize>,
+    right: Option<usize>,
+    section_kind: SectionKind,
+}
+
+#[derive(Debug, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize), serde(default))]
+pub struct MappingConfig {
+    /// Manual symbol mappings
+    pub mappings: BTreeMap<String, String>,
+    /// The right object symbol name that we're selecting a left symbol for
+    pub selecting_left: Option<String>,
+    /// The left object symbol name that we're selecting a right symbol for
+    pub selecting_right: Option<String>,
+}
+
+fn apply_symbol_mappings(
+    left: &Object,
+    right: &Object,
+    mapping_config: &MappingConfig,
+    left_used: &mut BTreeSet<usize>,
+    right_used: &mut BTreeSet<usize>,
+    matches: &mut Vec<SymbolMatch>,
+) -> Result<()> {
+    // If we're selecting a symbol to use as a comparison, mark it as used
+    // This ensures that we don't match it to another symbol at any point
+    if let Some(left_name) = &mapping_config.selecting_left
+        && let Some(left_symbol) = left.symbol_by_name(left_name)
+    {
+        left_used.insert(left_symbol);
+    }
+    if let Some(right_name) = &mapping_config.selecting_right
+        && let Some(right_symbol) = right.symbol_by_name(right_name)
+    {
+        right_used.insert(right_symbol);
+    }
+
+    // Apply manual symbol mappings
+    for (left_name, right_name) in &mapping_config.mappings {
+        let Some(left_symbol_index) = left.symbol_by_name(left_name) else {
+            continue;
+        };
+        if left_used.contains(&left_symbol_index) {
+            continue;
+        }
+        let Some(right_symbol_index) = right.symbol_by_name(right_name) else {
+            continue;
+        };
+        if right_used.contains(&right_symbol_index) {
+            continue;
+        }
+        let left_section_kind = left
+            .symbols
+            .get(left_symbol_index)
+            .and_then(|s| s.section)
+            .and_then(|section_index| left.sections.get(section_index))
+            .map_or(SectionKind::Unknown, |s| s.kind);
+        let right_section_kind = right
+            .symbols
+            .get(right_symbol_index)
+            .and_then(|s| s.section)
+            .and_then(|section_index| right.sections.get(section_index))
+            .map_or(SectionKind::Unknown, |s| s.kind);
+        if left_section_kind != right_section_kind {
+            log::warn!(
+                "Symbol section kind mismatch: {left_name} ({left_section_kind:?}) vs {right_name} ({right_section_kind:?})"
+            );
+            continue;
+        }
+        matches.push(SymbolMatch {
+            left: Some(left_symbol_index),
+            right: Some(right_symbol_index),
+            prev: None, // TODO
+            section_kind: left_section_kind,
+        });
+        left_used.insert(left_symbol_index);
+        right_used.insert(right_symbol_index);
+    }
+    Ok(())
+}
+
+/// Find matching symbols between each object.
+fn matching_symbols(
+    left: Option<&Object>,
+    right: Option<&Object>,
+    prev: Option<&Object>,
+    mappings: &MappingConfig,
+) -> Result<Vec<SymbolMatch>> {
+    let mut matches = Vec::new();
+    let mut left_used = BTreeSet::new();
+    let mut right_used = BTreeSet::new();
+    if let Some(left) = left {
+        if let Some(right) = right {
+            apply_symbol_mappings(
+                left,
+                right,
+                mappings,
+                &mut left_used,
+                &mut right_used,
+                &mut matches,
+            )?;
+        }
+        // Do two passes for nameless literals. The first only pairs up perfect matches to ensure
+        // those are correct first, while the second pass catches near matches.
+        for fuzzy_literals in [false, true] {
+            for (symbol_idx, symbol) in left.symbols.iter().enumerate() {
+                if symbol.size == 0 || symbol.flags.contains(SymbolFlag::Ignored) {
+                    continue;
+                }
+                let section_kind = symbol_section_kind(left, symbol);
+                if section_kind == SectionKind::Unknown {
+                    continue;
+                }
+                if left_used.contains(&symbol_idx) {
+                    continue;
+                }
+                let symbol_match = SymbolMatch {
+                    left: Some(symbol_idx),
+                    right: find_symbol(right, left, symbol_idx, Some(&right_used), fuzzy_literals),
+                    prev: find_symbol(prev, left, symbol_idx, None, fuzzy_literals),
+                    section_kind,
+                };
+                matches.push(symbol_match);
+                if let Some(right) = symbol_match.right {
+                    left_used.insert(symbol_idx);
+                    right_used.insert(right);
+                }
+            }
+        }
+    }
+    if let Some(right) = right {
+        // Do two passes for nameless literals. The first only pairs up perfect matches to ensure
+        // those are correct first, while the second pass catches near matches.
+        for fuzzy_literals in [false, true] {
+            for (symbol_idx, symbol) in right.symbols.iter().enumerate() {
+                if symbol.size == 0 || symbol.flags.contains(SymbolFlag::Ignored) {
+                    continue;
+                }
+                let section_kind = symbol_section_kind(right, symbol);
+                if section_kind == SectionKind::Unknown {
+                    continue;
+                }
+                if right_used.contains(&symbol_idx) {
+                    continue;
+                }
+                let symbol_match = SymbolMatch {
+                    left: None,
+                    right: Some(symbol_idx),
+                    prev: find_symbol(prev, right, symbol_idx, None, fuzzy_literals),
+                    section_kind,
+                };
+                matches.push(symbol_match);
+                if symbol_match.prev.is_some() {
+                    right_used.insert(symbol_idx);
+                }
+            }
+        }
+    }
+    Ok(matches)
+}
+
+fn unmatched_symbols<'obj, 'used>(
+    obj: &'obj Object,
+    used: Option<&'used BTreeSet<usize>>,
+) -> impl Iterator<Item = (usize, &'obj Symbol)> + 'used
+where
+    'obj: 'used,
+{
+    obj.symbols.iter().enumerate().filter(move |&(symbol_idx, symbol)| {
+        !symbol.flags.contains(SymbolFlag::Ignored)
+            // Skip symbols that have already been matched
+            && !used.is_some_and(|u| u.contains(&symbol_idx))
+    })
+}
+
+fn symbol_section<'obj>(obj: &'obj Object, symbol: &Symbol) -> Option<(&'obj str, SectionKind)> {
+    if let Some(section) = symbol.section.and_then(|section_idx| obj.sections.get(section_idx)) {
+        // Match x86 .rdata$r against .rdata$rs
+        let section_name =
+            section.name.split_once('$').map_or(section.name.as_str(), |(prefix, _)| prefix);
+        Some((section_name, section.kind))
+    } else if symbol.flags.contains(SymbolFlag::Common) {
+        Some((".comm", SectionKind::Common))
+    } else {
+        None
+    }
+}
+
+fn symbol_section_kind(obj: &Object, symbol: &Symbol) -> SectionKind {
+    match symbol.section {
+        Some(section_index) => obj.sections[section_index].kind,
+        None if symbol.flags.contains(SymbolFlag::Common) => SectionKind::Common,
+        None => SectionKind::Unknown,
+    }
+}
+
+/// Check if a symbol is a compiler-generated like @1234 or _$E1234.
+fn is_symbol_compiler_generated(symbol: &Symbol) -> bool {
+    if symbol.name.starts_with('@') && symbol.name[1..].chars().all(char::is_numeric) {
+        // Exclude @stringBase0, @GUARD@, etc.
+        return true;
+    }
+    if symbol.name.starts_with("_$E") && symbol.name[3..].chars().all(char::is_numeric) {
+        return true;
+    }
+    false
+}
+
+fn find_symbol(
+    obj: Option<&Object>,
+    in_obj: &Object,
+    in_symbol_idx: usize,
+    used: Option<&BTreeSet<usize>>,
+    fuzzy_literals: bool,
+) -> Option<usize> {
+    let in_symbol = &in_obj.symbols[in_symbol_idx];
+    let obj = obj?;
+    let (section_name, section_kind) = symbol_section(in_obj, in_symbol)?;
+
+    // Match compiler-generated symbols against each other (e.g. @251 -> @60)
+    // If they are in the same section and have the same value
+    if is_symbol_compiler_generated(in_symbol)
+        && matches!(section_kind, SectionKind::Code | SectionKind::Data | SectionKind::Bss)
+    {
+        let mut closest_match_symbol_idx = None;
+        let mut closest_match_percent = 0.0;
+        for (symbol_idx, symbol) in unmatched_symbols(obj, used) {
+            let Some(section_index) = symbol.section else {
+                continue;
+            };
+            if obj.sections[section_index].name != section_name {
+                continue;
+            }
+            if !is_symbol_compiler_generated(symbol) {
+                continue;
+            }
+            match section_kind {
+                SectionKind::Data | SectionKind::Code => {
+                    // For code or data, pick the first symbol with exactly matching bytes and relocations.
+                    // If no symbols match exactly, and `fuzzy_literals` is true, pick the closest
+                    // plausible match instead.
+                    if let Ok((left_diff, _right_diff)) =
+                        diff_data_symbol(in_obj, obj, in_symbol_idx, symbol_idx)
+                        && let Some(match_percent) = left_diff.match_percent
+                        && (match_percent == 100.0
+                            || (fuzzy_literals
+                                && match_percent >= 50.0
+                                && match_percent > closest_match_percent))
+                    {
+                        closest_match_symbol_idx = Some(symbol_idx);
+                        closest_match_percent = match_percent;
+                        if match_percent == 100.0 {
+                            break;
+                        }
+                    }
+                }
+                SectionKind::Bss => {
+                    // For BSS, pick the first symbol that has the exact matching size.
+                    if in_symbol.size == symbol.size {
+                        closest_match_symbol_idx = Some(symbol_idx);
+                        break;
+                    }
+                }
+                _ => unreachable!(),
+            }
+        }
+        return closest_match_symbol_idx;
+    }
+
+    // Try to find an exact name match
+    if let Some((symbol_idx, _)) = unmatched_symbols(obj, used).find(|(_, symbol)| {
+        symbol.name == in_symbol.name && symbol_section_kind(obj, symbol) == section_kind
+    }) {
+        return Some(symbol_idx);
+    }
+
+    if let Some((symbol_idx, _)) = unmatched_symbols(obj, used).find(|&(_, symbol)| {
+        symbol_name_matches(&in_symbol.name, &symbol.name)
+            && symbol_section_kind(obj, symbol) == section_kind
+            && symbol_section(obj, symbol).is_some_and(|(name, _)| name == section_name)
+    }) {
+        return Some(symbol_idx);
+    }
+
+    None
+}
+
+/// Find matching sections between each object.
+fn matching_sections(left: Option<&Object>, right: Option<&Object>) -> Result<Vec<SectionMatch>> {
+    let mut matches = Vec::with_capacity(
+        left.as_ref()
+            .map_or(0, |o| o.sections.len())
+            .max(right.as_ref().map_or(0, |o| o.sections.len())),
+    );
+    if let Some(left) = left {
+        for (section_idx, section) in left.sections.iter().enumerate() {
+            if section.kind == SectionKind::Unknown {
+                continue;
+            }
+            matches.push(SectionMatch {
+                left: Some(section_idx),
+                right: find_section(right, &section.name, section.kind, &matches),
+                section_kind: section.kind,
+            });
+        }
+    }
+    if let Some(right) = right {
+        for (section_idx, section) in right.sections.iter().enumerate() {
+            if section.kind == SectionKind::Unknown {
+                continue;
+            }
+            if matches.iter().any(|m| m.right == Some(section_idx)) {
+                continue;
+            }
+            matches.push(SectionMatch {
+                left: None,
+                right: Some(section_idx),
+                section_kind: section.kind,
+            });
+        }
+    }
+    Ok(matches)
+}
+
+fn find_section(
+    obj: Option<&Object>,
+    name: &str,
+    section_kind: SectionKind,
+    matches: &[SectionMatch],
+) -> Option<usize> {
+    obj?.sections.iter().enumerate().position(|(i, s)| {
+        s.kind == section_kind && s.name == name && !matches.iter().any(|m| m.right == Some(i))
+    })
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum DiffSide {
+    /// The target/expected side of the diff.
+    Target,
+    /// The base side of the diff.
+    Base,
+}

objdiff-core/src/jobs/check_update.rs

@@ -0,0 +1,50 @@
+use std::{sync::mpsc::Receiver, task::Waker};
+
+use anyhow::{Context, Result};
+use self_update::{
+    cargo_crate_version,
+    update::{Release, ReleaseUpdate},
+};
+
+use crate::jobs::{Job, JobContext, JobResult, JobState, start_job, update_status};
+
+pub struct CheckUpdateConfig {
+    pub build_updater: fn() -> Result<Box<dyn ReleaseUpdate>>,
+    pub bin_names: Vec<String>,
+}
+
+pub struct CheckUpdateResult {
+    pub update_available: bool,
+    pub latest_release: Release,
+    pub found_binary: Option<String>,
+}
+
+fn run_check_update(
+    context: &JobContext,
+    cancel: Receiver<()>,
+    config: CheckUpdateConfig,
+) -> Result<Box<CheckUpdateResult>> {
+    update_status(context, "Fetching latest release".to_string(), 0, 1, &cancel)?;
+    let updater = (config.build_updater)().context("Failed to create release updater")?;
+    let latest_release = updater.get_latest_release()?;
+    let update_available =
+        self_update::version::bump_is_greater(cargo_crate_version!(), &latest_release.version)?;
+    // Find the binary name in the release assets
+    let mut found_binary = None;
+    for bin_name in &config.bin_names {
+        if latest_release.assets.iter().any(|a| &a.name == bin_name) {
+            found_binary = Some(bin_name.clone());
+            break;
+        }
+    }
+
+    update_status(context, "Complete".to_string(), 1, 1, &cancel)?;
+    Ok(Box::new(CheckUpdateResult { update_available, latest_release, found_binary }))
+}
+
+pub fn start_check_update(waker: Waker, config: CheckUpdateConfig) -> JobState {
+    start_job(waker, "Check for updates", Job::CheckUpdate, move |context, cancel| {
+        run_check_update(&context, cancel, config)
+            .map(|result| JobResult::CheckUpdate(Some(result)))
+    })
+}

objdiff-core/src/jobs/create_scratch.rs

@@ -0,0 +1,103 @@
+use std::{fs, sync::mpsc::Receiver, task::Waker};
+
+use anyhow::{Context, Result, anyhow, bail};
+use typed_path::{Utf8PlatformPathBuf, Utf8UnixPathBuf};
+
+use crate::{
+    build::{BuildConfig, BuildStatus, run_make},
+    jobs::{Job, JobContext, JobResult, JobState, start_job, update_status},
+};
+
+#[derive(Debug, Clone)]
+pub struct CreateScratchConfig {
+    pub build_config: BuildConfig,
+    pub context_path: Option<Utf8UnixPathBuf>,
+    pub build_context: bool,
+
+    // Scratch fields
+    pub compiler: String,
+    pub platform: String,
+    pub compiler_flags: String,
+    pub function_name: String,
+    pub target_obj: Utf8PlatformPathBuf,
+    pub preset_id: Option<u32>,
+}
+
+#[derive(Default, Debug, Clone)]
+pub struct CreateScratchResult {
+    pub scratch_url: String,
+}
+
+#[derive(Debug, Default, Clone, serde::Deserialize)]
+struct CreateScratchResponse {
+    pub slug: String,
+    pub claim_token: String,
+}
+
+const API_HOST: &str = "https://decomp.me";
+
+fn run_create_scratch(
+    status: &JobContext,
+    cancel: Receiver<()>,
+    config: CreateScratchConfig,
+) -> Result<Box<CreateScratchResult>> {
+    let project_dir =
+        config.build_config.project_dir.as_ref().ok_or_else(|| anyhow!("Missing project dir"))?;
+
+    let mut context = None;
+    if let Some(context_path) = &config.context_path {
+        if config.build_context {
+            update_status(status, "Building context".to_string(), 0, 2, &cancel)?;
+            match run_make(&config.build_config, context_path.as_ref()) {
+                BuildStatus { success: true, .. } => {}
+                BuildStatus { success: false, stdout, stderr, .. } => {
+                    bail!("Failed to build context:\n{stdout}\n{stderr}")
+                }
+            }
+        }
+        let context_path = project_dir.join(context_path.with_platform_encoding());
+        context = Some(
+            fs::read_to_string(&context_path)
+                .map_err(|e| anyhow!("Failed to read {}: {}", context_path, e))?,
+        );
+    }
+
+    update_status(status, "Creating scratch".to_string(), 1, 2, &cancel)?;
+    let diff_flags = [format!("--disassemble={}", config.function_name)];
+    let diff_flags = serde_json::to_string(&diff_flags)?;
+    let file = reqwest::blocking::multipart::Part::file(&config.target_obj)
+        .with_context(|| format!("Failed to open {}", config.target_obj))?;
+    let mut form = reqwest::blocking::multipart::Form::new()
+        .text("compiler", config.compiler.clone())
+        .text("platform", config.platform.clone())
+        .text("compiler_flags", config.compiler_flags.clone())
+        .text("diff_label", config.function_name.clone())
+        .text("diff_flags", diff_flags)
+        .text("context", context.unwrap_or_default())
+        .text("source_code", "// Move related code from Context tab to here");
+    if let Some(preset) = config.preset_id {
+        form = form.text("preset", preset.to_string());
+    }
+    form = form.part("target_obj", file);
+    let client = reqwest::blocking::Client::new();
+    let response = client
+        .post(format!("{API_HOST}/api/scratch"))
+        .multipart(form)
+        .send()
+        .map_err(|e| anyhow!("Failed to send request: {}", e))?;
+    if !response.status().is_success() {
+        return Err(anyhow!("Failed to create scratch: {}", response.text()?));
+    }
+    let body: CreateScratchResponse = response.json().context("Failed to parse response")?;
+    let scratch_url = format!("{API_HOST}/scratch/{}/claim?token={}", body.slug, body.claim_token);
+
+    update_status(status, "Complete".to_string(), 2, 2, &cancel)?;
+    Ok(Box::from(CreateScratchResult { scratch_url }))
+}
+
+pub fn start_create_scratch(waker: Waker, config: CreateScratchConfig) -> JobState {
+    start_job(waker, "Create scratch", Job::CreateScratch, move |context, cancel| {
+        run_create_scratch(&context, cancel, config)
+            .map(|result| JobResult::CreateScratch(Some(result)))
+    })
+}

objdiff-core/src/jobs/mod.rs

@@ -0,0 +1,229 @@
+use std::{
+    sync::{
+        Arc, RwLock,
+        atomic::{AtomicUsize, Ordering},
+        mpsc::{Receiver, Sender, TryRecvError},
+    },
+    task::Waker,
+    thread::JoinHandle,
+};
+
+use anyhow::Result;
+
+use crate::jobs::{
+    check_update::CheckUpdateResult, create_scratch::CreateScratchResult, objdiff::ObjDiffResult,
+    update::UpdateResult,
+};
+
+pub mod check_update;
+pub mod create_scratch;
+pub mod objdiff;
+pub mod update;
+
+#[derive(Debug, Eq, PartialEq, Copy, Clone)]
+pub enum Job {
+    ObjDiff,
+    CheckUpdate,
+    Update,
+    CreateScratch,
+}
+pub static JOB_ID: AtomicUsize = AtomicUsize::new(0);
+
+#[derive(Default)]
+pub struct JobQueue {
+    pub jobs: Vec<JobState>,
+    pub results: Vec<JobResult>,
+}
+
+impl JobQueue {
+    /// Adds a job to the queue.
+    #[inline]
+    pub fn push(&mut self, state: JobState) { self.jobs.push(state); }
+
+    /// Adds a job to the queue if a job of the given kind is not already running.
+    #[inline]
+    pub fn push_once(&mut self, job: Job, func: impl FnOnce() -> JobState) {
+        if !self.is_running(job) {
+            self.push(func());
+        }
+    }
+
+    /// Returns whether a job of the given kind is running.
+    pub fn is_running(&self, kind: Job) -> bool {
+        self.jobs.iter().any(|j| j.kind == kind && j.handle.is_some())
+    }
+
+    /// Returns whether any job is running.
+    pub fn any_running(&self) -> bool {
+        self.jobs.iter().any(|job| {
+            if let Some(handle) = &job.handle {
+                return !handle.is_finished();
+            }
+            false
+        })
+    }
+
+    /// Iterates over all jobs mutably.
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut JobState> + '_ { self.jobs.iter_mut() }
+
+    /// Iterates over all finished jobs, returning the job state and the result.
+    pub fn iter_finished(
+        &mut self,
+    ) -> impl Iterator<Item = (&mut JobState, std::thread::Result<JobResult>)> + '_ {
+        self.jobs.iter_mut().filter_map(|job| {
+            if let Some(handle) = &job.handle {
+                if !handle.is_finished() {
+                    return None;
+                }
+                let result = job.handle.take().unwrap().join();
+                return Some((job, result));
+            }
+            None
+        })
+    }
+
+    /// Clears all finished jobs.
+    pub fn clear_finished(&mut self) {
+        self.jobs.retain(|job| {
+            !(job.handle.is_none() && job.context.status.read().unwrap().error.is_none())
+        });
+    }
+
+    /// Clears all errored jobs.
+    pub fn clear_errored(&mut self) {
+        self.jobs.retain(|job| job.context.status.read().unwrap().error.is_none());
+    }
+
+    /// Removes a job from the queue given its ID.
+    pub fn remove(&mut self, id: usize) { self.jobs.retain(|job| job.id != id); }
+
+    /// Collects the results of all finished jobs and handles any errors.
+    pub fn collect_results(&mut self) {
+        let mut results = vec![];
+        for (job, result) in self.iter_finished() {
+            match result {
+                Ok(result) => {
+                    match result {
+                        JobResult::None => {
+                            // Job context contains the error
+                        }
+                        _ => results.push(result),
+                    }
+                }
+                Err(err) => {
+                    let err = if let Some(msg) = err.downcast_ref::<&'static str>() {
+                        anyhow::Error::msg(*msg)
+                    } else if let Some(msg) = err.downcast_ref::<String>() {
+                        anyhow::Error::msg(msg.clone())
+                    } else {
+                        anyhow::Error::msg("Thread panicked")
+                    };
+                    let result = job.context.status.write();
+                    if let Ok(mut guard) = result {
+                        guard.error = Some(err);
+                    } else {
+                        drop(result);
+                        job.context.status = Arc::new(RwLock::new(JobStatus {
+                            title: "Error".to_string(),
+                            progress_percent: 0.0,
+                            progress_items: None,
+                            status: String::new(),
+                            error: Some(err),
+                        }));
+                    }
+                }
+            }
+        }
+        self.results.append(&mut results);
+        self.clear_finished();
+    }
+}
+
+#[derive(Clone)]
+pub struct JobContext {
+    pub status: Arc<RwLock<JobStatus>>,
+    pub waker: Waker,
+}
+
+pub struct JobState {
+    pub id: usize,
+    pub kind: Job,
+    pub handle: Option<JoinHandle<JobResult>>,
+    pub context: JobContext,
+    pub cancel: Sender<()>,
+}
+
+#[derive(Default)]
+pub struct JobStatus {
+    pub title: String,
+    pub progress_percent: f32,
+    pub progress_items: Option<[u32; 2]>,
+    pub status: String,
+    pub error: Option<anyhow::Error>,
+}
+
+pub enum JobResult {
+    None,
+    ObjDiff(Option<Box<ObjDiffResult>>),
+    CheckUpdate(Option<Box<CheckUpdateResult>>),
+    Update(Box<UpdateResult>),
+    CreateScratch(Option<Box<CreateScratchResult>>),
+}
+
+fn start_job(
+    waker: Waker,
+    title: &str,
+    kind: Job,
+    run: impl FnOnce(JobContext, Receiver<()>) -> Result<JobResult> + Send + 'static,
+) -> JobState {
+    let status = Arc::new(RwLock::new(JobStatus {
+        title: title.to_string(),
+        progress_percent: 0.0,
+        progress_items: None,
+        status: String::new(),
+        error: None,
+    }));
+    let context = JobContext { status: status.clone(), waker: waker.clone() };
+    let context_inner = JobContext { status: status.clone(), waker };
+    let (tx, rx) = std::sync::mpsc::channel();
+    let handle = std::thread::spawn(move || match run(context_inner, rx) {
+        Ok(state) => state,
+        Err(e) => {
+            if let Ok(mut w) = status.write() {
+                w.error = Some(e);
+            }
+            JobResult::None
+        }
+    });
+    let id = JOB_ID.fetch_add(1, Ordering::Relaxed);
+    JobState { id, kind, handle: Some(handle), context, cancel: tx }
+}
+
+fn update_status(
+    context: &JobContext,
+    str: String,
+    count: u32,
+    total: u32,
+    cancel: &Receiver<()>,
+) -> Result<()> {
+    let mut w =
+        context.status.write().map_err(|_| anyhow::Error::msg("Failed to lock job status"))?;
+    w.progress_items = Some([count, total]);
+    w.progress_percent = count as f32 / total as f32;
+    if should_cancel(cancel) {
+        w.status = "Cancelled".to_string();
+        return Err(anyhow::Error::msg("Cancelled"));
+    } else {
+        w.status = str;
+    }
+    drop(w);
+    context.waker.wake_by_ref();
+    Ok(())
+}
+
+fn should_cancel(rx: &Receiver<()>) -> bool {
+    match rx.try_recv() {
+        Ok(_) | Err(TryRecvError::Disconnected) => true,
+        Err(_) => false,
+    }
+}

objdiff-core/src/jobs/objdiff.rs

@@ -0,0 +1,188 @@
+use std::{sync::mpsc::Receiver, task::Waker};
+
+use anyhow::{Error, Result, bail};
+use time::OffsetDateTime;
+use typed_path::Utf8PlatformPathBuf;
+
+use crate::{
+    build::{BuildConfig, BuildStatus, run_make},
+    diff::{DiffObjConfig, DiffSide, MappingConfig, ObjectDiff, diff_objs},
+    jobs::{Job, JobContext, JobResult, JobState, start_job, update_status},
+    obj::{Object, read},
+};
+
+pub struct ObjDiffConfig {
+    pub build_config: BuildConfig,
+    pub build_base: bool,
+    pub build_target: bool,
+    pub target_path: Option<Utf8PlatformPathBuf>,
+    pub base_path: Option<Utf8PlatformPathBuf>,
+    pub diff_obj_config: DiffObjConfig,
+    pub mapping_config: MappingConfig,
+}
+
+pub struct ObjDiffResult {
+    pub first_status: BuildStatus,
+    pub second_status: BuildStatus,
+    pub first_obj: Option<(Object, ObjectDiff)>,
+    pub second_obj: Option<(Object, ObjectDiff)>,
+    pub time: OffsetDateTime,
+}
+
+fn run_build(
+    context: &JobContext,
+    cancel: Receiver<()>,
+    config: ObjDiffConfig,
+) -> Result<Box<ObjDiffResult>> {
+    let mut target_path_rel = None;
+    let mut base_path_rel = None;
+    if config.build_target || config.build_base {
+        let project_dir = config
+            .build_config
+            .project_dir
+            .as_ref()
+            .ok_or_else(|| Error::msg("Missing project dir"))?;
+        if let Some(target_path) = &config.target_path {
+            target_path_rel = match target_path.strip_prefix(project_dir) {
+                Ok(p) => Some(p.with_unix_encoding()),
+                Err(_) => {
+                    bail!("Target path '{}' doesn't begin with '{}'", target_path, project_dir);
+                }
+            };
+        }
+        if let Some(base_path) = &config.base_path {
+            base_path_rel = match base_path.strip_prefix(project_dir) {
+                Ok(p) => Some(p.with_unix_encoding()),
+                Err(_) => {
+                    bail!("Base path '{}' doesn't begin with '{}'", base_path, project_dir);
+                }
+            };
+        };
+    }
+
+    let mut total = 1;
+    if config.build_target && target_path_rel.is_some() {
+        total += 1;
+    }
+    if config.build_base && base_path_rel.is_some() {
+        total += 1;
+    }
+    if config.target_path.is_some() {
+        total += 1;
+    }
+    if config.base_path.is_some() {
+        total += 1;
+    }
+
+    let mut step_idx = 0;
+    let mut first_status = match target_path_rel {
+        Some(target_path_rel) if config.build_target => {
+            update_status(
+                context,
+                format!("Building target {target_path_rel}"),
+                step_idx,
+                total,
+                &cancel,
+            )?;
+            step_idx += 1;
+            run_make(&config.build_config, target_path_rel.as_ref())
+        }
+        _ => BuildStatus::default(),
+    };
+
+    let mut second_status = match base_path_rel {
+        Some(base_path_rel) if config.build_base => {
+            update_status(
+                context,
+                format!("Building base {base_path_rel}"),
+                step_idx,
+                total,
+                &cancel,
+            )?;
+            step_idx += 1;
+            run_make(&config.build_config, base_path_rel.as_ref())
+        }
+        _ => BuildStatus::default(),
+    };
+
+    let time = OffsetDateTime::now_utc();
+
+    let first_obj = match &config.target_path {
+        Some(target_path) if first_status.success => {
+            update_status(
+                context,
+                format!("Loading target {target_path}"),
+                step_idx,
+                total,
+                &cancel,
+            )?;
+            step_idx += 1;
+            match read::read(target_path.as_ref(), &config.diff_obj_config, DiffSide::Target) {
+                Ok(obj) => Some(obj),
+                Err(e) => {
+                    first_status = BuildStatus {
+                        success: false,
+                        stdout: format!("Loading object '{target_path}'"),
+                        stderr: format!("{e:#}"),
+                        ..Default::default()
+                    };
+                    None
+                }
+            }
+        }
+        Some(_) => {
+            step_idx += 1;
+            None
+        }
+        _ => None,
+    };
+
+    let second_obj = match &config.base_path {
+        Some(base_path) if second_status.success => {
+            update_status(context, format!("Loading base {base_path}"), step_idx, total, &cancel)?;
+            step_idx += 1;
+            match read::read(base_path.as_ref(), &config.diff_obj_config, DiffSide::Base) {
+                Ok(obj) => Some(obj),
+                Err(e) => {
+                    second_status = BuildStatus {
+                        success: false,
+                        stdout: format!("Loading object '{base_path}'"),
+                        stderr: format!("{e:#}"),
+                        ..Default::default()
+                    };
+                    None
+                }
+            }
+        }
+        Some(_) => {
+            step_idx += 1;
+            None
+        }
+        _ => None,
+    };
+
+    update_status(context, "Performing diff".to_string(), step_idx, total, &cancel)?;
+    step_idx += 1;
+    let result = diff_objs(
+        first_obj.as_ref(),
+        second_obj.as_ref(),
+        None,
+        &config.diff_obj_config,
+        &config.mapping_config,
+    )?;
+
+    update_status(context, "Complete".to_string(), step_idx, total, &cancel)?;
+    Ok(Box::new(ObjDiffResult {
+        first_status,
+        second_status,
+        first_obj: first_obj.and_then(|o| result.left.map(|d| (o, d))),
+        second_obj: second_obj.and_then(|o| result.right.map(|d| (o, d))),
+        time,
+    }))
+}
+
+pub fn start_build(waker: Waker, config: ObjDiffConfig) -> JobState {
+    start_job(waker, "Build", Job::ObjDiff, move |context, cancel| {
+        run_build(&context, cancel, config).map(|result| JobResult::ObjDiff(Some(result)))
+    })
+}

objdiff-core/src/jobs/update.rs

@@ -1,32 +1,38 @@
 use std::{
     env::{current_dir, current_exe},
-    fs,
     fs::File,
     path::PathBuf,
     sync::mpsc::Receiver,
+    task::Waker,
 };
 
 use anyhow::{Context, Result};
-use const_format::formatcp;
+pub use self_update; // Re-export self_update crate
+use self_update::update::ReleaseUpdate;
 
-use crate::{
-    jobs::{queue_job, update_status, Job, JobResult, JobState, Status},
-    update::{build_updater, BIN_NAME},
-};
+use crate::jobs::{Job, JobContext, JobResult, JobState, start_job, update_status};
+
+pub struct UpdateConfig {
+    pub build_updater: fn() -> Result<Box<dyn ReleaseUpdate>>,
+    pub bin_name: String,
+}
 
 pub struct UpdateResult {
     pub exe_path: PathBuf,
 }
 
-fn run_update(status: &Status, cancel: Receiver<()>) -> Result<Box<UpdateResult>> {
+fn run_update(
+    status: &JobContext,
+    cancel: Receiver<()>,
+    config: UpdateConfig,
+) -> Result<Box<UpdateResult>> {
     update_status(status, "Fetching latest release".to_string(), 0, 3, &cancel)?;
-    let updater = build_updater().context("Failed to create release updater")?;
+    let updater = (config.build_updater)().context("Failed to create release updater")?;
     let latest_release = updater.get_latest_release()?;
-    let asset = latest_release
-        .assets
-        .iter()
-        .find(|a| a.name == BIN_NAME)
-        .ok_or_else(|| anyhow::Error::msg(formatcp!("No release asset for {}", BIN_NAME)))?;
+    let asset =
+        latest_release.assets.iter().find(|a| a.name == config.bin_name).ok_or_else(|| {
+            anyhow::Error::msg(format!("No release asset for {}", config.bin_name))
+        })?;
 
     update_status(status, "Downloading release".to_string(), 1, 3, &cancel)?;
     let tmp_dir = tempfile::Builder::new().prefix("update").tempdir_in(current_dir()?)?;
@@ -34,7 +40,7 @@ fn run_update(status: &Status, cancel: Receiver<()>) -> Result<Box<UpdateResult>
     let tmp_file = File::create(&tmp_path)?;
     self_update::Download::from_url(&asset.download_url)
         .set_header(reqwest::header::ACCEPT, "application/octet-stream".parse()?)
-        .download_to(&tmp_file)?;
+        .download_to(tmp_file)?;
 
     update_status(status, "Extracting release".to_string(), 2, 3, &cancel)?;
     let tmp_file = tmp_dir.path().join("replacement_tmp");
@@ -44,18 +50,17 @@ fn run_update(status: &Status, cancel: Receiver<()>) -> Result<Box<UpdateResult>
         .to_dest(&target_file)?;
     #[cfg(unix)]
     {
-        use std::os::unix::fs::PermissionsExt;
-        let mut perms = fs::metadata(&target_file)?.permissions();
-        perms.set_mode(0o755);
-        fs::set_permissions(&target_file, perms)?;
+        use std::{fs, os::unix::fs::PermissionsExt};
+        fs::set_permissions(&target_file, fs::Permissions::from_mode(0o755))?;
     }
+    tmp_dir.close()?;
 
     update_status(status, "Complete".to_string(), 3, 3, &cancel)?;
     Ok(Box::from(UpdateResult { exe_path: target_file }))
 }
 
-pub fn queue_update() -> JobState {
-    queue_job("Update app", Job::Update, move |status, cancel| {
-        run_update(status, cancel).map(JobResult::Update)
+pub fn start_update(waker: Waker, config: UpdateConfig) -> JobState {
+    start_job(waker, "Update app", Job::Update, move |context, cancel| {
+        run_update(&context, cancel, config).map(JobResult::Update)
     })
 }

objdiff-core/src/lib.rs

@@ -0,0 +1,20 @@
+#![allow(clippy::too_many_arguments)]
+#![cfg_attr(not(feature = "std"), no_std)]
+extern crate alloc;
+
+#[cfg(feature = "any-arch")]
+pub mod arch;
+#[cfg(feature = "bindings")]
+pub mod bindings;
+#[cfg(feature = "build")]
+pub mod build;
+#[cfg(feature = "config")]
+pub mod config;
+#[cfg(feature = "any-arch")]
+pub mod diff;
+#[cfg(feature = "build")]
+pub mod jobs;
+#[cfg(feature = "any-arch")]
+pub mod obj;
+#[cfg(feature = "any-arch")]
+pub mod util;

objdiff-core/src/obj/dwarf2.rs

@@ -0,0 +1,109 @@
+use alloc::{borrow::Cow, vec::Vec};
+
+use anyhow::{Context, Result};
+use object::{Object as _, ObjectSection as _};
+use typed_arena::Arena;
+
+use crate::obj::{Section, SectionKind};
+
+/// Parse line information from DWARF 2+ sections.
+pub(crate) fn parse_line_info_dwarf2(
+    obj_file: &object::File,
+    sections: &mut [Section],
+) -> Result<()> {
+    let arena_data = Arena::new();
+    let arena_relocations = Arena::new();
+    let endian = match obj_file.endianness() {
+        object::Endianness::Little => gimli::RunTimeEndian::Little,
+        object::Endianness::Big => gimli::RunTimeEndian::Big,
+    };
+    let dwarf = gimli::Dwarf::load(|id: gimli::SectionId| -> Result<_> {
+        load_file_section(id, obj_file, endian, &arena_data, &arena_relocations)
+    })
+    .context("loading DWARF sections")?;
+
+    let mut iter = dwarf.units();
+    if let Some(header) = iter.next().map_err(|e| gimli_error(e, "iterating over DWARF units"))? {
+        let unit = dwarf.unit(header).map_err(|e| gimli_error(e, "loading DWARF unit"))?;
+        if let Some(program) = unit.line_program.clone() {
+            let mut text_sections = sections.iter_mut().filter(|s| s.kind == SectionKind::Code);
+            let mut lines = text_sections.next().map(|section| &mut section.line_info);
+
+            let mut rows = program.rows();
+            while let Some((_header, row)) =
+                rows.next_row().map_err(|e| gimli_error(e, "loading program row"))?
+            {
+                if let (Some(line), Some(lines)) = (row.line(), &mut lines) {
+                    lines.insert(row.address(), line.get() as u32);
+                }
+                if row.end_sequence() {
+                    // The next row is the start of a new sequence, which means we must
+                    // advance to the next .text section.
+                    lines = text_sections.next().map(|section| &mut section.line_info);
+                }
+            }
+        }
+    }
+    if iter.next().map_err(|e| gimli_error(e, "checking for next unit"))?.is_some() {
+        log::warn!("Multiple units found in DWARF data, only processing the first");
+    }
+
+    Ok(())
+}
+
+#[derive(Debug, Default)]
+struct RelocationMap(object::read::RelocationMap);
+
+impl RelocationMap {
+    fn add(&mut self, file: &object::File, section: &object::Section) {
+        for (offset, relocation) in section.relocations() {
+            if let Err(e) = self.0.add(file, offset, relocation) {
+                log::error!(
+                    "Relocation error for section {} at offset 0x{:08x}: {}",
+                    section.name().unwrap(),
+                    offset,
+                    e
+                );
+            }
+        }
+    }
+}
+
+impl gimli::read::Relocate for &'_ RelocationMap {
+    fn relocate_address(&self, offset: usize, value: u64) -> gimli::Result<u64> {
+        Ok(self.0.relocate(offset as u64, value))
+    }
+
+    fn relocate_offset(&self, offset: usize, value: usize) -> gimli::Result<usize> {
+        <usize as gimli::ReaderOffset>::from_u64(self.0.relocate(offset as u64, value as u64))
+    }
+}
+
+type Relocate<'a, R> = gimli::RelocateReader<R, &'a RelocationMap>;
+
+fn load_file_section<'input, 'arena, Endian: gimli::Endianity>(
+    id: gimli::SectionId,
+    file: &object::File<'input>,
+    endian: Endian,
+    arena_data: &'arena Arena<Cow<'input, [u8]>>,
+    arena_relocations: &'arena Arena<RelocationMap>,
+) -> Result<Relocate<'arena, gimli::EndianSlice<'arena, Endian>>> {
+    let mut relocations = RelocationMap::default();
+    let data = match file.section_by_name(id.name()) {
+        Some(ref section) => {
+            relocations.add(file, section);
+            section.uncompressed_data()?
+        }
+        // Use a non-zero capacity so that `ReaderOffsetId`s are unique.
+        None => Cow::Owned(Vec::with_capacity(1)),
+    };
+    let data_ref = arena_data.alloc(data);
+    let section = gimli::EndianSlice::new(data_ref, endian);
+    let relocations = arena_relocations.alloc(relocations);
+    Ok(Relocate::new(section, relocations))
+}
+
+#[inline]
+fn gimli_error(e: gimli::Error, context: &str) -> anyhow::Error {
+    anyhow::anyhow!("gimli error {context}: {e:?}")
+}

objdiff-core/src/obj/mdebug.rs

@@ -0,0 +1,401 @@
+use alloc::vec::Vec;
+
+use anyhow::{Context, Result, bail, ensure};
+use object::{Endianness, Object, ObjectSection};
+
+use super::{Section, SectionKind};
+
+const HDRR_SIZE: usize = 0x60;
+const FDR_SIZE: usize = 0x48;
+const PDR_SIZE: usize = 0x34;
+const SYMR_SIZE: usize = 0x0c;
+
+const ST_PROC: u8 = 6;
+const ST_STATICPROC: u8 = 14;
+const ST_END: u8 = 8;
+
+pub(super) fn parse_line_info_mdebug(
+    obj_file: &object::File,
+    sections: &mut [Section],
+) -> Result<()> {
+    let Some(section) = obj_file.section_by_name(".mdebug") else {
+        return Ok(());
+    };
+
+    let data = section.data().context("failed to read .mdebug contents")?;
+    if data.len() < HDRR_SIZE {
+        return Ok(());
+    }
+
+    let section_file_offset = section.file_range().map(|(offset, _)| offset as usize);
+
+    let endianness = obj_file.endianness();
+    let header = Header::parse(data, endianness)?;
+
+    let symbols_data = slice_at(
+        data,
+        header.cb_sym_offset,
+        header.isym_max.checked_mul(SYMR_SIZE as u32).context("symbol table size overflow")?,
+        section_file_offset,
+    )?;
+    let symbols = parse_symbols(symbols_data, endianness)?;
+
+    let fdr_data = slice_at(
+        data,
+        header.cb_fd_offset,
+        header
+            .ifd_max
+            .checked_mul(FDR_SIZE as u32)
+            .context("file descriptor table size overflow")?,
+        section_file_offset,
+    )?;
+
+    for fdr_index in 0..header.ifd_max as usize {
+        let fdr_offset = fdr_index * FDR_SIZE;
+        let fdr = FileDescriptor::parse(&fdr_data[fdr_offset..fdr_offset + FDR_SIZE], endianness)?;
+        if fdr.cpd == 0 || fdr.csym == 0 {
+            continue;
+        }
+
+        let sym_base = fdr.isym_base as usize;
+        let sym_end = sym_base + fdr.csym as usize;
+        if sym_end > symbols.len() {
+            continue;
+        }
+
+        let Some(line_file_offset) = header.cb_line_offset.checked_add(fdr.cb_line_offset) else {
+            continue;
+        };
+        let Some(line_file_base) =
+            resolve_offset(line_file_offset, data.len(), section_file_offset)
+        else {
+            continue;
+        };
+        let Some(line_file_end) = line_file_base.checked_add(fdr.cb_line as usize) else {
+            continue;
+        };
+        if line_file_end > data.len() {
+            continue;
+        }
+
+        for local_proc_index in 0..fdr.cpd as usize {
+            let pdr_index = fdr.ipd_first as usize + local_proc_index;
+            let pdr_offset = header
+                .cb_pd_offset
+                .checked_add((pdr_index as u32) * PDR_SIZE as u32)
+                .context("procedure descriptor offset overflow")?;
+            let pdr_data = match slice_at(data, pdr_offset, PDR_SIZE as u32, section_file_offset) {
+                Ok(data) => data,
+                Err(_) => continue,
+            };
+            let pdr = ProcDescriptor::parse(pdr_data, endianness)?;
+            if pdr.isym as usize >= fdr.csym as usize {
+                continue;
+            }
+            let global_sym_index = sym_base + pdr.isym as usize;
+            let Some(start_symbol) = symbols.get(global_sym_index) else {
+                continue;
+            };
+            if start_symbol.st != ST_PROC && start_symbol.st != ST_STATICPROC {
+                continue;
+            }
+
+            let local_index = pdr.isym as u32;
+            let mut end_address = None;
+            for sym in &symbols[global_sym_index..sym_end] {
+                if sym.st == ST_END && sym.index == local_index {
+                    end_address = Some(sym.value);
+                    break;
+                }
+            }
+            let Some(end_address) = end_address else {
+                continue;
+            };
+            let Some(size) = end_address.checked_sub(start_symbol.value) else {
+                continue;
+            };
+            if size == 0 || size % 4 != 0 {
+                continue;
+            }
+            let word_count = (size / 4) as usize;
+            if word_count == 0 {
+                continue;
+            }
+
+            let Some(mut cursor) = line_file_base.checked_add(pdr.cb_line_offset as usize) else {
+                continue;
+            };
+            if cursor >= line_file_end {
+                continue;
+            }
+
+            let mut line_number = pdr.ln_low as i32;
+            let mut lines = Vec::with_capacity(word_count);
+            while lines.len() < word_count && cursor < line_file_end {
+                let b0 = data[cursor];
+                cursor += 1;
+                let count = (b0 & 0x0f) as usize + 1;
+                let delta = decode_delta(endianness, b0 >> 4, data, &mut cursor, line_file_end)?;
+                line_number = line_number.wrapping_add(delta as i32);
+                for _ in 0..count {
+                    if lines.len() == word_count {
+                        break;
+                    }
+                    lines.push(line_number);
+                }
+            }
+
+            if lines.len() != word_count {
+                continue;
+            }
+
+            assign_lines(sections, fdr.adr as u64 + pdr.addr as u64, &lines);
+        }
+    }
+
+    Ok(())
+}
+
+fn assign_lines(sections: &mut [Section], base_address: u64, lines: &[i32]) {
+    let mut address = base_address;
+    for &line in lines {
+        if line >= 0
+            && let Some(section) = find_code_section(sections, address)
+        {
+            section.line_info.insert(address, line as u32);
+        }
+        address = address.wrapping_add(4);
+    }
+}
+
+fn find_code_section(sections: &mut [Section], address: u64) -> Option<&mut Section> {
+    sections.iter_mut().find(|section| {
+        section.kind == SectionKind::Code
+            && address >= section.address
+            && address < section.address + section.size
+    })
+}
+
+fn decode_delta(
+    endianness: Endianness,
+    nibble: u8,
+    data: &[u8],
+    cursor: &mut usize,
+    end: usize,
+) -> Result<i32> {
+    if nibble == 8 {
+        ensure!(*cursor + 2 <= end, "extended delta out of range");
+        let bytes: [u8; 2] = data[*cursor..*cursor + 2].try_into().unwrap();
+        *cursor += 2;
+        Ok(match endianness {
+            Endianness::Big => i16::from_be_bytes(bytes) as i32,
+            Endianness::Little => i16::from_le_bytes(bytes) as i32,
+        })
+    } else {
+        let mut value = (nibble & 0x0f) as i32;
+        if value & 0x8 != 0 {
+            value -= 0x10;
+        }
+        Ok(value)
+    }
+}
+
+fn slice_at(
+    data: &[u8],
+    offset: u32,
+    size: u32,
+    section_file_offset: Option<usize>,
+) -> Result<&[u8]> {
+    let size = size as usize;
+    if size == 0 {
+        ensure!(
+            resolve_offset(offset, data.len(), section_file_offset).is_some(),
+            "offset outside of .mdebug section"
+        );
+        return Ok(&data[0..0]);
+    }
+    let Some(offset) = resolve_offset(offset, data.len(), section_file_offset) else {
+        bail!("offset outside of .mdebug section");
+    };
+    let end = offset.checked_add(size).context("range overflow")?;
+    ensure!(end <= data.len(), "range exceeds .mdebug size");
+    Ok(&data[offset..end])
+}
+
+fn resolve_offset(
+    offset: u32,
+    data_len: usize,
+    section_file_offset: Option<usize>,
+) -> Option<usize> {
+    let offset = offset as usize;
+    if offset <= data_len {
+        Some(offset)
+    } else if let Some(file_offset) = section_file_offset {
+        offset.checked_sub(file_offset).filter(|rel| *rel <= data_len)
+    } else {
+        None
+    }
+}
+
+#[derive(Clone, Copy)]
+struct Header {
+    cb_line_offset: u32,
+    cb_pd_offset: u32,
+    cb_sym_offset: u32,
+    cb_fd_offset: u32,
+    isym_max: u32,
+    ifd_max: u32,
+}
+
+impl Header {
+    fn parse(data: &[u8], endianness: Endianness) -> Result<Self> {
+        ensure!(HDRR_SIZE <= data.len(), ".mdebug header truncated");
+        let mut cursor = 0;
+        let magic = read_u16(data, &mut cursor, endianness)?;
+        let _vstamp = read_u16(data, &mut cursor, endianness)?;
+        ensure!(magic == 0x7009, "unexpected .mdebug magic: {magic:#x}");
+        let _iline_max = read_u32(data, &mut cursor, endianness)?;
+        let _cb_line = read_u32(data, &mut cursor, endianness)?;
+        let cb_line_offset = read_u32(data, &mut cursor, endianness)?;
+        let _idn_max = read_u32(data, &mut cursor, endianness)?;
+        let _cb_dn_offset = read_u32(data, &mut cursor, endianness)?;
+        let _ipd_max = read_u32(data, &mut cursor, endianness)?;
+        let cb_pd_offset = read_u32(data, &mut cursor, endianness)?;
+        let isym_max = read_u32(data, &mut cursor, endianness)?;
+        let cb_sym_offset = read_u32(data, &mut cursor, endianness)?;
+        let _iopt_max = read_u32(data, &mut cursor, endianness)?;
+        let _cb_opt_offset = read_u32(data, &mut cursor, endianness)?;
+        let _iaux_max = read_u32(data, &mut cursor, endianness)?;
+        let _cb_aux_offset = read_u32(data, &mut cursor, endianness)?;
+        let _iss_max = read_u32(data, &mut cursor, endianness)?;
+        let _cb_ss_offset = read_u32(data, &mut cursor, endianness)?;
+        let _iss_ext_max = read_u32(data, &mut cursor, endianness)?;
+        let _cb_ss_ext_offset = read_u32(data, &mut cursor, endianness)?;
+        let ifd_max = read_u32(data, &mut cursor, endianness)?;
+        let cb_fd_offset = read_u32(data, &mut cursor, endianness)?;
+        let _crfd = read_u32(data, &mut cursor, endianness)?;
+        let _cb_rfd_offset = read_u32(data, &mut cursor, endianness)?;
+        let _iext_max = read_u32(data, &mut cursor, endianness)?;
+        let _cb_ext_offset = read_u32(data, &mut cursor, endianness)?;
+
+        Ok(Header { cb_line_offset, cb_pd_offset, cb_sym_offset, cb_fd_offset, isym_max, ifd_max })
+    }
+}
+
+#[derive(Clone, Copy)]
+struct FileDescriptor {
+    adr: u32,
+    isym_base: u32,
+    csym: u32,
+    ipd_first: u16,
+    cpd: u16,
+    cb_line_offset: u32,
+    cb_line: u32,
+}
+
+impl FileDescriptor {
+    fn parse(data: &[u8], endianness: Endianness) -> Result<Self> {
+        ensure!(data.len() >= FDR_SIZE, "FDR truncated");
+        let mut cursor = 0;
+        let adr = read_u32(data, &mut cursor, endianness)?;
+        let _rss = read_u32(data, &mut cursor, endianness)?;
+        let _iss_base = read_u32(data, &mut cursor, endianness)?;
+        let _cb_ss = read_u32(data, &mut cursor, endianness)?;
+        let isym_base = read_u32(data, &mut cursor, endianness)?;
+        let csym = read_u32(data, &mut cursor, endianness)?;
+        let _iline_base = read_u32(data, &mut cursor, endianness)?;
+        let _cline = read_u32(data, &mut cursor, endianness)?;
+        let _iopt_base = read_u32(data, &mut cursor, endianness)?;
+        let _copt = read_u32(data, &mut cursor, endianness)?;
+        let ipd_first = read_u16(data, &mut cursor, endianness)?;
+        let cpd = read_u16(data, &mut cursor, endianness)?;
+        let _iaux_base = read_u32(data, &mut cursor, endianness)?;
+        let _caux = read_u32(data, &mut cursor, endianness)?;
+        let _rfd_base = read_u32(data, &mut cursor, endianness)?;
+        let _crfd = read_u32(data, &mut cursor, endianness)?;
+        let _bits = read_u32(data, &mut cursor, endianness)?;
+        let cb_line_offset = read_u32(data, &mut cursor, endianness)?;
+        let cb_line = read_u32(data, &mut cursor, endianness)?;
+
+        Ok(FileDescriptor { adr, isym_base, csym, ipd_first, cpd, cb_line_offset, cb_line })
+    }
+}
+
+#[derive(Clone, Copy)]
+struct ProcDescriptor {
+    addr: u32,
+    isym: u32,
+    ln_low: i32,
+    cb_line_offset: u32,
+}
+
+impl ProcDescriptor {
+    fn parse(data: &[u8], endianness: Endianness) -> Result<Self> {
+        ensure!(data.len() >= PDR_SIZE, "PDR truncated");
+        let mut cursor = 0;
+        let addr = read_u32(data, &mut cursor, endianness)?;
+        let isym = read_u32(data, &mut cursor, endianness)?;
+        let _iline = read_u32(data, &mut cursor, endianness)?;
+        let _regmask = read_u32(data, &mut cursor, endianness)?;
+        let _regoffset = read_u32(data, &mut cursor, endianness)?;
+        let _iopt = read_u32(data, &mut cursor, endianness)?;
+        let _fregmask = read_u32(data, &mut cursor, endianness)?;
+        let _fregoffset = read_u32(data, &mut cursor, endianness)?;
+        let _frameoffset = read_u32(data, &mut cursor, endianness)?;
+        let _framereg = read_u16(data, &mut cursor, endianness)?;
+        let _pcreg = read_u16(data, &mut cursor, endianness)?;
+        let ln_low = read_i32(data, &mut cursor, endianness)?;
+        let _ln_high = read_i32(data, &mut cursor, endianness)?;
+        let cb_line_offset = read_u32(data, &mut cursor, endianness)?;
+
+        Ok(ProcDescriptor { addr, isym, ln_low, cb_line_offset })
+    }
+}
+
+#[derive(Clone, Copy)]
+struct SymbolEntry {
+    value: u32,
+    st: u8,
+    index: u32,
+}
+
+fn parse_symbols(data: &[u8], endianness: Endianness) -> Result<Vec<SymbolEntry>> {
+    ensure!(data.len().is_multiple_of(SYMR_SIZE), "symbol table misaligned");
+    let mut symbols = Vec::with_capacity(data.len() / SYMR_SIZE);
+    let mut cursor = 0;
+    while cursor + SYMR_SIZE <= data.len() {
+        let _iss = read_u32(data, &mut cursor, endianness)?;
+        let value = read_u32(data, &mut cursor, endianness)?;
+        let bits = read_u32(data, &mut cursor, endianness)?;
+        let (st, index) = match endianness {
+            Endianness::Big => (((bits >> 26) & 0x3f) as u8, bits & 0x000f_ffff),
+            Endianness::Little => (((bits & 0x3f) as u8), (bits >> 12) & 0x000f_ffff),
+        };
+        symbols.push(SymbolEntry { value, st, index });
+    }
+    Ok(symbols)
+}
+
+fn read_u16(data: &[u8], cursor: &mut usize, endianness: Endianness) -> Result<u16> {
+    ensure!(*cursor + 2 <= data.len(), "unexpected EOF while reading u16");
+    let bytes: [u8; 2] = data[*cursor..*cursor + 2].try_into().unwrap();
+    *cursor += 2;
+    Ok(match endianness {
+        Endianness::Big => u16::from_be_bytes(bytes),
+        Endianness::Little => u16::from_le_bytes(bytes),
+    })
+}
+
+fn read_u32(data: &[u8], cursor: &mut usize, endianness: Endianness) -> Result<u32> {
+    ensure!(*cursor + 4 <= data.len(), "unexpected EOF while reading u32");
+    let bytes: [u8; 4] = data[*cursor..*cursor + 4].try_into().unwrap();
+    *cursor += 4;
+    Ok(match endianness {
+        Endianness::Big => u32::from_be_bytes(bytes),
+        Endianness::Little => u32::from_le_bytes(bytes),
+    })
+}
+
+fn read_i32(data: &[u8], cursor: &mut usize, endianness: Endianness) -> Result<i32> {
+    Ok(read_u32(data, cursor, endianness)? as i32)
+}

objdiff-core/src/obj/mod.rs

@@ -0,0 +1,441 @@
+#[cfg(feature = "dwarf")]
+mod dwarf2;
+mod mdebug;
+pub mod read;
+pub mod split_meta;
+
+use alloc::{
+    borrow::Cow,
+    boxed::Box,
+    collections::BTreeMap,
+    string::{String, ToString},
+    vec,
+    vec::Vec,
+};
+use core::{
+    fmt,
+    num::{NonZeroU32, NonZeroU64},
+};
+
+use flagset::{FlagSet, flags};
+
+use crate::{
+    arch::{Arch, ArchDummy},
+    obj::split_meta::SplitMeta,
+    util::ReallySigned,
+};
+
+#[derive(Debug, Eq, PartialEq, Copy, Clone, Default)]
+pub enum SectionKind {
+    #[default]
+    Unknown = -1,
+    Code,
+    Data,
+    Bss,
+    Common,
+}
+
+flags! {
+    #[derive(Hash)]
+    pub enum SymbolFlag: u8 {
+        Global,
+        Local,
+        Weak,
+        Common,
+        Hidden,
+        /// Has extra data associated with the symbol
+        /// (e.g. exception table entry)
+        HasExtra,
+        /// Symbol size was missing and was inferred
+        SizeInferred,
+        /// Symbol should be ignored by any diffing
+        Ignored,
+    }
+}
+
+pub type SymbolFlagSet = FlagSet<SymbolFlag>;
+
+flags! {
+    #[derive(Hash)]
+    pub enum SectionFlag: u8 {
+        /// Section combined from multiple input sections
+        Combined,
+    }
+}
+
+pub type SectionFlagSet = FlagSet<SectionFlag>;
+
+#[derive(Debug, Clone, Default)]
+pub struct Section {
+    /// Unique section ID
+    pub id: String,
+    pub name: String,
+    pub address: u64,
+    pub size: u64,
+    pub kind: SectionKind,
+    pub data: SectionData,
+    pub flags: SectionFlagSet,
+    pub align: Option<NonZeroU64>,
+    pub relocations: Vec<Relocation>,
+    /// Line number info (.line or .debug_line section)
+    pub line_info: BTreeMap<u64, u32>,
+    /// Original virtual address (from .note.split section)
+    pub virtual_address: Option<u64>,
+}
+
+#[derive(Clone, Default)]
+#[repr(transparent)]
+pub struct SectionData(pub Vec<u8>);
+
+impl core::ops::Deref for SectionData {
+    type Target = Vec<u8>;
+
+    fn deref(&self) -> &Self::Target { &self.0 }
+}
+
+impl fmt::Debug for SectionData {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("SectionData").field(&self.0.len()).finish()
+    }
+}
+
+impl Section {
+    pub fn data_range(&self, address: u64, size: usize) -> Option<&[u8]> {
+        let offset = address.checked_sub(self.address)?;
+        self.data.get(offset as usize..offset as usize + size)
+    }
+
+    // The alignment to use when "Combine data/text sections" is enabled.
+    pub fn combined_alignment(&self) -> u64 {
+        const MIN_ALIGNMENT: u64 = 4;
+        self.align.map_or(MIN_ALIGNMENT, |align| align.get().max(MIN_ALIGNMENT))
+    }
+
+    pub fn relocation_at(&self, address: u64, size: u8) -> Option<&Relocation> {
+        match self.relocations.binary_search_by_key(&address, |r| r.address) {
+            Ok(mut i) => {
+                // Find the first relocation at the address
+                while i
+                    .checked_sub(1)
+                    .and_then(|n| self.relocations.get(n))
+                    .is_some_and(|r| r.address == address)
+                {
+                    i -= 1;
+                }
+                self.relocations.get(i)
+            }
+            Err(i) => self.relocations.get(i).filter(|r| r.address < address + size as u64),
+        }
+    }
+
+    pub fn resolve_relocation_at<'obj>(
+        &'obj self,
+        obj: &'obj Object,
+        address: u64,
+        size: u8,
+    ) -> Option<ResolvedRelocation<'obj>> {
+        self.relocation_at(address, size).and_then(|relocation| {
+            let symbol = obj.symbols.get(relocation.target_symbol)?;
+            Some(ResolvedRelocation { relocation, symbol })
+        })
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum InstructionArgValue<'a> {
+    Signed(i64),
+    Unsigned(u64),
+    Opaque(Cow<'a, str>),
+}
+
+impl InstructionArgValue<'_> {
+    pub fn loose_eq(&self, other: &InstructionArgValue) -> bool {
+        match (self, other) {
+            (InstructionArgValue::Signed(a), InstructionArgValue::Signed(b)) => a == b,
+            (InstructionArgValue::Unsigned(a), InstructionArgValue::Unsigned(b)) => a == b,
+            (InstructionArgValue::Signed(a), InstructionArgValue::Unsigned(b))
+            | (InstructionArgValue::Unsigned(b), InstructionArgValue::Signed(a)) => *a as u64 == *b,
+            (InstructionArgValue::Opaque(a), InstructionArgValue::Opaque(b)) => a == b,
+            _ => false,
+        }
+    }
+
+    pub fn to_static(&self) -> InstructionArgValue<'static> {
+        match self {
+            InstructionArgValue::Signed(v) => InstructionArgValue::Signed(*v),
+            InstructionArgValue::Unsigned(v) => InstructionArgValue::Unsigned(*v),
+            InstructionArgValue::Opaque(v) => InstructionArgValue::Opaque(v.to_string().into()),
+        }
+    }
+
+    pub fn into_static(self) -> InstructionArgValue<'static> {
+        match self {
+            InstructionArgValue::Signed(v) => InstructionArgValue::Signed(v),
+            InstructionArgValue::Unsigned(v) => InstructionArgValue::Unsigned(v),
+            InstructionArgValue::Opaque(v) => {
+                InstructionArgValue::Opaque(Cow::Owned(v.into_owned()))
+            }
+        }
+    }
+}
+
+impl fmt::Display for InstructionArgValue<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            InstructionArgValue::Signed(v) => write!(f, "{:#x}", ReallySigned(*v)),
+            InstructionArgValue::Unsigned(v) => write!(f, "{v:#x}"),
+            InstructionArgValue::Opaque(v) => write!(f, "{v}"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum InstructionArg<'a> {
+    Value(InstructionArgValue<'a>),
+    Reloc,
+    BranchDest(u64),
+}
+
+impl InstructionArg<'_> {
+    pub fn loose_eq(&self, other: &InstructionArg) -> bool {
+        match (self, other) {
+            (InstructionArg::Value(a), InstructionArg::Value(b)) => a.loose_eq(b),
+            (InstructionArg::Reloc, InstructionArg::Reloc) => true,
+            (InstructionArg::BranchDest(a), InstructionArg::BranchDest(b)) => a == b,
+            _ => false,
+        }
+    }
+
+    pub fn to_static(&self) -> InstructionArg<'static> {
+        match self {
+            InstructionArg::Value(v) => InstructionArg::Value(v.to_static()),
+            InstructionArg::Reloc => InstructionArg::Reloc,
+            InstructionArg::BranchDest(v) => InstructionArg::BranchDest(*v),
+        }
+    }
+
+    pub fn into_static(self) -> InstructionArg<'static> {
+        match self {
+            InstructionArg::Value(v) => InstructionArg::Value(v.into_static()),
+            InstructionArg::Reloc => InstructionArg::Reloc,
+            InstructionArg::BranchDest(v) => InstructionArg::BranchDest(v),
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, Default)]
+pub struct InstructionRef {
+    pub address: u64,
+    pub size: u8,
+    pub opcode: u16,
+    pub branch_dest: Option<u64>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ParsedInstruction {
+    pub ins_ref: InstructionRef,
+    pub mnemonic: Cow<'static, str>,
+    pub args: Vec<InstructionArg<'static>>,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
+pub enum SymbolKind {
+    #[default]
+    Unknown,
+    Function,
+    Object,
+    Section,
+}
+
+#[derive(Debug)]
+pub enum FlowAnalysisValue {
+    Text(String),
+}
+
+pub trait FlowAnalysisResult: core::fmt::Debug + Send {
+    fn get_argument_value_at_address(
+        &self,
+        address: u64,
+        argument: u8,
+    ) -> Option<&FlowAnalysisValue>;
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Default)]
+pub struct Symbol {
+    pub name: String,
+    pub demangled_name: Option<String>,
+    pub address: u64,
+    pub size: u64,
+    pub kind: SymbolKind,
+    pub section: Option<usize>,
+    pub flags: SymbolFlagSet,
+    /// Alignment (from Metrowerks .comment section)
+    pub align: Option<NonZeroU32>,
+    /// Original virtual address (from .note.split section)
+    pub virtual_address: Option<u64>,
+}
+
+#[derive(Debug)]
+pub struct Object {
+    pub arch: Box<dyn Arch>,
+    pub endianness: object::Endianness,
+    pub symbols: Vec<Symbol>,
+    pub sections: Vec<Section>,
+    /// Split object metadata (.note.split section)
+    pub split_meta: Option<SplitMeta>,
+    #[cfg(feature = "std")]
+    pub path: Option<std::path::PathBuf>,
+    #[cfg(feature = "std")]
+    pub timestamp: Option<filetime::FileTime>,
+    pub flow_analysis_results: BTreeMap<u64, Box<dyn FlowAnalysisResult>>,
+}
+
+impl Default for Object {
+    fn default() -> Self {
+        Self {
+            arch: ArchDummy::new(),
+            endianness: object::Endianness::Little,
+            symbols: vec![],
+            sections: vec![],
+            split_meta: None,
+            #[cfg(feature = "std")]
+            path: None,
+            #[cfg(feature = "std")]
+            timestamp: None,
+            flow_analysis_results: BTreeMap::<u64, Box<dyn FlowAnalysisResult>>::new(),
+        }
+    }
+}
+
+impl Object {
+    pub fn resolve_instruction_ref(
+        &self,
+        symbol_index: usize,
+        ins_ref: InstructionRef,
+    ) -> Option<ResolvedInstructionRef<'_>> {
+        let symbol = self.symbols.get(symbol_index)?;
+        let section_index = symbol.section?;
+        let section = self.sections.get(section_index)?;
+        let offset = ins_ref.address.checked_sub(section.address)?;
+        let code = section.data.get(offset as usize..offset as usize + ins_ref.size as usize)?;
+        let relocation = section.resolve_relocation_at(self, ins_ref.address, ins_ref.size);
+        Some(ResolvedInstructionRef {
+            ins_ref,
+            symbol_index,
+            symbol,
+            section,
+            section_index,
+            code,
+            relocation,
+        })
+    }
+
+    pub fn symbol_data(&self, symbol_index: usize) -> Option<&[u8]> {
+        let symbol = self.symbols.get(symbol_index)?;
+        let section_index = symbol.section?;
+        let section = self.sections.get(section_index)?;
+        let offset = symbol.address.checked_sub(section.address)?;
+        section.data.get(offset as usize..offset as usize + symbol.size as usize)
+    }
+
+    pub fn symbol_by_name(&self, name: &str) -> Option<usize> {
+        self.symbols.iter().position(|symbol| symbol.section.is_some() && symbol.name == name)
+    }
+
+    pub fn get_flow_analysis_result(&self, symbol: &Symbol) -> Option<&dyn FlowAnalysisResult> {
+        let key = symbol.section.unwrap_or_default() as u64 * 1024 * 1024 * 1024 + symbol.address;
+        self.flow_analysis_results.get(&key).map(|result| result.as_ref())
+    }
+
+    pub fn add_flow_analysis_result(
+        &mut self,
+        symbol: &Symbol,
+        result: Box<dyn FlowAnalysisResult>,
+    ) {
+        let key = symbol.section.unwrap_or_default() as u64 * 1024 * 1024 * 1024 + symbol.address;
+        self.flow_analysis_results.insert(key, result);
+    }
+
+    pub fn has_flow_analysis_result(&self) -> bool { !self.flow_analysis_results.is_empty() }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct Relocation {
+    pub flags: RelocationFlags,
+    pub address: u64,
+    pub target_symbol: usize,
+    pub addend: i64,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum RelocationFlags {
+    Elf(u32),
+    Coff(u16),
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct ResolvedRelocation<'a> {
+    pub relocation: &'a Relocation,
+    pub symbol: &'a Symbol,
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct ResolvedSymbol<'obj> {
+    pub obj: &'obj Object,
+    pub symbol_index: usize,
+    pub symbol: &'obj Symbol,
+    pub section_index: usize,
+    pub section: &'obj Section,
+    pub data: &'obj [u8],
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct ResolvedInstructionRef<'obj> {
+    pub ins_ref: InstructionRef,
+    pub symbol_index: usize,
+    pub symbol: &'obj Symbol,
+    pub section_index: usize,
+    pub section: &'obj Section,
+    pub code: &'obj [u8],
+    pub relocation: Option<ResolvedRelocation<'obj>>,
+}
+
+static DUMMY_SYMBOL: Symbol = Symbol {
+    name: String::new(),
+    demangled_name: None,
+    address: 0,
+    size: 0,
+    kind: SymbolKind::Unknown,
+    section: None,
+    flags: SymbolFlagSet::empty(),
+    align: None,
+    virtual_address: None,
+};
+
+static DUMMY_SECTION: Section = Section {
+    id: String::new(),
+    name: String::new(),
+    address: 0,
+    size: 0,
+    kind: SectionKind::Unknown,
+    data: SectionData(Vec::new()),
+    flags: SectionFlagSet::empty(),
+    align: None,
+    relocations: Vec::new(),
+    line_info: BTreeMap::new(),
+    virtual_address: None,
+};
+
+impl Default for ResolvedInstructionRef<'_> {
+    fn default() -> Self {
+        Self {
+            ins_ref: InstructionRef::default(),
+            symbol_index: 0,
+            symbol: &DUMMY_SYMBOL,
+            section_index: 0,
+            section: &DUMMY_SECTION,
+            code: &[],
+            relocation: None,
+        }
+    }
+}

objdiff-core/src/obj/snapshots/objdiff_core__obj__read__test__combine_sections.snap

@@ -0,0 +1,165 @@
+---
+source: objdiff-core/src/obj/read.rs
+expression: "(sections, symbols)"
+---
+(
+    [
+        Section {
+            id: ".text-0",
+            name: ".text",
+            address: 0,
+            size: 8,
+            kind: Code,
+            data: SectionData(
+                8,
+            ),
+            flags: FlagSet(),
+            align: None,
+            relocations: [
+                Relocation {
+                    flags: Elf(
+                        0,
+                    ),
+                    address: 0,
+                    target_symbol: 0,
+                    addend: 4,
+                },
+                Relocation {
+                    flags: Elf(
+                        0,
+                    ),
+                    address: 2,
+                    target_symbol: 1,
+                    addend: 0,
+                },
+                Relocation {
+                    flags: Elf(
+                        0,
+                    ),
+                    address: 4,
+                    target_symbol: 0,
+                    addend: 10,
+                },
+            ],
+            line_info: {},
+            virtual_address: None,
+        },
+        Section {
+            id: ".data-combined",
+            name: ".data",
+            address: 0,
+            size: 12,
+            kind: Data,
+            data: SectionData(
+                12,
+            ),
+            flags: FlagSet(Combined),
+            align: None,
+            relocations: [
+                Relocation {
+                    flags: Elf(
+                        0,
+                    ),
+                    address: 0,
+                    target_symbol: 2,
+                    addend: 0,
+                },
+                Relocation {
+                    flags: Elf(
+                        0,
+                    ),
+                    address: 4,
+                    target_symbol: 2,
+                    addend: 0,
+                },
+            ],
+            line_info: {
+                0: 1,
+                8: 2,
+            },
+            virtual_address: None,
+        },
+        Section {
+            id: ".data-1",
+            name: ".data",
+            address: 0,
+            size: 0,
+            kind: Unknown,
+            data: SectionData(
+                0,
+            ),
+            flags: FlagSet(),
+            align: None,
+            relocations: [],
+            line_info: {},
+            virtual_address: None,
+        },
+        Section {
+            id: ".data-2",
+            name: ".data",
+            address: 0,
+            size: 0,
+            kind: Unknown,
+            data: SectionData(
+                0,
+            ),
+            flags: FlagSet(),
+            align: None,
+            relocations: [],
+            line_info: {},
+            virtual_address: None,
+        },
+    ],
+    [
+        Symbol {
+            name: ".data",
+            demangled_name: None,
+            address: 0,
+            size: 0,
+            kind: Section,
+            section: Some(
+                1,
+            ),
+            flags: FlagSet(),
+            align: None,
+            virtual_address: None,
+        },
+        Symbol {
+            name: "symbol",
+            demangled_name: None,
+            address: 4,
+            size: 4,
+            kind: Object,
+            section: Some(
+                1,
+            ),
+            flags: FlagSet(),
+            align: None,
+            virtual_address: None,
+        },
+        Symbol {
+            name: "function",
+            demangled_name: None,
+            address: 0,
+            size: 8,
+            kind: Function,
+            section: Some(
+                0,
+            ),
+            flags: FlagSet(),
+            align: None,
+            virtual_address: None,
+        },
+        Symbol {
+            name: ".data",
+            demangled_name: None,
+            address: 0,
+            size: 0,
+            kind: Unknown,
+            section: None,
+            flags: FlagSet(),
+            align: None,
+            virtual_address: None,
+        },
+    ],
+)

objdiff-core/src/obj/split_meta.rs

@@ -0,0 +1,218 @@
+use alloc::{string::String, vec, vec::Vec};
+
+use anyhow::{Result, anyhow};
+use object::{Endian, ObjectSection, elf::SHT_NOTE};
+
+#[cfg(feature = "std")]
+use crate::util::align_data_to_4;
+use crate::util::align_size_to_4;
+
+pub const SPLITMETA_SECTION: &str = ".note.split";
+pub const SHT_SPLITMETA: u32 = SHT_NOTE;
+pub const ELF_NOTE_SPLIT: &[u8] = b"Split";
+
+/// This is used to store metadata about the source of an object file,
+/// such as the original virtual addresses and the tool that wrote it.
+#[derive(Debug, Default, Clone)]
+pub struct SplitMeta {
+    /// The tool that generated the object. Informational only.
+    pub generator: Option<String>,
+    /// The name of the source module. (e.g. the DOL or REL name)
+    pub module_name: Option<String>,
+    /// The ID of the source module. (e.g. the DOL or REL ID)
+    pub module_id: Option<u32>,
+    /// Original virtual addresses of each symbol in the object.
+    /// Index 0 is the ELF null symbol.
+    pub virtual_addresses: Option<Vec<u64>>,
+}
+
+const NT_SPLIT_GENERATOR: u32 = u32::from_be_bytes(*b"GENR");
+const NT_SPLIT_MODULE_NAME: u32 = u32::from_be_bytes(*b"MODN");
+const NT_SPLIT_MODULE_ID: u32 = u32::from_be_bytes(*b"MODI");
+const NT_SPLIT_VIRTUAL_ADDRESSES: u32 = u32::from_be_bytes(*b"VIRT");
+
+impl SplitMeta {
+    pub fn from_section<E>(section: object::Section, e: E, is_64: bool) -> Result<Self>
+    where E: Endian {
+        let mut result = SplitMeta::default();
+        let data = section.uncompressed_data().map_err(object_error)?;
+        let mut iter = NoteIterator::new(data.as_ref(), section.align(), e, is_64)?;
+        while let Some(note) = iter.next(e)? {
+            if note.name != ELF_NOTE_SPLIT {
+                continue;
+            }
+            match note.n_type {
+                NT_SPLIT_GENERATOR => {
+                    let string =
+                        String::from_utf8(note.desc.to_vec()).map_err(anyhow::Error::new)?;
+                    result.generator = Some(string);
+                }
+                NT_SPLIT_MODULE_NAME => {
+                    let string =
+                        String::from_utf8(note.desc.to_vec()).map_err(anyhow::Error::new)?;
+                    result.module_name = Some(string);
+                }
+                NT_SPLIT_MODULE_ID => {
+                    result.module_id = Some(e.read_u32_bytes(
+                        note.desc.try_into().map_err(|_| anyhow!("Invalid module ID size"))?,
+                    ));
+                }
+                NT_SPLIT_VIRTUAL_ADDRESSES => {
+                    let vec = if is_64 {
+                        let mut vec = vec![0u64; note.desc.len() / 8];
+                        for (i, v) in vec.iter_mut().enumerate() {
+                            *v =
+                                e.read_u64_bytes(note.desc[i * 8..(i + 1) * 8].try_into().unwrap());
+                        }
+                        vec
+                    } else {
+                        let mut vec = vec![0u64; note.desc.len() / 4];
+                        for (i, v) in vec.iter_mut().enumerate() {
+                            *v = e.read_u32_bytes(note.desc[i * 4..(i + 1) * 4].try_into().unwrap())
+                                as u64;
+                        }
+                        vec
+                    };
+                    result.virtual_addresses = Some(vec);
+                }
+                _ => {
+                    // Ignore unknown sections
+                }
+            }
+        }
+        Ok(result)
+    }
+
+    #[cfg(feature = "std")]
+    pub fn to_writer<E, W>(&self, writer: &mut W, e: E, is_64: bool) -> std::io::Result<()>
+    where
+        E: Endian,
+        W: std::io::Write + ?Sized,
+    {
+        if let Some(generator) = &self.generator {
+            write_note_header(writer, e, NT_SPLIT_GENERATOR, generator.len())?;
+            writer.write_all(generator.as_bytes())?;
+            align_data_to_4(writer, generator.len())?;
+        }
+        if let Some(module_name) = &self.module_name {
+            write_note_header(writer, e, NT_SPLIT_MODULE_NAME, module_name.len())?;
+            writer.write_all(module_name.as_bytes())?;
+            align_data_to_4(writer, module_name.len())?;
+        }
+        if let Some(module_id) = self.module_id {
+            write_note_header(writer, e, NT_SPLIT_MODULE_ID, 4)?;
+            writer.write_all(&e.write_u32_bytes(module_id))?;
+        }
+        if let Some(virtual_addresses) = &self.virtual_addresses {
+            let count = virtual_addresses.len();
+            let size = if is_64 { count * 8 } else { count * 4 };
+            write_note_header(writer, e, NT_SPLIT_VIRTUAL_ADDRESSES, size)?;
+            if is_64 {
+                for &addr in virtual_addresses {
+                    writer.write_all(&e.write_u64_bytes(addr))?;
+                }
+            } else {
+                for &addr in virtual_addresses {
+                    writer.write_all(&e.write_u32_bytes(addr as u32))?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub fn write_size(&self, is_64: bool) -> usize {
+        let mut size = 0;
+        if let Some(generator) = self.generator.as_deref() {
+            size += NOTE_HEADER_SIZE + generator.len();
+            size = align_size_to_4(size);
+        }
+        if let Some(module_name) = self.module_name.as_deref() {
+            size += NOTE_HEADER_SIZE + module_name.len();
+            size = align_size_to_4(size);
+        }
+        if self.module_id.is_some() {
+            size += NOTE_HEADER_SIZE + 4;
+            size = align_size_to_4(size);
+        }
+        if let Some(virtual_addresses) = self.virtual_addresses.as_deref() {
+            size += NOTE_HEADER_SIZE + if is_64 { 8 } else { 4 } * virtual_addresses.len();
+            size = align_size_to_4(size);
+        }
+        size
+    }
+}
+
+/// Convert an object::read::Error to a String.
+#[inline]
+fn object_error(err: object::read::Error) -> anyhow::Error { anyhow::Error::new(err) }
+
+/// An ELF note entry.
+struct Note<'data> {
+    n_type: u32,
+    name: &'data [u8],
+    desc: &'data [u8],
+}
+
+/// object::read::elf::NoteIterator is awkward to use generically,
+/// so wrap it in our own iterator.
+enum NoteIterator<'data, E>
+where E: Endian
+{
+    B32(object::read::elf::NoteIterator<'data, object::elf::FileHeader32<E>>),
+    B64(object::read::elf::NoteIterator<'data, object::elf::FileHeader64<E>>),
+}
+
+impl<'data, E> NoteIterator<'data, E>
+where E: Endian
+{
+    fn new(data: &'data [u8], align: u64, e: E, is_64: bool) -> Result<Self> {
+        Ok(if is_64 {
+            NoteIterator::B64(
+                object::read::elf::NoteIterator::new(e, align, data).map_err(object_error)?,
+            )
+        } else {
+            NoteIterator::B32(
+                object::read::elf::NoteIterator::new(e, align as u32, data)
+                    .map_err(object_error)?,
+            )
+        })
+    }
+
+    fn next(&mut self, e: E) -> Result<Option<Note<'data>>> {
+        match self {
+            NoteIterator::B32(iter) => Ok(iter.next().map_err(object_error)?.map(|note| Note {
+                n_type: note.n_type(e),
+                name: note.name(),
+                desc: note.desc(),
+            })),
+            NoteIterator::B64(iter) => Ok(iter.next().map_err(object_error)?.map(|note| Note {
+                n_type: note.n_type(e),
+                name: note.name(),
+                desc: note.desc(),
+            })),
+        }
+    }
+}
+
+// ELF note format:
+// Name Size | 4 bytes (integer)
+// Desc Size | 4 bytes (integer)
+// Type | 4 bytes (usually interpreted as an integer)
+// Name | variable size, padded to a 4 byte boundary
+// Desc | variable size, padded to a 4 byte boundary
+const NOTE_HEADER_SIZE: usize = 12 + ((ELF_NOTE_SPLIT.len() + 4) & !3);
+
+#[cfg(feature = "std")]
+fn write_note_header<E, W>(writer: &mut W, e: E, kind: u32, desc_len: usize) -> std::io::Result<()>
+where
+    E: Endian,
+    W: std::io::Write + ?Sized,
+{
+    writer.write_all(&e.write_u32_bytes(ELF_NOTE_SPLIT.len() as u32 + 1))?; // Name Size
+    writer.write_all(&e.write_u32_bytes(desc_len as u32))?; // Desc Size
+    writer.write_all(&e.write_u32_bytes(kind))?; // Type
+    writer.write_all(ELF_NOTE_SPLIT)?; // Name
+    writer.write_all(&[0; 1])?; // Null terminator
+    align_data_to_4(writer, ELF_NOTE_SPLIT.len() + 1)?;
+    Ok(())
+}

objdiff-core/src/util.rs

@@ -0,0 +1,91 @@
+use alloc::{format, vec::Vec};
+use core::fmt;
+
+use anyhow::{Result, ensure};
+use num_traits::PrimInt;
+use object::{Endian, Object};
+
+// https://stackoverflow.com/questions/44711012/how-do-i-format-a-signed-integer-to-a-sign-aware-hexadecimal-representation
+pub struct ReallySigned<N: PrimInt>(pub N);
+
+impl<N: PrimInt> fmt::LowerHex for ReallySigned<N> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let num = self.0.to_i64().unwrap();
+        let prefix = if f.alternate() { "0x" } else { "" };
+        let bare_hex = format!("{:x}", num.abs());
+        f.pad_integral(num >= 0, prefix, &bare_hex)
+    }
+}
+
+impl<N: PrimInt> fmt::UpperHex for ReallySigned<N> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let num = self.0.to_i64().unwrap();
+        let prefix = if f.alternate() { "0x" } else { "" };
+        let bare_hex = format!("{:X}", num.abs());
+        f.pad_integral(num >= 0, prefix, &bare_hex)
+    }
+}
+
+pub fn read_u32(obj_file: &object::File, reader: &mut &[u8]) -> Result<u32> {
+    ensure!(reader.len() >= 4, "Not enough bytes to read u32");
+    let value = u32::from_ne_bytes(reader[..4].try_into()?);
+    *reader = &reader[4..];
+    Ok(obj_file.endianness().read_u32(value))
+}
+
+pub fn read_u16(obj_file: &object::File, reader: &mut &[u8]) -> Result<u16> {
+    ensure!(reader.len() >= 2, "Not enough bytes to read u16");
+    let value = u16::from_ne_bytes(reader[..2].try_into()?);
+    *reader = &reader[2..];
+    Ok(obj_file.endianness().read_u16(value))
+}
+
+pub fn align_size_to_4(size: usize) -> usize { (size + 3) & !3 }
+
+#[cfg(feature = "std")]
+pub fn align_data_to_4<W: std::io::Write + ?Sized>(
+    writer: &mut W,
+    len: usize,
+) -> std::io::Result<()> {
+    const ALIGN_BYTES: &[u8] = &[0; 4];
+    if !len.is_multiple_of(4) {
+        writer.write_all(&ALIGN_BYTES[..4 - len % 4])?;
+    }
+    Ok(())
+}
+
+pub fn align_u64_to(len: u64, align: u64) -> u64 { len + ((align - (len % align)) % align) }
+
+pub fn align_data_slice_to(data: &mut Vec<u8>, align: u64) {
+    data.resize(align_u64_to(data.len() as u64, align) as usize, 0);
+}
+
+// Float where we specifically care about comparing the raw bits rather than
+// caring about IEEE semantics.
+#[derive(Copy, Clone, Debug)]
+pub struct RawFloat(pub f32);
+impl PartialEq for RawFloat {
+    fn eq(&self, other: &Self) -> bool { self.0.to_bits() == other.0.to_bits() }
+}
+impl Eq for RawFloat {}
+impl Ord for RawFloat {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering { self.0.to_bits().cmp(&other.0.to_bits()) }
+}
+impl PartialOrd for RawFloat {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> { Some(self.cmp(other)) }
+}
+
+// Double where we specifically care about comparing the raw bits rather than
+// caring about IEEE semantics.
+#[derive(Copy, Clone, Debug)]
+pub struct RawDouble(pub f64);
+impl PartialEq for RawDouble {
+    fn eq(&self, other: &Self) -> bool { self.0.to_bits() == other.0.to_bits() }
+}
+impl Eq for RawDouble {}
+impl Ord for RawDouble {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering { self.0.to_bits().cmp(&other.0.to_bits()) }
+}
+impl PartialOrd for RawDouble {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> { Some(self.cmp(other)) }
+}

objdiff-core/tests/arch_arm.rs

@@ -0,0 +1,75 @@
+use objdiff_core::{diff, obj};
+
+mod common;
+
+#[test]
+#[cfg(feature = "arm")]
+fn read_arm() {
+    let diff_config = diff::DiffObjConfig { ..Default::default() };
+    let obj = obj::read::parse(
+        include_object!("data/arm/LinkStateItem.o"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    insta::assert_debug_snapshot!(obj);
+    let symbol_idx =
+        obj.symbols.iter().position(|s| s.name == "_ZN13LinkStateItem12OnStateLeaveEi").unwrap();
+    let diff = diff::code::no_diff_code(&obj, symbol_idx, &diff_config).unwrap();
+    insta::assert_debug_snapshot!(diff.instruction_rows);
+    let output = common::display_diff(&obj, &diff, symbol_idx, &diff_config);
+    insta::assert_snapshot!(output);
+}
+
+#[test]
+#[cfg(feature = "arm")]
+fn read_thumb() {
+    let diff_config = diff::DiffObjConfig { ..Default::default() };
+    let obj =
+        obj::read::parse(include_object!("data/arm/thumb.o"), &diff_config, diff::DiffSide::Base)
+            .unwrap();
+    insta::assert_debug_snapshot!(obj);
+    let symbol_idx = obj
+        .symbols
+        .iter()
+        .position(|s| s.name == "THUMB_BRANCH_ServerDisplay_UncategorizedMove")
+        .unwrap();
+    let diff = diff::code::no_diff_code(&obj, symbol_idx, &diff_config).unwrap();
+    insta::assert_debug_snapshot!(diff.instruction_rows);
+    let output = common::display_diff(&obj, &diff, symbol_idx, &diff_config);
+    insta::assert_snapshot!(output);
+}
+
+#[test]
+#[cfg(feature = "arm")]
+fn combine_text_sections() {
+    let diff_config = diff::DiffObjConfig { combine_text_sections: true, ..Default::default() };
+    let obj = obj::read::parse(
+        include_object!("data/arm/enemy300.o"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    let symbol_idx = obj.symbols.iter().position(|s| s.name == "Enemy300Draw").unwrap();
+    let diff = diff::code::no_diff_code(&obj, symbol_idx, &diff_config).unwrap();
+    insta::assert_debug_snapshot!(diff.instruction_rows);
+    let output = common::display_diff(&obj, &diff, symbol_idx, &diff_config);
+    insta::assert_snapshot!(output);
+}
+
+#[test]
+#[cfg(feature = "arm")]
+fn trim_trailing_hword() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj = obj::read::parse(
+        include_object!("data/arm/issue_253.o"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    let symbol_idx = obj.symbols.iter().position(|s| s.name == "sub_8030F20").unwrap();
+    let diff = diff::code::no_diff_code(&obj, symbol_idx, &diff_config).unwrap();
+    insta::assert_debug_snapshot!(diff.instruction_rows);
+    let output = common::display_diff(&obj, &diff, symbol_idx, &diff_config);
+    insta::assert_snapshot!(output);
+}

objdiff-core/tests/arch_mips.rs

@@ -0,0 +1,82 @@
+use objdiff_core::{diff, obj};
+
+mod common;
+
+#[test]
+#[cfg(feature = "mips")]
+fn read_mips() {
+    let diff_config = diff::DiffObjConfig { mips_register_prefix: true, ..Default::default() };
+    let obj =
+        obj::read::parse(include_object!("data/mips/main.c.o"), &diff_config, diff::DiffSide::Base)
+            .unwrap();
+    insta::assert_debug_snapshot!(obj);
+    let symbol_idx = obj.symbols.iter().position(|s| s.name == "ControlEntry").unwrap();
+    let diff = diff::code::no_diff_code(&obj, symbol_idx, &diff_config).unwrap();
+    insta::assert_debug_snapshot!(diff.instruction_rows);
+    let output = common::display_diff(&obj, &diff, symbol_idx, &diff_config);
+    insta::assert_snapshot!(output);
+}
+
+#[test]
+#[cfg(feature = "mips")]
+fn cross_endian_diff() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj_be = obj::read::parse(
+        include_object!("data/mips/code_be.o"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    assert_eq!(obj_be.endianness, object::Endianness::Big);
+    let obj_le = obj::read::parse(
+        include_object!("data/mips/code_le.o"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    assert_eq!(obj_le.endianness, object::Endianness::Little);
+    let left_symbol_idx = obj_be.symbols.iter().position(|s| s.name == "func_00000000").unwrap();
+    let right_symbol_idx =
+        obj_le.symbols.iter().position(|s| s.name == "func_00000000__FPcPc").unwrap();
+    let (left_diff, right_diff) =
+        diff::code::diff_code(&obj_be, &obj_le, left_symbol_idx, right_symbol_idx, &diff_config)
+            .unwrap();
+    // Although the objects differ in endianness, the instructions should match.
+    assert_eq!(left_diff.instruction_rows[0].kind, diff::InstructionDiffKind::None);
+    assert_eq!(right_diff.instruction_rows[0].kind, diff::InstructionDiffKind::None);
+    assert_eq!(left_diff.instruction_rows[1].kind, diff::InstructionDiffKind::None);
+    assert_eq!(right_diff.instruction_rows[1].kind, diff::InstructionDiffKind::None);
+    assert_eq!(left_diff.instruction_rows[2].kind, diff::InstructionDiffKind::None);
+    assert_eq!(right_diff.instruction_rows[2].kind, diff::InstructionDiffKind::None);
+}
+
+#[test]
+#[cfg(feature = "mips")]
+fn filter_non_matching() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj = obj::read::parse(
+        include_object!("data/mips/vw_main.c.o"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    insta::assert_debug_snapshot!(obj.symbols);
+}
+
+#[test]
+#[cfg(feature = "mips")]
+fn ido_mdebug_line_numbers() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj = obj::read::parse(
+        include_object!("data/mips/ido_lines_example.o"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+
+    let text_section = obj.sections.iter().find(|s| s.name == ".text").unwrap();
+    assert_eq!(text_section.line_info.get(&0), Some(&6));
+    assert_eq!(text_section.line_info.get(&12), Some(&7));
+    assert_eq!(text_section.line_info.get(&56), Some(&9));
+    assert_eq!(text_section.line_info.len(), 66);
+}

objdiff-core/tests/arch_ppc.rs

@@ -0,0 +1,124 @@
+use objdiff_core::{
+    diff::{self, display},
+    obj,
+    obj::SectionKind,
+};
+
+mod common;
+
+#[test]
+#[cfg(feature = "ppc")]
+fn read_ppc() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj =
+        obj::read::parse(include_object!("data/ppc/IObj.o"), &diff_config, diff::DiffSide::Base)
+            .unwrap();
+    insta::assert_debug_snapshot!(obj);
+    let symbol_idx =
+        obj.symbols.iter().position(|s| s.name == "Type2Text__10SObjectTagFUi").unwrap();
+    let diff = diff::code::no_diff_code(&obj, symbol_idx, &diff_config).unwrap();
+    insta::assert_debug_snapshot!(diff.instruction_rows);
+    let output = common::display_diff(&obj, &diff, symbol_idx, &diff_config);
+    insta::assert_snapshot!(output);
+}
+
+#[test]
+#[cfg(feature = "ppc")]
+fn read_dwarf1_line_info() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj = obj::read::parse(
+        include_object!("data/ppc/m_Do_hostIO.o"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    let line_infos = obj
+        .sections
+        .iter()
+        .filter(|s| s.kind == SectionKind::Code)
+        .map(|s| s.line_info.clone())
+        .collect::<Vec<_>>();
+    insta::assert_debug_snapshot!(line_infos);
+}
+
+#[test]
+#[cfg(feature = "ppc")]
+fn read_extab() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj = obj::read::parse(
+        include_object!("data/ppc/NMWException.o"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    insta::assert_debug_snapshot!(obj);
+}
+
+#[test]
+#[cfg(feature = "ppc")]
+fn diff_ppc() {
+    let diff_config = diff::DiffObjConfig::default();
+    let mapping_config = diff::MappingConfig::default();
+    let target_obj = obj::read::parse(
+        include_object!("data/ppc/CDamageVulnerability_target.o"),
+        &diff_config,
+        diff::DiffSide::Target,
+    )
+    .unwrap();
+    let base_obj = obj::read::parse(
+        include_object!("data/ppc/CDamageVulnerability_base.o"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    let diff =
+        diff::diff_objs(Some(&target_obj), Some(&base_obj), None, &diff_config, &mapping_config)
+            .unwrap();
+
+    let target_diff = diff.left.as_ref().unwrap();
+    let base_diff = diff.right.as_ref().unwrap();
+    let sections_display = display::display_sections(
+        &target_obj,
+        target_diff,
+        display::SymbolFilter::None,
+        false,
+        false,
+        true,
+    );
+    insta::assert_debug_snapshot!(sections_display);
+
+    let target_symbol_idx = target_obj
+        .symbols
+        .iter()
+        .position(|s| s.name == "WeaponHurts__20CDamageVulnerabilityCFRC11CWeaponModei")
+        .unwrap();
+    let target_symbol_diff = &target_diff.symbols[target_symbol_idx];
+    let base_symbol_idx = base_obj
+        .symbols
+        .iter()
+        .position(|s| s.name == "WeaponHurts__20CDamageVulnerabilityCFRC11CWeaponModei")
+        .unwrap();
+    let base_symbol_diff = &base_diff.symbols[base_symbol_idx];
+    assert_eq!(target_symbol_diff.target_symbol, Some(base_symbol_idx));
+    assert_eq!(base_symbol_diff.target_symbol, Some(target_symbol_idx));
+    insta::assert_debug_snapshot!((target_symbol_diff, base_symbol_diff));
+}
+
+#[test]
+#[cfg(feature = "ppc")]
+fn read_vmx128_coff() {
+    let diff_config = diff::DiffObjConfig { combine_data_sections: true, ..Default::default() };
+    let obj = obj::read::parse(
+        include_object!("data/ppc/vmx128.obj"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    insta::assert_debug_snapshot!(obj);
+    let symbol_idx =
+        obj.symbols.iter().position(|s| s.name == "?FloatingPointExample@@YAXXZ").unwrap();
+    let diff = diff::code::no_diff_code(&obj, symbol_idx, &diff_config).unwrap();
+    insta::assert_debug_snapshot!(diff.instruction_rows);
+    let output = common::display_diff(&obj, &diff, symbol_idx, &diff_config);
+    insta::assert_snapshot!(output);
+}

objdiff-core/tests/arch_x86.rs

@@ -0,0 +1,124 @@
+use objdiff_core::{diff, diff::display::SymbolFilter, obj};
+
+mod common;
+
+#[test]
+#[cfg(feature = "x86")]
+fn read_x86() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj = obj::read::parse(
+        include_object!("data/x86/staticdebug.obj"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    insta::assert_debug_snapshot!(obj);
+    let symbol_idx = obj.symbols.iter().position(|s| s.name == "?PrintThing@@YAXXZ").unwrap();
+    let diff = diff::code::no_diff_code(&obj, symbol_idx, &diff_config).unwrap();
+    insta::assert_debug_snapshot!(diff.instruction_rows);
+    let output = common::display_diff(&obj, &diff, symbol_idx, &diff_config);
+    insta::assert_snapshot!(output);
+}
+
+#[test]
+#[cfg(feature = "x86")]
+fn read_x86_combine_sections() {
+    let diff_config = diff::DiffObjConfig {
+        combine_data_sections: true,
+        combine_text_sections: true,
+        ..Default::default()
+    };
+    let obj =
+        obj::read::parse(include_object!("data/x86/rtest.obj"), &diff_config, diff::DiffSide::Base)
+            .unwrap();
+    insta::assert_debug_snapshot!(obj.sections);
+}
+
+#[test]
+#[cfg(feature = "x86")]
+fn read_x86_64() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj = obj::read::parse(
+        include_object!("data/x86_64/vs2022.o"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    insta::assert_debug_snapshot!(obj);
+    let symbol_idx =
+        obj.symbols.iter().position(|s| s.name == "?Dot@Vector@@QEAAMPEAU1@@Z").unwrap();
+    let diff = diff::code::no_diff_code(&obj, symbol_idx, &diff_config).unwrap();
+    insta::assert_debug_snapshot!(diff.instruction_rows);
+    let output = common::display_diff(&obj, &diff, symbol_idx, &diff_config);
+    insta::assert_snapshot!(output);
+}
+
+#[test]
+#[cfg(feature = "x86")]
+fn display_section_ordering() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj = obj::read::parse(
+        include_object!("data/x86/basenode.obj"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    let obj_diff =
+        diff::diff_objs(Some(&obj), None, None, &diff_config, &diff::MappingConfig::default())
+            .unwrap()
+            .left
+            .unwrap();
+    let section_display =
+        diff::display::display_sections(&obj, &obj_diff, SymbolFilter::None, false, false, false);
+    insta::assert_debug_snapshot!(section_display);
+}
+
+#[test]
+#[cfg(feature = "x86")]
+fn read_x86_jumptable() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj = obj::read::parse(
+        include_object!("data/x86/jumptable.o"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    insta::assert_debug_snapshot!(obj);
+    let symbol_idx = obj.symbols.iter().position(|s| s.name == "?test@@YAHH@Z").unwrap();
+    let diff = diff::code::no_diff_code(&obj, symbol_idx, &diff_config).unwrap();
+    insta::assert_debug_snapshot!(diff.instruction_rows);
+    let output = common::display_diff(&obj, &diff, symbol_idx, &diff_config);
+    insta::assert_snapshot!(output);
+}
+
+// Inferred size of functions should ignore symbols with specific prefixes
+#[test]
+#[cfg(feature = "x86")]
+fn read_x86_local_labels() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj = obj::read::parse(
+        include_object!("data/x86/local_labels.obj"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    insta::assert_debug_snapshot!(obj);
+}
+
+#[test]
+#[cfg(feature = "x86")]
+fn read_x86_indirect_table() {
+    let diff_config = diff::DiffObjConfig::default();
+    let obj = obj::read::parse(
+        include_object!("data/x86/indirect_table.obj"),
+        &diff_config,
+        diff::DiffSide::Base,
+    )
+    .unwrap();
+    insta::assert_debug_snapshot!(obj);
+    let symbol_idx = obj.symbols.iter().position(|s| s.name == "?process@@YAHHHH@Z").unwrap();
+    let diff = diff::code::no_diff_code(&obj, symbol_idx, &diff_config).unwrap();
+    insta::assert_debug_snapshot!(diff.instruction_rows);
+    let output = common::display_diff(&obj, &diff, symbol_idx, &diff_config);
+    insta::assert_snapshot!(output);
+}

objdiff-core/tests/common.rs

@@ -0,0 +1,52 @@
+use objdiff_core::{
+    diff::{DiffObjConfig, SymbolDiff, display::DiffTextSegment},
+    obj::Object,
+};
+
+pub fn display_diff(
+    obj: &Object,
+    diff: &SymbolDiff,
+    symbol_idx: usize,
+    diff_config: &DiffObjConfig,
+) -> String {
+    let mut output = String::new();
+    for row in &diff.instruction_rows {
+        output.push('[');
+        let mut separator = false;
+        objdiff_core::diff::display::display_row(obj, symbol_idx, row, diff_config, |segment| {
+            if separator {
+                output.push_str(", ");
+            } else {
+                separator = true;
+            }
+            let DiffTextSegment { text, color, pad_to } = segment;
+            output.push_str(&format!("({text:?}, {color:?}, {pad_to:?})"));
+            Ok(())
+        })
+        .unwrap();
+        output.push_str("]\n");
+    }
+    output
+}
+
+#[repr(C)]
+pub struct AlignedAs<Align, Bytes: ?Sized> {
+    pub _align: [Align; 0],
+    pub bytes: Bytes,
+}
+
+#[macro_export]
+macro_rules! include_bytes_align_as {
+    ($align_ty:ty, $path:literal) => {{
+        static ALIGNED: &common::AlignedAs<$align_ty, [u8]> =
+            &common::AlignedAs { _align: [], bytes: *include_bytes!($path) };
+        &ALIGNED.bytes
+    }};
+}
+
+#[macro_export]
+macro_rules! include_object {
+    ($path:literal) => {
+        include_bytes_align_as!(u64, $path)
+    };
+}

objdiff-core/tests/snapshots/arch_arm__combine_text_sections-2.snap

@@ -0,0 +1,7 @@
+---
+source: objdiff-core/tests/arch_arm.rs
+expression: output
+---
+[(Line(90), Dim, 5), (Address(0), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r12")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(8), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Line(90), Dim, 5), (Address(4), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bx", 32777), Normal, 10), (Argument(Opaque("r12")), Normal, 0), (Eol, Normal, 0)]
+[(Line(90), Dim, 5), (Address(8), Dim, 5), (Spacing(4), Normal, 0), (Opcode(".word", 65534), Normal, 10), (Symbol(Symbol { name: "esEnemyDraw", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: None }), Bright, 0), (Eol, Normal, 0)]

objdiff-core/tests/snapshots/arch_arm__combine_text_sections.snap

@@ -0,0 +1,48 @@
+---
+source: objdiff-core/tests/arch_arm.rs
+expression: diff.instruction_rows
+---
+[
+    InstructionDiffRow {
+        ins_ref: Some(
+            InstructionRef {
+                address: 76,
+                size: 4,
+                opcode: 32792,
+                branch_dest: None,
+            },
+        ),
+        kind: None,
+        branch_from: None,
+        branch_to: None,
+        arg_diff: [],
+    },
+    InstructionDiffRow {
+        ins_ref: Some(
+            InstructionRef {
+                address: 80,
+                size: 4,
+                opcode: 32777,
+                branch_dest: None,
+            },
+        ),
+        kind: None,
+        branch_from: None,
+        branch_to: None,
+        arg_diff: [],
+    },
+    InstructionDiffRow {
+        ins_ref: Some(
+            InstructionRef {
+                address: 84,
+                size: 4,
+                opcode: 65534,
+                branch_dest: None,
+            },
+        ),
+        kind: None,
+        branch_from: None,
+        branch_to: None,
+        arg_diff: [],
+    },
+]

objdiff-core/tests/snapshots/arch_arm__read_arm-3.snap

@@ -0,0 +1,112 @@
+---
+source: objdiff-core/tests/arch_arm.rs
+expression: output
+---
+[(Address(0), Dim, 5), (Spacing(4), Normal, 0), (Opcode("stmdb", 32883), Normal, 10), (Argument(Opaque("sp")), Normal, 0), (Basic("!"), Normal, 0), (Basic(", "), Normal, 0), (Basic("{"), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r6")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("lr")), Normal, 0), (Basic("}"), Normal, 0), (Eol, Normal, 0)]
+[(Address(4), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Eol, Normal, 0)]
+[(Address(8), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r1")), Normal, 0), (Eol, Normal, 0)]
+[(Address(12), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN13LinkStateBase12OnStateLeaveEi", demangled_name: Some("LinkStateBase::OnStateLeave(int)"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(16), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(20)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(20), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 32784), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(10)), Normal, 0), (Eol, Normal, 0)]
+[(Address(24), Dim, 5), (Spacing(4), Normal, 0), (Opcode("addls", 32769), Normal, 10), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("lsl")), Normal, 0), (Spacing(1), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(2)), Normal, 0), (Eol, Normal, 0)]
+[(Address(28), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Address(32), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Address(36), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Address(40), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Address(44), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(192), Normal, 0), (Basic(" ~>"), Rotating(1), 0), (Eol, Normal, 0)]
+[(Address(48), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(124), Normal, 0), (Basic(" ~>"), Rotating(2), 0), (Eol, Normal, 0)]
+[(Address(52), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Address(56), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(140), Normal, 0), (Basic(" ~>"), Rotating(3), 0), (Eol, Normal, 0)]
+[(Address(60), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(76), Normal, 0), (Basic(" ~>"), Rotating(4), 0), (Eol, Normal, 0)]
+[(Address(64), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(152), Normal, 0), (Basic(" ~>"), Rotating(5), 0), (Eol, Normal, 0)]
+[(Address(68), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(164), Normal, 0), (Basic(" ~>"), Rotating(6), 0), (Eol, Normal, 0)]
+[(Address(72), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(164), Normal, 0), (Basic(" ~>"), Rotating(6), 0), (Eol, Normal, 0)]
+[(Address(76), Dim, 5), (Basic(" ~> "), Rotating(4), 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(336)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(420), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Address(80), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(84), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN18UnkStruct_027e103c19func_ov000_020cf01cEv", demangled_name: Some("UnkStruct_027e103c::func_ov000_020cf01c()"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(88), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldrb", 32793), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(224)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(92), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 32784), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(0)), Normal, 0), (Eol, Normal, 0)]
+[(Address(96), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bne", 32772), Normal, 10), (BranchDest(108), Normal, 0), (Basic(" ~>"), Rotating(7), 0), (Eol, Normal, 0)]
+[(Address(100), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (BranchDest(424), Normal, 0), (Basic(" ~>"), Rotating(8), 0), (Eol, Normal, 0)]
+[(Address(104), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN12EquipBombchu19func_ov014_0213ec64Ev", demangled_name: Some("EquipBombchu::func_ov014_0213ec64()"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(108), Dim, 5), (Basic(" ~> "), Rotating(7), 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(308)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(424), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Address(112), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(116), Dim, 5), (Spacing(4), Normal, 0), (Opcode("blx", 32776), Normal, 10), (Symbol(Symbol { name: "_Z19func_ov014_0211fd04Pi", demangled_name: Some("func_ov014_0211fd04(int*)"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(120), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Address(124), Dim, 5), (Basic(" ~> "), Rotating(2), 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)]
+[(Address(128), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Eol, Normal, 0)]
+[(Address(132), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN13LinkStateItem13StopUsingBombEi", demangled_name: Some("LinkStateItem::StopUsingBomb(int)"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(136), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Address(140), Dim, 5), (Basic(" ~> "), Rotating(3), 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)]
+[(Address(144), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN13LinkStateItem13StopUsingRopeEv", demangled_name: Some("LinkStateItem::StopUsingRope()"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(148), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Address(152), Dim, 5), (Basic(" ~> "), Rotating(5), 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)]
+[(Address(156), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN13LinkStateItem15StopUsingHammerEv", demangled_name: Some("LinkStateItem::StopUsingHammer()"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(160), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Address(164), Dim, 5), (Basic(" ~> "), Rotating(6), 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(248)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(420), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Address(168), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(0)), Normal, 0), (Eol, Normal, 0)]
+[(Address(172), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(176), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r2")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r1")), Normal, 0), (Eol, Normal, 0)]
+[(Address(180), Dim, 5), (Spacing(4), Normal, 0), (Opcode("strb", 32885), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(42)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(184), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN18UnkStruct_027e103c19func_ov000_020cf9dcEii", demangled_name: Some("UnkStruct_027e103c::func_ov000_020cf9dc(int, int)"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(188), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Address(192), Dim, 5), (Basic(" ~> "), Rotating(1), 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)]
+[(Address(196), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN13LinkStateItem14StopUsingScoopEv", demangled_name: Some("LinkStateItem::StopUsingScoop()"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(200), Dim, 5), (Basic(" ~> "), Rotating(0), 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(20)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(204), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mvn", 32819), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(0)), Normal, 0), (Eol, Normal, 0)]
+[(Address(208), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 32784), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Eol, Normal, 0)]
+[(Address(212), Dim, 5), (Spacing(4), Normal, 0), (Opcode("beq", 32772), Normal, 10), (BranchDest(236), Normal, 0), (Basic(" ~>"), Rotating(9), 0), (Eol, Normal, 0)]
+[(Address(216), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)]
+[(Address(220), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN13LinkStateBase12GetEquipItemEi", demangled_name: Some("LinkStateBase::GetEquipItem(int)"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(224), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(228), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(28)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(232), Dim, 5), (Spacing(4), Normal, 0), (Opcode("blx", 32776), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Eol, Normal, 0)]
+[(Address(236), Dim, 5), (Basic(" ~> "), Rotating(9), 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(20)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(240), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 32784), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(9)), Normal, 0), (Eol, Normal, 0)]
+[(Address(244), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bgt", 32772), Normal, 10), (BranchDest(288), Normal, 0), (Basic(" ~>"), Rotating(10), 0), (Eol, Normal, 0)]
+[(Address(248), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bge", 32772), Normal, 10), (BranchDest(296), Normal, 0), (Basic(" ~>"), Rotating(11), 0), (Eol, Normal, 0)]
+[(Address(252), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 32784), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(1)), Normal, 0), (Eol, Normal, 0)]
+[(Address(256), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bgt", 32772), Normal, 10), (BranchDest(308), Normal, 0), (Basic(" ~>"), Rotating(12), 0), (Eol, Normal, 0)]
+[(Address(260), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mvn", 32819), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(0)), Normal, 0), (Eol, Normal, 0)]
+[(Address(264), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 32784), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Eol, Normal, 0)]
+[(Address(268), Dim, 5), (Spacing(4), Normal, 0), (Opcode("blt", 32772), Normal, 10), (BranchDest(308), Normal, 0), (Basic(" ~>"), Rotating(12), 0), (Eol, Normal, 0)]
+[(Address(272), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmpne", 32784), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(0)), Normal, 0), (Eol, Normal, 0)]
+[(Address(276), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmpne", 32784), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(1)), Normal, 0), (Eol, Normal, 0)]
+[(Address(280), Dim, 5), (Spacing(4), Normal, 0), (Opcode("beq", 32772), Normal, 10), (BranchDest(340), Normal, 0), (Basic(" ~>"), Rotating(13), 0), (Eol, Normal, 0)]
+[(Address(284), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(308), Normal, 0), (Basic(" ~>"), Rotating(12), 0), (Eol, Normal, 0)]
+[(Address(288), Dim, 5), (Basic(" ~> "), Rotating(10), 0), (Opcode("cmp", 32784), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(10)), Normal, 0), (Eol, Normal, 0)]
+[(Address(292), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bne", 32772), Normal, 10), (BranchDest(308), Normal, 0), (Basic(" ~>"), Rotating(12), 0), (Eol, Normal, 0)]
+[(Address(296), Dim, 5), (Basic(" ~> "), Rotating(11), 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)]
+[(Address(300), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN13LinkStateBase18EquipItem_vfunc_28Ev", demangled_name: Some("LinkStateBase::EquipItem_vfunc_28()"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(304), Dim, 5), (Spacing(4), Normal, 0), (Opcode("b", 32772), Normal, 10), (BranchDest(340), Normal, 0), (Basic(" ~>"), Rotating(13), 0), (Eol, Normal, 0)]
+[(Address(308), Dim, 5), (Basic(" ~> "), Rotating(12), 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)]
+[(Address(312), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN13LinkStateBase18EquipItem_vfunc_28Ev", demangled_name: Some("LinkStateBase::EquipItem_vfunc_28()"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(316), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 32784), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(4)), Normal, 0), (Eol, Normal, 0)]
+[(Address(320), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmpne", 32784), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(2)), Normal, 0), (Eol, Normal, 0)]
+[(Address(324), Dim, 5), (Spacing(4), Normal, 0), (Opcode("beq", 32772), Normal, 10), (BranchDest(340), Normal, 0), (Basic(" ~>"), Rotating(13), 0), (Eol, Normal, 0)]
+[(Address(328), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN13LinkStateItem16GetLinkStateMoveEv", demangled_name: Some("LinkStateItem::GetLinkStateMove()"), address: 488, size: 16, kind: Function, section: Some(0), flags: FlagSet(Global), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(332), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(1)), Normal, 0), (Eol, Normal, 0)]
+[(Address(336), Dim, 5), (Spacing(4), Normal, 0), (Opcode("strb", 32885), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(20)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(340), Dim, 5), (Basic(" ~> "), Rotating(13), 0), (Opcode("mvn", 32819), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(0)), Normal, 0), (Eol, Normal, 0)]
+[(Address(344), Dim, 5), (Spacing(4), Normal, 0), (Opcode("add", 32769), Normal, 10), (Argument(Opaque("r6")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(80)), Normal, 0), (Eol, Normal, 0)]
+[(Address(348), Dim, 5), (Spacing(4), Normal, 0), (Opcode("add", 32769), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(88)), Normal, 0), (Eol, Normal, 0)]
+[(Address(352), Dim, 5), (Spacing(4), Normal, 0), (Opcode("str", 32884), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(24)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(356), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 32784), Normal, 10), (Argument(Opaque("r6")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Eol, Normal, 0)]
+[(Address(360), Dim, 5), (Spacing(4), Normal, 0), (Opcode("beq", 32772), Normal, 10), (BranchDest(384), Normal, 0), (Basic(" ~>"), Rotating(14), 0), (Eol, Normal, 0)]
+[(Address(364), Dim, 5), (Basic(" ~> "), Rotating(15), 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r6")), Normal, 0), (Eol, Normal, 0)]
+[(Address(368), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_Z19func_ov000_020b7e6cPi", demangled_name: Some("func_ov000_020b7e6c(int*)"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(372), Dim, 5), (Spacing(4), Normal, 0), (Opcode("add", 32769), Normal, 10), (Argument(Opaque("r6")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r6")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(4)), Normal, 0), (Eol, Normal, 0)]
+[(Address(376), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 32784), Normal, 10), (Argument(Opaque("r6")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Eol, Normal, 0)]
+[(Address(380), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bne", 32772), Normal, 10), (BranchDest(364), Normal, 0), (Basic(" ~>"), Rotating(15), 0), (Eol, Normal, 0)]
+[(Address(384), Dim, 5), (Basic(" ~> "), Rotating(14), 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(36)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(428), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Address(388), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 32792), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(392), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldrb", 32793), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(128)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(396), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 32784), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(0)), Normal, 0), (Eol, Normal, 0)]
+[(Address(400), Dim, 5), (Spacing(4), Normal, 0), (Opcode("beq", 32772), Normal, 10), (BranchDest(408), Normal, 0), (Basic(" ~>"), Rotating(16), 0), (Eol, Normal, 0)]
+[(Address(404), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 32775), Normal, 10), (Symbol(Symbol { name: "_ZN13PlayerControl13StopFollowingEv", demangled_name: Some("PlayerControl::StopFollowing()"), address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Addend(-8), Bright, 0), (Eol, Normal, 0)]
+[(Address(408), Dim, 5), (Basic(" ~> "), Rotating(16), 0), (Opcode("mov", 32811), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(0)), Normal, 0), (Eol, Normal, 0)]
+[(Address(412), Dim, 5), (Spacing(4), Normal, 0), (Opcode("strb", 32885), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(38)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Address(416), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldmia", 32791), Normal, 10), (Argument(Opaque("sp")), Normal, 0), (Basic("!"), Normal, 0), (Basic(", "), Normal, 0), (Basic("{"), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r6")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic("}"), Normal, 0), (Eol, Normal, 0)]
+[(Address(420), Dim, 5), (Spacing(4), Normal, 0), (Opcode(".word", 65534), Normal, 10), (Symbol(Symbol { name: "data_027e103c", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Eol, Normal, 0)]
+[(Address(424), Dim, 5), (Basic(" ~> "), Rotating(8), 0), (Opcode(".word", 65534), Normal, 10), (Symbol(Symbol { name: "data_027e1098", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Eol, Normal, 0)]
+[(Address(428), Dim, 5), (Spacing(4), Normal, 0), (Opcode(".word", 65534), Normal, 10), (Symbol(Symbol { name: "gPlayerControl", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global | Weak), align: None, virtual_address: None }), Bright, 0), (Eol, Normal, 0)]

objdiff-core/tests/snapshots/arch_arm__read_thumb-3.snap

@@ -0,0 +1,110 @@
+---
+source: objdiff-core/tests/arch_arm.rs
+expression: output
+---
+[(Line(37), Dim, 5), (Address(0), Dim, 5), (Spacing(4), Normal, 0), (Opcode("push", 59), Normal, 10), (Basic("{"), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r6")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r7")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("lr")), Normal, 0), (Basic("}"), Normal, 0), (Eol, Normal, 0)]
+[(Line(37), Dim, 5), (Address(2), Dim, 5), (Spacing(4), Normal, 0), (Opcode("sub", 126), Normal, 10), (Argument(Opaque("sp")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(16)), Normal, 0), (Eol, Normal, 0)]
+[(Line(37), Dim, 5), (Address(4), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Eol, Normal, 0)]
+[(Line(39), Dim, 5), (Address(6), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Eol, Normal, 0)]
+[(Line(39), Dim, 5), (Address(8), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r1")), Normal, 0), (Eol, Normal, 0)]
+[(Line(39), Dim, 5), (Address(10), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r6")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r2")), Normal, 0), (Eol, Normal, 0)]
+[(Line(39), Dim, 5), (Address(12), Dim, 5), (Spacing(4), Normal, 0), (Opcode("str", 116), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("sp")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(4)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(39), Dim, 5), (Address(14), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 7), Normal, 10), (Symbol(Symbol { name: "PokeSet_IsRemovedAll", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: None }), Bright, 0), (Addend(-4), Bright, 0), (Eol, Normal, 0)]
+[(Line(39), Dim, 5), (Address(18), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 16), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(0)), Normal, 0), (Eol, Normal, 0)]
+[(Line(39), Dim, 5), (Address(20), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bne", 4), Normal, 10), (BranchDest(212), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Line(44), Dim, 5), (Address(22), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldrh", 32), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(44), Dim, 5), (Address(24), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 16), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(164)), Normal, 0), (Eol, Normal, 0)]
+[(Line(44), Dim, 5), (Address(26), Dim, 5), (Spacing(4), Normal, 0), (Opcode("beq", 4), Normal, 10), (BranchDest(48), Normal, 0), (Basic(" ~>"), Rotating(1), 0), (Eol, Normal, 0)]
+[(Line(44), Dim, 5), (Address(28), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(184)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(216), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Line(44), Dim, 5), (Address(30), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 16), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Eol, Normal, 0)]
+[(Line(44), Dim, 5), (Address(32), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bne", 4), Normal, 10), (BranchDest(94), Normal, 0), (Basic(" ~>"), Rotating(2), 0), (Eol, Normal, 0)]
+[(Line(47), Dim, 5), (Address(34), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r2")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("sp")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(4)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(47), Dim, 5), (Address(36), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)]
+[(Line(47), Dim, 5), (Address(38), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r6")), Normal, 0), (Eol, Normal, 0)]
+[(Line(47), Dim, 5), (Address(40), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 7), Normal, 10), (Symbol(Symbol { name: "ServerDisplay_SkillSwap", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: None }), Bright, 0), (Addend(-4), Bright, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(44), Dim, 5), (Spacing(4), Normal, 0), (Opcode("add", 1), Normal, 10), (Argument(Opaque("sp")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(16)), Normal, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(46), Dim, 5), (Spacing(4), Normal, 0), (Opcode("pop", 58), Normal, 10), (Basic("{"), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r6")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r7")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic("}"), Normal, 0), (Eol, Normal, 0)]
+[(Line(50), Dim, 5), (Address(48), Dim, 5), (Basic(" ~> "), Rotating(1), 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)]
+[(Line(50), Dim, 5), (Address(50), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r6")), Normal, 0), (Eol, Normal, 0)]
+[(Line(50), Dim, 5), (Address(52), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 7), Normal, 10), (Symbol(Symbol { name: "ServerEvent_CreateSubstitute", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: None }), Bright, 0), (Addend(-4), Bright, 0), (Eol, Normal, 0)]
+[(Line(50), Dim, 5), (Address(56), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 16), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(0)), Normal, 0), (Eol, Normal, 0)]
+[(Line(50), Dim, 5), (Address(58), Dim, 5), (Spacing(4), Normal, 0), (Opcode("beq", 4), Normal, 10), (BranchDest(212), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(60), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(156)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(220), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(62), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(64), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldrb", 25), Normal, 10), (Argument(Opaque("r2")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(5)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(66), Dim, 5), (Spacing(4), Normal, 0), (Opcode("lsl", 36), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r2")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(31)), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(68), Dim, 5), (Spacing(4), Normal, 0), (Opcode("lsr", 37), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(31)), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(70), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bne", 4), Normal, 10), (BranchDest(212), Normal, 0), (Basic(" ~>"), Rotating(0), 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(72), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(1)), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(74), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bic", 5), Normal, 10), (Argument(Opaque("r2")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r1")), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(76), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(1)), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(78), Dim, 5), (Spacing(4), Normal, 0), (Opcode("orr", 54), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r2")), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(80), Dim, 5), (Spacing(4), Normal, 0), (Opcode("strb", 117), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(5)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(82), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldrb", 25), Normal, 10), (Argument(Opaque("r2")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(5)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(84), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(2)), Normal, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(86), Dim, 5), (Spacing(4), Normal, 0), (Opcode("add", 1), Normal, 10), (Argument(Opaque("sp")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(16)), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(88), Dim, 5), (Spacing(4), Normal, 0), (Opcode("orr", 54), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r2")), Normal, 0), (Eol, Normal, 0)]
+[(Line(52), Dim, 5), (Address(90), Dim, 5), (Spacing(4), Normal, 0), (Opcode("strb", 117), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(5)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(92), Dim, 5), (Spacing(4), Normal, 0), (Opcode("pop", 58), Normal, 10), (Basic("{"), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r6")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r7")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic("}"), Normal, 0), (Eol, Normal, 0)]
+[(Line(57), Dim, 5), (Address(94), Dim, 5), (Basic(" ~> "), Rotating(2), 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(128)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(224), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Line(57), Dim, 5), (Address(96), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(128)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(228), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Line(57), Dim, 5), (Address(98), Dim, 5), (Spacing(4), Normal, 0), (Opcode("add", 1), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Eol, Normal, 0)]
+[(Line(57), Dim, 5), (Address(100), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 7), Normal, 10), (Symbol(Symbol { name: "HEManager_PushState", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: None }), Bright, 0), (Addend(-4), Bright, 0), (Eol, Normal, 0)]
+[(Line(57), Dim, 5), (Address(104), Dim, 5), (Spacing(4), Normal, 0), (Opcode("str", 116), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("sp")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(8)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(61), Dim, 5), (Address(106), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)]
+[(Line(61), Dim, 5), (Address(108), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 7), Normal, 10), (Symbol(Symbol { name: "BattleHandler_Result", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: None }), Bright, 0), (Addend(-4), Bright, 0), (Eol, Normal, 0)]
+[(Line(61), Dim, 5), (Address(112), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r7")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Eol, Normal, 0)]
+[(Line(63), Dim, 5), (Address(114), Dim, 5), (Spacing(4), Normal, 0), (Opcode("add", 1), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("sp")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(12)), Normal, 0), (Eol, Normal, 0)]
+[(Line(63), Dim, 5), (Address(116), Dim, 5), (Spacing(4), Normal, 0), (Opcode("str", 116), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("sp")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(63), Dim, 5), (Address(118), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("sp")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(4)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(63), Dim, 5), (Address(120), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)]
+[(Line(63), Dim, 5), (Address(122), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Eol, Normal, 0)]
+[(Line(63), Dim, 5), (Address(124), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r2")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r6")), Normal, 0), (Eol, Normal, 0)]
+[(Line(63), Dim, 5), (Address(126), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 7), Normal, 10), (Symbol(Symbol { name: "ServerEvent_UncategorizedMove", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: None }), Bright, 0), (Addend(-4), Bright, 0), (Eol, Normal, 0)]
+[(Line(63), Dim, 5), (Address(130), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 16), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(0)), Normal, 0), (Eol, Normal, 0)]
+[(Line(63), Dim, 5), (Address(132), Dim, 5), (Spacing(4), Normal, 0), (Opcode("beq", 4), Normal, 10), (BranchDest(168), Normal, 0), (Basic(" ~>"), Rotating(3), 0), (Eol, Normal, 0)]
+[(Line(65), Dim, 5), (Address(134), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)]
+[(Line(65), Dim, 5), (Address(136), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 7), Normal, 10), (Symbol(Symbol { name: "BattleHandler_Result", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: None }), Bright, 0), (Addend(-4), Bright, 0), (Eol, Normal, 0)]
+[(Line(65), Dim, 5), (Address(140), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r7")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Eol, Normal, 0)]
+[(Line(66), Dim, 5), (Address(142), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 16), Normal, 10), (Argument(Opaque("r7")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(2)), Normal, 0), (Eol, Normal, 0)]
+[(Line(66), Dim, 5), (Address(144), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bne", 4), Normal, 10), (BranchDest(168), Normal, 0), (Basic(" ~>"), Rotating(3), 0), (Eol, Normal, 0)]
+[(Line(68), Dim, 5), (Address(146), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(72)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(220), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Line(68), Dim, 5), (Address(148), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(68), Dim, 5), (Address(150), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldrb", 25), Normal, 10), (Argument(Opaque("r2")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(5)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(68), Dim, 5), (Address(152), Dim, 5), (Spacing(4), Normal, 0), (Opcode("lsl", 36), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r2")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(31)), Normal, 0), (Eol, Normal, 0)]
+[(Line(68), Dim, 5), (Address(154), Dim, 5), (Spacing(4), Normal, 0), (Opcode("lsr", 37), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(31)), Normal, 0), (Eol, Normal, 0)]
+[(Line(68), Dim, 5), (Address(156), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bne", 4), Normal, 10), (BranchDest(168), Normal, 0), (Basic(" ~>"), Rotating(3), 0), (Eol, Normal, 0)]
+[(Line(68), Dim, 5), (Address(158), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(1)), Normal, 0), (Eol, Normal, 0)]
+[(Line(68), Dim, 5), (Address(160), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bic", 5), Normal, 10), (Argument(Opaque("r2")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r1")), Normal, 0), (Eol, Normal, 0)]
+[(Line(68), Dim, 5), (Address(162), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(1)), Normal, 0), (Eol, Normal, 0)]
+[(Line(68), Dim, 5), (Address(164), Dim, 5), (Spacing(4), Normal, 0), (Opcode("orr", 54), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r2")), Normal, 0), (Eol, Normal, 0)]
+[(Line(68), Dim, 5), (Address(166), Dim, 5), (Spacing(4), Normal, 0), (Opcode("strb", 117), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(5)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(72), Dim, 5), (Address(168), Dim, 5), (Basic(" ~> "), Rotating(3), 0), (Opcode("cmp", 16), Normal, 10), (Argument(Opaque("r7")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(1)), Normal, 0), (Eol, Normal, 0)]
+[(Line(72), Dim, 5), (Address(170), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bhi", 4), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(4), 0), (Eol, Normal, 0)]
+[(Line(75), Dim, 5), (Address(172), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("sp")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(12)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(75), Dim, 5), (Address(174), Dim, 5), (Spacing(4), Normal, 0), (Opcode("cmp", 16), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(0)), Normal, 0), (Eol, Normal, 0)]
+[(Line(75), Dim, 5), (Address(176), Dim, 5), (Spacing(4), Normal, 0), (Opcode("beq", 4), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(4), 0), (Eol, Normal, 0)]
+[(Line(75), Dim, 5), (Address(178), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(52)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(232), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Line(75), Dim, 5), (Address(180), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldrb", 25), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(75), Dim, 5), (Address(182), Dim, 5), (Spacing(4), Normal, 0), (Opcode("lsl", 36), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(27)), Normal, 0), (Eol, Normal, 0)]
+[(Line(75), Dim, 5), (Address(184), Dim, 5), (Spacing(4), Normal, 0), (Opcode("lsr", 37), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(31)), Normal, 0), (Eol, Normal, 0)]
+[(Line(75), Dim, 5), (Address(186), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bne", 4), Normal, 10), (BranchDest(200), Normal, 0), (Basic(" ~>"), Rotating(4), 0), (Eol, Normal, 0)]
+[(Line(77), Dim, 5), (Address(188), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(12)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(77), Dim, 5), (Address(190), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(44)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(236), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Line(77), Dim, 5), (Address(192), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(90)), Normal, 0), (Eol, Normal, 0)]
+[(Line(77), Dim, 5), (Address(194), Dim, 5), (Spacing(4), Normal, 0), (Opcode("mov", 43), Normal, 10), (Argument(Opaque("r2")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(71)), Normal, 0), (Eol, Normal, 0)]
+[(Line(77), Dim, 5), (Address(196), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 7), Normal, 10), (Symbol(Symbol { name: "SCQUE_PUT_MsgImpl", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: None }), Bright, 0), (Addend(-4), Bright, 0), (Eol, Normal, 0)]
+[(Line(81), Dim, 5), (Address(200), Dim, 5), (Basic(" ~> "), Rotating(4), 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(20)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(224), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Line(81), Dim, 5), (Address(202), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r1")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("sp")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(8)), Normal, 0), (Basic("]"), Normal, 0), (Eol, Normal, 0)]
+[(Line(81), Dim, 5), (Address(204), Dim, 5), (Spacing(4), Normal, 0), (Opcode("ldr", 24), Normal, 10), (Argument(Opaque("r2")), Normal, 0), (Basic(", "), Normal, 0), (Basic("["), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Signed(32)), Normal, 0), (Basic("]"), Normal, 0), (Basic(" (->"), Normal, 0), (BranchDest(240), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
+[(Line(81), Dim, 5), (Address(206), Dim, 5), (Spacing(4), Normal, 0), (Opcode("add", 1), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Eol, Normal, 0)]
+[(Line(81), Dim, 5), (Address(208), Dim, 5), (Spacing(4), Normal, 0), (Opcode("bl", 7), Normal, 10), (Symbol(Symbol { name: "HEManager_PopState", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: None }), Bright, 0), (Addend(-4), Bright, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(212), Dim, 5), (Basic(" ~> "), Rotating(0), 0), (Opcode("add", 1), Normal, 10), (Argument(Opaque("sp")), Normal, 0), (Basic(", "), Normal, 0), (Basic("#"), Normal, 0), (Argument(Unsigned(16)), Normal, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(214), Dim, 5), (Spacing(4), Normal, 0), (Opcode("pop", 58), Normal, 10), (Basic("{"), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r6")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r7")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("pc")), Normal, 0), (Basic("}"), Normal, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(216), Dim, 5), (Spacing(4), Normal, 0), (Opcode(".word", 65534), Normal, 10), (Argument(Unsigned(285)), Normal, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(220), Dim, 5), (Spacing(4), Normal, 0), (Opcode(".word", 65534), Normal, 10), (Argument(Unsigned(1192)), Normal, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(224), Dim, 5), (Spacing(4), Normal, 0), (Opcode(".word", 65534), Normal, 10), (Argument(Unsigned(7544)), Normal, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(228), Dim, 5), (Spacing(4), Normal, 0), (Opcode(".word", 65534), Normal, 10), (Argument(Unsigned(9103)), Normal, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(232), Dim, 5), (Spacing(4), Normal, 0), (Opcode(".word", 65534), Normal, 10), (Argument(Unsigned(1930)), Normal, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(236), Dim, 5), (Spacing(4), Normal, 0), (Opcode(".word", 65534), Normal, 10), (Argument(Unsigned(4294901760)), Normal, 0), (Eol, Normal, 0)]
+[(Line(86), Dim, 5), (Address(240), Dim, 5), (Spacing(4), Normal, 0), (Opcode(".word", 65534), Normal, 10), (Argument(Unsigned(9129)), Normal, 0), (Eol, Normal, 0)]