Repaint rework: more responsive, less energy

Previously, we repainted every frame on Windows at full refresh rate.
This is an enormous waste, as the UI will be static most of the time.
This was to work around a bug with `rfd` + `eframe`.
On other platforms, we only repainted every frame when a job was running,
which was better, but still not ideal. We also had a 100ms deadline, so
we'd repaint at ~10fps minimum to catch new events (file watcher, jobs).

This removes all repaint logic from the main loop and moves it into the
individual places where we change state from another thread.
For example, the file watcher thread will now immediately notify egui
to repaint, rather than relying on the 100ms deadline we had previously.
Jobs, when updating their status, also notify egui to repaint.

For `rfd` file dialogs, this migrates to using the async API built on top of
a polling thread + `pollster`. This interacts better with `eframe` on Windows.
Overall, this should reduce repaints and improve responsiveness to
file changes and background tasks.

.github/workflows/build.yaml

@@ -9,6 +9,7 @@ on:
   workflow_dispatch:
 
 env:
+  BUILD_PROFILE: release-lto
   CARGO_BIN_NAME: objdiff
   CARGO_TARGET_DIR: target
 
@@ -30,9 +31,25 @@ jobs:
         with:
           components: rustfmt, 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
@@ -103,16 +121,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 }}
       - 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 +147,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.3.4"
+version = "0.6.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,49 +13,60 @@ 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 = []
 wgpu = ["eframe/wgpu"]
+wsl = []
 
 [dependencies]
-anyhow = "1.0.71"
-bytes = "1.4.0"
+anyhow = "1.0.75"
+byteorder = "1.5.0"
+bytes = "1.5.0"
 cfg-if = "1.0.0"
-const_format = "0.2.31"
-cwdemangle = "0.1.5"
-eframe = { version = "0.22.0", features = ["persistence"] }
-egui = "0.22.0"
-egui_extras = "0.22.0"
-flagset = "0.4.3"
-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']
+const_format = "0.2.32"
+cwdemangle = "0.1.6"
+dirs = "5.0.1"
+eframe = { version = "0.23.0", features = ["persistence"] }
+egui = "0.23.0"
+egui_extras = "0.23.0"
+filetime = "0.2.22"
+flagset = "0.4.4"
+globset = { version = "0.4.13", features = ["serde1"] }
+log = "0.4.20"
+memmap2 = "0.9.0"
+notify = "6.1.1"
+object = { version = "0.32.1", features = ["read_core", "std", "elf"], default-features = false }
+png = "0.17.10"
+pollster = "0.3.0"
+ppc750cl = { git = "https://github.com/encounter/ppc750cl", rev = "4a2bbbc6f84dcb76255ab6f3595a8d4a0ce96618" }
+rabbitizer = "1.8.0"
+rfd = { version = "0.12.1" } #, default-features = false, features = ['xdg-portal']
+ron = "0.8.1"
+semver = "1.0.20"
 serde = { version = "1", features = ["derive"] }
-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.108"
+serde_yaml = "0.9.27"
+similar = "2.3.0"
+tempfile = "3.8.1"
+thiserror = "1.0.50"
+time = { version = "0.3.30", features = ["formatting", "local-offset"] }
+toml = "0.8.8"
 twox-hash = "1.6.3"
-byteorder = "1.4.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.22", default-features = false, features = ["blocking", "json", "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 = "0.11.22"
+self_update = "0.39.0"
 
 [target.'cfg(windows)'.dependencies]
 path-slash = "0.2.1"
@@ -77,5 +88,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.75"
+vergen = { version = "8.2.6", features = ["build", "cargo", "git", "gitcl"] }

README.md

@@ -5,14 +5,122 @@
 
 A local diffing tool for decompilation projects.
 
-Currently supports:
+Supports:
 - PowerPC 750CL (GameCube & Wii)
 - MIPS (Nintendo 64)
 
+See [Usage](#usage) for more information.
+
 ![Symbol Screenshot](assets/screen-symbols.png)
 ![Diff Screenshot](assets/screen-diff.png)
 
-### License
+## Usage
+
+objdiff works by comparing two relocatable object files (`.o`). The objects are expected to have the same relative path
+from the "target" and "base" directories.
+
+For example, if the target ("expected") object is located at `build/asm/MetroTRK/mslsupp.o` and the base ("actual")
+object is located at `build/src/MetroTRK/mslsupp.o`, the following configuration would be used:
+
+- Target build directory: `build/asm`
+- Base build directory: `build/src`
+- Object: `MetroTRK/mslsupp.o`
+
+objdiff will then execute the build system from the project directory to build both objects:
+
+```sh
+$ make build/asm/MetroTRK/mslsupp.o # Only if "Build target object" is enabled
+$ make build/src/MetroTRK/mslsupp.o
+```
+
+The objects will then be compared and the results will be displayed in the UI.
+
+See [Configuration](#configuration) for more information.
+
+## Configuration
+
+While **not required** (most settings can be specified in the UI), projects can add an `objdiff.json` (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",
+
+  // 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",
+    "*.cp",
+    "*.cpp",
+    "*.h",
+    "*.hpp",
+    "*.py"
+  ],
+  "objects": [
+    {
+      "name": "main/MetroTRK/mslsupp",
+
+      // Option 1: Relative to target_dir and base_dir
+      "path": "MetroTRK/mslsupp.o",
+      // 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
+    },
+    // ...
+  ]
+}
+```
+
+`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.
+
+
+
+## License
 
 Licensed under either of
 
@@ -23,6 +131,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_config.rs

@@ -0,0 +1,96 @@
+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,
+        }
+    }
+}
+
+#[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

@@ -0,0 +1,207 @@
+use std::{
+    fs::File,
+    io::Read,
+    path::{Component, Path, PathBuf},
+};
+
+use anyhow::{bail, Result};
+use filetime::FileTime;
+use globset::{Glob, GlobSet, GlobSetBuilder};
+
+use crate::{
+    app::{AppConfig, ProjectConfigInfo},
+    views::config::DEFAULT_WATCH_PATTERNS,
+};
+
+#[inline]
+fn bool_true() -> bool { true }
+
+#[derive(Default, Clone, serde::Deserialize)]
+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,
+    #[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>,
+    #[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>,
+}
+
+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),
+    Dir(String, Vec<ProjectObjectNode>),
+}
+
+fn find_dir<'a>(
+    name: &str,
+    nodes: &'a mut Vec<ProjectObjectNode>,
+) -> &'a mut Vec<ProjectObjectNode> {
+    if let Some(index) = nodes
+        .iter()
+        .position(|node| matches!(node, ProjectObjectNode::Dir(dir_name, _) if dir_name == name))
+    {
+        if let ProjectObjectNode::Dir(_, children) = &mut nodes[index] {
+            return children;
+        }
+    } else {
+        nodes.push(ProjectObjectNode::Dir(name.to_string(), vec![]));
+        if let Some(ProjectObjectNode::Dir(_, children)) = nodes.last_mut() {
+            return children;
+        }
+    }
+    unreachable!();
+}
+
+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 = 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 {
+                    let name = name.to_str().unwrap();
+                    out_nodes = find_dir(name, out_nodes);
+                }
+            }
+        }
+        let mut object = 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));
+    }
+    nodes
+}
+
+pub const CONFIG_FILENAMES: [&str; 3] = ["objdiff.yml", "objdiff.yaml", "objdiff.json"];
+
+pub fn load_project_config(config: &mut AppConfig) -> Result<()> {
+    let Some(project_dir) = &config.project_dir else {
+        return Ok(());
+    };
+    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.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, 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>, ProjectConfigInfo)> {
+    for filename in CONFIG_FILENAMES.iter() {
+        let config_path = dir.join(filename);
+        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<R: Read>(reader: &mut R) -> Result<ProjectConfig> {
+    Ok(serde_yaml::from_reader(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> {
+    let mut builder = GlobSetBuilder::new();
+    for glob in vec {
+        builder.add(glob.clone());
+    }
+    builder.build()
+}

src/diff/code.rs

@@ -0,0 +1,478 @@
+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, 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<u32, u32>>,
+) -> 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(
+    alg: DiffAlg,
+    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_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 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(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(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)
+}
+
+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,114 @@
+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 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.code_alg,
+                            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/jobs/bindiff.rs

@@ -1,44 +0,0 @@
-use std::sync::{mpsc::Receiver, Arc, RwLock};
-
-use anyhow::{Error, Result};
-
-use crate::{
-    app::{AppConfig, DiffConfig},
-    diff::diff_objs,
-    jobs::{queue_job, update_status, Job, JobResult, JobState, Status},
-    obj::{elf, ObjInfo},
-};
-
-pub struct BinDiffResult {
-    pub first_obj: ObjInfo,
-    pub second_obj: ObjInfo,
-}
-
-fn run_build(
-    status: &Status,
-    cancel: Receiver<()>,
-    config: Arc<RwLock<AppConfig>>,
-) -> Result<Box<BinDiffResult>> {
-    let config = config.read().map_err(|_| Error::msg("Failed to lock app config"))?.clone();
-    let target_path =
-        config.left_obj.as_ref().ok_or_else(|| Error::msg("Missing target obj path"))?;
-    let base_path = config.right_obj.as_ref().ok_or_else(|| Error::msg("Missing base obj path"))?;
-
-    update_status(status, "Loading target obj".to_string(), 0, 3, &cancel)?;
-    let mut left_obj = elf::read(target_path)?;
-
-    update_status(status, "Loading base obj".to_string(), 1, 3, &cancel)?;
-    let mut right_obj = elf::read(base_path)?;
-
-    update_status(status, "Performing diff".to_string(), 2, 3, &cancel)?;
-    diff_objs(&mut left_obj, &mut right_obj, &DiffConfig::default() /* TODO */)?;
-
-    update_status(status, "Complete".to_string(), 3, 3, &cancel)?;
-    Ok(Box::new(BinDiffResult { first_obj: left_obj, second_obj: right_obj }))
-}
-
-pub fn queue_bindiff(config: Arc<RwLock<AppConfig>>) -> JobState {
-    queue_job("Binary diff", Job::BinDiff, move |status, cancel| {
-        run_build(status, cancel, config).map(JobResult::BinDiff)
-    })
-}

src/jobs/check_update.rs

@@ -4,7 +4,7 @@ use anyhow::{Context, Result};
 use self_update::{cargo_crate_version, update::Release};
 
 use crate::{
-    jobs::{queue_job, update_status, Job, JobResult, JobState, Status},
+    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: &Status, 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 queue_check_update() -> JobState {
-    queue_job("Check for updates", Job::CheckUpdate, move |status, cancel| {
-        run_check_update(status, cancel).map(JobResult::CheckUpdate)
+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/mod.rs

@@ -9,12 +9,8 @@ use std::{
 
 use anyhow::Result;
 
-use crate::jobs::{
-    bindiff::BinDiffResult, check_update::CheckUpdateResult, objdiff::ObjDiffResult,
-    update::UpdateResult,
-};
+use crate::jobs::{check_update::CheckUpdateResult, objdiff::ObjDiffResult, update::UpdateResult};
 
-pub mod bindiff;
 pub mod check_update;
 pub mod objdiff;
 pub mod update;
@@ -22,19 +18,93 @@ pub mod update;
 #[derive(Debug, Eq, PartialEq, Copy, Clone)]
 pub enum Job {
     ObjDiff,
-    BinDiff,
     CheckUpdate,
     Update,
 }
 pub static JOB_ID: AtomicUsize = AtomicUsize::new(0);
+
+#[derive(Default)]
+pub struct JobQueue {
+    pub jobs: Vec<JobState>,
+    pub results: Vec<JobResult>,
+}
+
+impl JobQueue {
+    /// Adds a job to the queue.
+    #[inline]
+    pub fn push(&mut self, state: JobState) { self.jobs.push(state); }
+
+    /// Adds a job to the queue if a job of the given kind is not already running.
+    #[inline]
+    pub fn push_once(&mut self, job: Job, func: impl FnOnce() -> JobState) {
+        if !self.is_running(job) {
+            self.push(func());
+        }
+    }
+
+    /// Returns whether a job of the given kind is running.
+    pub fn is_running(&self, kind: Job) -> bool {
+        self.jobs.iter().any(|j| j.kind == kind && j.handle.is_some())
+    }
+
+    /// Returns whether any job is running.
+    #[allow(dead_code)]
+    pub fn any_running(&self) -> bool {
+        self.jobs.iter().any(|job| {
+            if let Some(handle) = &job.handle {
+                return !handle.is_finished();
+            }
+            false
+        })
+    }
+
+    /// Iterates over all jobs mutably.
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut JobState> + '_ { self.jobs.iter_mut() }
+
+    /// Iterates over all finished jobs, returning the job state and the result.
+    pub fn iter_finished(
+        &mut self,
+    ) -> impl Iterator<Item = (&mut JobState, std::thread::Result<JobResult>)> + '_ {
+        self.jobs.iter_mut().filter_map(|job| {
+            if let Some(handle) = &job.handle {
+                if !handle.is_finished() {
+                    return None;
+                }
+                let result = job.handle.take().unwrap().join();
+                return Some((job, result));
+            }
+            None
+        })
+    }
+
+    /// Clears all finished jobs.
+    pub fn clear_finished(&mut self) {
+        self.jobs.retain(|job| {
+            !(job.should_remove
+                && job.handle.is_none()
+                && job.context.status.read().unwrap().error.is_none())
+        });
+    }
+
+    /// Removes a job from the queue given its ID.
+    pub fn remove(&mut self, id: usize) { self.jobs.retain(|job| job.id != id); }
+}
+
+#[derive(Clone)]
+pub struct JobContext {
+    pub status: Arc<RwLock<JobStatus>>,
+    pub egui: egui::Context,
+}
+
 pub struct JobState {
     pub id: usize,
-    pub job_type: Job,
+    pub kind: Job,
     pub handle: Option<JoinHandle<JobResult>>,
-    pub status: Arc<RwLock<JobStatus>>,
+    pub context: JobContext,
     pub cancel: Sender<()>,
     pub should_remove: bool,
 }
+
 #[derive(Default)]
 pub struct JobStatus {
     pub title: String,
@@ -43,11 +113,11 @@ pub struct JobStatus {
     pub status: String,
     pub error: Option<anyhow::Error>,
 }
+
 pub enum JobResult {
     None,
-    ObjDiff(Box<ObjDiffResult>),
-    BinDiff(Box<BinDiffResult>),
-    CheckUpdate(Box<CheckUpdateResult>),
+    ObjDiff(Option<Box<ObjDiffResult>>),
+    CheckUpdate(Option<Box<CheckUpdateResult>>),
     Update(Box<UpdateResult>),
 }
 
@@ -58,12 +128,11 @@ fn should_cancel(rx: &Receiver<()>) -> bool {
     }
 }
 
-type Status = Arc<RwLock<JobStatus>>;
-
-fn queue_job(
+fn start_job(
+    ctx: &egui::Context,
     title: &str,
-    job_type: Job,
-    run: impl FnOnce(&Status, Receiver<()>) -> Result<JobResult> + Send + 'static,
+    kind: Job,
+    run: impl FnOnce(JobContext, Receiver<()>) -> Result<JobResult> + Send + 'static,
 ) -> JobState {
     let status = Arc::new(RwLock::new(JobStatus {
         title: title.to_string(),
@@ -72,10 +141,11 @@ fn queue_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() {
@@ -87,24 +157,18 @@ fn queue_job(
     });
     let id = JOB_ID.fetch_add(1, Ordering::Relaxed);
     log::info!("Started job {}", id);
-    JobState {
-        id,
-        job_type,
-        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: &Status,
+    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) {
@@ -113,5 +177,7 @@ fn update_status(
     } else {
         w.status = str;
     }
+    drop(w);
+    context.egui.request_repaint();
     Ok(())
 }

src/jobs/objdiff.rs

@@ -1,17 +1,17 @@
 use std::{
-    path::Path,
+    path::{Path, PathBuf},
     process::Command,
     str::from_utf8,
-    sync::{mpsc::Receiver, Arc, RwLock},
+    sync::mpsc::Receiver,
 };
 
-use anyhow::{Context, Error, Result};
+use anyhow::{anyhow, Context, Error, Result};
 use time::OffsetDateTime;
 
 use crate::{
-    app::{AppConfig, DiffConfig},
-    diff::diff_objs,
-    jobs::{queue_job, update_status, Job, JobResult, JobState, Status},
+    app::{AppConfig, ObjectConfig},
+    diff::{diff_objs, DiffAlg, DiffObjConfig},
+    jobs::{start_job, update_status, Job, JobContext, JobResult, JobState},
     obj::{elf, ObjInfo},
 };
 
@@ -20,6 +20,32 @@ pub struct BuildStatus {
     pub log: String,
 }
 
+pub struct ObjDiffConfig {
+    pub build_base: bool,
+    pub build_target: bool,
+    pub custom_make: Option<String>,
+    pub project_dir: Option<PathBuf>,
+    pub selected_obj: Option<ObjectConfig>,
+    pub selected_wsl_distro: Option<String>,
+    pub code_alg: DiffAlg,
+    pub data_alg: DiffAlg,
+}
+
+impl ObjDiffConfig {
+    pub(crate) fn from_config(config: &AppConfig) -> Self {
+        ObjDiffConfig {
+            build_base: config.build_base,
+            build_target: config.build_target,
+            custom_make: config.custom_make.clone(),
+            project_dir: config.project_dir.clone(),
+            selected_obj: config.selected_obj.clone(),
+            selected_wsl_distro: config.selected_wsl_distro.clone(),
+            code_alg: config.code_alg,
+            data_alg: config.data_alg,
+        }
+    }
+}
+
 pub struct ObjDiffResult {
     pub first_status: BuildStatus,
     pub second_status: BuildStatus,
@@ -28,7 +54,7 @@ pub struct ObjDiffResult {
     pub time: OffsetDateTime,
 }
 
-fn run_make(cwd: &Path, arg: &Path, config: &AppConfig) -> BuildStatus {
+fn run_make(cwd: &Path, arg: &Path, config: &ObjDiffConfig) -> BuildStatus {
     match (|| -> Result<BuildStatus> {
         let make = config.custom_make.as_deref().unwrap_or("make");
         #[cfg(not(windows))]
@@ -76,68 +102,117 @@ fn run_make(cwd: &Path, arg: &Path, config: &AppConfig) -> BuildStatus {
 }
 
 fn run_build(
-    status: &Status,
+    context: &JobContext,
     cancel: Receiver<()>,
-    config: Arc<RwLock<AppConfig>>,
-    diff_config: DiffConfig,
+    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 obj_config = config.selected_obj.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
-        .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)
+    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(project_dir, target_path_rel, &config)
+        }
+        _ => BuildStatus { success: true, log: String::new() },
+    };
+
+    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(project_dir, base_path_rel, &config)
+        }
+        _ => BuildStatus { success: true, log: String::new() },
+    };
 
     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 };
+    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, &diff_config)?;
-    }
-
-    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 queue_build(config: Arc<RwLock<AppConfig>>, diff_config: DiffConfig) -> JobState {
-    queue_job("Object diff", Job::ObjDiff, move |status, cancel| {
-        run_build(status, cancel, config, diff_config).map(JobResult::ObjDiff)
+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::{queue_job, update_status, Job, JobResult, JobState, Status},
+    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: &Status, 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: &Status, cancel: Receiver<()>) -> Result<Box<UpdateResult>
     Ok(Box::from(UpdateResult { exe_path: target_file }))
 }
 
-pub fn queue_update() -> JobState {
-    queue_job("Update app", Job::Update, move |status, cancel| {
-        run_update(status, cancel).map(JobResult::Update)
+pub fn start_update(ctx: &egui::Context) -> JobState {
+    start_job(ctx, "Update app", Job::Update, move |context, cancel| {
+        run_update(&context, cancel).map(JobResult::Update)
     })
 }