Reorder tooltip/context items slightly

* Show data literal values on instruction hover

Reimplements #108

* Show reloc diffs in func view when data's content differs

Reimplements #153

* Data diff view: Show relocs on hover and in context menu

This reimplements #154

Note that colorizing the text depending on the kind of diff has still not been reimplemented yet

* Fix up some comments

.cargo/config.toml

@@ -0,0 +1,5 @@
+[target.x86_64-pc-windows-msvc]
+linker = "rust-lld"
+
+[target.aarch64-pc-windows-msvc]
+linker = "rust-lld"

.github/workflows/build.yaml

@@ -9,8 +9,8 @@ on:
   workflow_dispatch:
 
 env:
-  CARGO_BIN_NAME: objdiff
-  CARGO_TARGET_DIR: target
+  BUILD_PROFILE: release-lto
+  CARGO_INCREMENTAL: 0
 
 jobs:
   check:
@@ -20,17 +20,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 --features all
       - name: Cargo clippy
-        run: cargo clippy --all-features
+        run: cargo clippy --features all
+
+  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 +63,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 +78,233 @@ 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 --features all
 
-  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 cargo-zigbuild
+        if: matrix.build == 'zigbuild'
+        run: |
+          python3 -m venv .venv
+          . .venv/bin/activate
+          echo PATH=$PATH >> $GITHUB_ENV
+          pip install ziglang==0.13.0.post1 cargo-zigbuild==0.19.8
+      - 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 cargo-zigbuild
+        if: matrix.build == 'zigbuild'
+        run: |
+          python3 -m venv .venv
+          . .venv/bin/activate
+          echo PATH=$PATH >> $GITHUB_ENV
+          pip install ziglang==0.13.0.post1 cargo-zigbuild==0.19.8
       - 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
 
+  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: Install dependencies
+        run: npm -C objdiff-wasm install
+      - name: Build
+        run: npm -C objdiff-wasm run build
+
   release:
     name: Release
     if: startsWith(github.ref, 'refs/tags/')
     runs-on: ubuntu-latest
-    needs: [ build ]
+    needs: [ build-cli, build-gui ]
+    permissions:
+      contents: write
     steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Check git tag against Cargo version
+        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
       - name: Download artifacts
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           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

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

Cargo.toml

@@ -1,67 +1,22 @@
-[package]
-name = "objdiff"
-version = "0.2.3"
-edition = "2021"
-rust-version = "1.62"
+[workspace]
+members = [
+    "objdiff-cli",
+    "objdiff-core",
+    "objdiff-gui",
+    "objdiff-wasm",
+]
+resolver = "2"
+
+[profile.release-lto]
+inherits = "release"
+lto = "fat"
+strip = "debuginfo"
+codegen-units = 1
+
+[workspace.package]
+version = "3.0.0-alpha.3"
 authors = ["Luke Street <luke@street.dev>"]
+edition = "2021"
 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
-
-[profile.release]
-lto = "thin"
-strip = "debuginfo"
-
-[dependencies]
-anyhow = "1.0.66"
-bytes = "1.3.0"
-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 }
-png = "0.17.7"
-ppc750cl = { git = "https://github.com/encounter/ppc750cl", rev = "aa631a33de7882c679afca89350898b87cb3ba3f" }
-rabbitizer = { git = "https://github.com/encounter/rabbitizer-rs", rev = "10c279b2ef251c62885b1dcdcfe740b0db8e9956" }
-reqwest = "0.11.13"
-rfd = { version = "0.10.0" } # , default-features = false, features = ['xdg-portal']
-self_update = "0.32.0"
-serde = { version = "1", features = ["derive"] }
-tempfile = "3.3.0"
-thiserror = "1.0.37"
-time = { version = "0.3.17", features = ["formatting", "local-offset"] }
-toml = "0.5.9"
-twox-hash = "1.6.3"
-
-[target.'cfg(windows)'.dependencies]
-path-slash = "0.2.1"
-winapi = "0.3.9"
-
-[target.'cfg(windows)'.build-dependencies]
-winres = "0.1.12"
-
-[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 }
+rust-version = "1.82"

README.md

@@ -3,26 +3,186 @@
 [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 symbol demangling for C++. (CodeWarrior, Itanium & MSVC)
+- Automatic rebuild on source file changes.
+- Project integration via [configuration file](#configuration).
+- Search and filter all of a project's objects and quickly switch.
+- Click to highlight all instances of values and registers.
+
+Supports:
+
+- PowerPC 750CL (GameCube, Wii)
+- MIPS (N64, PS1, PS2, PSP)
+- x86 (COFF only at the moment)
+- ARM (GBA, DS, 3DS)
+- ARM64 (Switch, experimental)
+
+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 can be found 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 works by comparing two relocatable object files (`.o`). The objects are expected to have the same relative path
+from the "target" and "base" directories.
+
+For example, if the target ("expected") object is located at `build/asm/MetroTRK/mslsupp.o` and the base ("actual")
+object is located at `build/src/MetroTRK/mslsupp.o`, the following configuration would be used:
+
+- Target build directory: `build/asm`
+- Base build directory: `build/src`
+- Object: `MetroTRK/mslsupp.o`
+
+objdiff will then execute the build system from the project directory to build both objects:
+
+```sh
+$ make build/asm/MetroTRK/mslsupp.o # Only if "Build target object" is enabled
+$ make build/src/MetroTRK/mslsupp.o
+```
+
+The objects will then be compared and the results will be displayed in the UI.
+
+See [Configuration](#configuration) for more information.
+
+## Configuration
+
+While **not required** (most settings can be specified in the UI), 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 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",
+    "*.cp",
+    "*.cpp",
+    "*.cxx",
+    "*.h",
+    "*.hp",
+    "*.hpp",
+    "*.hxx",
+    "*.s",
+    "*.S",
+    "*.asm",
+    "*.inc",
+    "*.py",
+    "*.yml",
+    "*.txt",
+    "*.json"
+  ],
+  "units": [
+    {
+      "name": "main/MetroTRK/mslsupp",
+      "target_path": "build/asm/MetroTRK/mslsupp.o",
+      "base_path": "build/src/MetroTRK/mslsupp.o",
+      "metadata": {}
+    }
+  ]
+}
+```
+
+### Schema
+
+View [config.schema.json](config.schema.json) for all available options. The below list is a summary of the most important options.
+
+`custom_make` _(optional)_: By default, objdiff will use `make` to build the project.  
+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`: If true, objdiff will tell the build system to build the target objects before diffing (e.g.
+  `make path/to/target.o`).  
+This is useful if the target objects are not built by default or can change based on project configuration or edits
+to assembly files.  
+Requires the build system to be configured properly.
+
+`build_base`: If true, objdiff will tell the build system to build the base objects before diffing (e.g. `make path/to/base.o`).  
+It's unlikely you'll want to disable this, unless you're using an external tool to rebuild the base object on source file changes.
+
+`watch_patterns` _(optional)_: A list of glob patterns to watch for changes.
+([Supported syntax](https://docs.rs/globset/latest/globset/#syntax))  
+If any of these files change, objdiff will automatically rebuild the objects and re-compare them.  
+If not specified, objdiff will use the default patterns listed above.
+
+`units` _(optional)_: If specified, objdiff will display a list of objects in the sidebar for easy navigation.
+
+> `name` _(optional)_: The name of the object in the UI. If not specified, the object's `path` will be used.
+> 
+> `target_path`: Path to the "target" or "expected" object from the project root.  
+> This object is the **intended result** of the match.
+> 
+> `base_path`: Path to the "base" or "actual" object from the project root.  
+> This object is built from the **current source code**.
+> 
+> `metadata.auto_generated` _(optional)_: Hides the object from the object list, but still includes it in reports.
+> 
+> `metadata.complete` _(optional)_: Marks the object as "complete" (or "linked") in the object list.  
+> This is useful for marking objects that are fully decompiled. A value of `false` will mark the object as "incomplete".
+
+## Building
+
+Install Rust via [rustup](https://rustup.rs).
+
+```shell
+$ git clone https://github.com/encounter/objdiff.git
+$ cd objdiff
+$ cargo run --release
+```
+
+Or using `cargo install`.
+
+```shell
+$ cargo install --locked --git https://github.com/encounter/objdiff.git objdiff-gui objdiff-cli
+```
+
+The binaries will be installed to `~/.cargo/bin` as `objdiff` and `objdiff-cli`.
+
+## 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,10 +0,0 @@
-use anyhow::Result;
-use vergen::{vergen, Config};
-
-fn main() -> Result<()> {
-    #[cfg(windows)]
-    {
-        winres::WindowsResource::new().set_icon("assets/icon.ico").compile()?;
-    }
-    vergen(Config::default())
-}

config.schema.json

@@ -0,0 +1,228 @@
+{
+  "$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": "By default, objdiff will use make to build the project.\nIf 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 tell the build system to build the target objects before diffing (e.g. `make path/to/target.o`).\nThis is useful if the target objects are not built by default or can change based on project configuration or edits to assembly files.\nRequires the build system to be configured properly.",
+      "default": false
+    },
+    "build_base": {
+      "type": "boolean",
+      "description": "If true, objdiff will tell the build system to build the base objects before diffing (e.g. `make path/to/base.o`).\nIt's unlikely you'll want to disable this, unless you're using an external tool to rebuild the base object on source file changes.",
+      "default": true
+    },
+    "watch_patterns": {
+      "type": "array",
+      "description": "List of glob patterns to watch for changes in the project.\nIf any of these files change, objdiff will automatically rebuild the objects and re-compare them.\nSupported syntax: https://docs.rs/globset/latest/globset/#syntax",
+      "items": {
+        "type": "string"
+      },
+      "default": [
+        "*.c",
+        "*.cp",
+        "*.cpp",
+        "*.cxx",
+        "*.h",
+        "*.hp",
+        "*.hpp",
+        "*.hxx",
+        "*.s",
+        "*.S",
+        "*.asm",
+        "*.inc",
+        "*.py",
+        "*.yml",
+        "*.txt",
+        "*.json"
+      ]
+    },
+    "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"
+      }
+    }
+  },
+  "$defs": {
+    "unit": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "The name of the object in the UI. If not specified, the object's path will be used."
+        },
+        "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 object from the project root.\nRequired if path is not specified."
+        },
+        "base_path": {
+          "type": "string",
+          "description": "Path to the base object from the project root.\nRequired if path is not specified."
+        },
+        "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"
+          }
+        }
+      }
+    },
+    "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
+        }
+      },
+      "required": [
+        "platform",
+        "compiler"
+      ]
+    },
+    "metadata": {
+      "type": "object",
+      "properties": {
+        "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\"."
+        },
+        "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 object list by default, but still includes it in 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,84 @@
 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" },
 ]
-# 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",
 ]
-# 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 +113,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 +152,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 +161,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 +237,14 @@ 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 = [
+    "CelestialAmber", # cwextab, rlwinmdec
+    "Decompollaborate", # rabbitizer
+    "enarx", # flagset
+    "encounter",
+]
+# 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.28"
+enable-ansi-support = "0.2"
+memmap2 = "0.9"
+objdiff-core = { path = "../objdiff-core", features = ["all"] }
+prost = "0.13"
+ratatui = "0.29"
+rayon = "1.10"
+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.10"
+
+[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::{parser::ParseGlobalOptions, EarlyExit, FromArgs, TopLevelCommand};
+
+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,470 @@
+use std::{
+    io::stdout,
+    mem,
+    str::FromStr,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    task::{Wake, Waker},
+    time::Duration,
+};
+
+use anyhow::{anyhow, bail, Context, Result};
+use argp::FromArgs;
+use crossterm::{
+    event,
+    event::{DisableMouseCapture, EnableMouseCapture},
+    terminal::{
+        disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen, SetTitle,
+    },
+};
+use objdiff_core::{
+    bindings::diff::DiffResult,
+    build::{
+        watcher::{create_watcher, Watcher},
+        BuildConfig,
+    },
+    config::{
+        build_globset,
+        path::{check_path_buf, platform_path, platform_path_serde_option},
+        ProjectConfig, ProjectObject, ProjectObjectMetadata,
+    },
+    diff::{
+        self, ConfigEnum, ConfigPropertyId, ConfigPropertyKind, DiffObjConfig, MappingConfig,
+        ObjectDiff,
+    },
+    jobs::{
+        objdiff::{start_build, ObjDiffConfig},
+        Job, JobQueue, JobResult,
+    },
+    obj::{self, Object},
+};
+use ratatui::prelude::*;
+use typed_path::{Utf8PlatformPath, Utf8PlatformPathBuf};
+
+use crate::{
+    util::{
+        output::{write_output, OutputFormat},
+        term::crossterm_panic_handler,
+    },
+    views::{function_diff::FunctionDiffUi, EventControlFlow, EventResult, UiView},
+};
+
+#[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(option, short = 'o', from_str_fn(platform_path))]
+    /// Output file (one-shot mode) ("-" for stdout)
+    output: Option<Utf8PlatformPathBuf>,
+    #[argp(option)]
+    /// Output format (json, json-pretty, proto) (default: json)
+    format: Option<String>,
+    #[argp(positional)]
+    /// Function symbol to diff
+    symbol: Option<String>,
+    #[argp(option, short = 'c')]
+    /// Configuration property (key=value)
+    config: Vec<String>,
+    #[argp(option, short = 'm')]
+    /// Symbol mapping (target=base)
+    mapping: Vec<String>,
+    #[argp(option)]
+    /// Left symbol name for selection
+    selecting_left: Option<String>,
+    #[argp(option)]
+    /// Right symbol name for selection
+    selecting_right: Option<String>,
+}
+
+pub fn run(args: Args) -> Result<()> {
+    let (target_path, base_path, project_config) =
+        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, 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 objects = project_config
+                    .units
+                    .iter()
+                    .flatten()
+                    .map(|o| {
+                        ObjectConfig::new(
+                            o,
+                            &project,
+                            target_obj_dir.as_deref(),
+                            base_obj_dir.as_deref(),
+                        )
+                    })
+                    .collect::<Vec<_>>();
+                let object = if let Some(u) = u {
+                    objects
+                        .iter()
+                        .find(|obj| obj.name == *u)
+                        .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) 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);
+                            count += 1;
+                            if count > 1 {
+                                break;
+                            }
+                        }
+                    }
+                    match (count, idx) {
+                        (0, None) => bail!("Symbol not found: {}", symbol_name),
+                        (1, Some(i)) => &objects[i],
+                        (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 target_path = object.target_path.clone();
+                let base_path = object.base_path.clone();
+                (target_path, base_path, Some(project_config))
+            }
+            _ => bail!("Either target and base or project and unit must be specified"),
+        };
+
+    if let Some(output) = &args.output {
+        run_oneshot(&args, output, target_path.as_deref(), base_path.as_deref())
+    } else {
+        run_interactive(args, target_path, base_path, project_config)
+    }
+}
+
+fn build_config_from_args(args: &Args) -> Result<(DiffObjConfig, MappingConfig)> {
+    let mut diff_config = DiffObjConfig::default();
+    for config in &args.config {
+        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)
+        })?;
+    }
+    let mut mapping_config = MappingConfig {
+        mappings: Default::default(),
+        selecting_left: args.selecting_left.clone(),
+        selecting_right: args.selecting_right.clone(),
+    };
+    for mapping in &args.mapping {
+        let (target, base) =
+            mapping.split_once('=').context("--mapping expects \"target=base\"")?;
+        mapping_config.mappings.insert(target.to_string(), base.to_string());
+    }
+    Ok((diff_config, mapping_config))
+}
+
+fn run_oneshot(
+    args: &Args,
+    output: &Utf8PlatformPath,
+    target_path: Option<&Utf8PlatformPath>,
+    base_path: Option<&Utf8PlatformPath>,
+) -> Result<()> {
+    let output_format = OutputFormat::from_option(args.format.as_deref())?;
+    let (diff_config, mapping_config) = build_config_from_args(args)?;
+    let target = target_path
+        .map(|p| {
+            obj::read::read(p.as_ref(), &diff_config).with_context(|| format!("Loading {}", p))
+        })
+        .transpose()?;
+    let base = base_path
+        .map(|p| {
+            obj::read::read(p.as_ref(), &diff_config).with_context(|| format!("Loading {}", p))
+        })
+        .transpose()?;
+    let result =
+        diff::diff_objs(target.as_ref(), base.as_ref(), None, &diff_config, &mapping_config)?;
+    let left = target.as_ref().and_then(|o| result.left.as_ref().map(|d| (o, d)));
+    let right = base.as_ref().and_then(|o| result.right.as_ref().map(|d| (o, d)));
+    write_output(&DiffResult::new(left, right), Some(output), output_format)?;
+    Ok(())
+}
+
+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_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_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>,
+) -> 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)?;
+    let mut state = AppState {
+        jobs: Default::default(),
+        waker: Default::default(),
+        project_dir: args.project.clone(),
+        project_config,
+        target_path,
+        base_path,
+        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()?;
+        state.watcher = Some(create_watcher(
+            state.modified.clone(),
+            project_dir.as_ref(),
+            build_globset(&watch_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!("{} - objdiff", symbol_name)),
+    )?;
+    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,2 @@
+pub mod diff;
+pub mod report;

objdiff-cli/src/cmd/report.rs

@@ -0,0 +1,423 @@
+use std::{collections::HashSet, fs::File, io::Read, time::Instant};
+
+use anyhow::{bail, Context, Result};
+use argp::FromArgs;
+use objdiff_core::{
+    bindings::report::{
+        ChangeItem, ChangeItemInfo, ChangeUnit, Changes, ChangesInput, Measures, Report,
+        ReportCategory, ReportItem, ReportItemMetadata, ReportUnit, ReportUnitMetadata,
+        REPORT_VERSION,
+    },
+    config::path::platform_path,
+    diff, obj,
+    obj::{SectionKind, SymbolFlag},
+};
+use prost::Message;
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+use tracing::{info, warn};
+use typed_path::{Utf8PlatformPath, Utf8PlatformPathBuf};
+
+use crate::{
+    cmd::diff::ObjectConfig,
+    util::output::{write_output, OutputFormat},
+};
+
+#[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>,
+}
+
+#[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 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"),
+    };
+    info!(
+        "Generating report for {} units (using {} threads)",
+        project.units().len(),
+        if args.deduplicate { 1 } else { rayon::current_num_threads() }
+    );
+
+    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 objects = project
+        .units
+        .iter()
+        .flatten()
+        .map(|o| {
+            ObjectConfig::new(o, project_dir, target_obj_dir.as_deref(), base_obj_dir.as_deref())
+        })
+        .collect::<Vec<_>>();
+
+    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 in &objects {
+            if let Some(unit) = report_object(object, Some(&mut existing_functions))? {
+                units.push(unit);
+            }
+        }
+    } else {
+        let vec = objects
+            .par_iter()
+            .map(|object| report_object(object, 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 report_object(
+    object: &ObjectConfig,
+    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 diff_config = diff::DiffObjConfig {
+        function_reloc_diffs: diff::FunctionRelocDiffs::None,
+        ..Default::default()
+    };
+    let mapping_config = diff::MappingConfig::default();
+    let target = object
+        .target_path
+        .as_ref()
+        .map(|p| {
+            obj::read::read(p.as_ref(), &diff_config)
+                .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)
+                .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)
+    {
+        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,
+            }),
+        });
+
+        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)
+            {
+                continue;
+            }
+            if let Some(existing_functions) = &mut existing_functions {
+                if (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,
+                }),
+            });
+            if match_percent == 100.0 {
+                measures.matched_functions += 1;
+            }
+            measures.total_functions += 1;
+        }
+    }
+    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::{filter::LevelFilter, EnvFilter};
+
+#[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::{bail, Context, Result};
+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::{disable_raw_mode, LeaveAlternateScreen},
+};
+
+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);
+    }));
+}