Version 1.0.0

Ignores differences in relocation targets. (Address, name, etc)

Resolves #34

.github/workflows/build.yaml

@@ -9,6 +9,7 @@ on:
   workflow_dispatch:
 
 env:
+  BUILD_PROFILE: release-lto
   CARGO_BIN_NAME: objdiff
   CARGO_TARGET_DIR: target
 
@@ -28,11 +29,27 @@ jobs:
       - name: Setup Rust toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
-          components: rustfmt, clippy
+          components: clippy
       - name: Cargo check
-        run: cargo check --all-features
+        run: cargo check
       - name: Cargo clippy
-        run: cargo clippy --all-features
+        run: cargo clippy
+
+  fmt:
+    name: Format
+    runs-on: ubuntu-latest
+    env:
+      RUSTFLAGS: -D warnings
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - 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
@@ -52,6 +69,7 @@ jobs:
 
   test:
     name: Test
+    if: 'false' # No tests yet
     strategy:
       matrix:
         platform: [ ubuntu-latest, windows-latest, macos-latest ]
@@ -68,7 +86,7 @@ jobs:
       - name: Setup Rust toolchain
         uses: dtolnay/rust-toolchain@stable
       - name: Cargo test
-        run: cargo test --release --all-features
+        run: cargo test --release
 
   build:
     name: Build
@@ -79,15 +97,19 @@ jobs:
             target: x86_64-unknown-linux-gnu
             name: linux-x86_64
             packages: libgtk-3-dev
+            features: default
           - platform: windows-latest
             target: x86_64-pc-windows-msvc
             name: windows-x86_64
+            features: default
           - platform: macos-latest
             target: x86_64-apple-darwin
             name: macos-x86_64
+            features: default
           - platform: macos-latest
             target: aarch64-apple-darwin
             name: macos-arm64
+            features: default
       fail-fast: false
     runs-on: ${{ matrix.platform }}
     steps:
@@ -103,16 +125,16 @@ jobs:
         with:
           targets: ${{ matrix.target }}
       - name: Cargo build
-        run: cargo build --release --all-features --target ${{ matrix.target }} --bin ${{ env.CARGO_BIN_NAME }}
+        run: cargo build --profile ${{ env.BUILD_PROFILE }} --target ${{ matrix.target }} --bin ${{ env.CARGO_BIN_NAME }} --features ${{ matrix.features }}
       - name: Upload artifacts
         uses: actions/upload-artifact@v3
         with:
           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
+            ${{ env.CARGO_TARGET_DIR }}/${{ env.BUILD_PROFILE }}/${{ env.CARGO_BIN_NAME }}
+            ${{ env.CARGO_TARGET_DIR }}/${{ env.BUILD_PROFILE }}/${{ env.CARGO_BIN_NAME }}.exe
+            ${{ env.CARGO_TARGET_DIR }}/${{ matrix.target }}/${{ env.BUILD_PROFILE }}/${{ env.CARGO_BIN_NAME }}
+            ${{ env.CARGO_TARGET_DIR }}/${{ matrix.target }}/${{ env.BUILD_PROFILE }}/${{ env.CARGO_BIN_NAME }}.exe
           if-no-files-found: error
 
   release:
@@ -129,8 +151,8 @@ jobs:
         working-directory: artifacts
         run: |
           mkdir ../out
-          for i in */*/release/$CARGO_BIN_NAME*; do
-            mv "$i" "../out/$(sed -E "s/([^/]+)\/[^/]+\/release\/($CARGO_BIN_NAME)/\2-\1/" <<< "$i")"
+          for i in */*/$BUILD_PROFILE/$CARGO_BIN_NAME*; do
+            mv "$i" "../out/$(sed -E "s/([^/]+)\/[^/]+\/$BUILD_PROFILE\/($CARGO_BIN_NAME)/\2-\1/" <<< "$i")"
           done
           ls -R ../out
       - name: Release

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "objdiff"
-version = "0.4.0"
+version = "1.0.0"
 edition = "2021"
-rust-version = "1.65"
+rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/encounter/objdiff"
@@ -13,53 +13,64 @@ A local diffing tool for decompilation projects.
 publish = false
 build = "build.rs"
 
-[profile.release]
+[profile.release-lto]
+inherits = "release"
 lto = "thin"
 strip = "debuginfo"
 
 [features]
-default = []
+default = ["wgpu", "wsl"]
 wgpu = ["eframe/wgpu"]
+wsl = []
 
 [dependencies]
-anyhow = "1.0.71"
-byteorder = "1.4.3"
-bytes = "1.4.0"
+anyhow = "1.0.79"
+byteorder = "1.5.0"
+bytes = "1.5.0"
 cfg-if = "1.0.0"
-const_format = "0.2.31"
-cwdemangle = "0.1.5"
+const_format = "0.2.32"
+cwdemangle = "0.1.6"
 dirs = "5.0.1"
-eframe = { version = "0.22.0", features = ["persistence"] }
-egui = "0.22.0"
-egui_extras = "0.22.0"
-flagset = "0.4.3"
-globset = { version = "0.4.13", features = ["serde1"] }
-log = "0.4.19"
-memmap2 = "0.7.1"
-notify = "6.0.1"
-object = { version = "0.31.1", features = ["read_core", "std", "elf"], default-features = false }
-png = "0.17.9"
-ppc750cl = { git = "https://github.com/terorie/ppc750cl", rev = "9ae36eef34aa6d74e00972c7671f547a2acfd0aa" }
-rabbitizer = "1.7.4"
-rfd = { version = "0.11.4" } #, default-features = false, features = ['xdg-portal']
+eframe = { version = "0.25.0", features = ["persistence"] }
+egui = "0.25.0"
+egui_extras = "0.25.0"
+filetime = "0.2.23"
+flagset = "0.4.4"
+float-ord = "0.3.2"
+font-kit = "0.12.0"
+gimli = { version = "0.28.1", default-features = false, features = ["read-all"] }
+globset = { version = "0.4.14", features = ["serde1"] }
+log = "0.4.20"
+memmap2 = "0.9.3"
+notify = "6.1.1"
+object = { version = "0.32.2", features = ["read_core", "std", "elf"], default-features = false }
+png = "0.17.11"
+pollster = "0.3.0"
+ppc750cl = { git = "https://github.com/encounter/ppc750cl", rev = "4a2bbbc6f84dcb76255ab6f3595a8d4a0ce96618" }
+rabbitizer = "1.8.1"
+rfd = { version = "0.13.0" } #, default-features = false, features = ['xdg-portal']
+ron = "0.8.1"
+semver = "1.0.21"
 serde = { version = "1", features = ["derive"] }
-serde_json = "1.0.104"
-serde_yaml = "0.9.25"
-tempfile = "3.6.0"
-thiserror = "1.0.41"
-time = { version = "0.3.22", features = ["formatting", "local-offset"] }
-toml = "0.7.6"
+serde_json = "1.0.111"
+serde_yaml = "0.9.30"
+shell-escape = "0.1.5"
+similar = "2.4.0"
+tempfile = "3.9.0"
+thiserror = "1.0.56"
+time = { version = "0.3.31", features = ["formatting", "local-offset"] }
+toml = "0.8.8"
 twox-hash = "1.6.3"
 
 # For Linux static binaries, use rustls
 [target.'cfg(target_os = "linux")'.dependencies]
-reqwest = { version = "0.11.18", default-features = false, features = ["blocking", "json", "rustls"] }
-self_update = { version = "0.37.0", default-features = false, features = ["rustls"] }
+reqwest = { version = "0.11.23", default-features = false, features = ["blocking", "json", "multipart", "rustls"] }
+self_update = { version = "0.39.0", default-features = false, features = ["rustls"] }
 
 # For all other platforms, use native TLS
 [target.'cfg(not(target_os = "linux"))'.dependencies]
-reqwest = "0.11.18"
-self_update = "0.37.0"
+reqwest = { version = "0.11.23", default-features = false, features = ["blocking", "json", "multipart", "default-tls"] }
+self_update = "0.39.0"
 
 [target.'cfg(windows)'.dependencies]
 path-slash = "0.2.1"
@@ -81,5 +92,5 @@ console_error_panic_hook = "0.1.7"
 tracing-wasm = "0.2"
 
 [build-dependencies]
-anyhow = "1.0.71"
-vergen = { version = "8.2.4", features = ["build", "cargo", "git", "gitcl"] }
+anyhow = "1.0.79"
+vergen = { version = "8.3.1", features = ["build", "cargo", "git", "gitcl"] }

README.md

@@ -3,7 +3,15 @@
 [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).
+
+Features:
+- Compare entire object files: functions and data.
+- Built-in symbol demangling for C++.
+- 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)
@@ -16,10 +24,11 @@ See [Usage](#usage) for more information.
 
 ## 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.
+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:
+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`
@@ -38,14 +47,22 @@ See [Configuration](#configuration) for more information.
 
 ## Configuration
 
-While **not required** (most settings can be specified in the UI), projects can add an `objdiff.json` (or `objdiff.yaml`, `objdiff.yml`) file to configure the tool automatically. The configuration file must be located in the root project directory.
+While **not required** (most settings can be specified in the UI), projects can add an `objdiff.json` (or
+`objdiff.yaml`, `objdiff.yml`) 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.
 
 ```json5
 // objdiff.json
 {
   "custom_make": "ninja",
-  "target_dir": "build/mp1.0/asm",
-  "base_dir": "build/mp1.0/src",
+
+  // Only required if objects use "path" instead of "target_path" and "base_path".
+  "target_dir": "build/asm",
+  "base_dir": "build/src",
+
   "build_target": true,
   "watch_patterns": [
     "*.c",
@@ -57,8 +74,15 @@ While **not required** (most settings can be specified in the UI), projects can
   ],
   "objects": [
     {
+      "name": "main/MetroTRK/mslsupp",
+
+      // Option 1: Relative to target_dir and base_dir
       "path": "MetroTRK/mslsupp.o",
-      "name": "MetroTRK/mslsupp",
+      // Option 2: Explicit paths from project root
+      // Useful for more complex directory layouts
+      "target_path": "build/asm/MetroTRK/mslsupp.o",
+      "base_path": "build/src/MetroTRK/mslsupp.o",
+      
       "reverse_fn_order": false
     },
     // ...
@@ -66,24 +90,53 @@ While **not required** (most settings can be specified in the UI), projects can
 }
 ```
 
-- `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.
-- `target_dir`: Relative from the root of the project, this where the "target" or "expected" objects are located.  
-  These are the **intended result** of the match.
-- `base_dir`: Relative from the root of the project, this is where the "base" or "actual" objects are located.  
-  These are objects built from the **current source code**.
-- `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.
-- `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.
-- `objects` _(optional)_: If specified, objdiff will display a list of objects in the sidebar for easy navigation.
-  - `path`: Relative path to the object from the `target_dir` and `base_dir`.
-  - `name` _(optional)_: The name of the object in the UI. If not specified, the object's `path` will be used.  
-  - `reverse_fn_order` _(optional)_: Displays function symbols in reversed order.  
-    Used to support MWCC's `-inline deferred` option, which reverses the order of functions in the object file.
+`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.
 
+`target_dir` _(optional)_: Relative from the root of the project, this where the "target" or "expected" objects are located.  
+These are the **intended result** of the match.
 
+`base_dir` _(optional)_: Relative from the root of the project, this is where the "base" or "actual" objects are located.  
+These are objects built from the **current source code**.
+
+`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.
+
+`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.
+
+`objects` _(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.
+> 
+> `path`: Relative path to the object from the `target_dir` and `base_dir`.  
+> Requires `target_dir` and `base_dir` to be specified.
+> 
+> `target_path`: Path to the target object from the project root.  
+> Required if `path` is not specified.
+> 
+> `base_path`: Path to the base object from the project root.  
+> Required if `path` is not specified.
+> 
+> `reverse_fn_order` _(optional)_: Displays function symbols in reversed order.  
+Used to support MWCC's `-inline deferred` option, which reverses the order of functions in the object file.
+
+## Building
+
+Install Rust via [rustup](https://rustup.rs).
+
+```shell
+$ git clone https://github.com/encounter/objdiff.git
+$ cd objdiff
+$ cargo run --release
+# or, for wgpu backend (recommended on macOS)
+$ cargo run --release --features wgpu
+```
 
 ## License
 
@@ -96,6 +149,5 @@ 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.

deny.toml

@@ -47,13 +47,7 @@ yanked = "warn"
 notice = "warn"
 # A list of advisory IDs to ignore. Note that ignored advisories will still
 # output a note when they are encountered.
-ignore = [
-    "RUSTSEC-2023-0022",
-    "RUSTSEC-2023-0023",
-    "RUSTSEC-2023-0024",
-    "RUSTSEC-2023-0034",
-    "RUSTSEC-2023-0044",
-]
+ignore = []
 # 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.
@@ -76,6 +70,7 @@ unlicensed = "deny"
 allow = [
     "MIT",
     "Apache-2.0",
+    "Apache-2.0 WITH LLVM-exception",
     "ISC",
     "BSD-2-Clause",
     "BSD-3-Clause",
@@ -159,7 +154,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

src/app.rs

@@ -1,28 +1,37 @@
 use std::{
     default::Default,
+    fs,
     path::{Path, PathBuf},
     rc::Rc,
     sync::{
         atomic::{AtomicBool, Ordering},
         Arc, Mutex, RwLock,
     },
-    time::Duration,
 };
 
-use globset::{Glob, GlobSet, GlobSetBuilder};
+use filetime::FileTime;
+use globset::{Glob, GlobSet};
 use notify::{RecursiveMode, Watcher};
 use time::UtcOffset;
 
 use crate::{
-    config::{
-        build_globset, load_project_config, ProjectObject, ProjectObjectNode, CONFIG_FILENAMES,
+    app_config::{deserialize_config, AppConfigVersion},
+    config::{build_globset, load_project_config, ProjectObject, ProjectObjectNode, ScratchConfig},
+    diff::DiffAlg,
+    jobs::{
+        objdiff::{start_build, ObjDiffConfig},
+        Job, JobQueue, JobResult, JobStatus,
     },
-    jobs::{objdiff::start_build, Job, JobQueue, JobResult, JobStatus},
     views::{
         appearance::{appearance_window, Appearance},
-        config::{config_ui, project_window, ConfigViewState},
+        config::{
+            config_ui, diff_options_window, project_window, ConfigViewState, CONFIG_DISABLED_TEXT,
+            DEFAULT_WATCH_PATTERNS,
+        },
         data_diff::data_diff_ui,
+        debug::debug_window,
         demangle::{demangle_window, DemangleViewState},
+        frame_history::FrameHistory,
         function_diff::function_diff_ui,
         jobs::jobs_ui,
         symbol_diff::{symbol_diff_ui, DiffViewState, View},
@@ -35,23 +44,75 @@ pub struct ViewState {
     pub config_state: ConfigViewState,
     pub demangle_state: DemangleViewState,
     pub diff_state: DiffViewState,
+    pub frame_history: FrameHistory,
     pub show_appearance_config: bool,
     pub show_demangle: bool,
     pub show_project_config: bool,
+    pub show_diff_options: bool,
+    pub show_debug: bool,
 }
 
-#[derive(Default, Clone, serde::Deserialize, serde::Serialize)]
+/// The configuration for a single object file.
+#[derive(Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+pub struct ObjectConfig {
+    pub name: String,
+    pub target_path: Option<PathBuf>,
+    pub base_path: Option<PathBuf>,
+    pub reverse_fn_order: Option<bool>,
+    pub complete: Option<bool>,
+    pub scratch: Option<ScratchConfig>,
+}
+
+#[derive(Clone, Eq, PartialEq)]
+pub struct ProjectConfigInfo {
+    pub path: PathBuf,
+    pub timestamp: FileTime,
+}
+
+#[inline]
+fn bool_true() -> bool { true }
+
+#[inline]
+fn default_watch_patterns() -> Vec<Glob> {
+    DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect()
+}
+
+#[derive(Clone, serde::Deserialize, serde::Serialize)]
 pub struct AppConfig {
+    // TODO: https://github.com/ron-rs/ron/pull/455
+    // #[serde(flatten)]
+    // pub version: AppConfigVersion,
+    pub version: u32,
+    #[serde(default)]
     pub custom_make: Option<String>,
+    #[serde(default)]
     pub selected_wsl_distro: Option<String>,
+    #[serde(default)]
     pub project_dir: Option<PathBuf>,
+    #[serde(default)]
     pub target_obj_dir: Option<PathBuf>,
+    #[serde(default)]
     pub base_obj_dir: Option<PathBuf>,
-    pub obj_path: Option<String>,
+    #[serde(default)]
+    pub selected_obj: Option<ObjectConfig>,
+    #[serde(default = "bool_true")]
+    pub build_base: bool,
+    #[serde(default)]
     pub build_target: bool,
-    pub watcher_enabled: bool,
+    #[serde(default = "bool_true")]
+    pub rebuild_on_changes: bool,
+    #[serde(default)]
     pub auto_update_check: bool,
+    #[serde(default = "default_watch_patterns")]
     pub watch_patterns: Vec<Glob>,
+    #[serde(default)]
+    pub recent_projects: Vec<PathBuf>,
+    #[serde(default)]
+    pub code_alg: DiffAlg,
+    #[serde(default)]
+    pub data_alg: DiffAlg,
+    #[serde(default)]
+    pub relax_reloc_diffs: bool,
 
     #[serde(skip)]
     pub objects: Vec<ProjectObject>,
@@ -65,14 +126,57 @@ pub struct AppConfig {
     pub obj_change: bool,
     #[serde(skip)]
     pub queue_build: bool,
+    #[serde(skip)]
+    pub queue_reload: bool,
+    #[serde(skip)]
+    pub queue_scratch: bool,
+    #[serde(skip)]
+    pub project_config_info: Option<ProjectConfigInfo>,
+}
+
+impl Default for AppConfig {
+    fn default() -> Self {
+        Self {
+            version: AppConfigVersion::default().version,
+            custom_make: None,
+            selected_wsl_distro: None,
+            project_dir: None,
+            target_obj_dir: None,
+            base_obj_dir: None,
+            selected_obj: None,
+            build_base: true,
+            build_target: false,
+            rebuild_on_changes: true,
+            auto_update_check: true,
+            watch_patterns: DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect(),
+            recent_projects: vec![],
+            code_alg: Default::default(),
+            data_alg: Default::default(),
+            relax_reloc_diffs: false,
+            objects: vec![],
+            object_nodes: vec![],
+            watcher_change: false,
+            config_change: false,
+            obj_change: false,
+            queue_build: false,
+            queue_reload: false,
+            queue_scratch: false,
+            project_config_info: None,
+        }
+    }
 }
 
 impl AppConfig {
     pub fn set_project_dir(&mut self, path: PathBuf) {
+        self.recent_projects.retain(|p| p != &path);
+        if self.recent_projects.len() > 9 {
+            self.recent_projects.truncate(9);
+        }
+        self.recent_projects.insert(0, path.clone());
         self.project_dir = Some(path);
         self.target_obj_dir = None;
         self.base_obj_dir = None;
-        self.obj_path = None;
+        self.selected_obj = None;
         self.build_target = false;
         self.objects.clear();
         self.object_nodes.clear();
@@ -80,24 +184,25 @@ impl AppConfig {
         self.config_change = true;
         self.obj_change = true;
         self.queue_build = false;
+        self.project_config_info = None;
     }
 
     pub fn set_target_obj_dir(&mut self, path: PathBuf) {
         self.target_obj_dir = Some(path);
-        self.obj_path = None;
+        self.selected_obj = None;
         self.obj_change = true;
         self.queue_build = false;
     }
 
     pub fn set_base_obj_dir(&mut self, path: PathBuf) {
         self.base_obj_dir = Some(path);
-        self.obj_path = None;
+        self.selected_obj = None;
         self.obj_change = true;
         self.queue_build = false;
     }
 
-    pub fn set_obj_path(&mut self, path: String) {
-        self.obj_path = Some(path);
+    pub fn set_selected_obj(&mut self, object: ObjectConfig) {
+        self.selected_obj = Some(object);
         self.obj_change = true;
         self.queue_build = false;
     }
@@ -111,14 +216,13 @@ pub struct App {
     view_state: ViewState,
     config: AppConfigRef,
     modified: Arc<AtomicBool>,
-    config_modified: Arc<AtomicBool>,
     watcher: Option<notify::RecommendedWatcher>,
     relaunch_path: Rc<Mutex<Option<PathBuf>>>,
     should_relaunch: bool,
 }
 
-const APPEARANCE_KEY: &str = "appearance";
-const CONFIG_KEY: &str = "app_config";
+pub const APPEARANCE_KEY: &str = "appearance";
+pub const CONFIG_KEY: &str = "app_config";
 
 impl App {
     /// Called once before the first frame.
@@ -127,9 +231,6 @@ impl App {
         utc_offset: UtcOffset,
         relaunch_path: Rc<Mutex<Option<PathBuf>>>,
     ) -> Self {
-        // This is also where you can customized the look at feel of egui using
-        // `cc.egui_ctx.set_visuals` and `cc.egui_ctx.set_fonts`.
-
         // Load previous app state (if any).
         // Note that you must enable the `persistence` feature for this to work.
         let mut app = Self::default();
@@ -137,22 +238,27 @@ impl App {
             if let Some(appearance) = eframe::get_value::<Appearance>(storage, APPEARANCE_KEY) {
                 app.appearance = appearance;
             }
-            if let Some(mut config) = eframe::get_value::<AppConfig>(storage, CONFIG_KEY) {
+            if let Some(mut config) = deserialize_config(storage) {
                 if config.project_dir.is_some() {
                     config.config_change = true;
                     config.watcher_change = true;
-                    app.modified.store(true, Ordering::Relaxed);
+                }
+                if config.selected_obj.is_some() {
+                    config.queue_build = true;
                 }
                 app.view_state.config_state.queue_check_update = config.auto_update_check;
                 app.config = Arc::new(RwLock::new(config));
             }
         }
+        app.appearance.init_fonts(&cc.egui_ctx);
         app.appearance.utc_offset = utc_offset;
         app.relaunch_path = relaunch_path;
         app
     }
 
-    fn pre_update(&mut self) {
+    fn pre_update(&mut self, ctx: &egui::Context) {
+        self.appearance.pre_update(ctx);
+
         let ViewState { jobs, diff_state, config_state, .. } = &mut self.view_state;
 
         let mut results = vec![];
@@ -162,7 +268,7 @@ impl App {
                     log::info!("Job {} finished", job.id);
                     match result {
                         JobResult::None => {
-                            if let Some(err) = &job.status.read().unwrap().error {
+                            if let Some(err) = &job.context.status.read().unwrap().error {
                                 log::error!("{:?}", err);
                             }
                         }
@@ -183,12 +289,12 @@ impl App {
                     } else {
                         anyhow::Error::msg("Thread panicked")
                     };
-                    let result = job.status.write();
+                    let result = job.context.status.write();
                     if let Ok(mut guard) = result {
                         guard.error = Some(err);
                     } else {
                         drop(result);
-                        job.status = Arc::new(RwLock::new(JobStatus {
+                        job.context.status = Arc::new(RwLock::new(JobStatus {
                             title: "Error".to_string(),
                             progress_percent: 0.0,
                             progress_items: None,
@@ -203,22 +309,26 @@ impl App {
         jobs.clear_finished();
 
         diff_state.pre_update(jobs, &self.config);
-        config_state.pre_update(jobs);
+        config_state.pre_update(jobs, &self.config);
         debug_assert!(jobs.results.is_empty());
     }
 
-    fn post_update(&mut self) {
+    fn post_update(&mut self, ctx: &egui::Context) {
+        self.appearance.post_update(ctx);
+
         let ViewState { jobs, diff_state, config_state, .. } = &mut self.view_state;
-        config_state.post_update(jobs, &self.config);
-        diff_state.post_update(jobs, &self.config);
+        config_state.post_update(ctx, jobs, &self.config);
+        diff_state.post_update(ctx, jobs, &self.config);
 
         let Ok(mut config) = self.config.write() else {
             return;
         };
         let config = &mut *config;
 
-        if self.config_modified.swap(false, Ordering::Relaxed) {
-            config.config_change = true;
+        if let Some(info) = &config.project_config_info {
+            if file_modified(&info.path, info.timestamp) {
+                config.config_change = true;
+            }
         }
 
         if config.config_change {
@@ -236,21 +346,14 @@ impl App {
             drop(self.watcher.take());
 
             if let Some(project_dir) = &config.project_dir {
-                if !config.watch_patterns.is_empty() {
-                    match build_globset(&config.watch_patterns)
-                        .map_err(anyhow::Error::new)
-                        .and_then(|globset| {
-                            create_watcher(
-                                self.modified.clone(),
-                                self.config_modified.clone(),
-                                project_dir,
-                                globset,
-                            )
+                match build_globset(&config.watch_patterns).map_err(anyhow::Error::new).and_then(
+                    |globset| {
+                        create_watcher(ctx.clone(), self.modified.clone(), project_dir, globset)
                             .map_err(anyhow::Error::new)
-                        }) {
-                        Ok(watcher) => self.watcher = Some(watcher),
-                        Err(e) => log::error!("Failed to create watcher: {e}"),
-                    }
+                    },
+                ) {
+                    Ok(watcher) => self.watcher = Some(watcher),
+                    Err(e) => log::error!("Failed to create watcher: {e}"),
                 }
                 config.watcher_change = false;
             }
@@ -258,21 +361,42 @@ impl App {
 
         if config.obj_change {
             *diff_state = Default::default();
-            if config.obj_path.is_some() {
+            if config.selected_obj.is_some() {
                 config.queue_build = true;
             }
             config.obj_change = false;
         }
 
-        if self.modified.swap(false, Ordering::Relaxed) {
+        if self.modified.swap(false, Ordering::Relaxed) && config.rebuild_on_changes {
             config.queue_build = true;
         }
 
+        if let Some(result) = &diff_state.build {
+            if let Some(obj) = &result.first_obj {
+                if file_modified(&obj.path, obj.timestamp) {
+                    config.queue_reload = true;
+                }
+            }
+            if let Some(obj) = &result.second_obj {
+                if file_modified(&obj.path, obj.timestamp) {
+                    config.queue_reload = true;
+                }
+            }
+        }
+
         // Don't clear `queue_build` if a build is running. A file may have been modified during
         // the build, so we'll start another build after the current one finishes.
-        if config.queue_build && config.obj_path.is_some() && !jobs.is_running(Job::ObjDiff) {
-            jobs.push(start_build(self.config.clone()));
+        if config.queue_build && config.selected_obj.is_some() && !jobs.is_running(Job::ObjDiff) {
+            jobs.push(start_build(ctx, ObjDiffConfig::from_config(config)));
             config.queue_build = false;
+            config.queue_reload = false;
+        } else if config.queue_reload && !jobs.is_running(Job::ObjDiff) {
+            let mut diff_config = ObjDiffConfig::from_config(config);
+            // Don't build, just reload the current files
+            diff_config.build_base = false;
+            diff_config.build_target = false;
+            jobs.push(start_build(ctx, diff_config));
+            config.queue_reload = false;
         }
     }
 }
@@ -282,34 +406,67 @@ impl eframe::App for App {
     /// Put your widgets into a `SidePanel`, `TopPanel`, `CentralPanel`, `Window` or `Area`.
     fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
         if self.should_relaunch {
-            frame.close();
+            ctx.send_viewport_cmd(egui::ViewportCommand::Close);
             return;
         }
 
-        self.pre_update();
+        self.pre_update(ctx);
 
         let Self { config, appearance, view_state, .. } = self;
-        ctx.set_style(appearance.apply(ctx.style().as_ref()));
-
         let ViewState {
             jobs,
-            show_appearance_config,
-            demangle_state,
-            show_demangle,
-            diff_state,
             config_state,
+            demangle_state,
+            diff_state,
+            frame_history,
+            show_appearance_config,
+            show_demangle,
             show_project_config,
+            show_diff_options,
+            show_debug,
         } = view_state;
 
+        frame_history.on_new_frame(ctx.input(|i| i.time), frame.info().cpu_usage);
+
         egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
             egui::menu::bar(ui, |ui| {
                 ui.menu_button("File", |ui| {
+                    #[cfg(debug_assertions)]
+                    if ui.button("Debug…").clicked() {
+                        *show_debug = !*show_debug;
+                        ui.close_menu();
+                    }
+                    if ui.button("Project…").clicked() {
+                        *show_project_config = !*show_project_config;
+                        ui.close_menu();
+                    }
+                    let recent_projects = if let Ok(guard) = config.read() {
+                        guard.recent_projects.clone()
+                    } else {
+                        vec![]
+                    };
+                    if recent_projects.is_empty() {
+                        ui.add_enabled(false, egui::Button::new("Recent projects…"));
+                    } else {
+                        ui.menu_button("Recent Projects…", |ui| {
+                            if ui.button("Clear").clicked() {
+                                config.write().unwrap().recent_projects.clear();
+                            };
+                            ui.separator();
+                            for path in recent_projects {
+                                if ui.button(format!("{}", path.display())).clicked() {
+                                    config.write().unwrap().set_project_dir(path);
+                                    ui.close_menu();
+                                }
+                            }
+                        });
+                    }
                     if ui.button("Appearance…").clicked() {
                         *show_appearance_config = !*show_appearance_config;
                         ui.close_menu();
                     }
                     if ui.button("Quit").clicked() {
-                        frame.close();
+                        ctx.send_viewport_cmd(egui::ViewportCommand::Close);
                     }
                 });
                 ui.menu_button("Tools", |ui| {
@@ -318,6 +475,40 @@ impl eframe::App for App {
                         ui.close_menu();
                     }
                 });
+                ui.menu_button("Diff Options", |ui| {
+                    if ui.button("Algorithm…").clicked() {
+                        *show_diff_options = !*show_diff_options;
+                        ui.close_menu();
+                    }
+                    let mut config = config.write().unwrap();
+                    let response = ui
+                        .checkbox(&mut config.rebuild_on_changes, "Rebuild on changes")
+                        .on_hover_text("Automatically re-run the build & diff when files change.");
+                    if response.changed() {
+                        config.watcher_change = true;
+                    };
+                    ui.add_enabled(
+                        !diff_state.symbol_state.disable_reverse_fn_order,
+                        egui::Checkbox::new(
+                            &mut diff_state.symbol_state.reverse_fn_order,
+                            "Reverse function order (-inline deferred)",
+                        ),
+                    )
+                    .on_disabled_hover_text(CONFIG_DISABLED_TEXT);
+                    ui.checkbox(
+                        &mut diff_state.symbol_state.show_hidden_symbols,
+                        "Show hidden symbols",
+                    );
+                    if ui
+                        .checkbox(&mut config.relax_reloc_diffs, "Relax relocation diffs")
+                        .on_hover_text(
+                            "Ignores differences in relocation targets. (Address, name, etc)",
+                        )
+                        .changed()
+                    {
+                        config.queue_reload = true;
+                    }
+                });
             });
         });
 
@@ -346,16 +537,10 @@ impl eframe::App for App {
         project_window(ctx, config, show_project_config, config_state, appearance);
         appearance_window(ctx, show_appearance_config, appearance);
         demangle_window(ctx, show_demangle, demangle_state, appearance);
+        diff_options_window(ctx, config, show_diff_options, appearance);
+        debug_window(ctx, show_debug, frame_history, appearance);
 
-        self.post_update();
-
-        // Windows + request_repaint_after breaks dialogs:
-        // https://github.com/emilk/egui/issues/2003
-        if cfg!(windows) || self.view_state.jobs.any_running() {
-            ctx.request_repaint();
-        } else {
-            ctx.request_repaint_after(Duration::from_millis(100));
-        }
+        self.post_update(ctx);
     }
 
     /// Called by the frame work to save state before shutdown.
@@ -368,27 +553,29 @@ impl eframe::App for App {
 }
 
 fn create_watcher(
+    ctx: egui::Context,
     modified: Arc<AtomicBool>,
-    config_modified: Arc<AtomicBool>,
     project_dir: &Path,
     patterns: GlobSet,
 ) -> notify::Result<notify::RecommendedWatcher> {
-    let mut config_patterns = GlobSetBuilder::new();
-    for filename in CONFIG_FILENAMES {
-        config_patterns.add(Glob::new(&format!("**/{filename}")).unwrap());
-    }
-    let config_patterns = config_patterns.build().unwrap();
-
+    let base_dir = project_dir.to_owned();
     let mut watcher =
         notify::recommended_watcher(move |res: notify::Result<notify::Event>| match res {
             Ok(event) => {
-                if matches!(event.kind, notify::EventKind::Modify(..)) {
+                if matches!(
+                    event.kind,
+                    notify::EventKind::Modify(..)
+                        | notify::EventKind::Create(..)
+                        | notify::EventKind::Remove(..)
+                ) {
                     for path in &event.paths {
-                        if config_patterns.is_match(path) {
-                            config_modified.store(true, Ordering::Relaxed);
-                        }
+                        let Ok(path) = path.strip_prefix(&base_dir) else {
+                            continue;
+                        };
                         if patterns.is_match(path) {
+                            log::info!("File modified: {}", path.display());
                             modified.store(true, Ordering::Relaxed);
+                            ctx.request_repaint();
                         }
                     }
                 }
@@ -398,3 +585,12 @@ fn create_watcher(
     watcher.watch(project_dir, RecursiveMode::Recursive)?;
     Ok(watcher)
 }
+
+#[inline]
+fn file_modified(path: &Path, last_ts: FileTime) -> bool {
+    if let Ok(metadata) = fs::metadata(path) {
+        FileTime::from_last_modification_time(&metadata) != last_ts
+    } else {
+        false
+    }
+}

src/app_config.rs

@@ -0,0 +1,97 @@
+use std::path::PathBuf;
+
+use eframe::Storage;
+use globset::Glob;
+
+use crate::app::{AppConfig, ObjectConfig, CONFIG_KEY};
+
+#[derive(Clone, serde::Deserialize, serde::Serialize)]
+pub struct AppConfigVersion {
+    pub version: u32,
+}
+
+impl Default for AppConfigVersion {
+    fn default() -> Self { Self { version: 1 } }
+}
+
+/// Deserialize the AppConfig from storage, handling upgrades from older versions.
+pub fn deserialize_config(storage: &dyn Storage) -> Option<AppConfig> {
+    let str = storage.get_string(CONFIG_KEY)?;
+    match ron::from_str::<AppConfigVersion>(&str) {
+        Ok(version) => match version.version {
+            1 => from_str::<AppConfig>(&str),
+            _ => {
+                log::warn!("Unknown config version: {}", version.version);
+                None
+            }
+        },
+        Err(e) => {
+            log::warn!("Failed to decode config version: {e}");
+            // Try to decode as v0
+            from_str::<AppConfigV0>(&str).map(|c| c.into_config())
+        }
+    }
+}
+
+fn from_str<T>(str: &str) -> Option<T>
+where T: serde::de::DeserializeOwned {
+    match ron::from_str(str) {
+        Ok(config) => Some(config),
+        Err(err) => {
+            log::warn!("Failed to decode config: {err}");
+            None
+        }
+    }
+}
+
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct ObjectConfigV0 {
+    pub name: String,
+    pub target_path: PathBuf,
+    pub base_path: PathBuf,
+    pub reverse_fn_order: Option<bool>,
+}
+
+impl ObjectConfigV0 {
+    fn into_config(self) -> ObjectConfig {
+        ObjectConfig {
+            name: self.name,
+            target_path: Some(self.target_path),
+            base_path: Some(self.base_path),
+            reverse_fn_order: self.reverse_fn_order,
+            complete: None,
+            scratch: None,
+        }
+    }
+}
+
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct AppConfigV0 {
+    pub custom_make: Option<String>,
+    pub selected_wsl_distro: Option<String>,
+    pub project_dir: Option<PathBuf>,
+    pub target_obj_dir: Option<PathBuf>,
+    pub base_obj_dir: Option<PathBuf>,
+    pub selected_obj: Option<ObjectConfigV0>,
+    pub build_target: bool,
+    pub auto_update_check: bool,
+    pub watch_patterns: Vec<Glob>,
+}
+
+impl AppConfigV0 {
+    fn into_config(self) -> AppConfig {
+        log::info!("Upgrading configuration from v0");
+        AppConfig {
+            custom_make: self.custom_make,
+            selected_wsl_distro: self.selected_wsl_distro,
+            project_dir: self.project_dir,
+            target_obj_dir: self.target_obj_dir,
+            base_obj_dir: self.base_obj_dir,
+            selected_obj: self.selected_obj.map(|obj| obj.into_config()),
+            build_target: self.build_target,
+            auto_update_check: self.auto_update_check,
+            watch_patterns: self.watch_patterns,
+            ..Default::default()
+        }
+    }
+}

src/config.rs

@@ -1,35 +1,88 @@
 use std::{
     fs::File,
+    io::Read,
     path::{Component, Path, PathBuf},
 };
 
-use anyhow::{Context, Result};
+use anyhow::{bail, Result};
+use filetime::FileTime;
 use globset::{Glob, GlobSet, GlobSetBuilder};
 
-use crate::app::AppConfig;
+use crate::{
+    app::{AppConfig, ProjectConfigInfo},
+    views::config::DEFAULT_WATCH_PATTERNS,
+};
+
+#[inline]
+fn bool_true() -> bool { true }
 
 #[derive(Default, Clone, serde::Deserialize)]
-#[serde(default)]
 pub struct ProjectConfig {
+    #[serde(default)]
+    pub min_version: Option<String>,
+    #[serde(default)]
     pub custom_make: Option<String>,
+    #[serde(default)]
     pub target_dir: Option<PathBuf>,
+    #[serde(default)]
     pub base_dir: Option<PathBuf>,
+    #[serde(default = "bool_true")]
+    pub build_base: bool,
+    #[serde(default)]
     pub build_target: bool,
-    pub watch_patterns: Vec<Glob>,
-    #[serde(alias = "units")]
+    #[serde(default)]
+    pub watch_patterns: Option<Vec<Glob>>,
+    #[serde(default, alias = "units")]
     pub objects: Vec<ProjectObject>,
 }
 
 #[derive(Default, Clone, serde::Deserialize)]
 pub struct ProjectObject {
+    #[serde(default)]
     pub name: Option<String>,
-    pub path: PathBuf,
+    #[serde(default)]
+    pub path: Option<PathBuf>,
+    #[serde(default)]
+    pub target_path: Option<PathBuf>,
+    #[serde(default)]
+    pub base_path: Option<PathBuf>,
+    #[serde(default)]
     pub reverse_fn_order: Option<bool>,
+    #[serde(default)]
+    pub complete: Option<bool>,
+    #[serde(default)]
+    pub scratch: Option<ScratchConfig>,
+}
+
+#[derive(Default, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+pub struct ScratchConfig {
+    #[serde(default)]
+    pub platform: Option<String>,
+    #[serde(default)]
+    pub compiler: Option<String>,
+    #[serde(default)]
+    pub c_flags: Option<String>,
+    #[serde(default)]
+    pub ctx_path: Option<PathBuf>,
+    #[serde(default)]
+    pub build_ctx: bool,
+}
+
+impl ProjectObject {
+    pub fn name(&self) -> &str {
+        if let Some(name) = &self.name {
+            name
+        } else if let Some(path) = &self.path {
+            path.to_str().unwrap_or("[invalid path]")
+        } else {
+            "[unknown]"
+        }
+    }
 }
 
 #[derive(Clone)]
 pub enum ProjectObjectNode {
-    File(String, ProjectObject),
+    File(String, Box<ProjectObject>),
     Dir(String, Vec<ProjectObjectNode>),
 }
 
@@ -53,11 +106,22 @@ fn find_dir<'a>(
     unreachable!();
 }
 
-fn build_nodes(objects: &[ProjectObject]) -> Vec<ProjectObjectNode> {
+fn build_nodes(
+    objects: &[ProjectObject],
+    project_dir: &Path,
+    target_obj_dir: &Option<PathBuf>,
+    base_obj_dir: &Option<PathBuf>,
+) -> Vec<ProjectObjectNode> {
     let mut nodes = vec![];
     for object in objects {
         let mut out_nodes = &mut nodes;
-        let path = object.name.as_ref().map(Path::new).unwrap_or(&object.path);
+        let path = if let Some(name) = &object.name {
+            Path::new(name)
+        } else if let Some(path) = &object.path {
+            path
+        } else {
+            continue;
+        };
         if let Some(parent) = path.parent() {
             for component in parent.components() {
                 if let Component::Normal(name) = component {
@@ -66,8 +130,23 @@ fn build_nodes(objects: &[ProjectObject]) -> Vec<ProjectObjectNode> {
                 }
             }
         }
+        let mut object = Box::new(object.clone());
+        if let (Some(target_obj_dir), Some(path), None) =
+            (target_obj_dir, &object.path, &object.target_path)
+        {
+            object.target_path = Some(target_obj_dir.join(path));
+        } else if let Some(path) = &object.target_path {
+            object.target_path = Some(project_dir.join(path));
+        }
+        if let (Some(base_obj_dir), Some(path), None) =
+            (base_obj_dir, &object.path, &object.base_path)
+        {
+            object.base_path = Some(base_obj_dir.join(path));
+        } else if let Some(path) = &object.base_path {
+            object.base_path = Some(project_dir.join(path));
+        }
         let filename = path.file_name().unwrap().to_str().unwrap().to_string();
-        out_nodes.push(ProjectObjectNode::File(filename, object.clone()));
+        out_nodes.push(ProjectObjectNode::File(filename, object));
     }
     nodes
 }
@@ -78,43 +157,61 @@ pub fn load_project_config(config: &mut AppConfig) -> Result<()> {
     let Some(project_dir) = &config.project_dir else {
         return Ok(());
     };
-    if let Some(result) = try_project_config(project_dir) {
+    if let Some((result, info)) = try_project_config(project_dir) {
         let project_config = result?;
+        if let Some(min_version) = &project_config.min_version {
+            let version_str = env!("CARGO_PKG_VERSION");
+            let version = semver::Version::parse(version_str).unwrap();
+            let version_req = semver::VersionReq::parse(&format!(">={min_version}"))?;
+            if !version_req.matches(&version) {
+                bail!("Project requires objdiff version {} or higher", min_version);
+            }
+        }
         config.custom_make = project_config.custom_make;
         config.target_obj_dir = project_config.target_dir.map(|p| project_dir.join(p));
         config.base_obj_dir = project_config.base_dir.map(|p| project_dir.join(p));
+        config.build_base = project_config.build_base;
         config.build_target = project_config.build_target;
-        config.watch_patterns = project_config.watch_patterns;
+        config.watch_patterns = project_config.watch_patterns.unwrap_or_else(|| {
+            DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect()
+        });
         config.watcher_change = true;
         config.objects = project_config.objects;
-        config.object_nodes = build_nodes(&config.objects);
+        config.object_nodes =
+            build_nodes(&config.objects, project_dir, &config.target_obj_dir, &config.base_obj_dir);
+        config.project_config_info = Some(info);
     }
     Ok(())
 }
 
-fn try_project_config(dir: &Path) -> Option<Result<ProjectConfig>> {
+fn try_project_config(dir: &Path) -> Option<(Result<ProjectConfig>, ProjectConfigInfo)> {
     for filename in CONFIG_FILENAMES.iter() {
         let config_path = dir.join(filename);
-        if config_path.is_file() {
-            return match filename.contains("json") {
-                true => Some(read_json_config(&config_path)),
-                false => Some(read_yml_config(&config_path)),
+        let Ok(mut file) = File::open(&config_path) else {
+            continue;
+        };
+        let metadata = file.metadata();
+        if let Ok(metadata) = metadata {
+            if !metadata.is_file() {
+                continue;
+            }
+            let ts = FileTime::from_last_modification_time(&metadata);
+            let config = match filename.contains("json") {
+                true => read_json_config(&mut file),
+                false => read_yml_config(&mut file),
             };
+            return Some((config, ProjectConfigInfo { path: config_path, timestamp: ts }));
         }
     }
     None
 }
 
-fn read_yml_config(config_path: &Path) -> Result<ProjectConfig> {
-    let mut reader = File::open(config_path)
-        .with_context(|| format!("Failed to open config file '{}'", config_path.display()))?;
-    Ok(serde_yaml::from_reader(&mut reader)?)
+fn read_yml_config<R: Read>(reader: &mut R) -> Result<ProjectConfig> {
+    Ok(serde_yaml::from_reader(reader)?)
 }
 
-fn read_json_config(config_path: &Path) -> Result<ProjectConfig> {
-    let mut reader = File::open(config_path)
-        .with_context(|| format!("Failed to open config file '{}'", config_path.display()))?;
-    Ok(serde_json::from_reader(&mut reader)?)
+fn read_json_config<R: Read>(reader: &mut R) -> Result<ProjectConfig> {
+    Ok(serde_json::from_reader(reader)?)
 }
 
 pub fn build_globset(vec: &[Glob]) -> std::result::Result<GlobSet, globset::Error> {

src/diff.rs

@@ -1,712 +0,0 @@
-use std::{collections::BTreeMap, mem::take};
-
-use anyhow::Result;
-
-use crate::{
-    editops::{editops_find, LevEditType},
-    obj::{
-        mips, ppc, ObjArchitecture, ObjDataDiff, ObjDataDiffKind, ObjInfo, ObjInsArg,
-        ObjInsArgDiff, ObjInsBranchFrom, ObjInsBranchTo, ObjInsDiff, ObjInsDiffKind, ObjReloc,
-        ObjSection, ObjSectionKind, ObjSymbol, ObjSymbolFlags,
-    },
-};
-
-fn no_diff_code(
-    arch: ObjArchitecture,
-    data: &[u8],
-    symbol: &mut ObjSymbol,
-    relocs: &[ObjReloc],
-    line_info: &Option<BTreeMap<u32, u32>>,
-) -> Result<()> {
-    let code =
-        &data[symbol.section_address as usize..(symbol.section_address + symbol.size) as usize];
-    let (_, ins) = match arch {
-        ObjArchitecture::PowerPc => ppc::process_code(code, symbol.address, relocs, line_info)?,
-        ObjArchitecture::Mips => mips::process_code(
-            code,
-            symbol.address,
-            symbol.address + symbol.size,
-            relocs,
-            line_info,
-        )?,
-    };
-
-    let mut diff = Vec::<ObjInsDiff>::new();
-    for i in ins {
-        diff.push(ObjInsDiff { ins: Some(i), kind: ObjInsDiffKind::None, ..Default::default() });
-    }
-    resolve_branches(&mut diff);
-    symbol.instructions = diff;
-    Ok(())
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn diff_code(
-    arch: ObjArchitecture,
-    left_data: &[u8],
-    right_data: &[u8],
-    left_symbol: &mut ObjSymbol,
-    right_symbol: &mut ObjSymbol,
-    left_relocs: &[ObjReloc],
-    right_relocs: &[ObjReloc],
-    left_line_info: &Option<BTreeMap<u32, u32>>,
-    right_line_info: &Option<BTreeMap<u32, u32>>,
-) -> Result<()> {
-    let left_code = &left_data[left_symbol.section_address as usize
-        ..(left_symbol.section_address + left_symbol.size) as usize];
-    let right_code = &right_data[right_symbol.section_address as usize
-        ..(right_symbol.section_address + right_symbol.size) as usize];
-    let ((left_ops, left_insts), (right_ops, right_insts)) = match arch {
-        ObjArchitecture::PowerPc => (
-            ppc::process_code(left_code, left_symbol.address, left_relocs, left_line_info)?,
-            ppc::process_code(right_code, right_symbol.address, right_relocs, right_line_info)?,
-        ),
-        ObjArchitecture::Mips => (
-            mips::process_code(
-                left_code,
-                left_symbol.address,
-                left_symbol.address + left_symbol.size,
-                left_relocs,
-                left_line_info,
-            )?,
-            mips::process_code(
-                right_code,
-                right_symbol.address,
-                left_symbol.address + left_symbol.size,
-                right_relocs,
-                right_line_info,
-            )?,
-        ),
-    };
-
-    let mut left_diff = Vec::<ObjInsDiff>::new();
-    let mut right_diff = Vec::<ObjInsDiff>::new();
-    let edit_ops = editops_find(&left_ops, &right_ops);
-
-    {
-        let mut op_iter = edit_ops.iter();
-        let mut left_iter = left_insts.iter();
-        let mut right_iter = right_insts.iter();
-        let mut cur_op = op_iter.next();
-        let mut cur_left = left_iter.next();
-        let mut cur_right = right_iter.next();
-        while let Some(op) = cur_op {
-            let left_addr = op.first_start as u32 * 4;
-            let right_addr = op.second_start as u32 * 4;
-            while let (Some(left), Some(right)) = (cur_left, cur_right) {
-                if (left.address - left_symbol.address as u32) < left_addr {
-                    left_diff.push(ObjInsDiff { ins: Some(left.clone()), ..ObjInsDiff::default() });
-                    right_diff
-                        .push(ObjInsDiff { ins: Some(right.clone()), ..ObjInsDiff::default() });
-                } else {
-                    break;
-                }
-                cur_left = left_iter.next();
-                cur_right = right_iter.next();
-            }
-            if let (Some(left), Some(right)) = (cur_left, cur_right) {
-                if (left.address - left_symbol.address as u32) != left_addr {
-                    return Err(anyhow::Error::msg("Instruction address mismatch (left)"));
-                }
-                if (right.address - right_symbol.address as u32) != right_addr {
-                    return Err(anyhow::Error::msg("Instruction address mismatch (right)"));
-                }
-                match op.op_type {
-                    LevEditType::Replace => {
-                        left_diff
-                            .push(ObjInsDiff { ins: Some(left.clone()), ..ObjInsDiff::default() });
-                        right_diff
-                            .push(ObjInsDiff { ins: Some(right.clone()), ..ObjInsDiff::default() });
-                        cur_left = left_iter.next();
-                        cur_right = right_iter.next();
-                    }
-                    LevEditType::Insert => {
-                        left_diff.push(ObjInsDiff::default());
-                        right_diff
-                            .push(ObjInsDiff { ins: Some(right.clone()), ..ObjInsDiff::default() });
-                        cur_right = right_iter.next();
-                    }
-                    LevEditType::Delete => {
-                        left_diff
-                            .push(ObjInsDiff { ins: Some(left.clone()), ..ObjInsDiff::default() });
-                        right_diff.push(ObjInsDiff::default());
-                        cur_left = left_iter.next();
-                    }
-                }
-            } else {
-                break;
-            }
-            cur_op = op_iter.next();
-        }
-        // Finalize
-        while cur_left.is_some() || cur_right.is_some() {
-            left_diff.push(ObjInsDiff { ins: cur_left.cloned(), ..ObjInsDiff::default() });
-            right_diff.push(ObjInsDiff { ins: cur_right.cloned(), ..ObjInsDiff::default() });
-            cur_left = left_iter.next();
-            cur_right = right_iter.next();
-        }
-    }
-
-    resolve_branches(&mut left_diff);
-    resolve_branches(&mut right_diff);
-
-    let mut diff_state = InsDiffState::default();
-    for (left, right) in left_diff.iter_mut().zip(right_diff.iter_mut()) {
-        let result = compare_ins(left, right, &mut diff_state)?;
-        left.kind = result.kind;
-        right.kind = result.kind;
-        left.arg_diff = result.left_args_diff;
-        right.arg_diff = result.right_args_diff;
-    }
-
-    let total = left_insts.len();
-    let percent = if diff_state.diff_count >= total {
-        0.0
-    } else {
-        ((total - diff_state.diff_count) as f32 / total as f32) * 100.0
-    };
-    left_symbol.match_percent = Some(percent);
-    right_symbol.match_percent = Some(percent);
-
-    left_symbol.instructions = left_diff;
-    right_symbol.instructions = right_diff;
-
-    Ok(())
-}
-
-fn resolve_branches(vec: &mut [ObjInsDiff]) {
-    let mut branch_idx = 0usize;
-    // Map addresses to indices
-    let mut addr_map = BTreeMap::<u32, usize>::new();
-    for (i, ins_diff) in vec.iter().enumerate() {
-        if let Some(ins) = &ins_diff.ins {
-            addr_map.insert(ins.address, i);
-        }
-    }
-    // Generate branches
-    let mut branches = BTreeMap::<usize, ObjInsBranchFrom>::new();
-    for (i, ins_diff) in vec.iter_mut().enumerate() {
-        if let Some(ins) = &ins_diff.ins {
-            // if ins.ins.is_blr() || ins.reloc.is_some() {
-            //     continue;
-            // }
-            if let Some(ins_idx) = ins
-                .args
-                .iter()
-                .find_map(|a| if let ObjInsArg::BranchOffset(offs) = a { Some(offs) } else { None })
-                .and_then(|offs| addr_map.get(&((ins.address as i32 + offs) as u32)))
-            {
-                if let Some(branch) = branches.get_mut(ins_idx) {
-                    ins_diff.branch_to =
-                        Some(ObjInsBranchTo { ins_idx: *ins_idx, branch_idx: branch.branch_idx });
-                    branch.ins_idx.push(i);
-                } else {
-                    ins_diff.branch_to = Some(ObjInsBranchTo { ins_idx: *ins_idx, branch_idx });
-                    branches.insert(*ins_idx, ObjInsBranchFrom { ins_idx: vec![i], branch_idx });
-                    branch_idx += 1;
-                }
-            }
-        }
-    }
-    // Store branch from
-    for (i, branch) in branches {
-        vec[i].branch_from = Some(branch);
-    }
-}
-
-fn address_eq(left: &ObjSymbol, right: &ObjSymbol) -> bool {
-    left.address as i64 + left.addend == right.address as i64 + right.addend
-}
-
-fn reloc_eq(left_reloc: Option<&ObjReloc>, right_reloc: Option<&ObjReloc>) -> bool {
-    let (Some(left), Some(right)) = (left_reloc, right_reloc) else {
-        return false;
-    };
-    if left.kind != right.kind {
-        return false;
-    }
-
-    let name_matches = left.target.name == right.target.name;
-    match (&left.target_section, &right.target_section) {
-        (Some(sl), Some(sr)) => {
-            // Match if section and name or address match
-            sl == sr && (name_matches || address_eq(&left.target, &right.target))
-        }
-        (Some(_), None) => false,
-        (None, Some(_)) => {
-            // Match if possibly stripped weak symbol
-            name_matches && right.target.flags.0.contains(ObjSymbolFlags::Weak)
-        }
-        (None, None) => name_matches,
-    }
-}
-
-fn arg_eq(
-    left: &ObjInsArg,
-    right: &ObjInsArg,
-    left_diff: &ObjInsDiff,
-    right_diff: &ObjInsDiff,
-) -> bool {
-    return match left {
-        ObjInsArg::PpcArg(l) => match right {
-            ObjInsArg::PpcArg(r) => format!("{l}") == format!("{r}"),
-            _ => false,
-        },
-        ObjInsArg::Reloc => {
-            matches!(right, ObjInsArg::Reloc)
-                && reloc_eq(
-                    left_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
-                    right_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
-                )
-        }
-        ObjInsArg::RelocWithBase => {
-            matches!(right, ObjInsArg::RelocWithBase)
-                && reloc_eq(
-                    left_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
-                    right_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
-                )
-        }
-        ObjInsArg::MipsArg(ls) | ObjInsArg::MipsArgWithBase(ls) => {
-            matches!(right, ObjInsArg::MipsArg(rs) | ObjInsArg::MipsArgWithBase(rs) if ls == rs)
-        }
-        ObjInsArg::BranchOffset(_) => {
-            // Compare dest instruction idx after diffing
-            left_diff.branch_to.as_ref().map(|b| b.ins_idx)
-                == right_diff.branch_to.as_ref().map(|b| b.ins_idx)
-        }
-    };
-}
-
-#[derive(Default)]
-struct InsDiffState {
-    diff_count: usize,
-    left_arg_idx: usize,
-    right_arg_idx: usize,
-    left_args_idx: BTreeMap<String, usize>,
-    right_args_idx: BTreeMap<String, usize>,
-}
-#[derive(Default)]
-struct InsDiffResult {
-    kind: ObjInsDiffKind,
-    left_args_diff: Vec<Option<ObjInsArgDiff>>,
-    right_args_diff: Vec<Option<ObjInsArgDiff>>,
-}
-
-fn compare_ins(
-    left: &ObjInsDiff,
-    right: &ObjInsDiff,
-    state: &mut InsDiffState,
-) -> Result<InsDiffResult> {
-    let mut result = InsDiffResult::default();
-    if let (Some(left_ins), Some(right_ins)) = (&left.ins, &right.ins) {
-        if left_ins.args.len() != right_ins.args.len() || left_ins.op != right_ins.op {
-            // Totally different op
-            result.kind = ObjInsDiffKind::Replace;
-            state.diff_count += 1;
-            return Ok(result);
-        }
-        if left_ins.mnemonic != right_ins.mnemonic {
-            // Same op but different mnemonic, still cmp args
-            result.kind = ObjInsDiffKind::OpMismatch;
-            state.diff_count += 1;
-        }
-        for (a, b) in left_ins.args.iter().zip(&right_ins.args) {
-            if arg_eq(a, b, left, right) {
-                result.left_args_diff.push(None);
-                result.right_args_diff.push(None);
-            } else {
-                if result.kind == ObjInsDiffKind::None {
-                    result.kind = ObjInsDiffKind::ArgMismatch;
-                    state.diff_count += 1;
-                }
-                let a_str = match a {
-                    ObjInsArg::PpcArg(arg) => format!("{arg}"),
-                    ObjInsArg::Reloc | ObjInsArg::RelocWithBase => String::new(),
-                    ObjInsArg::MipsArg(str) | ObjInsArg::MipsArgWithBase(str) => str.clone(),
-                    ObjInsArg::BranchOffset(arg) => format!("{arg}"),
-                };
-                let a_diff = if let Some(idx) = state.left_args_idx.get(&a_str) {
-                    ObjInsArgDiff { idx: *idx }
-                } else {
-                    let idx = state.left_arg_idx;
-                    state.left_args_idx.insert(a_str, idx);
-                    state.left_arg_idx += 1;
-                    ObjInsArgDiff { idx }
-                };
-                let b_str = match b {
-                    ObjInsArg::PpcArg(arg) => format!("{arg}"),
-                    ObjInsArg::Reloc | ObjInsArg::RelocWithBase => String::new(),
-                    ObjInsArg::MipsArg(str) | ObjInsArg::MipsArgWithBase(str) => str.clone(),
-                    ObjInsArg::BranchOffset(arg) => format!("{arg}"),
-                };
-                let b_diff = if let Some(idx) = state.right_args_idx.get(&b_str) {
-                    ObjInsArgDiff { idx: *idx }
-                } else {
-                    let idx = state.right_arg_idx;
-                    state.right_args_idx.insert(b_str, idx);
-                    state.right_arg_idx += 1;
-                    ObjInsArgDiff { idx }
-                };
-                result.left_args_diff.push(Some(a_diff));
-                result.right_args_diff.push(Some(b_diff));
-            }
-        }
-    } else if left.ins.is_some() {
-        result.kind = ObjInsDiffKind::Delete;
-        state.diff_count += 1;
-    } else {
-        result.kind = ObjInsDiffKind::Insert;
-        state.diff_count += 1;
-    }
-    Ok(result)
-}
-
-fn find_section_and_symbol(obj: &ObjInfo, name: &str) -> Option<(usize, usize)> {
-    for (section_idx, section) in obj.sections.iter().enumerate() {
-        let symbol_idx = match section.symbols.iter().position(|symbol| symbol.name == name) {
-            Some(symbol_idx) => symbol_idx,
-            None => continue,
-        };
-        return Some((section_idx, symbol_idx));
-    }
-    None
-}
-
-pub fn diff_objs(left: &mut ObjInfo, right: &mut ObjInfo) -> Result<()> {
-    for left_section in &mut left.sections {
-        if left_section.kind == ObjSectionKind::Code {
-            for left_symbol in &mut left_section.symbols {
-                if let Some((right_section_idx, right_symbol_idx)) =
-                    find_section_and_symbol(right, &left_symbol.name)
-                {
-                    let right_section = &mut right.sections[right_section_idx];
-                    let right_symbol = &mut right_section.symbols[right_symbol_idx];
-                    left_symbol.diff_symbol = Some(right_symbol.name.clone());
-                    right_symbol.diff_symbol = Some(left_symbol.name.clone());
-                    diff_code(
-                        left.architecture,
-                        &left_section.data,
-                        &right_section.data,
-                        left_symbol,
-                        right_symbol,
-                        &left_section.relocations,
-                        &right_section.relocations,
-                        &left.line_info,
-                        &right.line_info,
-                    )?;
-                } else {
-                    no_diff_code(
-                        left.architecture,
-                        &left_section.data,
-                        left_symbol,
-                        &left_section.relocations,
-                        &left.line_info,
-                    )?;
-                }
-            }
-        } else {
-            let Some(right_section) =
-                right.sections.iter_mut().find(|s| s.name == left_section.name)
-            else {
-                continue;
-            };
-            if left_section.kind == ObjSectionKind::Data {
-                diff_data(left_section, right_section);
-                // diff_data_symbols(left_section, right_section)?;
-            } else if left_section.kind == ObjSectionKind::Bss {
-                diff_bss_symbols(&mut left_section.symbols, &mut right_section.symbols)?;
-            }
-        }
-    }
-    for right_section in right.sections.iter_mut().filter(|s| s.kind == ObjSectionKind::Code) {
-        for right_symbol in &mut right_section.symbols {
-            if right_symbol.instructions.is_empty() {
-                no_diff_code(
-                    right.architecture,
-                    &right_section.data,
-                    right_symbol,
-                    &right_section.relocations,
-                    &right.line_info,
-                )?;
-            }
-        }
-    }
-    diff_bss_symbols(&mut left.common, &mut right.common)?;
-    Ok(())
-}
-
-fn diff_bss_symbols(left_symbols: &mut [ObjSymbol], right_symbols: &mut [ObjSymbol]) -> Result<()> {
-    for left_symbol in left_symbols {
-        if let Some(right_symbol) = right_symbols.iter_mut().find(|s| s.name == left_symbol.name) {
-            left_symbol.diff_symbol = Some(right_symbol.name.clone());
-            right_symbol.diff_symbol = Some(left_symbol.name.clone());
-            let percent = if left_symbol.size == right_symbol.size { 100.0 } else { 50.0 };
-            left_symbol.match_percent = Some(percent);
-            right_symbol.match_percent = Some(percent);
-        }
-    }
-    Ok(())
-}
-
-// WIP diff-by-symbol
-#[allow(dead_code)]
-fn diff_data_symbols(left: &mut ObjSection, right: &mut ObjSection) -> Result<()> {
-    let mut left_ops = Vec::<u32>::with_capacity(left.symbols.len());
-    let mut right_ops = Vec::<u32>::with_capacity(right.symbols.len());
-    for left_symbol in &left.symbols {
-        let data = &left.data
-            [left_symbol.address as usize..(left_symbol.address + left_symbol.size) as usize];
-        let hash = twox_hash::xxh3::hash64(data);
-        left_ops.push(hash as u32);
-    }
-    for symbol in &right.symbols {
-        let data = &right.data[symbol.address as usize..(symbol.address + symbol.size) as usize];
-        let hash = twox_hash::xxh3::hash64(data);
-        right_ops.push(hash as u32);
-    }
-
-    let edit_ops = editops_find(&left_ops, &right_ops);
-    if edit_ops.is_empty() && !left.data.is_empty() {
-        let mut left_iter = left.symbols.iter_mut();
-        let mut right_iter = right.symbols.iter_mut();
-        loop {
-            let (left_symbol, right_symbol) = match (left_iter.next(), right_iter.next()) {
-                (Some(l), Some(r)) => (l, r),
-                (None, None) => break,
-                _ => return Err(anyhow::Error::msg("L/R mismatch in diff_data_symbols")),
-            };
-            let left_data = &left.data
-                [left_symbol.address as usize..(left_symbol.address + left_symbol.size) as usize];
-            let right_data = &right.data[right_symbol.address as usize
-                ..(right_symbol.address + right_symbol.size) as usize];
-
-            left.data_diff.push(ObjDataDiff {
-                data: left_data.to_vec(),
-                kind: ObjDataDiffKind::None,
-                len: left_symbol.size as usize,
-                symbol: left_symbol.name.clone(),
-            });
-            right.data_diff.push(ObjDataDiff {
-                data: right_data.to_vec(),
-                kind: ObjDataDiffKind::None,
-                len: right_symbol.size as usize,
-                symbol: right_symbol.name.clone(),
-            });
-            left_symbol.diff_symbol = Some(right_symbol.name.clone());
-            left_symbol.match_percent = Some(100.0);
-            right_symbol.diff_symbol = Some(left_symbol.name.clone());
-            right_symbol.match_percent = Some(100.0);
-        }
-        return Ok(());
-    }
-    Ok(())
-}
-
-fn diff_data(left: &mut ObjSection, right: &mut ObjSection) {
-    let edit_ops = editops_find(&left.data, &right.data);
-    if edit_ops.is_empty() && !left.data.is_empty() {
-        left.data_diff = vec![ObjDataDiff {
-            data: left.data.clone(),
-            kind: ObjDataDiffKind::None,
-            len: left.data.len(),
-            symbol: String::new(),
-        }];
-        right.data_diff = vec![ObjDataDiff {
-            data: right.data.clone(),
-            kind: ObjDataDiffKind::None,
-            len: right.data.len(),
-            symbol: String::new(),
-        }];
-        return;
-    }
-
-    let mut left_diff = Vec::<ObjDataDiff>::new();
-    let mut right_diff = Vec::<ObjDataDiff>::new();
-    let mut left_cur = 0usize;
-    let mut right_cur = 0usize;
-    let mut cur_op = LevEditType::Replace;
-    let mut cur_left_data = Vec::<u8>::new();
-    let mut cur_right_data = Vec::<u8>::new();
-    for op in edit_ops {
-        if cur_op != op.op_type || left_cur < op.first_start || right_cur < op.second_start {
-            match cur_op {
-                LevEditType::Replace => {
-                    let left_data = take(&mut cur_left_data);
-                    let right_data = take(&mut cur_right_data);
-                    let left_data_len = left_data.len();
-                    let right_data_len = right_data.len();
-                    left_diff.push(ObjDataDiff {
-                        data: left_data,
-                        kind: ObjDataDiffKind::Replace,
-                        len: left_data_len,
-                        symbol: String::new(),
-                    });
-                    right_diff.push(ObjDataDiff {
-                        data: right_data,
-                        kind: ObjDataDiffKind::Replace,
-                        len: right_data_len,
-                        symbol: String::new(),
-                    });
-                }
-                LevEditType::Insert => {
-                    let right_data = take(&mut cur_right_data);
-                    let right_data_len = right_data.len();
-                    left_diff.push(ObjDataDiff {
-                        data: vec![],
-                        kind: ObjDataDiffKind::Insert,
-                        len: right_data_len,
-                        symbol: String::new(),
-                    });
-                    right_diff.push(ObjDataDiff {
-                        data: right_data,
-                        kind: ObjDataDiffKind::Insert,
-                        len: right_data_len,
-                        symbol: String::new(),
-                    });
-                }
-                LevEditType::Delete => {
-                    let left_data = take(&mut cur_left_data);
-                    let left_data_len = left_data.len();
-                    left_diff.push(ObjDataDiff {
-                        data: left_data,
-                        kind: ObjDataDiffKind::Delete,
-                        len: left_data_len,
-                        symbol: String::new(),
-                    });
-                    right_diff.push(ObjDataDiff {
-                        data: vec![],
-                        kind: ObjDataDiffKind::Delete,
-                        len: left_data_len,
-                        symbol: String::new(),
-                    });
-                }
-            }
-        }
-        if left_cur < op.first_start {
-            left_diff.push(ObjDataDiff {
-                data: left.data[left_cur..op.first_start].to_vec(),
-                kind: ObjDataDiffKind::None,
-                len: op.first_start - left_cur,
-                symbol: String::new(),
-            });
-            left_cur = op.first_start;
-        }
-        if right_cur < op.second_start {
-            right_diff.push(ObjDataDiff {
-                data: right.data[right_cur..op.second_start].to_vec(),
-                kind: ObjDataDiffKind::None,
-                len: op.second_start - right_cur,
-                symbol: String::new(),
-            });
-            right_cur = op.second_start;
-        }
-        match op.op_type {
-            LevEditType::Replace => {
-                cur_left_data.push(left.data[left_cur]);
-                cur_right_data.push(right.data[right_cur]);
-                left_cur += 1;
-                right_cur += 1;
-            }
-            LevEditType::Insert => {
-                cur_right_data.push(right.data[right_cur]);
-                right_cur += 1;
-            }
-            LevEditType::Delete => {
-                cur_left_data.push(left.data[left_cur]);
-                left_cur += 1;
-            }
-        }
-        cur_op = op.op_type;
-    }
-    // if left_cur < left.data.len() {
-    //     let len = left.data.len() - left_cur;
-    //     left_diff.push(ObjDataDiff {
-    //         data: left.data[left_cur..].to_vec(),
-    //         kind: ObjDataDiffKind::Delete,
-    //         len,
-    //     });
-    //     right_diff.push(ObjDataDiff { data: vec![], kind: ObjDataDiffKind::Delete, len });
-    // } else if right_cur < right.data.len() {
-    //     let len = right.data.len() - right_cur;
-    //     left_diff.push(ObjDataDiff { data: vec![], kind: ObjDataDiffKind::Insert, len });
-    //     right_diff.push(ObjDataDiff {
-    //         data: right.data[right_cur..].to_vec(),
-    //         kind: ObjDataDiffKind::Insert,
-    //         len,
-    //     });
-    // }
-
-    // TODO: merge with above
-    match cur_op {
-        LevEditType::Replace => {
-            let left_data = take(&mut cur_left_data);
-            let right_data = take(&mut cur_right_data);
-            let left_data_len = left_data.len();
-            let right_data_len = right_data.len();
-            left_diff.push(ObjDataDiff {
-                data: left_data,
-                kind: ObjDataDiffKind::Replace,
-                len: left_data_len,
-                symbol: String::new(),
-            });
-            right_diff.push(ObjDataDiff {
-                data: right_data,
-                kind: ObjDataDiffKind::Replace,
-                len: right_data_len,
-                symbol: String::new(),
-            });
-        }
-        LevEditType::Insert => {
-            let right_data = take(&mut cur_right_data);
-            let right_data_len = right_data.len();
-            left_diff.push(ObjDataDiff {
-                data: vec![],
-                kind: ObjDataDiffKind::Insert,
-                len: right_data_len,
-                symbol: String::new(),
-            });
-            right_diff.push(ObjDataDiff {
-                data: right_data,
-                kind: ObjDataDiffKind::Insert,
-                len: right_data_len,
-                symbol: String::new(),
-            });
-        }
-        LevEditType::Delete => {
-            let left_data = take(&mut cur_left_data);
-            let left_data_len = left_data.len();
-            left_diff.push(ObjDataDiff {
-                data: left_data,
-                kind: ObjDataDiffKind::Delete,
-                len: left_data_len,
-                symbol: String::new(),
-            });
-            right_diff.push(ObjDataDiff {
-                data: vec![],
-                kind: ObjDataDiffKind::Delete,
-                len: left_data_len,
-                symbol: String::new(),
-            });
-        }
-    }
-
-    if left_cur < left.data.len() {
-        left_diff.push(ObjDataDiff {
-            data: left.data[left_cur..].to_vec(),
-            kind: ObjDataDiffKind::None,
-            len: left.data.len() - left_cur,
-            symbol: String::new(),
-        });
-    }
-    if right_cur < right.data.len() {
-        right_diff.push(ObjDataDiff {
-            data: right.data[right_cur..].to_vec(),
-            kind: ObjDataDiffKind::None,
-            len: right.data.len() - right_cur,
-            symbol: String::new(),
-        });
-    }
-
-    left.data_diff = left_diff;
-    right.data_diff = right_diff;
-}

src/diff/code.rs

@@ -0,0 +1,489 @@
+use std::{
+    cmp::max,
+    collections::BTreeMap,
+    time::{Duration, Instant},
+};
+
+use anyhow::Result;
+use similar::{capture_diff_slices_deadline, Algorithm};
+
+use crate::{
+    diff::{
+        editops::{editops_find, LevEditType},
+        DiffAlg, DiffObjConfig, ProcessCodeResult,
+    },
+    obj::{
+        mips, ppc, ObjArchitecture, ObjInfo, ObjInsArg, ObjInsArgDiff, ObjInsBranchFrom,
+        ObjInsBranchTo, ObjInsDiff, ObjInsDiffKind, ObjReloc, ObjSymbol, ObjSymbolFlags,
+    },
+};
+
+pub fn no_diff_code(
+    arch: ObjArchitecture,
+    data: &[u8],
+    symbol: &mut ObjSymbol,
+    relocs: &[ObjReloc],
+    line_info: &Option<BTreeMap<u64, u64>>,
+) -> Result<()> {
+    let code =
+        &data[symbol.section_address as usize..(symbol.section_address + symbol.size) as usize];
+    let out = match arch {
+        ObjArchitecture::PowerPc => ppc::process_code(code, symbol.address, relocs, line_info)?,
+        ObjArchitecture::Mips => mips::process_code(
+            code,
+            symbol.address,
+            symbol.address + symbol.size,
+            relocs,
+            line_info,
+        )?,
+    };
+
+    let mut diff = Vec::<ObjInsDiff>::new();
+    for i in out.insts {
+        diff.push(ObjInsDiff { ins: Some(i), kind: ObjInsDiffKind::None, ..Default::default() });
+    }
+    resolve_branches(&mut diff);
+    symbol.instructions = diff;
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn diff_code(
+    config: &DiffObjConfig,
+    arch: ObjArchitecture,
+    left_data: &[u8],
+    right_data: &[u8],
+    left_symbol: &mut ObjSymbol,
+    right_symbol: &mut ObjSymbol,
+    left_relocs: &[ObjReloc],
+    right_relocs: &[ObjReloc],
+    left_line_info: &Option<BTreeMap<u64, u64>>,
+    right_line_info: &Option<BTreeMap<u64, u64>>,
+) -> Result<()> {
+    let left_code = &left_data[left_symbol.section_address as usize
+        ..(left_symbol.section_address + left_symbol.size) as usize];
+    let right_code = &right_data[right_symbol.section_address as usize
+        ..(right_symbol.section_address + right_symbol.size) as usize];
+    let (left_out, right_out) = match arch {
+        ObjArchitecture::PowerPc => (
+            ppc::process_code(left_code, left_symbol.address, left_relocs, left_line_info)?,
+            ppc::process_code(right_code, right_symbol.address, right_relocs, right_line_info)?,
+        ),
+        ObjArchitecture::Mips => (
+            mips::process_code(
+                left_code,
+                left_symbol.address,
+                left_symbol.address + left_symbol.size,
+                left_relocs,
+                left_line_info,
+            )?,
+            mips::process_code(
+                right_code,
+                right_symbol.address,
+                left_symbol.address + left_symbol.size,
+                right_relocs,
+                right_line_info,
+            )?,
+        ),
+    };
+
+    let mut left_diff = Vec::<ObjInsDiff>::new();
+    let mut right_diff = Vec::<ObjInsDiff>::new();
+    match config.code_alg {
+        DiffAlg::Levenshtein => {
+            diff_instructions_lev(
+                &mut left_diff,
+                &mut right_diff,
+                left_symbol,
+                right_symbol,
+                &left_out,
+                &right_out,
+            )?;
+        }
+        DiffAlg::Lcs => {
+            diff_instructions_similar(
+                Algorithm::Lcs,
+                &mut left_diff,
+                &mut right_diff,
+                &left_out,
+                &right_out,
+            )?;
+        }
+        DiffAlg::Myers => {
+            diff_instructions_similar(
+                Algorithm::Myers,
+                &mut left_diff,
+                &mut right_diff,
+                &left_out,
+                &right_out,
+            )?;
+        }
+        DiffAlg::Patience => {
+            diff_instructions_similar(
+                Algorithm::Patience,
+                &mut left_diff,
+                &mut right_diff,
+                &left_out,
+                &right_out,
+            )?;
+        }
+    }
+
+    resolve_branches(&mut left_diff);
+    resolve_branches(&mut right_diff);
+
+    let mut diff_state = InsDiffState::default();
+    for (left, right) in left_diff.iter_mut().zip(right_diff.iter_mut()) {
+        let result = compare_ins(config, left, right, &mut diff_state)?;
+        left.kind = result.kind;
+        right.kind = result.kind;
+        left.arg_diff = result.left_args_diff;
+        right.arg_diff = result.right_args_diff;
+    }
+
+    let total = left_out.insts.len();
+    let percent = if diff_state.diff_count >= total {
+        0.0
+    } else {
+        ((total - diff_state.diff_count) as f32 / total as f32) * 100.0
+    };
+    left_symbol.match_percent = Some(percent);
+    right_symbol.match_percent = Some(percent);
+
+    left_symbol.instructions = left_diff;
+    right_symbol.instructions = right_diff;
+
+    Ok(())
+}
+
+fn diff_instructions_similar(
+    alg: Algorithm,
+    left_diff: &mut Vec<ObjInsDiff>,
+    right_diff: &mut Vec<ObjInsDiff>,
+    left_code: &ProcessCodeResult,
+    right_code: &ProcessCodeResult,
+) -> Result<()> {
+    let deadline = Instant::now() + Duration::from_secs(5);
+    let ops = capture_diff_slices_deadline(alg, &left_code.ops, &right_code.ops, Some(deadline));
+    if ops.is_empty() {
+        left_diff.extend(
+            left_code
+                .insts
+                .iter()
+                .map(|i| ObjInsDiff { ins: Some(i.clone()), ..Default::default() }),
+        );
+        right_diff.extend(
+            right_code
+                .insts
+                .iter()
+                .map(|i| ObjInsDiff { ins: Some(i.clone()), ..Default::default() }),
+        );
+        return Ok(());
+    }
+
+    for op in ops {
+        let (_tag, left_range, right_range) = op.as_tag_tuple();
+        let len = max(left_range.len(), right_range.len());
+        left_diff.extend(
+            left_code.insts[left_range.clone()]
+                .iter()
+                .map(|i| ObjInsDiff { ins: Some(i.clone()), ..Default::default() }),
+        );
+        right_diff.extend(
+            right_code.insts[right_range.clone()]
+                .iter()
+                .map(|i| ObjInsDiff { ins: Some(i.clone()), ..Default::default() }),
+        );
+        if left_range.len() < len {
+            left_diff.extend((left_range.len()..len).map(|_| ObjInsDiff::default()));
+        }
+        if right_range.len() < len {
+            right_diff.extend((right_range.len()..len).map(|_| ObjInsDiff::default()));
+        }
+    }
+
+    Ok(())
+}
+
+fn diff_instructions_lev(
+    left_diff: &mut Vec<ObjInsDiff>,
+    right_diff: &mut Vec<ObjInsDiff>,
+    left_symbol: &ObjSymbol,
+    right_symbol: &ObjSymbol,
+    left_code: &ProcessCodeResult,
+    right_code: &ProcessCodeResult,
+) -> Result<()> {
+    let edit_ops = editops_find(&left_code.ops, &right_code.ops);
+
+    let mut op_iter = edit_ops.iter();
+    let mut left_iter = left_code.insts.iter();
+    let mut right_iter = right_code.insts.iter();
+    let mut cur_op = op_iter.next();
+    let mut cur_left = left_iter.next();
+    let mut cur_right = right_iter.next();
+    while let Some(op) = cur_op {
+        let left_addr = op.first_start as u32 * 4;
+        let right_addr = op.second_start as u32 * 4;
+        while let (Some(left), Some(right)) = (cur_left, cur_right) {
+            if (left.address - left_symbol.address as u32) < left_addr {
+                left_diff.push(ObjInsDiff { ins: Some(left.clone()), ..ObjInsDiff::default() });
+                right_diff.push(ObjInsDiff { ins: Some(right.clone()), ..ObjInsDiff::default() });
+            } else {
+                break;
+            }
+            cur_left = left_iter.next();
+            cur_right = right_iter.next();
+        }
+        if let (Some(left), Some(right)) = (cur_left, cur_right) {
+            if (left.address - left_symbol.address as u32) != left_addr {
+                return Err(anyhow::Error::msg("Instruction address mismatch (left)"));
+            }
+            if (right.address - right_symbol.address as u32) != right_addr {
+                return Err(anyhow::Error::msg("Instruction address mismatch (right)"));
+            }
+            match op.op_type {
+                LevEditType::Replace => {
+                    left_diff.push(ObjInsDiff { ins: Some(left.clone()), ..ObjInsDiff::default() });
+                    right_diff
+                        .push(ObjInsDiff { ins: Some(right.clone()), ..ObjInsDiff::default() });
+                    cur_left = left_iter.next();
+                    cur_right = right_iter.next();
+                }
+                LevEditType::Insert => {
+                    left_diff.push(ObjInsDiff::default());
+                    right_diff
+                        .push(ObjInsDiff { ins: Some(right.clone()), ..ObjInsDiff::default() });
+                    cur_right = right_iter.next();
+                }
+                LevEditType::Delete => {
+                    left_diff.push(ObjInsDiff { ins: Some(left.clone()), ..ObjInsDiff::default() });
+                    right_diff.push(ObjInsDiff::default());
+                    cur_left = left_iter.next();
+                }
+            }
+        } else {
+            break;
+        }
+        cur_op = op_iter.next();
+    }
+
+    // Finalize
+    while cur_left.is_some() || cur_right.is_some() {
+        left_diff.push(ObjInsDiff { ins: cur_left.cloned(), ..ObjInsDiff::default() });
+        right_diff.push(ObjInsDiff { ins: cur_right.cloned(), ..ObjInsDiff::default() });
+        cur_left = left_iter.next();
+        cur_right = right_iter.next();
+    }
+
+    Ok(())
+}
+
+fn resolve_branches(vec: &mut [ObjInsDiff]) {
+    let mut branch_idx = 0usize;
+    // Map addresses to indices
+    let mut addr_map = BTreeMap::<u32, usize>::new();
+    for (i, ins_diff) in vec.iter().enumerate() {
+        if let Some(ins) = &ins_diff.ins {
+            addr_map.insert(ins.address, i);
+        }
+    }
+    // Generate branches
+    let mut branches = BTreeMap::<usize, ObjInsBranchFrom>::new();
+    for (i, ins_diff) in vec.iter_mut().enumerate() {
+        if let Some(ins) = &ins_diff.ins {
+            // if ins.ins.is_blr() || ins.reloc.is_some() {
+            //     continue;
+            // }
+            if let Some(ins_idx) = ins
+                .args
+                .iter()
+                .find_map(|a| if let ObjInsArg::BranchOffset(offs) = a { Some(offs) } else { None })
+                .and_then(|offs| addr_map.get(&((ins.address as i32 + offs) as u32)))
+            {
+                if let Some(branch) = branches.get_mut(ins_idx) {
+                    ins_diff.branch_to =
+                        Some(ObjInsBranchTo { ins_idx: *ins_idx, branch_idx: branch.branch_idx });
+                    branch.ins_idx.push(i);
+                } else {
+                    ins_diff.branch_to = Some(ObjInsBranchTo { ins_idx: *ins_idx, branch_idx });
+                    branches.insert(*ins_idx, ObjInsBranchFrom { ins_idx: vec![i], branch_idx });
+                    branch_idx += 1;
+                }
+            }
+        }
+    }
+    // Store branch from
+    for (i, branch) in branches {
+        vec[i].branch_from = Some(branch);
+    }
+}
+
+fn address_eq(left: &ObjSymbol, right: &ObjSymbol) -> bool {
+    left.address as i64 + left.addend == right.address as i64 + right.addend
+}
+
+fn reloc_eq(
+    config: &DiffObjConfig,
+    left_reloc: Option<&ObjReloc>,
+    right_reloc: Option<&ObjReloc>,
+) -> bool {
+    let (Some(left), Some(right)) = (left_reloc, right_reloc) else {
+        return false;
+    };
+    if left.kind != right.kind {
+        return false;
+    }
+    if config.relax_reloc_diffs {
+        return true;
+    }
+
+    let name_matches = left.target.name == right.target.name;
+    match (&left.target_section, &right.target_section) {
+        (Some(sl), Some(sr)) => {
+            // Match if section and name or address match
+            sl == sr && (name_matches || address_eq(&left.target, &right.target))
+        }
+        (Some(_), None) => false,
+        (None, Some(_)) => {
+            // Match if possibly stripped weak symbol
+            name_matches && right.target.flags.0.contains(ObjSymbolFlags::Weak)
+        }
+        (None, None) => name_matches,
+    }
+}
+
+fn arg_eq(
+    config: &DiffObjConfig,
+    left: &ObjInsArg,
+    right: &ObjInsArg,
+    left_diff: &ObjInsDiff,
+    right_diff: &ObjInsDiff,
+) -> bool {
+    return match left {
+        ObjInsArg::PpcArg(l) => match right {
+            ObjInsArg::PpcArg(r) => format!("{l}") == format!("{r}"),
+            _ => false,
+        },
+        ObjInsArg::Reloc => {
+            matches!(right, ObjInsArg::Reloc)
+                && reloc_eq(
+                    config,
+                    left_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
+                    right_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
+                )
+        }
+        ObjInsArg::RelocWithBase => {
+            matches!(right, ObjInsArg::RelocWithBase)
+                && reloc_eq(
+                    config,
+                    left_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
+                    right_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
+                )
+        }
+        ObjInsArg::MipsArg(ls) | ObjInsArg::MipsArgWithBase(ls) => {
+            matches!(right, ObjInsArg::MipsArg(rs) | ObjInsArg::MipsArgWithBase(rs) if ls == rs)
+        }
+        ObjInsArg::BranchOffset(_) => {
+            // Compare dest instruction idx after diffing
+            left_diff.branch_to.as_ref().map(|b| b.ins_idx)
+                == right_diff.branch_to.as_ref().map(|b| b.ins_idx)
+        }
+    };
+}
+
+#[derive(Default)]
+struct InsDiffState {
+    diff_count: usize,
+    left_arg_idx: usize,
+    right_arg_idx: usize,
+    left_args_idx: BTreeMap<String, usize>,
+    right_args_idx: BTreeMap<String, usize>,
+}
+
+#[derive(Default)]
+struct InsDiffResult {
+    kind: ObjInsDiffKind,
+    left_args_diff: Vec<Option<ObjInsArgDiff>>,
+    right_args_diff: Vec<Option<ObjInsArgDiff>>,
+}
+
+fn compare_ins(
+    config: &DiffObjConfig,
+    left: &ObjInsDiff,
+    right: &ObjInsDiff,
+    state: &mut InsDiffState,
+) -> Result<InsDiffResult> {
+    let mut result = InsDiffResult::default();
+    if let (Some(left_ins), Some(right_ins)) = (&left.ins, &right.ins) {
+        if left_ins.args.len() != right_ins.args.len() || left_ins.op != right_ins.op {
+            // Totally different op
+            result.kind = ObjInsDiffKind::Replace;
+            state.diff_count += 1;
+            return Ok(result);
+        }
+        if left_ins.mnemonic != right_ins.mnemonic {
+            // Same op but different mnemonic, still cmp args
+            result.kind = ObjInsDiffKind::OpMismatch;
+            state.diff_count += 1;
+        }
+        for (a, b) in left_ins.args.iter().zip(&right_ins.args) {
+            if arg_eq(config, a, b, left, right) {
+                result.left_args_diff.push(None);
+                result.right_args_diff.push(None);
+            } else {
+                if result.kind == ObjInsDiffKind::None {
+                    result.kind = ObjInsDiffKind::ArgMismatch;
+                    state.diff_count += 1;
+                }
+                let a_str = match a {
+                    ObjInsArg::PpcArg(arg) => format!("{arg}"),
+                    ObjInsArg::Reloc | ObjInsArg::RelocWithBase => String::new(),
+                    ObjInsArg::MipsArg(str) | ObjInsArg::MipsArgWithBase(str) => str.clone(),
+                    ObjInsArg::BranchOffset(arg) => format!("{arg}"),
+                };
+                let a_diff = if let Some(idx) = state.left_args_idx.get(&a_str) {
+                    ObjInsArgDiff { idx: *idx }
+                } else {
+                    let idx = state.left_arg_idx;
+                    state.left_args_idx.insert(a_str, idx);
+                    state.left_arg_idx += 1;
+                    ObjInsArgDiff { idx }
+                };
+                let b_str = match b {
+                    ObjInsArg::PpcArg(arg) => format!("{arg}"),
+                    ObjInsArg::Reloc | ObjInsArg::RelocWithBase => String::new(),
+                    ObjInsArg::MipsArg(str) | ObjInsArg::MipsArgWithBase(str) => str.clone(),
+                    ObjInsArg::BranchOffset(arg) => format!("{arg}"),
+                };
+                let b_diff = if let Some(idx) = state.right_args_idx.get(&b_str) {
+                    ObjInsArgDiff { idx: *idx }
+                } else {
+                    let idx = state.right_arg_idx;
+                    state.right_args_idx.insert(b_str, idx);
+                    state.right_arg_idx += 1;
+                    ObjInsArgDiff { idx }
+                };
+                result.left_args_diff.push(Some(a_diff));
+                result.right_args_diff.push(Some(b_diff));
+            }
+        }
+    } else if left.ins.is_some() {
+        result.kind = ObjInsDiffKind::Delete;
+        state.diff_count += 1;
+    } else {
+        result.kind = ObjInsDiffKind::Insert;
+        state.diff_count += 1;
+    }
+    Ok(result)
+}
+
+pub fn find_section_and_symbol(obj: &ObjInfo, name: &str) -> Option<(usize, usize)> {
+    for (section_idx, section) in obj.sections.iter().enumerate() {
+        let symbol_idx = match section.symbols.iter().position(|symbol| symbol.name == name) {
+            Some(symbol_idx) => symbol_idx,
+            None => continue,
+        };
+        return Some((section_idx, symbol_idx));
+    }
+    None
+}

src/diff/data.rs

@@ -0,0 +1,406 @@
+use std::{
+    cmp::{max, min, Ordering},
+    mem::take,
+    time::{Duration, Instant},
+};
+
+use anyhow::{bail, Result};
+use similar::{capture_diff_slices_deadline, Algorithm};
+
+use crate::{
+    diff::{
+        editops::{editops_find, LevEditType},
+        DiffAlg,
+    },
+    obj::{ObjDataDiff, ObjDataDiffKind, ObjSection, ObjSymbol},
+};
+
+pub fn diff_data(alg: DiffAlg, left: &mut ObjSection, right: &mut ObjSection) -> Result<()> {
+    match alg {
+        DiffAlg::Levenshtein => diff_data_lev(left, right),
+        DiffAlg::Lcs => diff_data_similar(Algorithm::Lcs, left, right),
+        DiffAlg::Myers => diff_data_similar(Algorithm::Myers, left, right),
+        DiffAlg::Patience => diff_data_similar(Algorithm::Patience, left, right),
+    }
+}
+
+pub fn diff_bss_symbols(
+    left_symbols: &mut [ObjSymbol],
+    right_symbols: &mut [ObjSymbol],
+) -> Result<()> {
+    for left_symbol in left_symbols {
+        if let Some(right_symbol) = right_symbols.iter_mut().find(|s| s.name == left_symbol.name) {
+            left_symbol.diff_symbol = Some(right_symbol.name.clone());
+            right_symbol.diff_symbol = Some(left_symbol.name.clone());
+            let percent = if left_symbol.size == right_symbol.size { 100.0 } else { 50.0 };
+            left_symbol.match_percent = Some(percent);
+            right_symbol.match_percent = Some(percent);
+        }
+    }
+    Ok(())
+}
+
+// WIP diff-by-symbol
+#[allow(dead_code)]
+pub fn diff_data_symbols(left: &mut ObjSection, right: &mut ObjSection) -> Result<()> {
+    let mut left_ops = Vec::<u32>::with_capacity(left.symbols.len());
+    let mut right_ops = Vec::<u32>::with_capacity(right.symbols.len());
+    for left_symbol in &left.symbols {
+        let data = &left.data
+            [left_symbol.address as usize..(left_symbol.address + left_symbol.size) as usize];
+        let hash = twox_hash::xxh3::hash64(data);
+        left_ops.push(hash as u32);
+    }
+    for symbol in &right.symbols {
+        let data = &right.data[symbol.address as usize..(symbol.address + symbol.size) as usize];
+        let hash = twox_hash::xxh3::hash64(data);
+        right_ops.push(hash as u32);
+    }
+
+    let edit_ops = editops_find(&left_ops, &right_ops);
+    if edit_ops.is_empty() && !left.data.is_empty() {
+        let mut left_iter = left.symbols.iter_mut();
+        let mut right_iter = right.symbols.iter_mut();
+        loop {
+            let (left_symbol, right_symbol) = match (left_iter.next(), right_iter.next()) {
+                (Some(l), Some(r)) => (l, r),
+                (None, None) => break,
+                _ => return Err(anyhow::Error::msg("L/R mismatch in diff_data_symbols")),
+            };
+            let left_data = &left.data
+                [left_symbol.address as usize..(left_symbol.address + left_symbol.size) as usize];
+            let right_data = &right.data[right_symbol.address as usize
+                ..(right_symbol.address + right_symbol.size) as usize];
+
+            left.data_diff.push(ObjDataDiff {
+                data: left_data.to_vec(),
+                kind: ObjDataDiffKind::None,
+                len: left_symbol.size as usize,
+                symbol: left_symbol.name.clone(),
+            });
+            right.data_diff.push(ObjDataDiff {
+                data: right_data.to_vec(),
+                kind: ObjDataDiffKind::None,
+                len: right_symbol.size as usize,
+                symbol: right_symbol.name.clone(),
+            });
+            left_symbol.diff_symbol = Some(right_symbol.name.clone());
+            left_symbol.match_percent = Some(100.0);
+            right_symbol.diff_symbol = Some(left_symbol.name.clone());
+            right_symbol.match_percent = Some(100.0);
+        }
+        return Ok(());
+    }
+    Ok(())
+}
+
+pub fn diff_data_similar(
+    alg: Algorithm,
+    left: &mut ObjSection,
+    right: &mut ObjSection,
+) -> Result<()> {
+    let deadline = Instant::now() + Duration::from_secs(5);
+    let ops = capture_diff_slices_deadline(alg, &left.data, &right.data, Some(deadline));
+
+    let mut left_diff = Vec::<ObjDataDiff>::new();
+    let mut right_diff = Vec::<ObjDataDiff>::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 = max(left_len, right_len);
+        let kind = match tag {
+            similar::DiffTag::Equal => ObjDataDiffKind::None,
+            similar::DiffTag::Delete => ObjDataDiffKind::Delete,
+            similar::DiffTag::Insert => ObjDataDiffKind::Insert,
+            similar::DiffTag::Replace => {
+                // Ensure replacements are equal length
+                len = min(left_len, right_len);
+                ObjDataDiffKind::Replace
+            }
+        };
+        let left_data = &left.data[left_range];
+        let right_data = &right.data[right_range];
+        left_diff.push(ObjDataDiff {
+            data: left_data[..min(len, left_data.len())].to_vec(),
+            kind,
+            len,
+            ..Default::default()
+        });
+        right_diff.push(ObjDataDiff {
+            data: right_data[..min(len, right_data.len())].to_vec(),
+            kind,
+            len,
+            ..Default::default()
+        });
+        if kind == ObjDataDiffKind::Replace {
+            match left_len.cmp(&right_len) {
+                Ordering::Less => {
+                    let len = right_len - left_len;
+                    left_diff.push(ObjDataDiff {
+                        data: vec![],
+                        kind: ObjDataDiffKind::Insert,
+                        len,
+                        ..Default::default()
+                    });
+                    right_diff.push(ObjDataDiff {
+                        data: right_data[left_len..right_len].to_vec(),
+                        kind: ObjDataDiffKind::Insert,
+                        len,
+                        ..Default::default()
+                    });
+                }
+                Ordering::Greater => {
+                    let len = left_len - right_len;
+                    left_diff.push(ObjDataDiff {
+                        data: left_data[right_len..left_len].to_vec(),
+                        kind: ObjDataDiffKind::Delete,
+                        len,
+                        ..Default::default()
+                    });
+                    right_diff.push(ObjDataDiff {
+                        data: vec![],
+                        kind: ObjDataDiffKind::Delete,
+                        len,
+                        ..Default::default()
+                    });
+                }
+                Ordering::Equal => {}
+            }
+        }
+    }
+
+    left.data_diff = left_diff;
+    right.data_diff = right_diff;
+    Ok(())
+}
+
+pub fn diff_data_lev(left: &mut ObjSection, right: &mut ObjSection) -> Result<()> {
+    let matrix_size = (left.data.len() as u64).saturating_mul(right.data.len() as u64);
+    if matrix_size > 1_000_000_000 {
+        bail!(
+            "Data section {} too large for Levenshtein diff ({} * {} = {})",
+            left.name,
+            left.data.len(),
+            right.data.len(),
+            matrix_size
+        );
+    }
+
+    let edit_ops = editops_find(&left.data, &right.data);
+    if edit_ops.is_empty() && !left.data.is_empty() {
+        left.data_diff = vec![ObjDataDiff {
+            data: left.data.clone(),
+            kind: ObjDataDiffKind::None,
+            len: left.data.len(),
+            symbol: String::new(),
+        }];
+        right.data_diff = vec![ObjDataDiff {
+            data: right.data.clone(),
+            kind: ObjDataDiffKind::None,
+            len: right.data.len(),
+            symbol: String::new(),
+        }];
+        return Ok(());
+    }
+
+    let mut left_diff = Vec::<ObjDataDiff>::new();
+    let mut right_diff = Vec::<ObjDataDiff>::new();
+    let mut left_cur = 0usize;
+    let mut right_cur = 0usize;
+    let mut cur_op = LevEditType::Replace;
+    let mut cur_left_data = Vec::<u8>::new();
+    let mut cur_right_data = Vec::<u8>::new();
+    for op in edit_ops {
+        if cur_op != op.op_type || left_cur < op.first_start || right_cur < op.second_start {
+            match cur_op {
+                LevEditType::Replace => {
+                    let left_data = take(&mut cur_left_data);
+                    let right_data = take(&mut cur_right_data);
+                    let left_data_len = left_data.len();
+                    let right_data_len = right_data.len();
+                    left_diff.push(ObjDataDiff {
+                        data: left_data,
+                        kind: ObjDataDiffKind::Replace,
+                        len: left_data_len,
+                        symbol: String::new(),
+                    });
+                    right_diff.push(ObjDataDiff {
+                        data: right_data,
+                        kind: ObjDataDiffKind::Replace,
+                        len: right_data_len,
+                        symbol: String::new(),
+                    });
+                }
+                LevEditType::Insert => {
+                    let right_data = take(&mut cur_right_data);
+                    let right_data_len = right_data.len();
+                    left_diff.push(ObjDataDiff {
+                        data: vec![],
+                        kind: ObjDataDiffKind::Insert,
+                        len: right_data_len,
+                        symbol: String::new(),
+                    });
+                    right_diff.push(ObjDataDiff {
+                        data: right_data,
+                        kind: ObjDataDiffKind::Insert,
+                        len: right_data_len,
+                        symbol: String::new(),
+                    });
+                }
+                LevEditType::Delete => {
+                    let left_data = take(&mut cur_left_data);
+                    let left_data_len = left_data.len();
+                    left_diff.push(ObjDataDiff {
+                        data: left_data,
+                        kind: ObjDataDiffKind::Delete,
+                        len: left_data_len,
+                        symbol: String::new(),
+                    });
+                    right_diff.push(ObjDataDiff {
+                        data: vec![],
+                        kind: ObjDataDiffKind::Delete,
+                        len: left_data_len,
+                        symbol: String::new(),
+                    });
+                }
+            }
+        }
+        if left_cur < op.first_start {
+            left_diff.push(ObjDataDiff {
+                data: left.data[left_cur..op.first_start].to_vec(),
+                kind: ObjDataDiffKind::None,
+                len: op.first_start - left_cur,
+                symbol: String::new(),
+            });
+            left_cur = op.first_start;
+        }
+        if right_cur < op.second_start {
+            right_diff.push(ObjDataDiff {
+                data: right.data[right_cur..op.second_start].to_vec(),
+                kind: ObjDataDiffKind::None,
+                len: op.second_start - right_cur,
+                symbol: String::new(),
+            });
+            right_cur = op.second_start;
+        }
+        match op.op_type {
+            LevEditType::Replace => {
+                cur_left_data.push(left.data[left_cur]);
+                cur_right_data.push(right.data[right_cur]);
+                left_cur += 1;
+                right_cur += 1;
+            }
+            LevEditType::Insert => {
+                cur_right_data.push(right.data[right_cur]);
+                right_cur += 1;
+            }
+            LevEditType::Delete => {
+                cur_left_data.push(left.data[left_cur]);
+                left_cur += 1;
+            }
+        }
+        cur_op = op.op_type;
+    }
+    // if left_cur < left.data.len() {
+    //     let len = left.data.len() - left_cur;
+    //     left_diff.push(ObjDataDiff {
+    //         data: left.data[left_cur..].to_vec(),
+    //         kind: ObjDataDiffKind::Delete,
+    //         len,
+    //     });
+    //     right_diff.push(ObjDataDiff { data: vec![], kind: ObjDataDiffKind::Delete, len });
+    // } else if right_cur < right.data.len() {
+    //     let len = right.data.len() - right_cur;
+    //     left_diff.push(ObjDataDiff { data: vec![], kind: ObjDataDiffKind::Insert, len });
+    //     right_diff.push(ObjDataDiff {
+    //         data: right.data[right_cur..].to_vec(),
+    //         kind: ObjDataDiffKind::Insert,
+    //         len,
+    //     });
+    // }
+
+    // TODO: merge with above
+    match cur_op {
+        LevEditType::Replace => {
+            let left_data = take(&mut cur_left_data);
+            let right_data = take(&mut cur_right_data);
+            let left_data_len = left_data.len();
+            let right_data_len = right_data.len();
+            left_diff.push(ObjDataDiff {
+                data: left_data,
+                kind: ObjDataDiffKind::Replace,
+                len: left_data_len,
+                symbol: String::new(),
+            });
+            right_diff.push(ObjDataDiff {
+                data: right_data,
+                kind: ObjDataDiffKind::Replace,
+                len: right_data_len,
+                symbol: String::new(),
+            });
+        }
+        LevEditType::Insert => {
+            let right_data = take(&mut cur_right_data);
+            let right_data_len = right_data.len();
+            left_diff.push(ObjDataDiff {
+                data: vec![],
+                kind: ObjDataDiffKind::Insert,
+                len: right_data_len,
+                symbol: String::new(),
+            });
+            right_diff.push(ObjDataDiff {
+                data: right_data,
+                kind: ObjDataDiffKind::Insert,
+                len: right_data_len,
+                symbol: String::new(),
+            });
+        }
+        LevEditType::Delete => {
+            let left_data = take(&mut cur_left_data);
+            let left_data_len = left_data.len();
+            left_diff.push(ObjDataDiff {
+                data: left_data,
+                kind: ObjDataDiffKind::Delete,
+                len: left_data_len,
+                symbol: String::new(),
+            });
+            right_diff.push(ObjDataDiff {
+                data: vec![],
+                kind: ObjDataDiffKind::Delete,
+                len: left_data_len,
+                symbol: String::new(),
+            });
+        }
+    }
+
+    if left_cur < left.data.len() {
+        left_diff.push(ObjDataDiff {
+            data: left.data[left_cur..].to_vec(),
+            kind: ObjDataDiffKind::None,
+            len: left.data.len() - left_cur,
+            symbol: String::new(),
+        });
+    }
+    if right_cur < right.data.len() {
+        right_diff.push(ObjDataDiff {
+            data: right.data[right_cur..].to_vec(),
+            kind: ObjDataDiffKind::None,
+            len: right.data.len() - right_cur,
+            symbol: String::new(),
+        });
+    }
+
+    left.data_diff = left_diff;
+    right.data_diff = right_diff;
+    Ok(())
+}
+
+pub fn no_diff_data(section: &mut ObjSection) {
+    section.data_diff = vec![ObjDataDiff {
+        data: section.data.clone(),
+        kind: ObjDataDiffKind::None,
+        len: section.data.len(),
+        symbol: String::new(),
+    }];
+}

src/diff/mod.rs

@@ -0,0 +1,115 @@
+pub mod code;
+pub mod data;
+pub mod editops;
+
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    diff::{
+        code::{diff_code, find_section_and_symbol, no_diff_code},
+        data::{diff_bss_symbols, diff_data, no_diff_data},
+    },
+    obj::{ObjInfo, ObjIns, ObjSectionKind},
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub enum DiffAlg {
+    #[default]
+    Patience,
+    Levenshtein,
+    Myers,
+    Lcs,
+}
+
+pub struct DiffObjConfig {
+    pub code_alg: DiffAlg,
+    pub data_alg: DiffAlg,
+    pub relax_reloc_diffs: bool,
+}
+
+pub struct ProcessCodeResult {
+    pub ops: Vec<u8>,
+    pub insts: Vec<ObjIns>,
+}
+
+pub fn diff_objs(
+    config: &DiffObjConfig,
+    mut left: Option<&mut ObjInfo>,
+    mut right: Option<&mut ObjInfo>,
+) -> Result<()> {
+    if let Some(left) = left.as_mut() {
+        for left_section in &mut left.sections {
+            if left_section.kind == ObjSectionKind::Code {
+                for left_symbol in &mut left_section.symbols {
+                    if let Some((right, (right_section_idx, right_symbol_idx))) =
+                        right.as_mut().and_then(|obj| {
+                            find_section_and_symbol(obj, &left_symbol.name).map(|s| (obj, s))
+                        })
+                    {
+                        let right_section = &mut right.sections[right_section_idx];
+                        let right_symbol = &mut right_section.symbols[right_symbol_idx];
+                        left_symbol.diff_symbol = Some(right_symbol.name.clone());
+                        right_symbol.diff_symbol = Some(left_symbol.name.clone());
+                        diff_code(
+                            config,
+                            left.architecture,
+                            &left_section.data,
+                            &right_section.data,
+                            left_symbol,
+                            right_symbol,
+                            &left_section.relocations,
+                            &right_section.relocations,
+                            &left.line_info,
+                            &right.line_info,
+                        )?;
+                    } else {
+                        no_diff_code(
+                            left.architecture,
+                            &left_section.data,
+                            left_symbol,
+                            &left_section.relocations,
+                            &left.line_info,
+                        )?;
+                    }
+                }
+            } else if let Some(right_section) = right
+                .as_mut()
+                .and_then(|obj| obj.sections.iter_mut().find(|s| s.name == left_section.name))
+            {
+                if left_section.kind == ObjSectionKind::Data {
+                    diff_data(config.data_alg, left_section, right_section)?;
+                } else if left_section.kind == ObjSectionKind::Bss {
+                    diff_bss_symbols(&mut left_section.symbols, &mut right_section.symbols)?;
+                }
+            } else if left_section.kind == ObjSectionKind::Data {
+                no_diff_data(left_section);
+            }
+        }
+    }
+    if let Some(right) = right.as_mut() {
+        for right_section in right.sections.iter_mut() {
+            if right_section.kind == ObjSectionKind::Code {
+                for right_symbol in &mut right_section.symbols {
+                    if right_symbol.instructions.is_empty() {
+                        no_diff_code(
+                            right.architecture,
+                            &right_section.data,
+                            right_symbol,
+                            &right_section.relocations,
+                            &right.line_info,
+                        )?;
+                    }
+                }
+            } else if right_section.kind == ObjSectionKind::Data
+                && right_section.data_diff.is_empty()
+            {
+                no_diff_data(right_section);
+            }
+        }
+    }
+    if let (Some(left), Some(right)) = (left, right) {
+        diff_bss_symbols(&mut left.common, &mut right.common)?;
+    }
+    Ok(())
+}

src/fonts/matching.rs

@@ -0,0 +1,146 @@
+// font-kit/src/matching.rs
+//
+// Copyright © 2018 The Pathfinder Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Determines the closest font matching a description per the CSS Fonts Level 3 specification.
+
+use float_ord::FloatOrd;
+use font_kit::{
+    error::SelectionError,
+    properties::{Properties, Stretch, Style, Weight},
+};
+
+/// This follows CSS Fonts Level 3 § 5.2 [1].
+///
+/// https://drafts.csswg.org/css-fonts-3/#font-style-matching
+pub fn find_best_match(
+    candidates: &[Properties],
+    query: &Properties,
+) -> Result<usize, SelectionError> {
+    // Step 4.
+    let mut matching_set: Vec<usize> = (0..candidates.len()).collect();
+    if matching_set.is_empty() {
+        return Err(SelectionError::NotFound);
+    }
+
+    // Step 4a (`font-stretch`).
+    let matching_stretch = if matching_set
+        .iter()
+        .any(|&index| candidates[index].stretch == query.stretch)
+    {
+        // Exact match.
+        query.stretch
+    } else if query.stretch <= Stretch::NORMAL {
+        // Closest width, first checking narrower values and then wider values.
+        match matching_set
+            .iter()
+            .filter(|&&index| candidates[index].stretch < query.stretch)
+            .min_by_key(|&&index| FloatOrd(query.stretch.0 - candidates[index].stretch.0))
+        {
+            Some(&matching_index) => candidates[matching_index].stretch,
+            None => {
+                let matching_index = *matching_set
+                    .iter()
+                    .min_by_key(|&&index| FloatOrd(candidates[index].stretch.0 - query.stretch.0))
+                    .unwrap();
+                candidates[matching_index].stretch
+            }
+        }
+    } else {
+        // Closest width, first checking wider values and then narrower values.
+        match matching_set
+            .iter()
+            .filter(|&&index| candidates[index].stretch > query.stretch)
+            .min_by_key(|&&index| FloatOrd(candidates[index].stretch.0 - query.stretch.0))
+        {
+            Some(&matching_index) => candidates[matching_index].stretch,
+            None => {
+                let matching_index = *matching_set
+                    .iter()
+                    .min_by_key(|&&index| FloatOrd(query.stretch.0 - candidates[index].stretch.0))
+                    .unwrap();
+                candidates[matching_index].stretch
+            }
+        }
+    };
+    matching_set.retain(|&index| candidates[index].stretch == matching_stretch);
+
+    // Step 4b (`font-style`).
+    let style_preference = match query.style {
+        Style::Italic => [Style::Italic, Style::Oblique, Style::Normal],
+        Style::Oblique => [Style::Oblique, Style::Italic, Style::Normal],
+        Style::Normal => [Style::Normal, Style::Oblique, Style::Italic],
+    };
+    let matching_style = *style_preference
+        .iter()
+        .find(|&query_style| {
+            matching_set.iter().any(|&index| candidates[index].style == *query_style)
+        })
+        .unwrap();
+    matching_set.retain(|&index| candidates[index].style == matching_style);
+
+    // Step 4c (`font-weight`).
+    //
+    // The spec doesn't say what to do if the weight is between 400 and 500 exclusive, so we
+    // just use 450 as the cutoff.
+    let matching_weight =
+        if matching_set.iter().any(|&index| candidates[index].weight == query.weight) {
+            query.weight
+        } else if query.weight >= Weight(400.0)
+            && query.weight < Weight(450.0)
+            && matching_set.iter().any(|&index| candidates[index].weight == Weight(500.0))
+        {
+            // Check 500 first.
+            Weight(500.0)
+        } else if query.weight >= Weight(450.0)
+            && query.weight <= Weight(500.0)
+            && matching_set.iter().any(|&index| candidates[index].weight == Weight(400.0))
+        {
+            // Check 400 first.
+            Weight(400.0)
+        } else if query.weight <= Weight(500.0) {
+            // Closest weight, first checking thinner values and then fatter ones.
+            match matching_set
+                .iter()
+                .filter(|&&index| candidates[index].weight <= query.weight)
+                .min_by_key(|&&index| FloatOrd(query.weight.0 - candidates[index].weight.0))
+            {
+                Some(&matching_index) => candidates[matching_index].weight,
+                None => {
+                    let matching_index = *matching_set
+                        .iter()
+                        .min_by_key(|&&index| FloatOrd(candidates[index].weight.0 - query.weight.0))
+                        .unwrap();
+                    candidates[matching_index].weight
+                }
+            }
+        } else {
+            // Closest weight, first checking fatter values and then thinner ones.
+            match matching_set
+                .iter()
+                .filter(|&&index| candidates[index].weight >= query.weight)
+                .min_by_key(|&&index| FloatOrd(candidates[index].weight.0 - query.weight.0))
+            {
+                Some(&matching_index) => candidates[matching_index].weight,
+                None => {
+                    let matching_index = *matching_set
+                        .iter()
+                        .min_by_key(|&&index| FloatOrd(query.weight.0 - candidates[index].weight.0))
+                        .unwrap();
+                    candidates[matching_index].weight
+                }
+            }
+        };
+    matching_set.retain(|&index| candidates[index].weight == matching_weight);
+
+    // Step 4d concerns `font-size`, but fonts in `font-kit` are unsized, so we ignore that.
+
+    // Return the result.
+    matching_set.into_iter().next().ok_or(SelectionError::NotFound)
+}

src/fonts/mod.rs

@@ -0,0 +1,104 @@
+pub mod matching;
+
+use std::{borrow::Cow, fs, sync::Arc};
+
+use anyhow::{Context, Result};
+
+use crate::fonts::matching::find_best_match;
+
+pub struct LoadedFontFamily {
+    pub family_name: String,
+    pub fonts: Vec<font_kit::font::Font>,
+    pub handles: Vec<font_kit::handle::Handle>,
+    pub properties: Vec<font_kit::properties::Properties>,
+    pub default_index: usize,
+}
+
+pub struct LoadedFont {
+    pub font_name: String,
+    pub font_data: egui::FontData,
+}
+
+pub fn load_font_family(
+    source: &font_kit::source::SystemSource,
+    name: &str,
+) -> Option<LoadedFontFamily> {
+    let family_handle = source.select_family_by_name(name).ok()?;
+    if family_handle.fonts().is_empty() {
+        log::warn!("No fonts found for family '{}'", name);
+        return None;
+    }
+    let handles = family_handle.fonts().to_vec();
+    let mut loaded = Vec::with_capacity(handles.len());
+    for handle in handles.iter() {
+        match font_kit::loaders::default::Font::from_handle(handle) {
+            Ok(font) => loaded.push(font),
+            Err(err) => {
+                log::warn!("Failed to load font '{}': {}", name, err);
+                return None;
+            }
+        }
+    }
+    let properties = loaded.iter().map(|f| f.properties()).collect::<Vec<_>>();
+    let default_index =
+        find_best_match(&properties, &font_kit::properties::Properties::new()).unwrap_or(0);
+    let font_family_name =
+        loaded.first().map(|f| f.family_name()).unwrap_or_else(|| name.to_string());
+    Some(LoadedFontFamily {
+        family_name: font_family_name,
+        fonts: loaded,
+        handles,
+        properties,
+        default_index,
+    })
+}
+
+pub fn load_font(handle: &font_kit::handle::Handle) -> Result<LoadedFont> {
+    let loaded = font_kit::loaders::default::Font::from_handle(handle)?;
+    let data = match handle {
+        font_kit::handle::Handle::Memory { bytes, font_index } => egui::FontData {
+            font: Cow::Owned(bytes.to_vec()),
+            index: *font_index,
+            tweak: Default::default(),
+        },
+        font_kit::handle::Handle::Path { path, font_index } => {
+            let vec = fs::read(path).with_context(|| {
+                format!("Failed to load font '{}' (index {})", path.display(), font_index)
+            })?;
+            egui::FontData { font: Cow::Owned(vec), index: *font_index, tweak: Default::default() }
+        }
+    };
+    Ok(LoadedFont { font_name: loaded.full_name(), font_data: data })
+}
+
+pub fn load_font_if_needed(
+    ctx: &egui::Context,
+    source: &font_kit::source::SystemSource,
+    font_id: &egui::FontId,
+    base_family: egui::FontFamily,
+    fonts: &mut egui::FontDefinitions,
+) -> Result<()> {
+    if fonts.families.contains_key(&font_id.family) {
+        return Ok(());
+    }
+    let family_name = match &font_id.family {
+        egui::FontFamily::Proportional | egui::FontFamily::Monospace => return Ok(()),
+        egui::FontFamily::Name(v) => v,
+    };
+    let family = load_font_family(source, family_name)
+        .with_context(|| format!("Failed to load font family '{}'", family_name))?;
+    let default_fonts = fonts.families.get(&base_family).cloned().unwrap_or_default();
+    // FIXME clean up
+    let default_font_ref = family.fonts.get(family.default_index).unwrap();
+    let default_font = family.handles.get(family.default_index).unwrap();
+    let default_font_data = load_font(default_font).unwrap();
+    log::info!("Loaded font family '{}'", family.family_name);
+    fonts.font_data.insert(default_font_ref.full_name(), default_font_data.font_data);
+    fonts
+        .families
+        .entry(egui::FontFamily::Name(Arc::from(family.family_name)))
+        .or_insert_with(|| default_fonts)
+        .insert(0, default_font_ref.full_name());
+    ctx.set_fonts(fonts.clone());
+    Ok(())
+}

src/jobs/check_update.rs

@@ -4,7 +4,7 @@ use anyhow::{Context, Result};
 use self_update::{cargo_crate_version, update::Release};
 
 use crate::{
-    jobs::{start_job, update_status, Job, JobResult, JobState, JobStatusRef},
+    jobs::{start_job, update_status, Job, JobContext, JobResult, JobState},
     update::{build_updater, BIN_NAME},
 };
 
@@ -14,20 +14,20 @@ pub struct CheckUpdateResult {
     pub found_binary: bool,
 }
 
-fn run_check_update(status: &JobStatusRef, cancel: Receiver<()>) -> Result<Box<CheckUpdateResult>> {
-    update_status(status, "Fetching latest release".to_string(), 0, 1, &cancel)?;
+fn run_check_update(context: &JobContext, cancel: Receiver<()>) -> Result<Box<CheckUpdateResult>> {
+    update_status(context, "Fetching latest release".to_string(), 0, 1, &cancel)?;
     let updater = 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)?;
     let found_binary = latest_release.assets.iter().any(|a| a.name == BIN_NAME);
 
-    update_status(status, "Complete".to_string(), 1, 1, &cancel)?;
+    update_status(context, "Complete".to_string(), 1, 1, &cancel)?;
     Ok(Box::new(CheckUpdateResult { update_available, latest_release, found_binary }))
 }
 
-pub fn start_check_update() -> JobState {
-    start_job("Check for updates", Job::CheckUpdate, move |status, cancel| {
-        run_check_update(status, cancel).map(|result| JobResult::CheckUpdate(Some(result)))
+pub fn start_check_update(ctx: &egui::Context) -> JobState {
+    start_job(ctx, "Check for updates", Job::CheckUpdate, move |context, cancel| {
+        run_check_update(&context, cancel).map(|result| JobResult::CheckUpdate(Some(result)))
     })
 }

src/jobs/create_scratch.rs

@@ -0,0 +1,135 @@
+use std::{fs, path::PathBuf, sync::mpsc::Receiver};
+
+use anyhow::{anyhow, bail, Context, Result};
+use const_format::formatcp;
+
+use crate::{
+    app::AppConfig,
+    jobs::{
+        objdiff::{run_make, BuildConfig, BuildStatus},
+        start_job, update_status, Job, JobContext, JobResult, JobState,
+    },
+};
+
+#[derive(Debug, Clone)]
+pub struct CreateScratchConfig {
+    pub build_config: BuildConfig,
+    pub context_path: Option<PathBuf>,
+    pub build_context: bool,
+
+    // Scratch fields
+    pub compiler: String,
+    pub platform: String,
+    pub compiler_flags: String,
+    pub function_name: String,
+    pub target_obj: PathBuf,
+}
+
+impl CreateScratchConfig {
+    pub(crate) fn from_config(config: &AppConfig, function_name: String) -> Result<Self> {
+        let Some(selected_obj) = &config.selected_obj else {
+            bail!("No object selected");
+        };
+        let Some(target_path) = &selected_obj.target_path else {
+            bail!("No target path for {}", selected_obj.name);
+        };
+        let Some(scratch_config) = &selected_obj.scratch else {
+            bail!("No scratch configuration for {}", selected_obj.name);
+        };
+        Ok(Self {
+            build_config: BuildConfig::from_config(config),
+            context_path: scratch_config.ctx_path.clone(),
+            build_context: scratch_config.build_ctx,
+            compiler: scratch_config.compiler.clone().unwrap_or_default(),
+            platform: scratch_config.platform.clone().unwrap_or_default(),
+            compiler_flags: scratch_config.c_flags.clone().unwrap_or_default(),
+            function_name,
+            target_obj: target_path.to_path_buf(),
+        })
+    }
+
+    pub fn is_available(config: &AppConfig) -> bool {
+        let Some(selected_obj) = &config.selected_obj else {
+            return false;
+        };
+        selected_obj.target_path.is_some() && selected_obj.scratch.is_some()
+    }
+}
+
+#[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 = "http://127.0.0.1:8000";
+const WEB_HOST: &str = "http://localhost:8080";
+
+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) {
+                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);
+        context = Some(
+            fs::read_to_string(&context_path)
+                .map_err(|e| anyhow!("Failed to read {}: {}", context_path.display(), 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).unwrap();
+    let obj_path = project_dir.join(&config.target_obj);
+    let file = reqwest::blocking::multipart::Part::file(&obj_path)
+        .with_context(|| format!("Failed to open {}", obj_path.display()))?;
+    let 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")
+        .part("target_obj", file);
+    let client = reqwest::blocking::Client::new();
+    let response = client
+        .post(formatcp!("{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!("{WEB_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(ctx: &egui::Context, config: CreateScratchConfig) -> JobState {
+    start_job(ctx, "Create scratch", Job::CreateScratch, move |context, cancel| {
+        run_create_scratch(&context, cancel, config)
+            .map(|result| JobResult::CreateScratch(Some(result)))
+    })
+}

src/jobs/mod.rs

@@ -9,9 +9,13 @@ use std::{
 
 use anyhow::Result;
 
-use crate::jobs::{check_update::CheckUpdateResult, objdiff::ObjDiffResult, update::UpdateResult};
+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;
 
@@ -20,6 +24,7 @@ pub enum Job {
     ObjDiff,
     CheckUpdate,
     Update,
+    CreateScratch,
 }
 pub static JOB_ID: AtomicUsize = AtomicUsize::new(0);
 
@@ -48,6 +53,7 @@ impl JobQueue {
     }
 
     /// Returns whether any job is running.
+    #[allow(dead_code)]
     pub fn any_running(&self) -> bool {
         self.jobs.iter().any(|job| {
             if let Some(handle) = &job.handle {
@@ -81,7 +87,7 @@ impl JobQueue {
         self.jobs.retain(|job| {
             !(job.should_remove
                 && job.handle.is_none()
-                && job.status.read().unwrap().error.is_none())
+                && job.context.status.read().unwrap().error.is_none())
         });
     }
 
@@ -89,13 +95,17 @@ impl JobQueue {
     pub fn remove(&mut self, id: usize) { self.jobs.retain(|job| job.id != id); }
 }
 
-pub type JobStatusRef = Arc<RwLock<JobStatus>>;
+#[derive(Clone)]
+pub struct JobContext {
+    pub status: Arc<RwLock<JobStatus>>,
+    pub egui: egui::Context,
+}
 
 pub struct JobState {
     pub id: usize,
     pub kind: Job,
     pub handle: Option<JoinHandle<JobResult>>,
-    pub status: JobStatusRef,
+    pub context: JobContext,
     pub cancel: Sender<()>,
     pub should_remove: bool,
 }
@@ -114,6 +124,7 @@ pub enum JobResult {
     ObjDiff(Option<Box<ObjDiffResult>>),
     CheckUpdate(Option<Box<CheckUpdateResult>>),
     Update(Box<UpdateResult>),
+    CreateScratch(Option<Box<CreateScratchResult>>),
 }
 
 fn should_cancel(rx: &Receiver<()>) -> bool {
@@ -124,9 +135,10 @@ fn should_cancel(rx: &Receiver<()>) -> bool {
 }
 
 fn start_job(
+    ctx: &egui::Context,
     title: &str,
     kind: Job,
-    run: impl FnOnce(&JobStatusRef, Receiver<()>) -> Result<JobResult> + Send + 'static,
+    run: impl FnOnce(JobContext, Receiver<()>) -> Result<JobResult> + Send + 'static,
 ) -> JobState {
     let status = Arc::new(RwLock::new(JobStatus {
         title: title.to_string(),
@@ -135,10 +147,11 @@ fn start_job(
         status: String::new(),
         error: None,
     }));
-    let status_clone = status.clone();
+    let context = JobContext { status: status.clone(), egui: ctx.clone() };
+    let context_inner = JobContext { status: status.clone(), egui: ctx.clone() };
     let (tx, rx) = std::sync::mpsc::channel();
     let handle = std::thread::spawn(move || {
-        return match run(&status, rx) {
+        return match run(context_inner, rx) {
             Ok(state) => state,
             Err(e) => {
                 if let Ok(mut w) = status.write() {
@@ -150,24 +163,18 @@ fn start_job(
     });
     let id = JOB_ID.fetch_add(1, Ordering::Relaxed);
     log::info!("Started job {}", id);
-    JobState {
-        id,
-        kind,
-        handle: Some(handle),
-        status: status_clone,
-        cancel: tx,
-        should_remove: true,
-    }
+    JobState { id, kind, handle: Some(handle), context, cancel: tx, should_remove: true }
 }
 
 fn update_status(
-    status: &JobStatusRef,
+    context: &JobContext,
     str: String,
     count: u32,
     total: u32,
     cancel: &Receiver<()>,
 ) -> Result<()> {
-    let mut w = status.write().map_err(|_| anyhow::Error::msg("Failed to lock job status"))?;
+    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) {
@@ -176,5 +183,7 @@ fn update_status(
     } else {
         w.status = str;
     }
+    drop(w);
+    context.egui.request_repaint();
     Ok(())
 }

src/jobs/objdiff.rs

@@ -1,18 +1,77 @@
-use std::{path::Path, process::Command, str::from_utf8, sync::mpsc::Receiver};
+use std::{
+    path::{Path, PathBuf},
+    process::Command,
+    str::from_utf8,
+    sync::mpsc::Receiver,
+};
 
-use anyhow::{Context, Error, Result};
+use anyhow::{anyhow, Context, Error, Result};
 use time::OffsetDateTime;
 
 use crate::{
-    app::{AppConfig, AppConfigRef},
-    diff::diff_objs,
-    jobs::{start_job, update_status, Job, JobResult, JobState, JobStatusRef},
+    app::{AppConfig, ObjectConfig},
+    diff::{diff_objs, DiffAlg, DiffObjConfig},
+    jobs::{start_job, update_status, Job, JobContext, JobResult, JobState},
     obj::{elf, ObjInfo},
 };
 
 pub struct BuildStatus {
     pub success: bool,
-    pub log: String,
+    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<PathBuf>,
+    pub custom_make: Option<String>,
+    pub selected_wsl_distro: Option<String>,
+}
+
+impl BuildConfig {
+    pub(crate) fn from_config(config: &AppConfig) -> Self {
+        Self {
+            project_dir: config.project_dir.clone(),
+            custom_make: config.custom_make.clone(),
+            selected_wsl_distro: config.selected_wsl_distro.clone(),
+        }
+    }
+}
+
+pub struct ObjDiffConfig {
+    pub build_config: BuildConfig,
+    pub build_base: bool,
+    pub build_target: bool,
+    pub selected_obj: Option<ObjectConfig>,
+    pub code_alg: DiffAlg,
+    pub data_alg: DiffAlg,
+    pub relax_reloc_diffs: bool,
+}
+
+impl ObjDiffConfig {
+    pub(crate) fn from_config(config: &AppConfig) -> Self {
+        Self {
+            build_config: BuildConfig::from_config(config),
+            build_base: config.build_base,
+            build_target: config.build_target,
+            selected_obj: config.selected_obj.clone(),
+            code_alg: config.code_alg,
+            data_alg: config.data_alg,
+            relax_reloc_diffs: config.relax_reloc_diffs,
+        }
+    }
 }
 
 pub struct ObjDiffResult {
@@ -23,7 +82,14 @@ pub struct ObjDiffResult {
     pub time: OffsetDateTime,
 }
 
-fn run_make(cwd: &Path, arg: &Path, config: &AppConfig) -> BuildStatus {
+pub(crate) fn run_make(config: &BuildConfig, arg: &Path) -> BuildStatus {
+    let Some(cwd) = &config.project_dir else {
+        return BuildStatus {
+            success: false,
+            stderr: "Missing project dir".to_string(),
+            ..Default::default()
+        };
+    };
     match (|| -> Result<BuildStatus> {
         let make = config.custom_make.as_deref().unwrap_or("make");
         #[cfg(not(windows))]
@@ -57,81 +123,146 @@ fn run_make(cwd: &Path, arg: &Path, config: &AppConfig) -> BuildStatus {
             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 = command.output().context("Failed to execute build")?;
         let stdout = from_utf8(&output.stdout).context("Failed to process stdout")?;
         let stderr = from_utf8(&output.stderr).context("Failed to process stderr")?;
         Ok(BuildStatus {
             success: output.status.code().unwrap_or(-1) == 0,
-            log: format!("{stdout}\n{stderr}"),
+            cmdline,
+            stdout: stdout.to_string(),
+            stderr: stderr.to_string(),
         })
     })() {
         Ok(status) => status,
-        Err(e) => BuildStatus { success: false, log: e.to_string() },
+        Err(e) => BuildStatus { success: false, stderr: e.to_string(), ..Default::default() },
     }
 }
 
 fn run_build(
-    status: &JobStatusRef,
+    context: &JobContext,
     cancel: Receiver<()>,
-    config: AppConfigRef,
+    config: ObjDiffConfig,
 ) -> Result<Box<ObjDiffResult>> {
-    let config = config.read().map_err(|_| Error::msg("Failed to lock app config"))?.clone();
-    let obj_path = config.obj_path.as_ref().ok_or_else(|| Error::msg("Missing obj path"))?;
-    let project_dir =
-        config.project_dir.as_ref().ok_or_else(|| Error::msg("Missing project dir"))?;
-    let mut target_path = config
-        .target_obj_dir
+    let obj_config = config.selected_obj.as_ref().ok_or_else(|| Error::msg("Missing obj path"))?;
+    let project_dir = config
+        .build_config
+        .project_dir
         .as_ref()
-        .ok_or_else(|| Error::msg("Missing target obj dir"))?
-        .to_owned();
-    target_path.push(obj_path);
-    let mut base_path =
-        config.base_obj_dir.as_ref().ok_or_else(|| Error::msg("Missing base obj dir"))?.to_owned();
-    base_path.push(obj_path);
-    let target_path_rel = target_path
-        .strip_prefix(project_dir)
-        .context("Failed to create relative target obj path")?;
-    let base_path_rel =
-        base_path.strip_prefix(project_dir).context("Failed to create relative base obj path")?;
-
-    let total = if config.build_target { 5 } else { 4 };
-    let first_status = if config.build_target {
-        update_status(status, format!("Building target {obj_path}"), 0, total, &cancel)?;
-        run_make(project_dir, target_path_rel, &config)
+        .ok_or_else(|| Error::msg("Missing project dir"))?;
+    let target_path_rel = if let Some(target_path) = &obj_config.target_path {
+        Some(target_path.strip_prefix(project_dir).map_err(|_| {
+            anyhow!(
+                "Target path '{}' doesn't begin with '{}'",
+                target_path.display(),
+                project_dir.display()
+            )
+        })?)
     } else {
-        BuildStatus { success: true, log: String::new() }
+        None
+    };
+    let base_path_rel = if let Some(base_path) = &obj_config.base_path {
+        Some(base_path.strip_prefix(project_dir).map_err(|_| {
+            anyhow!(
+                "Base path '{}' doesn't begin with '{}'",
+                base_path.display(),
+                project_dir.display()
+            )
+        })?)
+    } else {
+        None
     };
 
-    update_status(status, format!("Building base {obj_path}"), 1, total, &cancel)?;
-    let second_status = run_make(project_dir, base_path_rel, &config);
+    let mut total = 3;
+    if config.build_target && target_path_rel.is_some() {
+        total += 1;
+    }
+    if config.build_base && base_path_rel.is_some() {
+        total += 1;
+    }
+    let first_status = match target_path_rel {
+        Some(target_path_rel) if config.build_target => {
+            update_status(
+                context,
+                format!("Building target {}", target_path_rel.display()),
+                0,
+                total,
+                &cancel,
+            )?;
+            run_make(&config.build_config, target_path_rel)
+        }
+        _ => BuildStatus::default(),
+    };
+
+    let second_status = match base_path_rel {
+        Some(base_path_rel) if config.build_base => {
+            update_status(
+                context,
+                format!("Building base {}", base_path_rel.display()),
+                0,
+                total,
+                &cancel,
+            )?;
+            run_make(&config.build_config, base_path_rel)
+        }
+        _ => BuildStatus::default(),
+    };
 
     let time = OffsetDateTime::now_utc();
 
-    let mut first_obj = if first_status.success {
-        update_status(status, format!("Loading target {obj_path}"), 2, total, &cancel)?;
-        Some(elf::read(&target_path)?)
-    } else {
-        None
+    let mut first_obj =
+        match &obj_config.target_path {
+            Some(target_path) if first_status.success => {
+                update_status(
+                    context,
+                    format!("Loading target {}", target_path_rel.unwrap().display()),
+                    2,
+                    total,
+                    &cancel,
+                )?;
+                Some(elf::read(target_path).with_context(|| {
+                    format!("Failed to read object '{}'", target_path.display())
+                })?)
+            }
+            _ => None,
+        };
+
+    let mut second_obj = match &obj_config.base_path {
+        Some(base_path) if second_status.success => {
+            update_status(
+                context,
+                format!("Loading base {}", base_path_rel.unwrap().display()),
+                3,
+                total,
+                &cancel,
+            )?;
+            Some(
+                elf::read(base_path)
+                    .with_context(|| format!("Failed to read object '{}'", base_path.display()))?,
+            )
+        }
+        _ => None,
     };
 
-    let mut second_obj = if second_status.success {
-        update_status(status, format!("Loading base {obj_path}"), 3, total, &cancel)?;
-        Some(elf::read(&base_path)?)
-    } else {
-        None
+    update_status(context, "Performing diff".to_string(), 4, total, &cancel)?;
+    let diff_config = DiffObjConfig {
+        code_alg: config.code_alg,
+        data_alg: config.data_alg,
+        relax_reloc_diffs: config.relax_reloc_diffs,
     };
+    diff_objs(&diff_config, first_obj.as_mut(), second_obj.as_mut())?;
 
-    if let (Some(first_obj), Some(second_obj)) = (&mut first_obj, &mut second_obj) {
-        update_status(status, "Performing diff".to_string(), 4, total, &cancel)?;
-        diff_objs(first_obj, second_obj)?;
-    }
-
-    update_status(status, "Complete".to_string(), total, total, &cancel)?;
+    update_status(context, "Complete".to_string(), total, total, &cancel)?;
     Ok(Box::new(ObjDiffResult { first_status, second_status, first_obj, second_obj, time }))
 }
 
-pub fn start_build(config: AppConfigRef) -> JobState {
-    start_job("Object diff", Job::ObjDiff, move |status, cancel| {
-        run_build(status, cancel, config).map(|result| JobResult::ObjDiff(Some(result)))
+pub fn start_build(ctx: &egui::Context, config: ObjDiffConfig) -> JobState {
+    start_job(ctx, "Object diff", Job::ObjDiff, move |context, cancel| {
+        run_build(&context, cancel, config).map(|result| JobResult::ObjDiff(Some(result)))
     })
 }

src/jobs/update.rs

@@ -9,7 +9,7 @@ use anyhow::{Context, Result};
 use const_format::formatcp;
 
 use crate::{
-    jobs::{start_job, update_status, Job, JobResult, JobState, JobStatusRef},
+    jobs::{start_job, update_status, Job, JobContext, JobResult, JobState},
     update::{build_updater, BIN_NAME},
 };
 
@@ -17,7 +17,7 @@ pub struct UpdateResult {
     pub exe_path: PathBuf,
 }
 
-fn run_update(status: &JobStatusRef, cancel: Receiver<()>) -> Result<Box<UpdateResult>> {
+fn run_update(status: &JobContext, cancel: Receiver<()>) -> 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 latest_release = updater.get_latest_release()?;
@@ -53,8 +53,8 @@ fn run_update(status: &JobStatusRef, cancel: Receiver<()>) -> Result<Box<UpdateR
     Ok(Box::from(UpdateResult { exe_path: target_file }))
 }
 
-pub fn start_update() -> JobState {
-    start_job("Update app", Job::Update, move |status, cancel| {
-        run_update(status, cancel).map(JobResult::Update)
+pub fn start_update(ctx: &egui::Context) -> JobState {
+    start_job(ctx, "Update app", Job::Update, move |context, cancel| {
+        run_update(&context, cancel).map(JobResult::Update)
     })
 }

src/lib.rs

@@ -3,9 +3,10 @@
 pub use app::App;
 
 mod app;
+mod app_config;
 mod config;
 mod diff;
-mod editops;
+mod fonts;
 mod jobs;
 mod obj;
 mod update;

src/main.rs

@@ -1,14 +1,17 @@
 #![warn(clippy::all, rust_2018_idioms)]
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use std::{path::PathBuf, rc::Rc, sync::Mutex};
+use std::{
+    path::PathBuf,
+    rc::Rc,
+    sync::{Arc, Mutex},
+};
 
 use anyhow::{Error, Result};
 use cfg_if::cfg_if;
-use eframe::IconData;
 use time::UtcOffset;
 
-fn load_icon() -> Result<IconData> {
+fn load_icon() -> Result<egui::IconData> {
     use bytes::Buf;
     let decoder = png::Decoder::new(include_bytes!("../assets/icon_64.png").reader());
     let mut reader = decoder.read_info()?;
@@ -21,7 +24,7 @@ fn load_icon() -> Result<IconData> {
         return Err(Error::msg("Invalid color type"));
     }
     buf.truncate(info.buffer_size());
-    Ok(IconData { rgba: buf, width: info.width, height: info.height })
+    Ok(egui::IconData { rgba: buf, width: info.width, height: info.height })
 }
 
 // When compiling natively:
@@ -41,7 +44,7 @@ fn main() {
         eframe::NativeOptions { follow_system_theme: false, ..Default::default() };
     match load_icon() {
         Ok(data) => {
-            native_options.icon_data = Some(data);
+            native_options.viewport.icon = Some(Arc::new(data));
         }
         Err(e) => {
             log::warn!("Failed to load application icon: {}", e);

src/obj/elf.rs

@@ -1,12 +1,13 @@
-use std::{collections::BTreeMap, fs, io::Cursor, path::Path};
+use std::{borrow::Cow, collections::BTreeMap, fs, io::Cursor, path::Path};
 
 use anyhow::{anyhow, bail, Context, Result};
 use byteorder::{BigEndian, ReadBytesExt};
 use cwdemangle::demangle;
+use filetime::FileTime;
 use flagset::Flags;
 use object::{
-    elf, Architecture, File, Object, ObjectSection, ObjectSymbol, RelocationKind, RelocationTarget,
-    SectionIndex, SectionKind, Symbol, SymbolKind, SymbolSection,
+    elf, Architecture, Endianness, File, Object, ObjectSection, ObjectSymbol, RelocationKind,
+    RelocationTarget, SectionIndex, SectionKind, Symbol, SymbolKind, SymbolScope, SymbolSection,
 };
 
 use crate::obj::{
@@ -42,6 +43,9 @@ fn to_obj_symbol(obj_file: &File<'_>, symbol: &Symbol<'_, '_>, addend: i64) -> R
     if symbol.is_weak() {
         flags = ObjSymbolFlagSet(flags.0 | ObjSymbolFlags::Weak);
     }
+    if symbol.scope() == SymbolScope::Linkage {
+        flags = ObjSymbolFlagSet(flags.0 | ObjSymbolFlags::Hidden);
+    }
     let section_address = if let Some(section) =
         symbol.section_index().and_then(|idx| obj_file.section_by_index(idx).ok())
     {
@@ -274,7 +278,9 @@ fn relocations_by_section(
     Ok(relocations)
 }
 
-fn line_info(obj_file: &File<'_>) -> Result<Option<BTreeMap<u32, u32>>> {
+fn line_info(obj_file: &File<'_>) -> Result<Option<BTreeMap<u64, u64>>> {
+    // DWARF 1.1
+    let mut map = BTreeMap::new();
     if let Some(section) = obj_file.section_by_name(".line") {
         if section.size() == 0 {
             return Ok(None);
@@ -282,28 +288,56 @@ fn line_info(obj_file: &File<'_>) -> Result<Option<BTreeMap<u32, u32>>> {
         let data = section.uncompressed_data()?;
         let mut reader = Cursor::new(data.as_ref());
 
-        let mut map = BTreeMap::new();
         let size = reader.read_u32::<BigEndian>()?;
-        let base_address = reader.read_u32::<BigEndian>()?;
+        let base_address = reader.read_u32::<BigEndian>()? as u64;
         while reader.position() < size as u64 {
-            let line_number = reader.read_u32::<BigEndian>()?;
+            let line_number = reader.read_u32::<BigEndian>()? as u64;
             let statement_pos = reader.read_u16::<BigEndian>()?;
             if statement_pos != 0xFFFF {
                 log::warn!("Unhandled statement pos {}", statement_pos);
             }
-            let address_delta = reader.read_u32::<BigEndian>()?;
+            let address_delta = reader.read_u32::<BigEndian>()? as u64;
             map.insert(base_address + address_delta, line_number);
         }
-        log::debug!("Line info: {map:#X?}");
-        return Ok(Some(map));
     }
-    Ok(None)
+
+    // DWARF 2+
+    let dwarf_cow = gimli::Dwarf::load(|id| {
+        Ok::<_, gimli::Error>(
+            obj_file
+                .section_by_name(id.name())
+                .and_then(|section| section.uncompressed_data().ok())
+                .unwrap_or(Cow::Borrowed(&[][..])),
+        )
+    })?;
+    let endian = match obj_file.endianness() {
+        Endianness::Little => gimli::RunTimeEndian::Little,
+        Endianness::Big => gimli::RunTimeEndian::Big,
+    };
+    let dwarf = dwarf_cow.borrow(|section| gimli::EndianSlice::new(section, endian));
+    let mut iter = dwarf.units();
+    while let Some(header) = iter.next()? {
+        let unit = dwarf.unit(header)?;
+        if let Some(program) = unit.line_program.clone() {
+            let mut rows = program.rows();
+            while let Some((_header, row)) = rows.next_row()? {
+                if let Some(line) = row.line() {
+                    map.insert(row.address(), line.get());
+                }
+            }
+        }
+    }
+    if map.is_empty() {
+        return Ok(None);
+    }
+    Ok(Some(map))
 }
 
 pub fn read(obj_path: &Path) -> Result<ObjInfo> {
-    let data = {
+    let (data, timestamp) = {
         let file = fs::File::open(obj_path)?;
-        unsafe { memmap2::Mmap::map(&file) }?
+        let timestamp = FileTime::from_last_modification_time(&file.metadata()?);
+        (unsafe { memmap2::Mmap::map(&file) }?, timestamp)
     };
     let obj_file = File::parse(&*data)?;
     let architecture = match obj_file.architecture() {
@@ -319,6 +353,7 @@ pub fn read(obj_path: &Path) -> Result<ObjInfo> {
     let mut result = ObjInfo {
         architecture,
         path: obj_path.to_owned(),
+        timestamp,
         sections: filter_sections(&obj_file)?,
         common: common_symbols(&obj_file)?,
         line_info: line_info(&obj_file)?,

src/obj/mips.rs

@@ -3,7 +3,10 @@ use std::collections::BTreeMap;
 use anyhow::Result;
 use rabbitizer::{config, Abi, InstrCategory, Instruction, OperandType};
 
-use crate::obj::{ObjIns, ObjInsArg, ObjReloc};
+use crate::{
+    diff::ProcessCodeResult,
+    obj::{ObjIns, ObjInsArg, ObjReloc},
+};
 
 fn configure_rabbitizer() {
     unsafe {
@@ -16,8 +19,8 @@ pub fn process_code(
     start_address: u64,
     end_address: u64,
     relocs: &[ObjReloc],
-    line_info: &Option<BTreeMap<u32, u32>>,
-) -> Result<(Vec<u8>, Vec<ObjIns>)> {
+    line_info: &Option<BTreeMap<u64, u64>>,
+) -> Result<ProcessCodeResult> {
     configure_rabbitizer();
 
     let ins_count = data.len() / 4;
@@ -80,8 +83,9 @@ pub fn process_code(
                 }
             }
         }
-        let line =
-            line_info.as_ref().and_then(|map| map.range(..=cur_addr).last().map(|(_, &b)| b));
+        let line = line_info
+            .as_ref()
+            .and_then(|map| map.range(..=cur_addr as u64).last().map(|(_, &b)| b));
         insts.push(ObjIns {
             address: cur_addr,
             code,
@@ -91,8 +95,9 @@ pub fn process_code(
             reloc: reloc.cloned(),
             branch_dest,
             line,
+            orig: None,
         });
         cur_addr += 4;
     }
-    Ok((ops, insts))
+    Ok(ProcessCodeResult { ops, insts })
 }

src/obj/mod.rs

@@ -4,6 +4,7 @@ pub mod ppc;
 
 use std::{collections::BTreeMap, path::PathBuf};
 
+use filetime::FileTime;
 use flagset::{flags, FlagSet};
 
 #[derive(Debug, Eq, PartialEq, Copy, Clone)]
@@ -18,6 +19,7 @@ flags! {
         Local,
         Weak,
         Common,
+        Hidden,
     }
 }
 #[derive(Debug, Copy, Clone, Default)]
@@ -37,7 +39,8 @@ pub struct ObjSection {
     pub data_diff: Vec<ObjDataDiff>,
     pub match_percent: f32,
 }
-#[derive(Debug, Clone)]
+
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub enum ObjInsArg {
     PpcArg(ppc750cl::Argument),
     MipsArg(String),
@@ -46,6 +49,41 @@ pub enum ObjInsArg {
     RelocWithBase,
     BranchOffset(i32),
 }
+
+impl ObjInsArg {
+    pub fn loose_eq(&self, other: &ObjInsArg) -> bool {
+        match (self, other) {
+            (ObjInsArg::PpcArg(a), ObjInsArg::PpcArg(b)) => {
+                a == b
+                    || match (a, b) {
+                        // Consider Simm and Offset equivalent
+                        (ppc750cl::Argument::Simm(simm), ppc750cl::Argument::Offset(off))
+                        | (ppc750cl::Argument::Offset(off), ppc750cl::Argument::Simm(simm)) => {
+                            simm.0 == off.0
+                        }
+                        // Consider Uimm and Offset equivalent
+                        (ppc750cl::Argument::Uimm(uimm), ppc750cl::Argument::Offset(off))
+                        | (ppc750cl::Argument::Offset(off), ppc750cl::Argument::Uimm(uimm)) => {
+                            uimm.0 == off.0 as u16
+                        }
+                        // Consider Uimm and Simm equivalent
+                        (ppc750cl::Argument::Uimm(uimm), ppc750cl::Argument::Simm(simm))
+                        | (ppc750cl::Argument::Simm(simm), ppc750cl::Argument::Uimm(uimm)) => {
+                            uimm.0 == simm.0 as u16
+                        }
+                        _ => false,
+                    }
+            }
+            (ObjInsArg::MipsArg(a), ObjInsArg::MipsArg(b)) => a == b,
+            (ObjInsArg::MipsArgWithBase(a), ObjInsArg::MipsArgWithBase(b)) => a == b,
+            (ObjInsArg::Reloc, ObjInsArg::Reloc) => true,
+            (ObjInsArg::RelocWithBase, ObjInsArg::RelocWithBase) => true,
+            (ObjInsArg::BranchOffset(a), ObjInsArg::BranchOffset(b)) => a == b,
+            _ => false,
+        }
+    }
+}
+
 #[derive(Debug, Copy, Clone)]
 pub struct ObjInsArgDiff {
     /// Incrementing index for coloring
@@ -85,7 +123,9 @@ pub struct ObjIns {
     pub reloc: Option<ObjReloc>,
     pub branch_dest: Option<u32>,
     /// Line info
-    pub line: Option<u32>,
+    pub line: Option<u64>,
+    /// Original (unsimplified) instruction
+    pub orig: Option<String>,
 }
 #[derive(Debug, Clone, Default)]
 pub struct ObjInsDiff {
@@ -139,9 +179,10 @@ pub enum ObjArchitecture {
 pub struct ObjInfo {
     pub architecture: ObjArchitecture,
     pub path: PathBuf,
+    pub timestamp: FileTime,
     pub sections: Vec<ObjSection>,
     pub common: Vec<ObjSymbol>,
-    pub line_info: Option<BTreeMap<u32, u32>>,
+    pub line_info: Option<BTreeMap<u64, u64>>,
 }
 #[derive(Debug, Eq, PartialEq, Copy, Clone)]
 pub enum ObjRelocKind {

src/obj/ppc.rs

@@ -1,9 +1,12 @@
 use std::collections::BTreeMap;
 
 use anyhow::Result;
-use ppc750cl::{disasm_iter, Argument};
+use ppc750cl::{disasm_iter, Argument, SimplifiedIns};
 
-use crate::obj::{ObjIns, ObjInsArg, ObjReloc, ObjRelocKind};
+use crate::{
+    diff::ProcessCodeResult,
+    obj::{ObjIns, ObjInsArg, ObjReloc, ObjRelocKind},
+};
 
 // Relative relocation, can be Simm or BranchOffset
 fn is_relative_arg(arg: &ObjInsArg) -> bool {
@@ -21,8 +24,8 @@ pub fn process_code(
     data: &[u8],
     address: u64,
     relocs: &[ObjReloc],
-    line_info: &Option<BTreeMap<u32, u32>>,
-) -> Result<(Vec<u8>, Vec<ObjIns>)> {
+    line_info: &Option<BTreeMap<u64, u64>>,
+) -> Result<ProcessCodeResult> {
     let ins_count = data.len() / 4;
     let mut ops = Vec::<u8>::with_capacity(ins_count);
     let mut insts = Vec::<ObjIns>::with_capacity(ins_count);
@@ -40,7 +43,7 @@ pub fn process_code(
                 _ => ins.code,
             };
         }
-        let simplified = ins.simplified();
+        let simplified = ins.clone().simplified();
         let mut args: Vec<ObjInsArg> = simplified
             .args
             .iter()
@@ -79,17 +82,18 @@ pub fn process_code(
         ops.push(simplified.ins.op as u8);
         let line = line_info
             .as_ref()
-            .and_then(|map| map.range(..=simplified.ins.addr).last().map(|(_, &b)| b));
+            .and_then(|map| map.range(..=simplified.ins.addr as u64).last().map(|(_, &b)| b));
         insts.push(ObjIns {
             address: simplified.ins.addr,
             code: simplified.ins.code,
             mnemonic: format!("{}{}", simplified.mnemonic, simplified.suffix),
             args,
             reloc: reloc.cloned(),
-            op: 0,
+            op: ins.op as u8,
             branch_dest: None,
             line,
+            orig: Some(format!("{}", SimplifiedIns::basic_form(ins))),
         });
     }
-    Ok((ops, insts))
+    Ok(ProcessCodeResult { ops, insts })
 }

src/views/appearance.rs

@@ -1,6 +1,10 @@
-use egui::{Color32, FontFamily, FontId, TextStyle};
+use std::sync::Arc;
+
+use egui::{text::LayoutJob, Color32, FontFamily, FontId, TextStyle, Widget};
 use time::UtcOffset;
 
+use crate::fonts::load_font_if_needed;
+
 #[derive(serde::Deserialize, serde::Serialize)]
 #[serde(default)]
 pub struct Appearance {
@@ -28,13 +32,29 @@ pub struct Appearance {
     // Global
     #[serde(skip)]
     pub utc_offset: UtcOffset,
+    #[serde(skip)]
+    pub fonts: FontState,
+    #[serde(skip)]
+    pub next_ui_font: Option<FontId>,
+    #[serde(skip)]
+    pub next_code_font: Option<FontId>,
 }
 
+pub struct FontState {
+    definitions: egui::FontDefinitions,
+    source: font_kit::source::SystemSource,
+    family_names: Vec<String>,
+    // loaded_families: HashMap<String, LoadedFontFamily>,
+}
+
+const DEFAULT_UI_FONT: FontId = FontId { size: 12.0, family: FontFamily::Proportional };
+const DEFAULT_CODE_FONT: FontId = FontId { size: 14.0, family: FontFamily::Monospace };
+
 impl Default for Appearance {
     fn default() -> Self {
         Self {
-            ui_font: FontId { size: 12.0, family: FontFamily::Proportional },
-            code_font: FontId { size: 14.0, family: FontFamily::Monospace },
+            ui_font: DEFAULT_UI_FONT,
+            code_font: DEFAULT_CODE_FONT,
             diff_colors: DEFAULT_COLOR_ROTATION.to_vec(),
             theme: eframe::Theme::Dark,
             text_color: Color32::GRAY,
@@ -45,13 +65,27 @@ impl Default for Appearance {
             insert_color: Color32::GREEN,
             delete_color: Color32::from_rgb(200, 40, 41),
             utc_offset: UtcOffset::UTC,
+            fonts: FontState::default(),
+            next_ui_font: None,
+            next_code_font: None,
+        }
+    }
+}
+
+impl Default for FontState {
+    fn default() -> Self {
+        Self {
+            definitions: Default::default(),
+            source: font_kit::source::SystemSource::new(),
+            family_names: Default::default(),
+            // loaded_families: Default::default(),
         }
     }
 }
 
 impl Appearance {
-    pub fn apply(&mut self, style: &egui::Style) -> egui::Style {
-        let mut style = style.clone();
+    pub fn pre_update(&mut self, ctx: &egui::Context) {
+        let mut style = ctx.style().as_ref().clone();
         style.text_styles.insert(TextStyle::Body, FontId {
             size: (self.ui_font.size * 0.75).floor(),
             family: self.ui_font.family.clone(),
@@ -85,7 +119,71 @@ impl Appearance {
                 self.delete_color = Color32::from_rgb(200, 40, 41);
             }
         }
-        style
+        ctx.set_style(style);
+    }
+
+    pub fn post_update(&mut self, ctx: &egui::Context) {
+        // Load fonts for next frame
+        if let Some(next_ui_font) = self.next_ui_font.take() {
+            match load_font_if_needed(
+                ctx,
+                &self.fonts.source,
+                &next_ui_font,
+                DEFAULT_UI_FONT.family,
+                &mut self.fonts.definitions,
+            ) {
+                Ok(()) => self.ui_font = next_ui_font,
+                Err(e) => {
+                    log::error!("Failed to load font: {}", e)
+                }
+            }
+        }
+        if let Some(next_code_font) = self.next_code_font.take() {
+            match load_font_if_needed(
+                ctx,
+                &self.fonts.source,
+                &next_code_font,
+                DEFAULT_CODE_FONT.family,
+                &mut self.fonts.definitions,
+            ) {
+                Ok(()) => self.code_font = next_code_font,
+                Err(e) => {
+                    log::error!("Failed to load font: {}", e)
+                }
+            }
+        }
+    }
+
+    pub fn init_fonts(&mut self, ctx: &egui::Context) {
+        self.fonts.family_names = self.fonts.source.all_families().unwrap_or_default();
+        match load_font_if_needed(
+            ctx,
+            &self.fonts.source,
+            &self.ui_font,
+            DEFAULT_UI_FONT.family,
+            &mut self.fonts.definitions,
+        ) {
+            Ok(_) => {}
+            Err(e) => {
+                log::error!("Failed to load font: {}", e);
+                // Revert to default
+                self.ui_font = DEFAULT_UI_FONT;
+            }
+        }
+        match load_font_if_needed(
+            ctx,
+            &self.fonts.source,
+            &self.code_font,
+            DEFAULT_CODE_FONT.family,
+            &mut self.fonts.definitions,
+        ) {
+            Ok(_) => {}
+            Err(e) => {
+                log::error!("Failed to load font: {}", e);
+                // Revert to default
+                self.code_font = DEFAULT_CODE_FONT;
+            }
+        }
     }
 }
 
@@ -101,6 +199,65 @@ pub const DEFAULT_COLOR_ROTATION: [Color32; 9] = [
     Color32::from_rgb(213, 138, 138),
 ];
 
+fn font_id_ui(
+    ui: &mut egui::Ui,
+    label: &str,
+    mut font_id: FontId,
+    default: FontId,
+    appearance: &Appearance,
+) -> Option<FontId> {
+    ui.push_id(label, |ui| {
+        let font_size = font_id.size;
+        let label_job = LayoutJob::simple(
+            font_id.family.to_string(),
+            font_id.clone(),
+            appearance.text_color,
+            0.0,
+        );
+        let mut changed = ui
+            .horizontal(|ui| {
+                ui.label(label);
+                let mut changed = egui::Slider::new(&mut font_id.size, 4.0..=40.0)
+                    .max_decimals(1)
+                    .ui(ui)
+                    .changed();
+                if ui.button("Reset").clicked() {
+                    font_id = default;
+                    changed = true;
+                }
+                changed
+            })
+            .inner;
+        let family = &mut font_id.family;
+        changed |= egui::ComboBox::from_label("Font family")
+            .selected_text(label_job)
+            .width(font_size * 20.0)
+            .show_ui(ui, |ui| {
+                let mut result = false;
+                result |= ui
+                    .selectable_value(family, FontFamily::Proportional, "Proportional (built-in)")
+                    .changed();
+                result |= ui
+                    .selectable_value(family, FontFamily::Monospace, "Monospace (built-in)")
+                    .changed();
+                for family_name in &appearance.fonts.family_names {
+                    result |= ui
+                        .selectable_value(
+                            family,
+                            FontFamily::Name(Arc::from(family_name.as_str())),
+                            family_name,
+                        )
+                        .changed();
+                }
+                result
+            })
+            .inner
+            .unwrap_or(false);
+        changed.then_some(font_id)
+    })
+    .inner
+}
+
 pub fn appearance_window(ctx: &egui::Context, show: &mut bool, appearance: &mut Appearance) {
     egui::Window::new("Appearance").open(show).show(ctx, |ui| {
         egui::ComboBox::from_label("Theme")
@@ -109,11 +266,17 @@ pub fn appearance_window(ctx: &egui::Context, show: &mut bool, appearance: &mut
                 ui.selectable_value(&mut appearance.theme, eframe::Theme::Dark, "Dark");
                 ui.selectable_value(&mut appearance.theme, eframe::Theme::Light, "Light");
             });
-        ui.label("UI font:");
-        egui::introspection::font_id_ui(ui, &mut appearance.ui_font);
         ui.separator();
-        ui.label("Code font:");
-        egui::introspection::font_id_ui(ui, &mut appearance.code_font);
+        appearance.next_ui_font =
+            font_id_ui(ui, "UI font:", appearance.ui_font.clone(), DEFAULT_UI_FONT, appearance);
+        ui.separator();
+        appearance.next_code_font = font_id_ui(
+            ui,
+            "Code font:",
+            appearance.code_font.clone(),
+            DEFAULT_CODE_FONT,
+            appearance,
+        );
         ui.separator();
         ui.label("Diff colors:");
         if ui.button("Reset").clicked() {

src/views/config.rs

@@ -1,4 +1,4 @@
-#[cfg(windows)]
+#[cfg(all(windows, feature = "wsl"))]
 use std::string::FromUtf16Error;
 use std::{
     borrow::Cow,
@@ -6,26 +6,30 @@ use std::{
     path::{PathBuf, MAIN_SEPARATOR},
 };
 
-#[cfg(windows)]
+#[cfg(all(windows, feature = "wsl"))]
 use anyhow::{Context, Result};
 use const_format::formatcp;
 use egui::{
     output::OpenUrl, text::LayoutJob, CollapsingHeader, FontFamily, FontId, RichText,
-    SelectableLabel, TextFormat, Widget,
+    SelectableLabel, TextFormat, Widget, WidgetText,
 };
 use globset::Glob;
 use self_update::cargo_crate_version;
 
 use crate::{
-    app::{AppConfig, AppConfigRef},
+    app::{AppConfig, AppConfigRef, ObjectConfig},
     config::{ProjectObject, ProjectObjectNode},
+    diff::DiffAlg,
     jobs::{
         check_update::{start_check_update, CheckUpdateResult},
         update::start_update,
         Job, JobQueue, JobResult,
     },
     update::RELEASE_URL,
-    views::appearance::Appearance,
+    views::{
+        appearance::Appearance,
+        file::{FileDialogResult, FileDialogState},
+    },
 };
 
 #[derive(Default)]
@@ -40,12 +44,15 @@ pub struct ConfigViewState {
     pub watch_pattern_text: String,
     pub load_error: Option<String>,
     pub object_search: String,
-    #[cfg(windows)]
+    pub filter_diffable: bool,
+    pub filter_incomplete: bool,
+    #[cfg(all(windows, feature = "wsl"))]
     pub available_wsl_distros: Option<Vec<String>>,
+    pub file_dialog_state: FileDialogState,
 }
 
 impl ConfigViewState {
-    pub fn pre_update(&mut self, jobs: &mut JobQueue) {
+    pub fn pre_update(&mut self, jobs: &mut JobQueue, config: &AppConfigRef) {
         jobs.results.retain_mut(|result| {
             if let JobResult::CheckUpdate(result) = result {
                 self.check_update = take(result);
@@ -57,9 +64,54 @@ impl ConfigViewState {
         self.build_running = jobs.is_running(Job::ObjDiff);
         self.check_update_running = jobs.is_running(Job::CheckUpdate);
         self.update_running = jobs.is_running(Job::Update);
+
+        // Check async file dialog results
+        match self.file_dialog_state.poll() {
+            FileDialogResult::None => {}
+            FileDialogResult::ProjectDir(path) => {
+                let mut guard = config.write().unwrap();
+                guard.set_project_dir(path.to_path_buf());
+            }
+            FileDialogResult::TargetDir(path) => {
+                let mut guard = config.write().unwrap();
+                guard.set_target_obj_dir(path.to_path_buf());
+            }
+            FileDialogResult::BaseDir(path) => {
+                let mut guard = config.write().unwrap();
+                guard.set_base_obj_dir(path.to_path_buf());
+            }
+            FileDialogResult::Object(path) => {
+                let mut guard = config.write().unwrap();
+                if let (Some(base_dir), Some(target_dir)) =
+                    (&guard.base_obj_dir, &guard.target_obj_dir)
+                {
+                    if let Ok(obj_path) = path.strip_prefix(base_dir) {
+                        let target_path = target_dir.join(obj_path);
+                        guard.set_selected_obj(ObjectConfig {
+                            name: obj_path.display().to_string(),
+                            target_path: Some(target_path),
+                            base_path: Some(path),
+                            reverse_fn_order: None,
+                            complete: None,
+                            scratch: None,
+                        });
+                    } else if let Ok(obj_path) = path.strip_prefix(target_dir) {
+                        let base_path = base_dir.join(obj_path);
+                        guard.set_selected_obj(ObjectConfig {
+                            name: obj_path.display().to_string(),
+                            target_path: Some(path),
+                            base_path: Some(base_path),
+                            reverse_fn_order: None,
+                            complete: None,
+                            scratch: None,
+                        });
+                    }
+                }
+            }
+        }
     }
 
-    pub fn post_update(&mut self, jobs: &mut JobQueue, config: &AppConfigRef) {
+    pub fn post_update(&mut self, ctx: &egui::Context, jobs: &mut JobQueue, config: &AppConfigRef) {
         if self.queue_build {
             self.queue_build = false;
             if let Ok(mut config) = config.write() {
@@ -69,22 +121,22 @@ impl ConfigViewState {
 
         if self.queue_check_update {
             self.queue_check_update = false;
-            jobs.push_once(Job::CheckUpdate, start_check_update);
+            jobs.push_once(Job::CheckUpdate, || start_check_update(ctx));
         }
 
         if self.queue_update {
             self.queue_update = false;
-            jobs.push_once(Job::Update, start_update);
+            jobs.push_once(Job::Update, || start_update(ctx));
         }
     }
 }
 
-const DEFAULT_WATCH_PATTERNS: &[&str] = &[
+pub const DEFAULT_WATCH_PATTERNS: &[&str] = &[
     "*.c", "*.cp", "*.cpp", "*.cxx", "*.h", "*.hp", "*.hpp", "*.hxx", "*.s", "*.S", "*.asm",
     "*.inc", "*.py", "*.yml", "*.txt", "*.json",
 ];
 
-#[cfg(windows)]
+#[cfg(all(windows, feature = "wsl"))]
 fn process_utf16(bytes: &[u8]) -> Result<String, FromUtf16Error> {
     let u16_bytes: Vec<u16> = bytes
         .chunks_exact(2)
@@ -93,7 +145,7 @@ fn process_utf16(bytes: &[u8]) -> Result<String, FromUtf16Error> {
     String::from_utf16(&u16_bytes)
 }
 
-#[cfg(windows)]
+#[cfg(all(windows, feature = "wsl"))]
 fn wsl_cmd(args: &[&str]) -> Result<String> {
     use std::{os::windows::process::CommandExt, process::Command};
     let output = Command::new("wsl")
@@ -104,7 +156,7 @@ fn wsl_cmd(args: &[&str]) -> Result<String> {
     process_utf16(&output.stdout).context("Failed to process stdout")
 }
 
-#[cfg(windows)]
+#[cfg(all(windows, feature = "wsl"))]
 fn fetch_wsl2_distros() -> Vec<String> {
     wsl_cmd(&["-l", "-q"])
         .map(|stdout| {
@@ -126,10 +178,9 @@ pub fn config_ui(
 ) {
     let mut config_guard = config.write().unwrap();
     let AppConfig {
-        selected_wsl_distro,
         target_obj_dir,
         base_obj_dir,
-        obj_path,
+        selected_obj,
         auto_update_check,
         objects,
         object_nodes,
@@ -177,27 +228,6 @@ pub fn config_ui(
     }
     ui.separator();
 
-    #[cfg(windows)]
-    {
-        ui.heading("Build");
-        if state.available_wsl_distros.is_none() {
-            state.available_wsl_distros = Some(fetch_wsl2_distros());
-        }
-        egui::ComboBox::from_label("Run in WSL2")
-            .selected_text(selected_wsl_distro.as_ref().unwrap_or(&"Disabled".to_string()))
-            .show_ui(ui, |ui| {
-                ui.selectable_value(selected_wsl_distro, None, "Disabled");
-                for distro in state.available_wsl_distros.as_ref().unwrap() {
-                    ui.selectable_value(selected_wsl_distro, Some(distro.clone()), distro);
-                }
-            });
-        ui.separator();
-    }
-    #[cfg(not(windows))]
-    {
-        let _ = selected_wsl_distro;
-    }
-
     ui.horizontal(|ui| {
         ui.heading("Project");
         if ui.button(RichText::new("Settings")).clicked() {
@@ -205,98 +235,121 @@ pub fn config_ui(
         }
     });
 
-    if let (Some(base_dir), Some(target_dir)) = (base_obj_dir, target_obj_dir) {
-        let mut new_build_obj = obj_path.clone();
-        if objects.is_empty() {
+    let mut new_selected_obj = selected_obj.clone();
+    if objects.is_empty() {
+        if let (Some(_base_dir), Some(target_dir)) = (base_obj_dir, target_obj_dir) {
             if ui.button("Select object").clicked() {
-                if let Some(path) = rfd::FileDialog::new()
-                    .set_directory(&target_dir)
-                    .add_filter("Object file", &["o", "elf"])
-                    .pick_file()
-                {
-                    if let Ok(obj_path) = path.strip_prefix(&base_dir) {
-                        new_build_obj = Some(obj_path.display().to_string());
-                    } else if let Ok(obj_path) = path.strip_prefix(&target_dir) {
-                        new_build_obj = Some(obj_path.display().to_string());
-                    }
-                }
+                state.file_dialog_state.queue(
+                    || {
+                        Box::pin(
+                            rfd::AsyncFileDialog::new()
+                                .set_directory(&target_dir)
+                                .add_filter("Object file", &["o", "elf"])
+                                .pick_file(),
+                        )
+                    },
+                    FileDialogResult::Object,
+                );
             }
-            if let Some(obj) = obj_path {
+            if let Some(obj) = selected_obj {
                 ui.label(
-                    RichText::new(&*obj)
+                    RichText::new(&obj.name)
                         .color(appearance.replace_color)
                         .family(FontFamily::Monospace),
                 );
             }
         } else {
-            let had_search = !state.object_search.is_empty();
-            egui::TextEdit::singleline(&mut state.object_search).hint_text("Filter").ui(ui);
+            ui.colored_label(appearance.delete_color, "Missing project settings");
+        }
+    } else {
+        let had_search = !state.object_search.is_empty();
+        egui::TextEdit::singleline(&mut state.object_search).hint_text("Filter").ui(ui);
 
-            let mut root_open = None;
-            let mut node_open = NodeOpen::Default;
-            ui.horizontal(|ui| {
-                if ui.small_button("⏶").on_hover_text_at_pointer("Collapse all").clicked() {
-                    root_open = Some(false);
-                    node_open = NodeOpen::Close;
-                }
-                if ui.small_button("⏷").on_hover_text_at_pointer("Expand all").clicked() {
-                    root_open = Some(true);
-                    node_open = NodeOpen::Open;
-                }
-                if ui
-                    .add_enabled(obj_path.is_some(), egui::Button::new("⌖").small())
-                    .on_hover_text_at_pointer("Current object")
-                    .clicked()
-                {
-                    root_open = Some(true);
-                    node_open = NodeOpen::Object;
-                }
-            });
-            if state.object_search.is_empty() {
-                if had_search {
-                    root_open = Some(true);
-                    node_open = NodeOpen::Object;
-                }
-            } else if !had_search {
+        let mut root_open = None;
+        let mut node_open = NodeOpen::Default;
+        ui.horizontal(|ui| {
+            if ui.small_button("⏶").on_hover_text_at_pointer("Collapse all").clicked() {
+                root_open = Some(false);
+                node_open = NodeOpen::Close;
+            }
+            if ui.small_button("⏷").on_hover_text_at_pointer("Expand all").clicked() {
                 root_open = Some(true);
                 node_open = NodeOpen::Open;
             }
-
-            CollapsingHeader::new(RichText::new("🗀 Objects").font(FontId {
-                size: appearance.ui_font.size,
-                family: appearance.code_font.family.clone(),
-            }))
-            .open(root_open)
-            .default_open(true)
-            .show(ui, |ui| {
-                let mut nodes = Cow::Borrowed(object_nodes);
-                if !state.object_search.is_empty() {
-                    let search = state.object_search.to_ascii_lowercase();
-                    nodes = Cow::Owned(
-                        object_nodes.iter().filter_map(|node| filter_node(node, &search)).collect(),
-                    );
-                }
-
-                ui.style_mut().wrap = Some(false);
-                for node in nodes.iter() {
-                    display_node(ui, &mut new_build_obj, node, appearance, node_open);
-                }
-            });
-        }
-
-        if new_build_obj != *obj_path {
-            if let Some(obj) = new_build_obj {
-                // Will set obj_changed, which will trigger a rebuild
-                config_guard.set_obj_path(obj);
+            if ui
+                .add_enabled(selected_obj.is_some(), egui::Button::new("⌖").small())
+                .on_hover_text_at_pointer("Current object")
+                .clicked()
+            {
+                root_open = Some(true);
+                node_open = NodeOpen::Object;
             }
+            if ui
+                .selectable_label(state.filter_diffable, "Diffable")
+                .on_hover_text_at_pointer("Only show objects with a source file")
+                .clicked()
+            {
+                state.filter_diffable = !state.filter_diffable;
+            }
+            if ui
+                .selectable_label(state.filter_incomplete, "Incomplete")
+                .on_hover_text_at_pointer("Only show objects not marked complete")
+                .clicked()
+            {
+                state.filter_incomplete = !state.filter_incomplete;
+            }
+        });
+        if state.object_search.is_empty() {
+            if had_search {
+                root_open = Some(true);
+                node_open = NodeOpen::Object;
+            }
+        } else if !had_search {
+            root_open = Some(true);
+            node_open = NodeOpen::Open;
         }
-        if config_guard.obj_path.is_some()
-            && ui.add_enabled(!state.build_running, egui::Button::new("Build")).clicked()
-        {
-            state.queue_build = true;
+
+        CollapsingHeader::new(RichText::new("🗀 Objects").font(FontId {
+            size: appearance.ui_font.size,
+            family: appearance.code_font.family.clone(),
+        }))
+        .open(root_open)
+        .default_open(true)
+        .show(ui, |ui| {
+            let mut nodes = Cow::Borrowed(object_nodes);
+            if !state.object_search.is_empty() || state.filter_diffable || state.filter_incomplete {
+                let search = state.object_search.to_ascii_lowercase();
+                nodes = Cow::Owned(
+                    object_nodes
+                        .iter()
+                        .filter_map(|node| {
+                            filter_node(
+                                node,
+                                &search,
+                                state.filter_diffable,
+                                state.filter_incomplete,
+                            )
+                        })
+                        .collect(),
+                );
+            }
+
+            ui.style_mut().wrap = Some(false);
+            for node in nodes.iter() {
+                display_node(ui, &mut new_selected_obj, node, appearance, node_open);
+            }
+        });
+    }
+    if new_selected_obj != *selected_obj {
+        if let Some(obj) = new_selected_obj {
+            // Will set obj_changed, which will trigger a rebuild
+            config_guard.set_selected_obj(obj);
         }
-    } else {
-        ui.colored_label(appearance.delete_color, "Missing project settings");
+    }
+    if config_guard.selected_obj.is_some()
+        && ui.add_enabled(!state.build_running, egui::Button::new("Build")).clicked()
+    {
+        state.queue_build = true;
     }
 
     ui.separator();
@@ -304,15 +357,25 @@ pub fn config_ui(
 
 fn display_object(
     ui: &mut egui::Ui,
-    obj_path: &mut Option<String>,
+    selected_obj: &mut Option<ObjectConfig>,
     name: &str,
     object: &ProjectObject,
     appearance: &Appearance,
 ) {
-    let path_string = object.path.to_string_lossy().to_string();
-    let selected = matches!(obj_path, Some(path) if path == &path_string);
-    let color = if selected { appearance.emphasized_text_color } else { appearance.text_color };
-    if SelectableLabel::new(
+    let object_name = object.name();
+    let selected = matches!(selected_obj, Some(obj) if obj.name == object_name);
+    let color = if selected {
+        appearance.emphasized_text_color
+    } else if let Some(complete) = object.complete {
+        if complete {
+            appearance.insert_color
+        } else {
+            appearance.delete_color
+        }
+    } else {
+        appearance.text_color
+    };
+    let clicked = SelectableLabel::new(
         selected,
         RichText::new(name)
             .font(FontId {
@@ -322,9 +385,18 @@ fn display_object(
             .color(color),
     )
     .ui(ui)
-    .clicked()
-    {
-        *obj_path = Some(path_string);
+    .clicked();
+    // Always recreate ObjectConfig if selected, in case the project config changed.
+    // ObjectConfig is compared using equality, so this won't unnecessarily trigger a rebuild.
+    if selected || clicked {
+        *selected_obj = Some(ObjectConfig {
+            name: object_name.to_string(),
+            target_path: object.target_path.clone(),
+            base_path: object.base_path.clone(),
+            reverse_fn_order: object.reverse_fn_order,
+            complete: object.complete,
+            scratch: object.scratch.clone(),
+        });
     }
 }
 
@@ -339,17 +411,17 @@ enum NodeOpen {
 
 fn display_node(
     ui: &mut egui::Ui,
-    obj_path: &mut Option<String>,
+    selected_obj: &mut Option<ObjectConfig>,
     node: &ProjectObjectNode,
     appearance: &Appearance,
     node_open: NodeOpen,
 ) {
     match node {
         ProjectObjectNode::File(name, object) => {
-            display_object(ui, obj_path, name, object, appearance);
+            display_object(ui, selected_obj, name, object, appearance);
         }
         ProjectObjectNode::Dir(name, children) => {
-            let contains_obj = obj_path.as_ref().map(|path| contains_node(node, path));
+            let contains_obj = selected_obj.as_ref().map(|path| contains_node(node, path));
             let open = match node_open {
                 NodeOpen::Default => None,
                 NodeOpen::Open => Some(true),
@@ -372,40 +444,51 @@ fn display_node(
             .open(open)
             .show(ui, |ui| {
                 for node in children {
-                    display_node(ui, obj_path, node, appearance, node_open);
+                    display_node(ui, selected_obj, node, appearance, node_open);
                 }
             });
         }
     }
 }
 
-fn contains_node(node: &ProjectObjectNode, path: &str) -> bool {
+fn contains_node(node: &ProjectObjectNode, selected_obj: &ObjectConfig) -> bool {
     match node {
-        ProjectObjectNode::File(_, object) => {
-            let path_string = object.path.to_string_lossy().to_string();
-            path == path_string
-        }
+        ProjectObjectNode::File(_, object) => object.name() == selected_obj.name,
         ProjectObjectNode::Dir(_, children) => {
-            children.iter().any(|node| contains_node(node, path))
+            children.iter().any(|node| contains_node(node, selected_obj))
         }
     }
 }
 
-fn filter_node(node: &ProjectObjectNode, search: &str) -> Option<ProjectObjectNode> {
+fn filter_node(
+    node: &ProjectObjectNode,
+    search: &str,
+    filter_diffable: bool,
+    filter_incomplete: bool,
+) -> Option<ProjectObjectNode> {
     match node {
-        ProjectObjectNode::File(name, _) => {
-            if name.to_ascii_lowercase().contains(search) {
+        ProjectObjectNode::File(name, object) => {
+            if (search.is_empty() || name.to_ascii_lowercase().contains(search))
+                && (!filter_diffable
+                    || (object.base_path.is_some() && object.target_path.is_some()))
+                && (!filter_incomplete || matches!(object.complete, None | Some(false)))
+            {
                 Some(node.clone())
             } else {
                 None
             }
         }
         ProjectObjectNode::Dir(name, children) => {
-            if name.to_ascii_lowercase().contains(search) {
+            if (search.is_empty() || name.to_ascii_lowercase().contains(search))
+                && !filter_diffable
+                && !filter_incomplete
+            {
                 return Some(node.clone());
             }
-            let new_children =
-                children.iter().filter_map(|child| filter_node(child, search)).collect::<Vec<_>>();
+            let new_children = children
+                .iter()
+                .filter_map(|child| filter_node(child, search, filter_diffable, filter_incomplete))
+                .collect::<Vec<_>>();
             if !new_children.is_empty() {
                 Some(ProjectObjectNode::Dir(name.clone(), new_children))
             } else {
@@ -438,17 +521,22 @@ fn format_path(path: &Option<PathBuf>, appearance: &Appearance) -> RichText {
     RichText::new(text).color(color).family(FontFamily::Monospace)
 }
 
+pub const CONFIG_DISABLED_TEXT: &str =
+    "Option disabled because it's set by the project configuration file.";
+
 fn pick_folder_ui(
     ui: &mut egui::Ui,
     dir: &Option<PathBuf>,
     label: &str,
     tooltip: impl FnOnce(&mut egui::Ui),
     appearance: &Appearance,
+    enabled: bool,
 ) -> egui::Response {
     let response = ui.horizontal(|ui| {
         subheading(ui, label, appearance);
         ui.link(HELP_ICON).on_hover_ui(tooltip);
-        ui.button("Select")
+        ui.add_enabled(enabled, egui::Button::new("Select"))
+            .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
     });
     ui.label(format_path(dir, appearance));
     response.inner
@@ -506,11 +594,13 @@ fn split_obj_config_ui(
             ui.label(job);
         },
         appearance,
+        true,
     );
     if response.clicked() {
-        if let Some(path) = rfd::FileDialog::new().pick_folder() {
-            config.set_project_dir(path);
-        }
+        state.file_dialog_state.queue(
+            || Box::pin(rfd::AsyncFileDialog::new().pick_folder()),
+            FileDialogResult::ProjectDir,
+        );
     }
     ui.separator();
 
@@ -537,13 +627,38 @@ fn split_obj_config_ui(
         });
     });
     let mut custom_make_str = config.custom_make.clone().unwrap_or_default();
-    if ui.text_edit_singleline(&mut custom_make_str).changed() {
+    if ui
+        .add_enabled(
+            config.project_config_info.is_none(),
+            egui::TextEdit::singleline(&mut custom_make_str),
+        )
+        .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
+        .changed()
+    {
         if custom_make_str.is_empty() {
             config.custom_make = None;
         } else {
             config.custom_make = Some(custom_make_str);
         }
     }
+    #[cfg(all(windows, feature = "wsl"))]
+    {
+        if state.available_wsl_distros.is_none() {
+            state.available_wsl_distros = Some(fetch_wsl2_distros());
+        }
+        egui::ComboBox::from_label("Run in WSL2")
+            .selected_text(config.selected_wsl_distro.as_ref().unwrap_or(&"Disabled".to_string()))
+            .show_ui(ui, |ui| {
+                ui.selectable_value(&mut config.selected_wsl_distro, None, "Disabled");
+                for distro in state.available_wsl_distros.as_ref().unwrap() {
+                    ui.selectable_value(
+                        &mut config.selected_wsl_distro,
+                        Some(distro.clone()),
+                        distro,
+                    );
+                }
+            });
+    }
     ui.separator();
 
     if let Some(project_dir) = config.project_dir.clone() {
@@ -566,13 +681,20 @@ fn split_obj_config_ui(
                 ui.label(job);
             },
             appearance,
+            config.project_config_info.is_none(),
         );
         if response.clicked() {
-            if let Some(path) = rfd::FileDialog::new().set_directory(&project_dir).pick_folder() {
-                config.set_target_obj_dir(path);
-            }
+            state.file_dialog_state.queue(
+                || Box::pin(rfd::AsyncFileDialog::new().set_directory(&project_dir).pick_folder()),
+                FileDialogResult::TargetDir,
+            );
         }
-        ui.checkbox(&mut config.build_target, "Build target objects").on_hover_ui(|ui| {
+        ui.add_enabled(
+            config.project_config_info.is_none(),
+            egui::Checkbox::new(&mut config.build_target, "Build target objects"),
+        )
+        .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
+        .on_hover_ui(|ui| {
             let mut job = LayoutJob::default();
             job.append(
                 "Tells the build system to produce the target object.\n",
@@ -615,18 +737,48 @@ fn split_obj_config_ui(
                 ui.label(job);
             },
             appearance,
+            config.project_config_info.is_none(),
         );
         if response.clicked() {
-            if let Some(path) = rfd::FileDialog::new().set_directory(&project_dir).pick_folder() {
-                config.set_base_obj_dir(path);
-            }
+            state.file_dialog_state.queue(
+                || Box::pin(rfd::AsyncFileDialog::new().set_directory(&project_dir).pick_folder()),
+                FileDialogResult::BaseDir,
+            );
         }
+        ui.add_enabled(
+            config.project_config_info.is_none(),
+            egui::Checkbox::new(&mut config.build_base, "Build base objects"),
+        )
+        .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
+        .on_hover_ui(|ui| {
+            let mut job = LayoutJob::default();
+            job.append(
+                "Tells the build system to produce the base object.\n",
+                0.0,
+                text_format.clone(),
+            );
+            job.append("For example, this would call ", 0.0, text_format.clone());
+            job.append("make path/to/base.o", 0.0, code_format.clone());
+            job.append(".\n\n", 0.0, text_format.clone());
+            job.append(
+                "This can be disabled if you're running the build system\n",
+                0.0,
+                text_format.clone(),
+            );
+            job.append(
+                "externally, and just want objdiff to reload the files\n",
+                0.0,
+                text_format.clone(),
+            );
+            job.append("when they change.", 0.0, text_format.clone());
+            ui.label(job);
+        });
         ui.separator();
     }
 
     subheading(ui, "Watch settings", appearance);
     let response =
-        ui.checkbox(&mut config.watcher_enabled, "Rebuild on changes").on_hover_ui(|ui| {
+        ui.checkbox(&mut config.rebuild_on_changes, "Rebuild on changes").on_hover_ui(|ui| {
             let mut job = LayoutJob::default();
             job.append(
                 "Automatically re-run the build & diff when files change.",
@@ -641,7 +793,11 @@ fn split_obj_config_ui(
 
     ui.horizontal(|ui| {
         ui.label(RichText::new("File patterns").color(appearance.text_color));
-        if ui.button("Reset").clicked() {
+        if ui
+            .add_enabled(config.project_config_info.is_none(), egui::Button::new("Reset"))
+            .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
+            .clicked()
+        {
             config.watch_patterns =
                 DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect();
             config.watcher_change = true;
@@ -655,7 +811,11 @@ fn split_obj_config_ui(
                     .color(appearance.text_color)
                     .family(FontFamily::Monospace),
             );
-            if ui.small_button("-").clicked() {
+            if ui
+                .add_enabled(config.project_config_info.is_none(), egui::Button::new("-").small())
+                .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
+                .clicked()
+            {
                 remove_at = Some(idx);
             }
         });
@@ -665,8 +825,16 @@ fn split_obj_config_ui(
         config.watcher_change = true;
     }
     ui.horizontal(|ui| {
-        egui::TextEdit::singleline(&mut state.watch_pattern_text).desired_width(100.0).show(ui);
-        if ui.small_button("+").clicked() {
+        ui.add_enabled(
+            config.project_config_info.is_none(),
+            egui::TextEdit::singleline(&mut state.watch_pattern_text).desired_width(100.0),
+        )
+        .on_disabled_hover_text(CONFIG_DISABLED_TEXT);
+        if ui
+            .add_enabled(config.project_config_info.is_none(), egui::Button::new("+").small())
+            .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
+            .clicked()
+        {
             if let Ok(glob) = Glob::new(&state.watch_pattern_text) {
                 config.watch_patterns.push(glob);
                 config.watcher_change = true;
@@ -675,3 +843,70 @@ fn split_obj_config_ui(
         }
     });
 }
+
+pub fn diff_options_window(
+    ctx: &egui::Context,
+    config: &AppConfigRef,
+    show: &mut bool,
+    appearance: &Appearance,
+) {
+    let mut config_guard = config.write().unwrap();
+    egui::Window::new("Diff Options").open(show).show(ctx, |ui| {
+        diff_options_ui(ui, &mut config_guard, appearance);
+    });
+}
+
+fn diff_options_ui(ui: &mut egui::Ui, config: &mut AppConfig, appearance: &Appearance) {
+    let mut job = LayoutJob::default();
+    job.append(
+        "Current default: ",
+        0.0,
+        TextFormat::simple(appearance.ui_font.clone(), appearance.text_color),
+    );
+    job.append(
+        diff_alg_to_string(DiffAlg::default()),
+        0.0,
+        TextFormat::simple(appearance.ui_font.clone(), appearance.emphasized_text_color),
+    );
+    ui.label(job);
+    let mut job = LayoutJob::default();
+    job.append(
+        "Previous default: ",
+        0.0,
+        TextFormat::simple(appearance.ui_font.clone(), appearance.text_color),
+    );
+    job.append(
+        "Levenshtein",
+        0.0,
+        TextFormat::simple(appearance.ui_font.clone(), appearance.emphasized_text_color),
+    );
+    ui.label(job);
+    ui.label("Please provide feedback!");
+    if diff_alg_ui(ui, "Code diff algorithm", &mut config.code_alg) {
+        config.queue_reload = true;
+    }
+    if diff_alg_ui(ui, "Data diff algorithm", &mut config.data_alg) {
+        config.queue_reload = true;
+    }
+}
+
+fn diff_alg_ui(ui: &mut egui::Ui, label: impl Into<WidgetText>, alg: &mut DiffAlg) -> bool {
+    let response = egui::ComboBox::from_label(label)
+        .selected_text(diff_alg_to_string(*alg))
+        .show_ui(ui, |ui| {
+            ui.selectable_value(alg, DiffAlg::Patience, "Patience").changed()
+                | ui.selectable_value(alg, DiffAlg::Levenshtein, "Levenshtein").changed()
+                | ui.selectable_value(alg, DiffAlg::Myers, "Myers").changed()
+                | ui.selectable_value(alg, DiffAlg::Lcs, "LCS").changed()
+        });
+    response.inner.unwrap_or(false)
+}
+
+const fn diff_alg_to_string(alg: DiffAlg) -> &'static str {
+    match alg {
+        DiffAlg::Patience => "Patience",
+        DiffAlg::Levenshtein => "Levenshtein",
+        DiffAlg::Lcs => "LCS",
+        DiffAlg::Myers => "Myers",
+    }
+}

src/views/data_diff.rs

@@ -132,31 +132,40 @@ fn split_diffs(diffs: &[ObjDataDiff]) -> Vec<Vec<ObjDataDiff>> {
 
 fn data_table_ui(
     table: TableBuilder<'_>,
-    left_obj: &ObjInfo,
-    right_obj: &ObjInfo,
+    left_obj: Option<&ObjInfo>,
+    right_obj: Option<&ObjInfo>,
     selected_symbol: &SymbolReference,
     config: &Appearance,
 ) -> Option<()> {
-    let left_section = find_section(left_obj, selected_symbol)?;
-    let right_section = find_section(right_obj, selected_symbol)?;
+    let left_section = left_obj.and_then(|obj| find_section(obj, selected_symbol));
+    let right_section = right_obj.and_then(|obj| find_section(obj, selected_symbol));
 
-    let total_bytes = left_section.data_diff.iter().fold(0usize, |accum, item| accum + item.len);
+    let total_bytes = left_section
+        .or(right_section)?
+        .data_diff
+        .iter()
+        .fold(0usize, |accum, item| accum + item.len);
     if total_bytes == 0 {
         return None;
     }
     let total_rows = (total_bytes - 1) / BYTES_PER_ROW + 1;
 
-    let left_diffs = split_diffs(&left_section.data_diff);
-    let right_diffs = split_diffs(&right_section.data_diff);
+    let left_diffs = left_section.map(|section| split_diffs(&section.data_diff));
+    let right_diffs = right_section.map(|section| split_diffs(&section.data_diff));
 
     table.body(|body| {
-        body.rows(config.code_font.size, total_rows, |row_index, mut row| {
+        body.rows(config.code_font.size, total_rows, |mut row| {
+            let row_index = row.index();
             let address = row_index * BYTES_PER_ROW;
             row.col(|ui| {
-                data_row_ui(ui, address, &left_diffs[row_index], config);
+                if let Some(left_diffs) = &left_diffs {
+                    data_row_ui(ui, address, &left_diffs[row_index], config);
+                }
             });
             row.col(|ui| {
-                data_row_ui(ui, address, &right_diffs[row_index], config);
+                if let Some(right_diffs) = &right_diffs {
+                    data_row_ui(ui, address, &right_diffs[row_index], config);
+                }
             });
         });
     });
@@ -183,7 +192,7 @@ pub fn data_diff_ui(ui: &mut egui::Ui, state: &mut DiffViewState, appearance: &A
                 |ui| {
                     ui.set_width(column_width);
 
-                    if ui.button("Back").clicked() {
+                    if ui.button("⏴ Back").clicked() {
                         state.current_view = View::SymbolDiff;
                     }
 
@@ -243,15 +252,19 @@ pub fn data_diff_ui(ui: &mut egui::Ui, state: &mut DiffViewState, appearance: &A
     ui.separator();
 
     // Table
-    if let (Some(left_obj), Some(right_obj)) = (&result.first_obj, &result.second_obj) {
-        let available_height = ui.available_height();
-        let table = TableBuilder::new(ui)
-            .striped(false)
-            .cell_layout(Layout::left_to_right(Align::Min))
-            .columns(Column::exact(column_width).clip(true), 2)
-            .resizable(false)
-            .auto_shrink([false, false])
-            .min_scrolled_height(available_height);
-        data_table_ui(table, left_obj, right_obj, selected_symbol, appearance);
-    }
+    let available_height = ui.available_height();
+    let table = TableBuilder::new(ui)
+        .striped(false)
+        .cell_layout(Layout::left_to_right(Align::Min))
+        .columns(Column::exact(column_width).clip(true), 2)
+        .resizable(false)
+        .auto_shrink([false, false])
+        .min_scrolled_height(available_height);
+    data_table_ui(
+        table,
+        result.first_obj.as_ref(),
+        result.second_obj.as_ref(),
+        selected_symbol,
+        appearance,
+    );
 }

src/views/debug.rs

@@ -0,0 +1,17 @@
+use crate::views::{appearance::Appearance, frame_history::FrameHistory};
+
+pub fn debug_window(
+    ctx: &egui::Context,
+    show: &mut bool,
+    frame_history: &mut FrameHistory,
+    appearance: &Appearance,
+) {
+    egui::Window::new("Debug").open(show).show(ctx, |ui| {
+        debug_ui(ui, frame_history, appearance);
+    });
+}
+
+fn debug_ui(ui: &mut egui::Ui, frame_history: &mut FrameHistory, _appearance: &Appearance) {
+    ui.label(format!("Repainting the UI each frame. FPS: {:.1}", frame_history.fps()));
+    frame_history.ui(ui);
+}

src/views/file.rs

@@ -0,0 +1,51 @@
+use std::{future::Future, path::PathBuf, pin::Pin, thread::JoinHandle};
+
+use pollster::FutureExt;
+use rfd::FileHandle;
+
+#[derive(Default)]
+pub enum FileDialogResult {
+    #[default]
+    None,
+    ProjectDir(PathBuf),
+    TargetDir(PathBuf),
+    BaseDir(PathBuf),
+    Object(PathBuf),
+}
+
+#[derive(Default)]
+pub struct FileDialogState {
+    thread: Option<JoinHandle<FileDialogResult>>,
+}
+
+impl FileDialogState {
+    pub fn queue<InitCb, ResultCb>(&mut self, init: InitCb, result_cb: ResultCb)
+    where
+        InitCb: FnOnce() -> Pin<Box<dyn Future<Output = Option<FileHandle>> + Send>>,
+        ResultCb: FnOnce(PathBuf) -> FileDialogResult + Send + 'static,
+    {
+        if self.thread.is_some() {
+            return;
+        }
+        let future = init();
+        self.thread = Some(std::thread::spawn(move || {
+            if let Some(handle) = future.block_on() {
+                result_cb(PathBuf::from(handle))
+            } else {
+                FileDialogResult::None
+            }
+        }));
+    }
+
+    pub fn poll(&mut self) -> FileDialogResult {
+        if let Some(thread) = &mut self.thread {
+            if thread.is_finished() {
+                self.thread.take().unwrap().join().unwrap_or(FileDialogResult::None)
+            } else {
+                FileDialogResult::None
+            }
+        } else {
+            FileDialogResult::None
+        }
+    }
+}

src/views/frame_history.rs

@@ -0,0 +1,142 @@
+// From https://github.com/emilk/egui/blob/e037489ac20a9e419715ae75d205a8baa117c3cf/crates/egui_demo_app/src/frame_history.rs
+// Copyright (c) 2018-2021 Emil Ernerfeldt <emil.ernerfeldt@gmail.com>
+//
+// Permission is hereby granted, free of charge, to any
+// person obtaining a copy of this software and associated
+// documentation files (the "Software"), to deal in the
+// Software without restriction, including without
+// limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software
+// is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice
+// shall be included in all copies or substantial portions
+// of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+use egui::util::History;
+
+pub struct FrameHistory {
+    frame_times: History<f32>,
+}
+
+impl Default for FrameHistory {
+    fn default() -> Self {
+        let max_age: f32 = 1.0;
+        let max_len = (max_age * 300.0).round() as usize;
+        Self { frame_times: History::new(0..max_len, max_age) }
+    }
+}
+
+impl FrameHistory {
+    // Called first
+    pub fn on_new_frame(&mut self, now: f64, previous_frame_time: Option<f32>) {
+        let previous_frame_time = previous_frame_time.unwrap_or_default();
+        if let Some(latest) = self.frame_times.latest_mut() {
+            *latest = previous_frame_time; // rewrite history now that we know
+        }
+        self.frame_times.add(now, previous_frame_time); // projected
+    }
+
+    pub fn mean_frame_time(&self) -> f32 { self.frame_times.average().unwrap_or_default() }
+
+    pub fn fps(&self) -> f32 { 1.0 / self.frame_times.mean_time_interval().unwrap_or_default() }
+
+    pub fn ui(&mut self, ui: &mut egui::Ui) {
+        ui.label(format!("Mean CPU usage: {:.2} ms / frame", 1e3 * self.mean_frame_time()))
+            .on_hover_text(
+                "Includes egui layout and tessellation time.\n\
+            Does not include GPU usage, nor overhead for sending data to GPU.",
+            );
+        egui::warn_if_debug_build(ui);
+
+        if !cfg!(target_arch = "wasm32") {
+            egui::CollapsingHeader::new("📊 CPU usage history").default_open(false).show(
+                ui,
+                |ui| {
+                    self.graph(ui);
+                },
+            );
+        }
+    }
+
+    fn graph(&mut self, ui: &mut egui::Ui) -> egui::Response {
+        use egui::*;
+
+        ui.label("egui CPU usage history");
+
+        let history = &self.frame_times;
+
+        // TODO(emilk): we should not use `slider_width` as default graph width.
+        let height = ui.spacing().slider_width;
+        let size = vec2(ui.available_size_before_wrap().x, height);
+        let (rect, response) = ui.allocate_at_least(size, Sense::hover());
+        let style = ui.style().noninteractive();
+
+        let graph_top_cpu_usage = 0.010;
+        let graph_rect = Rect::from_x_y_ranges(history.max_age()..=0.0, graph_top_cpu_usage..=0.0);
+        let to_screen = emath::RectTransform::from_to(graph_rect, rect);
+
+        let mut shapes = Vec::with_capacity(3 + 2 * history.len());
+        shapes.push(Shape::Rect(epaint::RectShape::new(
+            rect,
+            style.rounding,
+            ui.visuals().extreme_bg_color,
+            ui.style().noninteractive().bg_stroke,
+        )));
+
+        let rect = rect.shrink(4.0);
+        let color = ui.visuals().text_color();
+        let line_stroke = Stroke::new(1.0, color);
+
+        if let Some(pointer_pos) = response.hover_pos() {
+            let y = pointer_pos.y;
+            shapes.push(Shape::line_segment(
+                [pos2(rect.left(), y), pos2(rect.right(), y)],
+                line_stroke,
+            ));
+            let cpu_usage = to_screen.inverse().transform_pos(pointer_pos).y;
+            let text = format!("{:.1} ms", 1e3 * cpu_usage);
+            shapes.push(ui.fonts(|f| {
+                Shape::text(
+                    f,
+                    pos2(rect.left(), y),
+                    egui::Align2::LEFT_BOTTOM,
+                    text,
+                    TextStyle::Monospace.resolve(ui.style()),
+                    color,
+                )
+            }));
+        }
+
+        let circle_color = color;
+        let radius = 2.0;
+        let right_side_time = ui.input(|i| i.time); // Time at right side of screen
+
+        for (time, cpu_usage) in history.iter() {
+            let age = (right_side_time - time) as f32;
+            let pos = to_screen.transform_pos_clamped(Pos2::new(age, cpu_usage));
+
+            shapes.push(Shape::line_segment([pos2(pos.x, rect.bottom()), pos], line_stroke));
+
+            if cpu_usage < graph_top_cpu_usage {
+                shapes.push(Shape::circle_filled(pos, radius, circle_color));
+            }
+        }
+
+        ui.painter().extend(shapes);
+
+        response
+    }
+}

src/views/function_diff.rs

@@ -1,9 +1,11 @@
-use std::{cmp::Ordering, default::Default};
+use std::{
+    cmp::{max, Ordering},
+    default::Default,
+};
 
 use cwdemangle::demangle;
-use eframe::emath::Align;
-use egui::{text::LayoutJob, Color32, FontId, Label, Layout, Sense, Vec2};
-use egui_extras::{Column, TableBuilder};
+use egui::{text::LayoutJob, Align, Color32, Label, Layout, RichText, Sense, TextFormat, Vec2};
+use egui_extras::{Column, TableBuilder, TableRow};
 use ppc750cl::Argument;
 use time::format_description;
 
@@ -19,21 +21,49 @@ use crate::{
     },
 };
 
+#[derive(Default)]
+pub enum HighlightKind {
+    #[default]
+    None,
+    Opcode(u8),
+    Arg(ObjInsArg),
+    Symbol(String),
+    Address(u32),
+}
+
+#[derive(Default)]
+pub struct FunctionViewState {
+    pub highlight: HighlightKind,
+}
+
 fn write_reloc_name(
     reloc: &ObjReloc,
     color: Color32,
+    background_color: Color32,
     job: &mut LayoutJob,
-    font_id: FontId,
     appearance: &Appearance,
 ) {
     let name = reloc.target.demangled_name.as_ref().unwrap_or(&reloc.target.name);
-    write_text(name, appearance.emphasized_text_color, job, font_id.clone());
+    job.append(name, 0.0, TextFormat {
+        font_id: appearance.code_font.clone(),
+        color: appearance.emphasized_text_color,
+        background: background_color,
+        ..Default::default()
+    });
     match reloc.target.addend.cmp(&0i64) {
-        Ordering::Greater => {
-            write_text(&format!("+{:#X}", reloc.target.addend), color, job, font_id)
-        }
+        Ordering::Greater => write_text(
+            &format!("+{:#X}", reloc.target.addend),
+            color,
+            job,
+            appearance.code_font.clone(),
+        ),
         Ordering::Less => {
-            write_text(&format!("-{:#X}", -reloc.target.addend), color, job, font_id);
+            write_text(
+                &format!("-{:#X}", -reloc.target.addend),
+                color,
+                job,
+                appearance.code_font.clone(),
+            );
         }
         _ => {}
     }
@@ -42,57 +72,57 @@ fn write_reloc_name(
 fn write_reloc(
     reloc: &ObjReloc,
     color: Color32,
+    background_color: Color32,
     job: &mut LayoutJob,
-    font_id: FontId,
     appearance: &Appearance,
 ) {
     match reloc.kind {
         ObjRelocKind::PpcAddr16Lo => {
-            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
-            write_text("@l", color, job, font_id);
+            write_reloc_name(reloc, color, background_color, job, appearance);
+            write_text("@l", color, job, appearance.code_font.clone());
         }
         ObjRelocKind::PpcAddr16Hi => {
-            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
-            write_text("@h", color, job, font_id);
+            write_reloc_name(reloc, color, background_color, job, appearance);
+            write_text("@h", color, job, appearance.code_font.clone());
         }
         ObjRelocKind::PpcAddr16Ha => {
-            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
-            write_text("@ha", color, job, font_id);
+            write_reloc_name(reloc, color, background_color, job, appearance);
+            write_text("@ha", color, job, appearance.code_font.clone());
         }
         ObjRelocKind::PpcEmbSda21 => {
-            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
-            write_text("@sda21", color, job, font_id);
+            write_reloc_name(reloc, color, background_color, job, appearance);
+            write_text("@sda21", color, job, appearance.code_font.clone());
         }
         ObjRelocKind::MipsHi16 => {
-            write_text("%hi(", color, job, font_id.clone());
-            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
-            write_text(")", color, job, font_id);
+            write_text("%hi(", color, job, appearance.code_font.clone());
+            write_reloc_name(reloc, color, background_color, job, appearance);
+            write_text(")", color, job, appearance.code_font.clone());
         }
         ObjRelocKind::MipsLo16 => {
-            write_text("%lo(", color, job, font_id.clone());
-            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
-            write_text(")", color, job, font_id);
+            write_text("%lo(", color, job, appearance.code_font.clone());
+            write_reloc_name(reloc, color, background_color, job, appearance);
+            write_text(")", color, job, appearance.code_font.clone());
         }
         ObjRelocKind::MipsGot16 => {
-            write_text("%got(", color, job, font_id.clone());
-            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
-            write_text(")", color, job, font_id);
+            write_text("%got(", color, job, appearance.code_font.clone());
+            write_reloc_name(reloc, color, background_color, job, appearance);
+            write_text(")", color, job, appearance.code_font.clone());
         }
         ObjRelocKind::MipsCall16 => {
-            write_text("%call16(", color, job, font_id.clone());
-            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
-            write_text(")", color, job, font_id);
+            write_text("%call16(", color, job, appearance.code_font.clone());
+            write_reloc_name(reloc, color, background_color, job, appearance);
+            write_text(")", color, job, appearance.code_font.clone());
         }
         ObjRelocKind::MipsGpRel16 => {
-            write_text("%gp_rel(", color, job, font_id.clone());
-            write_reloc_name(reloc, color, job, font_id.clone(), appearance);
-            write_text(")", color, job, font_id);
+            write_text("%gp_rel(", color, job, appearance.code_font.clone());
+            write_reloc_name(reloc, color, background_color, job, appearance);
+            write_text(")", color, job, appearance.code_font.clone());
         }
         ObjRelocKind::PpcRel24 | ObjRelocKind::PpcRel14 | ObjRelocKind::Mips26 => {
-            write_reloc_name(reloc, color, job, font_id, appearance);
+            write_reloc_name(reloc, color, background_color, job, appearance);
         }
         ObjRelocKind::Absolute | ObjRelocKind::MipsGpRel32 => {
-            write_text("[INVALID]", color, job, font_id);
+            write_text("[INVALID]", color, job, appearance.code_font.clone());
         }
     };
 }
@@ -102,8 +132,9 @@ fn write_ins(
     diff_kind: &ObjInsDiffKind,
     args: &[Option<ObjInsArgDiff>],
     base_addr: u32,
-    job: &mut LayoutJob,
+    ui: &mut egui::Ui,
     appearance: &Appearance,
+    ins_view_state: &mut FunctionViewState,
 ) {
     let base_color = match diff_kind {
         ObjInsDiffKind::None | ObjInsDiffKind::OpMismatch | ObjInsDiffKind::ArgMismatch => {
@@ -113,49 +144,96 @@ fn write_ins(
         ObjInsDiffKind::Delete => appearance.delete_color,
         ObjInsDiffKind::Insert => appearance.insert_color,
     };
-    write_text(
-        &format!("{:<11}", ins.mnemonic),
-        match diff_kind {
-            ObjInsDiffKind::OpMismatch => appearance.replace_color,
-            _ => base_color,
-        },
-        job,
-        appearance.code_font.clone(),
-    );
+
+    let highlighted_op =
+        matches!(ins_view_state.highlight, HighlightKind::Opcode(op) if op == ins.op);
+    let op_label = RichText::new(ins.mnemonic.clone())
+        .font(appearance.code_font.clone())
+        .color(if highlighted_op {
+            appearance.emphasized_text_color
+        } else {
+            match diff_kind {
+                ObjInsDiffKind::OpMismatch => appearance.replace_color,
+                _ => base_color,
+            }
+        })
+        .background_color(if highlighted_op {
+            appearance.deemphasized_text_color
+        } else {
+            Color32::TRANSPARENT
+        });
+    if ui
+        .add(Label::new(op_label).sense(Sense::click()))
+        .context_menu(|ui| ins_context_menu(ui, ins))
+        .clicked()
+    {
+        if highlighted_op {
+            ins_view_state.highlight = HighlightKind::None;
+        } else {
+            ins_view_state.highlight = HighlightKind::Opcode(ins.op);
+        }
+    }
+    let space_width = ui.fonts(|f| f.glyph_width(&appearance.code_font, ' '));
+    ui.add_space(space_width * (max(11, ins.mnemonic.len()) - ins.mnemonic.len()) as f32);
+
     let mut writing_offset = false;
     for (i, arg) in ins.args.iter().enumerate() {
+        let mut job = LayoutJob::default();
         if i == 0 {
-            write_text(" ", base_color, job, appearance.code_font.clone());
+            write_text(" ", base_color, &mut job, appearance.code_font.clone());
         }
         if i > 0 && !writing_offset {
-            write_text(", ", base_color, job, appearance.code_font.clone());
+            write_text(", ", base_color, &mut job, appearance.code_font.clone());
         }
-        let color = if let Some(diff) = args.get(i).and_then(|a| a.as_ref()) {
+        let highlighted_arg = match &ins_view_state.highlight {
+            HighlightKind::Symbol(v) => {
+                matches!(arg, ObjInsArg::Reloc | ObjInsArg::RelocWithBase)
+                    && matches!(&ins.reloc, Some(reloc) if &reloc.target.name == v)
+            }
+            HighlightKind::Address(v) => {
+                matches!(arg, ObjInsArg::BranchOffset(offset) if (offset + ins.address as i32 - base_addr as i32) as u32 == *v)
+            }
+            HighlightKind::Arg(v) => v.loose_eq(arg),
+            _ => false,
+        };
+        let color = if highlighted_arg {
+            appearance.emphasized_text_color
+        } else if let Some(diff) = args.get(i).and_then(|a| a.as_ref()) {
             appearance.diff_colors[diff.idx % appearance.diff_colors.len()]
         } else {
             base_color
         };
+        let text_format = TextFormat {
+            font_id: appearance.code_font.clone(),
+            color,
+            background: if highlighted_arg {
+                appearance.deemphasized_text_color
+            } else {
+                Color32::TRANSPARENT
+            },
+            ..Default::default()
+        };
+        let mut new_writing_offset = false;
         match arg {
             ObjInsArg::PpcArg(arg) => match arg {
                 Argument::Offset(val) => {
-                    write_text(&format!("{val}"), color, job, appearance.code_font.clone());
-                    write_text("(", base_color, job, appearance.code_font.clone());
-                    writing_offset = true;
-                    continue;
+                    job.append(&format!("{val}"), 0.0, text_format);
+                    write_text("(", base_color, &mut job, appearance.code_font.clone());
+                    new_writing_offset = true;
                 }
                 Argument::Uimm(_) | Argument::Simm(_) => {
-                    write_text(&format!("{arg}"), color, job, appearance.code_font.clone());
+                    job.append(&format!("{arg}"), 0.0, text_format);
                 }
                 _ => {
-                    write_text(&format!("{arg}"), color, job, appearance.code_font.clone());
+                    job.append(&format!("{arg}"), 0.0, text_format);
                 }
             },
             ObjInsArg::Reloc => {
                 write_reloc(
                     ins.reloc.as_ref().unwrap(),
                     base_color,
-                    job,
-                    appearance.code_font.clone(),
+                    text_format.background,
+                    &mut job,
                     appearance,
                 );
             }
@@ -163,41 +241,46 @@ fn write_ins(
                 write_reloc(
                     ins.reloc.as_ref().unwrap(),
                     base_color,
-                    job,
-                    appearance.code_font.clone(),
+                    text_format.background,
+                    &mut job,
                     appearance,
                 );
-                write_text("(", base_color, job, appearance.code_font.clone());
-                writing_offset = true;
-                continue;
+                write_text("(", base_color, &mut job, appearance.code_font.clone());
+                new_writing_offset = true;
             }
             ObjInsArg::MipsArg(str) => {
-                write_text(
-                    str.strip_prefix('$').unwrap_or(str),
-                    color,
-                    job,
-                    appearance.code_font.clone(),
-                );
+                job.append(str.strip_prefix('$').unwrap_or(str), 0.0, text_format);
             }
             ObjInsArg::MipsArgWithBase(str) => {
-                write_text(
-                    str.strip_prefix('$').unwrap_or(str),
-                    color,
-                    job,
-                    appearance.code_font.clone(),
-                );
-                write_text("(", base_color, job, appearance.code_font.clone());
-                writing_offset = true;
-                continue;
+                job.append(str.strip_prefix('$').unwrap_or(str), 0.0, text_format);
+                write_text("(", base_color, &mut job, appearance.code_font.clone());
+                new_writing_offset = true;
             }
             ObjInsArg::BranchOffset(offset) => {
                 let addr = offset + ins.address as i32 - base_addr as i32;
-                write_text(&format!("{addr:x}"), color, job, appearance.code_font.clone());
+                job.append(&format!("{addr:x}"), 0.0, text_format);
             }
         }
         if writing_offset {
-            write_text(")", base_color, job, appearance.code_font.clone());
-            writing_offset = false;
+            write_text(")", base_color, &mut job, appearance.code_font.clone());
+        }
+        writing_offset = new_writing_offset;
+        if ui
+            .add(Label::new(job).sense(Sense::click()))
+            .context_menu(|ui| ins_context_menu(ui, ins))
+            .clicked()
+        {
+            if highlighted_arg {
+                ins_view_state.highlight = HighlightKind::None;
+            } else if matches!(arg, ObjInsArg::Reloc | ObjInsArg::RelocWithBase) {
+                ins_view_state.highlight =
+                    HighlightKind::Symbol(ins.reloc.as_ref().unwrap().target.name.clone());
+            } else if let ObjInsArg::BranchOffset(offset) = arg {
+                ins_view_state.highlight =
+                    HighlightKind::Address((offset + ins.address as i32 - base_addr as i32) as u32);
+            } else {
+                ins_view_state.highlight = HighlightKind::Arg(arg.clone());
+            }
         }
     }
 }
@@ -209,6 +292,10 @@ fn ins_hover_ui(ui: &mut egui::Ui, ins: &ObjIns, appearance: &Appearance) {
 
         ui.label(format!("{:02X?}", ins.code.to_be_bytes()));
 
+        if let Some(orig) = &ins.orig {
+            ui.label(format!("Original: {}", orig));
+        }
+
         for arg in &ins.args {
             if let ObjInsArg::PpcArg(arg) = arg {
                 match arg {
@@ -316,7 +403,9 @@ fn asm_row_ui(
     ins_diff: &ObjInsDiff,
     symbol: &ObjSymbol,
     appearance: &Appearance,
+    ins_view_state: &mut FunctionViewState,
 ) {
+    ui.spacing_mut().item_spacing.x = 0.0;
     if ins_diff.kind != ObjInsDiffKind::None {
         ui.painter().rect_filled(ui.available_rect_before_wrap(), 0.0, ui.visuals().faint_bg_color);
     }
@@ -345,58 +434,133 @@ fn asm_row_ui(
         );
         pad = 12 - line_str.len();
     }
-    write_text(
-        &format!("{:<1$}", format!("{:x}: ", ins.address - symbol.address as u32), pad),
-        base_color,
-        &mut job,
-        appearance.code_font.clone(),
+    let base_addr = symbol.address as u32;
+    let addr_highlight = matches!(
+        &ins_view_state.highlight,
+        HighlightKind::Address(v) if *v == (ins.address - base_addr)
     );
-    if let Some(branch) = &ins_diff.branch_from {
-        write_text(
-            "~> ",
-            appearance.diff_colors[branch.branch_idx % appearance.diff_colors.len()],
-            &mut job,
-            appearance.code_font.clone(),
-        );
-    } else {
-        write_text("   ", base_color, &mut job, appearance.code_font.clone());
+    let addr_string = format!("{:x}", ins.address - symbol.address as u32);
+    pad -= addr_string.len();
+    job.append(&addr_string, 0.0, TextFormat {
+        font_id: appearance.code_font.clone(),
+        color: if addr_highlight { appearance.emphasized_text_color } else { base_color },
+        background: if addr_highlight {
+            appearance.deemphasized_text_color
+        } else {
+            Color32::TRANSPARENT
+        },
+        ..Default::default()
+    });
+    if ui
+        .add(Label::new(job).sense(Sense::click()))
+        .context_menu(|ui| ins_context_menu(ui, ins))
+        .clicked()
+    {
+        if addr_highlight {
+            ins_view_state.highlight = HighlightKind::None;
+        } else {
+            ins_view_state.highlight = HighlightKind::Address(ins.address - base_addr);
+        }
     }
-    write_ins(ins, &ins_diff.kind, &ins_diff.arg_diff, symbol.address as u32, &mut job, appearance);
+
+    let mut job = LayoutJob::default();
+    let space_width = ui.fonts(|f| f.glyph_width(&appearance.code_font, ' '));
+    let spacing = space_width * pad as f32;
+    job.append(": ", 0.0, TextFormat {
+        font_id: appearance.code_font.clone(),
+        color: base_color,
+        ..Default::default()
+    });
+    if let Some(branch) = &ins_diff.branch_from {
+        job.append("~> ", spacing, TextFormat {
+            font_id: appearance.code_font.clone(),
+            color: appearance.diff_colors[branch.branch_idx % appearance.diff_colors.len()],
+            ..Default::default()
+        });
+    } else {
+        job.append("   ", spacing, TextFormat {
+            font_id: appearance.code_font.clone(),
+            color: base_color,
+            ..Default::default()
+        });
+    }
+    ui.add(Label::new(job));
+    write_ins(ins, &ins_diff.kind, &ins_diff.arg_diff, base_addr, ui, appearance, ins_view_state);
     if let Some(branch) = &ins_diff.branch_to {
+        let mut job = LayoutJob::default();
         write_text(
             " ~>",
             appearance.diff_colors[branch.branch_idx % appearance.diff_colors.len()],
             &mut job,
             appearance.code_font.clone(),
         );
+        ui.add(Label::new(job));
     }
-    ui.add(Label::new(job).sense(Sense::click()))
-        .on_hover_ui_at_pointer(|ui| ins_hover_ui(ui, ins, appearance))
-        .context_menu(|ui| ins_context_menu(ui, ins));
+}
+
+fn asm_col_ui(
+    row: &mut TableRow<'_, '_>,
+    ins_diff: &ObjInsDiff,
+    symbol: &ObjSymbol,
+    appearance: &Appearance,
+    ins_view_state: &mut FunctionViewState,
+) {
+    let (_, response) = row.col(|ui| {
+        asm_row_ui(ui, ins_diff, symbol, appearance, ins_view_state);
+    });
+    if let Some(ins) = &ins_diff.ins {
+        response
+            .on_hover_ui_at_pointer(|ui| {
+                ins_hover_ui(ui, ins, appearance);
+            })
+            .context_menu(|ui| {
+                ins_context_menu(ui, ins);
+            });
+    }
+}
+
+fn empty_col_ui(row: &mut TableRow<'_, '_>) {
+    row.col(|ui| {
+        ui.label("");
+    });
 }
 
 fn asm_table_ui(
     table: TableBuilder<'_>,
-    left_obj: &ObjInfo,
-    right_obj: &ObjInfo,
+    left_obj: Option<&ObjInfo>,
+    right_obj: Option<&ObjInfo>,
     selected_symbol: &SymbolReference,
     appearance: &Appearance,
+    ins_view_state: &mut FunctionViewState,
 ) -> Option<()> {
-    let left_symbol = find_symbol(left_obj, selected_symbol);
-    let right_symbol = find_symbol(right_obj, selected_symbol);
+    let left_symbol = left_obj.and_then(|obj| find_symbol(obj, selected_symbol));
+    let right_symbol = right_obj.and_then(|obj| find_symbol(obj, selected_symbol));
     let instructions_len = left_symbol.or(right_symbol).map(|s| s.instructions.len())?;
     table.body(|body| {
-        body.rows(appearance.code_font.size, instructions_len, |row_index, mut row| {
-            row.col(|ui| {
-                if let Some(symbol) = left_symbol {
-                    asm_row_ui(ui, &symbol.instructions[row_index], symbol, appearance);
-                }
-            });
-            row.col(|ui| {
-                if let Some(symbol) = right_symbol {
-                    asm_row_ui(ui, &symbol.instructions[row_index], symbol, appearance);
-                }
-            });
+        body.rows(appearance.code_font.size, instructions_len, |mut row| {
+            let row_index = row.index();
+            if let Some(symbol) = left_symbol {
+                asm_col_ui(
+                    &mut row,
+                    &symbol.instructions[row_index],
+                    symbol,
+                    appearance,
+                    ins_view_state,
+                );
+            } else {
+                empty_col_ui(&mut row);
+            }
+            if let Some(symbol) = right_symbol {
+                asm_col_ui(
+                    &mut row,
+                    &symbol.instructions[row_index],
+                    symbol,
+                    appearance,
+                    ins_view_state,
+                );
+            } else {
+                empty_col_ui(&mut row);
+            }
         });
     });
     Some(())
@@ -422,9 +586,23 @@ pub fn function_diff_ui(ui: &mut egui::Ui, state: &mut DiffViewState, appearance
                 |ui| {
                     ui.set_width(column_width);
 
-                    if ui.button("Back").clicked() {
-                        state.current_view = View::SymbolDiff;
-                    }
+                    ui.horizontal(|ui| {
+                        if ui.button("⏴ Back").clicked() {
+                            state.current_view = View::SymbolDiff;
+                        }
+                        ui.separator();
+                        if ui
+                            .add_enabled(
+                                !state.scratch_running && state.scratch_available,
+                                egui::Button::new("📲 decomp.me"),
+                            )
+                            .on_hover_text_at_pointer("Create a new scratch on decomp.me (beta)")
+                            .on_disabled_hover_text("Scratch configuration missing")
+                            .clicked()
+                        {
+                            state.queue_scratch = true;
+                        }
+                    });
 
                     let demangled = demangle(&selected_symbol.symbol_name, &Default::default());
                     let name = demangled.as_deref().unwrap_or(&selected_symbol.symbol_name);
@@ -492,7 +670,7 @@ pub fn function_diff_ui(ui: &mut egui::Ui, state: &mut DiffViewState, appearance
                                 &format!("{match_percent:.0}%"),
                             );
                         } else {
-                            ui.label("");
+                            ui.colored_label(appearance.replace_color, "Missing");
                         }
                         ui.label("Diff base:");
                     });
@@ -503,15 +681,20 @@ pub fn function_diff_ui(ui: &mut egui::Ui, state: &mut DiffViewState, appearance
     ui.separator();
 
     // Table
-    if let (Some(left_obj), Some(right_obj)) = (&result.first_obj, &result.second_obj) {
-        let available_height = ui.available_height();
-        let table = TableBuilder::new(ui)
-            .striped(false)
-            .cell_layout(Layout::left_to_right(Align::Min))
-            .columns(Column::exact(column_width).clip(true), 2)
-            .resizable(false)
-            .auto_shrink([false, false])
-            .min_scrolled_height(available_height);
-        asm_table_ui(table, left_obj, right_obj, selected_symbol, appearance);
-    }
+    let available_height = ui.available_height();
+    let table = TableBuilder::new(ui)
+        .striped(false)
+        .cell_layout(Layout::left_to_right(Align::Min))
+        .columns(Column::exact(column_width).clip(true), 2)
+        .resizable(false)
+        .auto_shrink([false, false])
+        .min_scrolled_height(available_height);
+    asm_table_ui(
+        table,
+        result.first_obj.as_ref(),
+        result.second_obj.as_ref(),
+        selected_symbol,
+        appearance,
+        &mut state.function_state,
+    );
 }

src/views/jobs.rs

@@ -1,4 +1,4 @@
-use egui::{ProgressBar, Widget};
+use egui::{ProgressBar, RichText, Widget};
 
 use crate::{jobs::JobQueue, views::appearance::Appearance};
 
@@ -7,7 +7,7 @@ pub fn jobs_ui(ui: &mut egui::Ui, jobs: &mut JobQueue, appearance: &Appearance)
 
     let mut remove_job: Option<usize> = None;
     for job in jobs.iter_mut() {
-        let Ok(status) = job.status.read() else {
+        let Ok(status) = job.context.status.read() else {
             continue;
         };
         ui.group(|ui| {
@@ -31,7 +31,7 @@ pub fn jobs_ui(ui: &mut egui::Ui, jobs: &mut JobQueue, appearance: &Appearance)
             bar.ui(ui);
             const STATUS_LENGTH: usize = 80;
             if let Some(err) = &status.error {
-                let err_string = err.to_string();
+                let err_string = format!("{:#}", err);
                 ui.colored_label(
                     appearance.delete_color,
                     if err_string.len() > STATUS_LENGTH - 10 {
@@ -39,13 +39,15 @@ pub fn jobs_ui(ui: &mut egui::Ui, jobs: &mut JobQueue, appearance: &Appearance)
                     } else {
                         format!("Error: {:width$}", err_string, width = STATUS_LENGTH - 7)
                     },
-                );
+                )
+                .on_hover_text_at_pointer(RichText::new(err_string).color(appearance.delete_color));
             } else {
                 ui.label(if status.status.len() > STATUS_LENGTH - 3 {
                     format!("{}…", &status.status[0..STATUS_LENGTH - 3])
                 } else {
                     format!("{:width$}", &status.status, width = STATUS_LENGTH)
-                });
+                })
+                .on_hover_text_at_pointer(&status.status);
             }
         });
     }

src/views/mod.rs

@@ -3,7 +3,10 @@ use egui::{text::LayoutJob, Color32, FontId, TextFormat};
 pub(crate) mod appearance;
 pub(crate) mod config;
 pub(crate) mod data_diff;
+pub(crate) mod debug;
 pub(crate) mod demangle;
+pub(crate) mod file;
+pub(crate) mod frame_history;
 pub(crate) mod function_diff;
 pub(crate) mod jobs;
 pub(crate) mod symbol_diff;

src/views/symbol_diff.rs

@@ -1,19 +1,20 @@
 use std::mem::take;
 
 use egui::{
-    text::LayoutJob, Align, CollapsingHeader, Color32, Layout, Rgba, ScrollArea, SelectableLabel,
-    TextEdit, Ui, Vec2, Widget,
+    text::LayoutJob, Align, CollapsingHeader, Color32, Id, Layout, OpenUrl, ScrollArea,
+    SelectableLabel, TextEdit, Ui, Vec2, Widget,
 };
 use egui_extras::{Size, StripBuilder};
 
 use crate::{
     app::AppConfigRef,
     jobs::{
+        create_scratch::{start_create_scratch, CreateScratchConfig, CreateScratchResult},
         objdiff::{BuildStatus, ObjDiffResult},
         Job, JobQueue, JobResult,
     },
     obj::{ObjInfo, ObjSection, ObjSectionKind, ObjSymbol, ObjSymbolFlags},
-    views::{appearance::Appearance, write_text},
+    views::{appearance::Appearance, function_diff::FunctionViewState, write_text},
 };
 
 pub struct SymbolReference {
@@ -33,11 +34,16 @@ pub enum View {
 #[derive(Default)]
 pub struct DiffViewState {
     pub build: Option<Box<ObjDiffResult>>,
+    pub scratch: Option<Box<CreateScratchResult>>,
     pub current_view: View,
     pub symbol_state: SymbolViewState,
+    pub function_state: FunctionViewState,
     pub search: String,
     pub queue_build: bool,
     pub build_running: bool,
+    pub scratch_available: bool,
+    pub queue_scratch: bool,
+    pub scratch_running: bool,
 }
 
 #[derive(Default)]
@@ -46,43 +52,68 @@ pub struct SymbolViewState {
     pub selected_symbol: Option<SymbolReference>,
     pub reverse_fn_order: bool,
     pub disable_reverse_fn_order: bool,
+    pub show_hidden_symbols: bool,
 }
 
 impl DiffViewState {
     pub fn pre_update(&mut self, jobs: &mut JobQueue, config: &AppConfigRef) {
-        jobs.results.retain_mut(|result| {
-            if let JobResult::ObjDiff(result) = result {
+        jobs.results.retain_mut(|result| match result {
+            JobResult::ObjDiff(result) => {
                 self.build = take(result);
                 false
-            } else {
-                true
             }
+            JobResult::CreateScratch(result) => {
+                self.scratch = take(result);
+                false
+            }
+            _ => true,
         });
         self.build_running = jobs.is_running(Job::ObjDiff);
+        self.scratch_running = jobs.is_running(Job::CreateScratch);
 
         self.symbol_state.disable_reverse_fn_order = false;
         if let Ok(config) = config.read() {
-            if let Some(obj_path) = &config.obj_path {
-                if let Some(object) = config.objects.iter().find(|object| {
-                    let path_string = object.path.to_string_lossy().to_string();
-                    &path_string == obj_path
-                }) {
-                    if let Some(value) = object.reverse_fn_order {
-                        self.symbol_state.reverse_fn_order = value;
-                        self.symbol_state.disable_reverse_fn_order = true;
-                    }
+            if let Some(obj_config) = &config.selected_obj {
+                if let Some(value) = obj_config.reverse_fn_order {
+                    self.symbol_state.reverse_fn_order = value;
+                    self.symbol_state.disable_reverse_fn_order = true;
                 }
             }
+            self.scratch_available = CreateScratchConfig::is_available(&config);
         }
     }
 
-    pub fn post_update(&mut self, _jobs: &mut JobQueue, config: &AppConfigRef) {
+    pub fn post_update(&mut self, ctx: &egui::Context, jobs: &mut JobQueue, config: &AppConfigRef) {
+        if let Some(result) = take(&mut self.scratch) {
+            ctx.output_mut(|o| o.open_url = Some(OpenUrl::new_tab(result.scratch_url)));
+        }
+
         if self.queue_build {
             self.queue_build = false;
             if let Ok(mut config) = config.write() {
                 config.queue_build = true;
             }
         }
+
+        if self.queue_scratch {
+            self.queue_scratch = false;
+            if let Some(function_name) =
+                self.symbol_state.selected_symbol.as_ref().map(|sym| sym.symbol_name.clone())
+            {
+                if let Ok(config) = config.read() {
+                    match CreateScratchConfig::from_config(&config, function_name) {
+                        Ok(config) => {
+                            jobs.push_once(Job::CreateScratch, || {
+                                start_create_scratch(ctx, config)
+                            });
+                        }
+                        Err(err) => {
+                            log::error!("Failed to create scratch config: {err}");
+                        }
+                    }
+                }
+            }
+        }
     }
 }
 
@@ -140,6 +171,9 @@ fn symbol_ui(
     state: &mut SymbolViewState,
     appearance: &Appearance,
 ) -> Option<View> {
+    if symbol.flags.0.contains(ObjSymbolFlags::Hidden) && !state.show_hidden_symbols {
+        return None;
+    }
     let mut ret = None;
     let mut job = LayoutJob::default();
     let name: &str =
@@ -159,6 +193,9 @@ fn symbol_ui(
     if symbol.flags.0.contains(ObjSymbolFlags::Weak) {
         write_text("w", appearance.text_color, &mut job, appearance.code_font.clone());
     }
+    if symbol.flags.0.contains(ObjSymbolFlags::Hidden) {
+        write_text("h", appearance.deemphasized_text_color, &mut job, appearance.code_font.clone());
+    }
     write_text("] ", appearance.text_color, &mut job, appearance.code_font.clone());
     if let Some(match_percent) = symbol.match_percent {
         write_text("(", appearance.text_color, &mut job, appearance.code_font.clone());
@@ -231,6 +268,7 @@ fn symbol_list_ui(
 
             for section in &obj.sections {
                 CollapsingHeader::new(format!("{} ({:x})", section.name, section.size))
+                    .id_source(Id::new(section.name.clone()).with(section.index))
                     .default_open(true)
                     .show(ui, |ui| {
                         if section.kind == ObjSectionKind::Code && state.reverse_fn_order {
@@ -259,15 +297,36 @@ fn symbol_list_ui(
 
 fn build_log_ui(ui: &mut Ui, status: &BuildStatus, appearance: &Appearance) {
     ScrollArea::both().auto_shrink([false, false]).show(ui, |ui| {
+        ui.horizontal(|ui| {
+            if ui.button("Copy command").clicked() {
+                ui.output_mut(|output| output.copied_text = status.cmdline.clone());
+            }
+            if ui.button("Copy log").clicked() {
+                ui.output_mut(|output| {
+                    output.copied_text = format!("{}\n{}", status.stdout, status.stderr)
+                });
+            }
+        });
         ui.scope(|ui| {
             ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
             ui.style_mut().wrap = Some(false);
 
-            ui.colored_label(appearance.replace_color, &status.log);
+            ui.label(&status.cmdline);
+            ui.colored_label(appearance.replace_color, &status.stdout);
+            ui.colored_label(appearance.delete_color, &status.stderr);
         });
     });
 }
 
+fn missing_obj_ui(ui: &mut Ui, appearance: &Appearance) {
+    ui.scope(|ui| {
+        ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
+        ui.style_mut().wrap = Some(false);
+
+        ui.colored_label(appearance.replace_color, "No object configured");
+    });
+}
+
 pub fn symbol_diff_ui(ui: &mut Ui, state: &mut DiffViewState, appearance: &Appearance) {
     let DiffViewState { build, current_view, symbol_state, search, .. } = state;
     let Some(result) = build else {
@@ -294,9 +353,13 @@ pub fn symbol_diff_ui(ui: &mut Ui, state: &mut DiffViewState, appearance: &Appea
 
                         ui.label("Build target:");
                         if result.first_status.success {
-                            ui.label("OK");
+                            if result.first_obj.is_none() {
+                                ui.colored_label(appearance.replace_color, "Missing");
+                            } else {
+                                ui.label("OK");
+                            }
                         } else {
-                            ui.colored_label(Rgba::from_rgb(1.0, 0.0, 0.0), "Fail");
+                            ui.colored_label(appearance.delete_color, "Fail");
                         }
                     });
 
@@ -317,19 +380,19 @@ pub fn symbol_diff_ui(ui: &mut Ui, state: &mut DiffViewState, appearance: &Appea
 
                         ui.label("Build base:");
                         if result.second_status.success {
-                            ui.label("OK");
+                            if result.second_obj.is_none() {
+                                ui.colored_label(appearance.replace_color, "Missing");
+                            } else {
+                                ui.label("OK");
+                            }
                         } else {
-                            ui.colored_label(Rgba::from_rgb(1.0, 0.0, 0.0), "Fail");
+                            ui.colored_label(appearance.delete_color, "Fail");
                         }
                     });
 
-                    ui.add_enabled(
-                        !symbol_state.disable_reverse_fn_order,
-                        egui::Checkbox::new(
-                            &mut symbol_state.reverse_fn_order,
-                            "Reverse function order (-inline deferred)",
-                        ),
-                    );
+                    if ui.add_enabled(!state.build_running, egui::Button::new("Build")).clicked() {
+                        state.queue_build = true;
+                    }
                 },
             );
         },
@@ -353,6 +416,8 @@ pub fn symbol_diff_ui(ui: &mut Ui, state: &mut DiffViewState, appearance: &Appea
                                     &lower_search,
                                     appearance,
                                 ));
+                            } else {
+                                missing_obj_ui(ui, appearance);
                             }
                         } else {
                             build_log_ui(ui, &result.first_status, appearance);
@@ -370,6 +435,8 @@ pub fn symbol_diff_ui(ui: &mut Ui, state: &mut DiffViewState, appearance: &Appea
                                     &lower_search,
                                     appearance,
                                 ));
+                            } else {
+                                missing_obj_ui(ui, appearance);
                             }
                         } else {
                             build_log_ui(ui, &result.second_status, appearance);