Support min_version field in objdiff.json

- Support `completed` field for objects in project config. In object tree, displays red for incomplete, green for complete.
- Add support for one-sided diffs. A project can include objects without an associated source file for viewing.
- Add versioning to AppConfig, supporting upgrades without losing user configuration.

Cargo.lock

@@ -840,9 +840,9 @@ dependencies = [
 
 [[package]]
 name = "cwdemangle"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b58d34a3a03cfe0a4ebfd03aeda6ee8a0f2e99bd3308476a8a89815add3ec373"
+checksum = "c251bc5553377b3dc85c7b9b3955cfc2eb5a7b5544cf65adc2d53c2a4c2f4162"
 dependencies = [
  "argh",
 ]
@@ -2457,7 +2457,7 @@ dependencies = [
 
 [[package]]
 name = "objdiff"
-version = "0.4.0"
+version = "0.4.1"
 dependencies = [
  "anyhow",
  "byteorder",
@@ -2483,7 +2483,9 @@ dependencies = [
  "rabbitizer",
  "reqwest",
  "rfd",
+ "ron",
  "self_update",
+ "semver",
  "serde",
  "serde_json",
  "serde_yaml",
@@ -3044,9 +3046,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.101.1"
+version = "0.101.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15f36a6828982f422756984e47912a7a51dcbc2a197aa791158f8ca61cd8204e"
+checksum = "7d93931baf2d282fff8d3a532bbfd7653f734643161b87e3e01e59a04439bf0d"
 dependencies = [
  "ring",
  "untrusted",
@@ -4051,9 +4053,9 @@ dependencies = [
 
 [[package]]
 name = "webpki"
-version = "0.22.0"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
+checksum = "f0e74f82d49d545ad128049b7e88f6576df2da6b02e9ce565c6f533be576957e"
 dependencies = [
  "ring",
  "untrusted",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "objdiff"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 rust-version = "1.65"
 authors = ["Luke Street <luke@street.dev>"]
@@ -27,7 +27,7 @@ byteorder = "1.4.3"
 bytes = "1.4.0"
 cfg-if = "1.0.0"
 const_format = "0.2.31"
-cwdemangle = "0.1.5"
+cwdemangle = "0.1.6"
 dirs = "5.0.1"
 eframe = { version = "0.22.0", features = ["persistence"] }
 egui = "0.22.0"
@@ -42,6 +42,8 @@ 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']
+ron = "0.8.0"
+semver = "1.0.17"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1.0.104"
 serde_yaml = "0.9.25"

README.md

@@ -16,10 +16,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 
+For example, if the target ("expected") object is located at `build/asm/MetroTRK/mslsupp.o` and the base ("actual")
-is located at `build/src/MetroTRK/mslsupp.o`, the following configuration would be used:
+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 +39,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 +66,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,22 +82,41 @@ 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.  
+`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.
+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.
+`target_dir` _(optional)_: Relative from the root of the project, this where the "target" or "expected" objects are located.  
-- `base_dir`: Relative from the root of the project, this is where the "base" or "actual" objects are located.  
+These are the **intended result** of the match.
-  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`).  
+`base_dir` _(optional)_: Relative from the root of the project, this is where the "base" or "actual" objects are located.  
-  This is useful if the target objects are not built by default or can change based on project configuration or edits to assembly files.  
+These are objects built from the **current source code**.
-  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))  
+`build_target`: If true, objdiff will tell the build system to build the target objects before diffing (e.g.
-  If any of these files change, objdiff will automatically rebuild the objects and re-compare them.
+  `make path/to/target.o`).  
-- `objects` _(optional)_: If specified, objdiff will display a list of objects in the sidebar for easy navigation.
+This is useful if the target objects are not built by default or can change based on project configuration or edits
-  - `path`: Relative path to the object from the `target_dir` and `base_dir`.
+to assembly files.  
-  - `name` _(optional)_: The name of the object in the UI. If not specified, the object's `path` will be used.  
+Requires the build system to be configured properly.
-  - `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.
+`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.
 
 
 
@@ -96,6 +131,5 @@ at your option.
 
 ### Contribution
 
-Unless you explicitly state otherwise, any contribution intentionally submitted
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as
-for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any
+defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
-additional terms or conditions.

src/app.rs

@@ -14,13 +14,14 @@ use notify::{RecursiveMode, Watcher};
 use time::UtcOffset;
 
 use crate::{
+    app_config::{deserialize_config, AppConfigVersion},
     config::{
         build_globset, load_project_config, ProjectObject, ProjectObjectNode, CONFIG_FILENAMES,
     },
     jobs::{objdiff::start_build, Job, JobQueue, JobResult, JobStatus},
     views::{
         appearance::{appearance_window, Appearance},
-        config::{config_ui, project_window, ConfigViewState},
+        config::{config_ui, project_window, ConfigViewState, DEFAULT_WATCH_PATTERNS},
         data_diff::data_diff_ui,
         demangle::{demangle_window, DemangleViewState},
         function_diff::function_diff_ui,
@@ -40,16 +41,34 @@ pub struct ViewState {
     pub show_project_config: 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>,
+}
+
+#[inline]
+fn bool_true() -> bool { true }
+
+#[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,
     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 obj_path: Option<String>,
+    pub selected_obj: Option<ObjectConfig>,
     pub build_target: bool,
-    pub watcher_enabled: bool,
+    #[serde(default = "bool_true")]
+    pub rebuild_on_changes: bool,
     pub auto_update_check: bool,
     pub watch_patterns: Vec<Glob>,
 
@@ -65,6 +84,33 @@ pub struct AppConfig {
     pub obj_change: bool,
     #[serde(skip)]
     pub queue_build: bool,
+    #[serde(skip)]
+    pub project_config_loaded: bool,
+}
+
+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_target: false,
+            rebuild_on_changes: true,
+            auto_update_check: true,
+            watch_patterns: DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect(),
+            objects: vec![],
+            object_nodes: vec![],
+            watcher_change: false,
+            config_change: false,
+            obj_change: false,
+            queue_build: false,
+            project_config_loaded: false,
+        }
+    }
 }
 
 impl AppConfig {
@@ -72,7 +118,7 @@ impl AppConfig {
         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 +126,25 @@ impl AppConfig {
         self.config_change = true;
         self.obj_change = true;
         self.queue_build = false;
+        self.project_config_loaded = false;
     }
 
     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) {
+    pub fn set_selected_obj(&mut self, object: ObjectConfig) {
-        self.obj_path = Some(path);
+        self.selected_obj = Some(object);
         self.obj_change = true;
         self.queue_build = false;
     }
@@ -117,8 +164,8 @@ pub struct App {
     should_relaunch: bool,
 }
 
-const APPEARANCE_KEY: &str = "appearance";
+pub const APPEARANCE_KEY: &str = "appearance";
-const CONFIG_KEY: &str = "app_config";
+pub const CONFIG_KEY: &str = "app_config";
 
 impl App {
     /// Called once before the first frame.
@@ -137,7 +184,7 @@ 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;
@@ -258,19 +305,19 @@ 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;
         }
 
         // 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) {
+        if config.queue_build && config.selected_obj.is_some() && !jobs.is_running(Job::ObjDiff) {
             jobs.push(start_build(self.config.clone()));
             config.queue_build = false;
         }
@@ -375,19 +422,27 @@ fn create_watcher(
 ) -> notify::Result<notify::RecommendedWatcher> {
     let mut config_patterns = GlobSetBuilder::new();
     for filename in CONFIG_FILENAMES {
-        config_patterns.add(Glob::new(&format!("**/{filename}")).unwrap());
+        config_patterns.add(Glob::new(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 {
+                        let Ok(path) = path.strip_prefix(&base_dir) else {
+                            continue;
+                        };
                         if config_patterns.is_match(path) {
                             config_modified.store(true, Ordering::Relaxed);
-                        }
+                        } else if patterns.is_match(path) {
-                        if patterns.is_match(path) {
                             modified.store(true, Ordering::Relaxed);
                         }
                     }

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

@@ -3,19 +3,20 @@ use std::{
     path::{Component, Path, PathBuf},
 };
 
-use anyhow::{Context, Result};
+use anyhow::{bail, Context, Result};
 use globset::{Glob, GlobSet, GlobSetBuilder};
 
-use crate::app::AppConfig;
+use crate::{app::AppConfig, views::config::DEFAULT_WATCH_PATTERNS};
 
 #[derive(Default, Clone, serde::Deserialize)]
 #[serde(default)]
 pub struct ProjectConfig {
+    pub min_version: Option<String>,
     pub custom_make: Option<String>,
     pub target_dir: Option<PathBuf>,
     pub base_dir: Option<PathBuf>,
     pub build_target: bool,
-    pub watch_patterns: Vec<Glob>,
+    pub watch_patterns: Option<Vec<Glob>>,
     #[serde(alias = "units")]
     pub objects: Vec<ProjectObject>,
 }
@@ -23,8 +24,23 @@ pub struct ProjectConfig {
 #[derive(Default, Clone, serde::Deserialize)]
 pub struct ProjectObject {
     pub name: Option<String>,
-    pub path: PathBuf,
+    pub path: Option<PathBuf>,
+    pub target_path: Option<PathBuf>,
+    pub base_path: Option<PathBuf>,
     pub reverse_fn_order: Option<bool>,
+    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)]
@@ -53,11 +69,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 +93,23 @@ fn build_nodes(objects: &[ProjectObject]) -> Vec<ProjectObjectNode> {
                 }
             }
         }
+        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.clone()));
+        out_nodes.push(ProjectObjectNode::File(filename, object));
     }
     nodes
 }
@@ -80,14 +122,26 @@ pub fn load_project_config(config: &mut AppConfig) -> Result<()> {
     };
     if let Some(result) = 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_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_loaded = true;
     }
     Ok(())
 }

src/diff.rs

@@ -372,66 +372,80 @@ fn find_section_and_symbol(obj: &ObjInfo, name: &str) -> Option<(usize, usize)>
     None
 }
 
-pub fn diff_objs(left: &mut ObjInfo, right: &mut ObjInfo) -> Result<()> {
+pub fn diff_objs(mut left: Option<&mut ObjInfo>, mut right: Option<&mut ObjInfo>) -> Result<()> {
-    for left_section in &mut left.sections {
+    if let Some(left) = left.as_mut() {
-        if left_section.kind == ObjSectionKind::Code {
+        for left_section in &mut left.sections {
-            for left_symbol in &mut left_section.symbols {
+            if left_section.kind == ObjSectionKind::Code {
-                if let Some((right_section_idx, right_symbol_idx)) =
+                for left_symbol in &mut left_section.symbols {
-                    find_section_and_symbol(right, &left_symbol.name)
+                    if let Some((right, (right_section_idx, right_symbol_idx))) =
-                {
+                        right.as_mut().and_then(|obj| {
-                    let right_section = &mut right.sections[right_section_idx];
+                            find_section_and_symbol(obj, &left_symbol.name).map(|s| (obj, s))
-                    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());
+                        let right_section = &mut right.sections[right_section_idx];
-                    diff_code(
+                        let right_symbol = &mut right_section.symbols[right_symbol_idx];
-                        left.architecture,
+                        left_symbol.diff_symbol = Some(right_symbol.name.clone());
-                        &left_section.data,
+                        right_symbol.diff_symbol = Some(left_symbol.name.clone());
-                        &right_section.data,
+                        diff_code(
-                        left_symbol,
+                            left.architecture,
-                        right_symbol,
+                            &left_section.data,
-                        &left_section.relocations,
+                            &right_section.data,
-                        &right_section.relocations,
+                            left_symbol,
-                        &left.line_info,
+                            right_symbol,
-                        &right.line_info,
+                            &left_section.relocations,
-                    )?;
+                            &right_section.relocations,
-                } else {
+                            &left.line_info,
-                    no_diff_code(
+                            &right.line_info,
-                        left.architecture,
+                        )?;
-                        &left_section.data,
+                    } else {
-                        left_symbol,
+                        no_diff_code(
-                        &left_section.relocations,
+                            left.architecture,
-                        &left.line_info,
+                            &left_section.data,
-                    )?;
+                            left_symbol,
+                            &left_section.relocations,
+                            &left.line_info,
+                        )?;
+                    }
                 }
-            }
+            } else if let Some(right_section) = right
-        } else {
+                .as_mut()
-            let Some(right_section) =
+                .and_then(|obj| obj.sections.iter_mut().find(|s| s.name == left_section.name))
-                right.sections.iter_mut().find(|s| s.name == left_section.name)
+            {
-            else {
+                if left_section.kind == ObjSectionKind::Data {
-                continue;
+                    diff_data(left_section, right_section);
-            };
+                    // diff_data_symbols(left_section, right_section)?;
-            if left_section.kind == ObjSectionKind::Data {
+                } else if left_section.kind == ObjSectionKind::Bss {
-                diff_data(left_section, right_section);
+                    diff_bss_symbols(&mut left_section.symbols, &mut right_section.symbols)?;
-                // diff_data_symbols(left_section, right_section)?;
+                }
-            } else if left_section.kind == ObjSectionKind::Bss {
+            } else if left_section.kind == ObjSectionKind::Data {
-                diff_bss_symbols(&mut left_section.symbols, &mut right_section.symbols)?;
+                no_diff_data(left_section);
             }
         }
     }
-    for right_section in right.sections.iter_mut().filter(|s| s.kind == ObjSectionKind::Code) {
+    if let Some(right) = right.as_mut() {
-        for right_symbol in &mut right_section.symbols {
+        for right_section in right.sections.iter_mut() {
-            if right_symbol.instructions.is_empty() {
+            if right_section.kind == ObjSectionKind::Code {
-                no_diff_code(
+                for right_symbol in &mut right_section.symbols {
-                    right.architecture,
+                    if right_symbol.instructions.is_empty() {
-                    &right_section.data,
+                        no_diff_code(
-                    right_symbol,
+                            right.architecture,
-                    &right_section.relocations,
+                            &right_section.data,
-                    &right.line_info,
+                            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);
             }
         }
     }
-    diff_bss_symbols(&mut left.common, &mut right.common)?;
+    if let (Some(left), Some(right)) = (left, right) {
+        diff_bss_symbols(&mut left.common, &mut right.common)?;
+    }
     Ok(())
 }
 
@@ -710,3 +724,12 @@ fn diff_data(left: &mut ObjSection, right: &mut ObjSection) {
     left.data_diff = left_diff;
     right.data_diff = right_diff;
 }
+
+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/jobs/objdiff.rs

@@ -1,6 +1,6 @@
 use std::{path::Path, process::Command, str::from_utf8, sync::mpsc::Receiver};
 
-use anyhow::{Context, Error, Result};
+use anyhow::{anyhow, Context, Error, Result};
 use time::OffsetDateTime;
 
 use crate::{
@@ -76,55 +76,104 @@ fn run_build(
     config: AppConfigRef,
 ) -> 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
+    let target_path_rel = if let Some(target_path) = &obj_config.target_path {
-        .target_obj_dir
+        Some(target_path.strip_prefix(project_dir).map_err(|_| {
-        .as_ref()
+            anyhow!(
-        .ok_or_else(|| Error::msg("Missing target obj dir"))?
+                "Target path '{}' doesn't begin with '{}'",
-        .to_owned();
+                target_path.display(),
-    target_path.push(obj_path);
+                project_dir.display()
-    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);
+    } else {
-    let target_path_rel = target_path
+        None
-        .strip_prefix(project_dir)
+    };
-        .context("Failed to create relative target obj path")?;
+    let base_path_rel = if let Some(base_path) = &obj_config.base_path {
-    let base_path_rel =
+        Some(base_path.strip_prefix(project_dir).map_err(|_| {
-        base_path.strip_prefix(project_dir).context("Failed to create relative base obj path")?;
+            anyhow!(
+                "Base path '{}' doesn't begin with '{}'",
+                base_path.display(),
+                project_dir.display()
+            )
+        })?)
+    } else {
+        None
+    };
 
-    let total = if config.build_target { 5 } else { 4 };
+    let mut total = 3;
-    let first_status = if config.build_target {
+    if config.build_target && target_path_rel.is_some() {
-        update_status(status, format!("Building target {obj_path}"), 0, total, &cancel)?;
+        total += 1;
-        run_make(project_dir, target_path_rel, &config)
+    }
+    if base_path_rel.is_some() {
+        total += 1;
+    }
+    let first_status = match target_path_rel {
+        Some(target_path_rel) if config.build_target => {
+            update_status(
+                status,
+                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 = if let Some(base_path_rel) = base_path_rel {
+        update_status(
+            status,
+            format!("Building base {}", base_path_rel.display()),
+            1,
+            total,
+            &cancel,
+        )?;
+        run_make(project_dir, base_path_rel, &config)
     } else {
         BuildStatus { success: true, log: String::new() }
     };
 
-    update_status(status, format!("Building base {obj_path}"), 1, total, &cancel)?;
-    let second_status = run_make(project_dir, base_path_rel, &config);
-
     let time = OffsetDateTime::now_utc();
 
-    let mut first_obj = if first_status.success {
+    let mut first_obj =
-        update_status(status, format!("Loading target {obj_path}"), 2, total, &cancel)?;
+        match &obj_config.target_path {
-        Some(elf::read(&target_path)?)
+            Some(target_path) if first_status.success => {
-    } else {
+                update_status(
-        None
+                    status,
+                    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(
+                status,
+                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, "Performing diff".to_string(), 4, total, &cancel)?;
-        update_status(status, format!("Loading base {obj_path}"), 3, total, &cancel)?;
+    diff_objs(first_obj.as_mut(), second_obj.as_mut())?;
-        Some(elf::read(&base_path)?)
-    } else {
-        None
-    };
-
-    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)?;
     Ok(Box::new(ObjDiffResult { first_status, second_status, first_obj, second_obj, time }))

src/lib.rs

@@ -3,6 +3,7 @@
 pub use app::App;
 
 mod app;
+mod app_config;
 mod config;
 mod diff;
 mod editops;

src/views/config.rs

@@ -17,7 +17,7 @@ use globset::Glob;
 use self_update::cargo_crate_version;
 
 use crate::{
-    app::{AppConfig, AppConfigRef},
+    app::{AppConfig, AppConfigRef, ObjectConfig},
     config::{ProjectObject, ProjectObjectNode},
     jobs::{
         check_update::{start_check_update, CheckUpdateResult},
@@ -40,6 +40,7 @@ pub struct ConfigViewState {
     pub watch_pattern_text: String,
     pub load_error: Option<String>,
     pub object_search: String,
+    pub filter_diffable: bool,
     #[cfg(windows)]
     pub available_wsl_distros: Option<Vec<String>>,
 }
@@ -79,7 +80,7 @@ impl ConfigViewState {
     }
 }
 
-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",
 ];
@@ -129,7 +130,7 @@ pub fn config_ui(
         selected_wsl_distro,
         target_obj_dir,
         base_obj_dir,
-        obj_path,
+        selected_obj,
         auto_update_check,
         objects,
         object_nodes,
@@ -205,9 +206,9 @@ pub fn config_ui(
         }
     });
 
-    if let (Some(base_dir), Some(target_dir)) = (base_obj_dir, target_obj_dir) {
+    let mut new_selected_obj = selected_obj.clone();
-        let mut new_build_obj = obj_path.clone();
+    if objects.is_empty() {
-        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)
@@ -215,88 +216,111 @@ pub fn config_ui(
                     .pick_file()
                 {
                     if let Ok(obj_path) = path.strip_prefix(&base_dir) {
-                        new_build_obj = Some(obj_path.display().to_string());
+                        let target_path = target_dir.join(obj_path);
+                        new_selected_obj = Some(ObjectConfig {
+                            name: obj_path.display().to_string(),
+                            target_path: Some(target_path),
+                            base_path: Some(path),
+                            reverse_fn_order: None,
+                            complete: None,
+                        });
                     } else if let Ok(obj_path) = path.strip_prefix(&target_dir) {
-                        new_build_obj = Some(obj_path.display().to_string());
+                        let base_path = base_dir.join(obj_path);
+                        new_selected_obj = Some(ObjectConfig {
+                            name: obj_path.display().to_string(),
+                            target_path: Some(path),
+                            base_path: Some(base_path),
+                            reverse_fn_order: None,
+                            complete: None,
+                        });
                     }
                 }
             }
-            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();
+            ui.colored_label(appearance.delete_color, "Missing project settings");
-            egui::TextEdit::singleline(&mut state.object_search).hint_text("Filter").ui(ui);
+        }
+    } 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 root_open = None;
-            let mut node_open = NodeOpen::Default;
+        let mut node_open = NodeOpen::Default;
-            ui.horizontal(|ui| {
+        ui.horizontal(|ui| {
-                if ui.small_button("⏶").on_hover_text_at_pointer("Collapse all").clicked() {
+            if ui.small_button("⏶").on_hover_text_at_pointer("Collapse all").clicked() {
-                    root_open = Some(false);
+                root_open = Some(false);
-                    node_open = NodeOpen::Close;
+                node_open = NodeOpen::Close;
-                }
+            }
-                if ui.small_button("⏷").on_hover_text_at_pointer("Expand all").clicked() {
+            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 {
                 root_open = Some(true);
                 node_open = NodeOpen::Open;
             }
-
+            if ui
-            CollapsingHeader::new(RichText::new("🗀 Objects").font(FontId {
+                .add_enabled(selected_obj.is_some(), egui::Button::new("⌖").small())
-                size: appearance.ui_font.size,
+                .on_hover_text_at_pointer("Current object")
-                family: appearance.code_font.family.clone(),
+                .clicked()
-            }))
+            {
-            .open(root_open)
+                root_open = Some(true);
-            .default_open(true)
+                node_open = NodeOpen::Object;
-            .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
+                .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 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()
+        CollapsingHeader::new(RichText::new("🗀 Objects").font(FontId {
-        {
+            size: appearance.ui_font.size,
-            state.queue_build = true;
+            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 {
+                let search = state.object_search.to_ascii_lowercase();
+                nodes = Cow::Owned(
+                    object_nodes
+                        .iter()
+                        .filter_map(|node| filter_node(node, &search, state.filter_diffable))
+                        .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 +328,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 object_name = object.name();
-    let selected = matches!(obj_path, Some(path) if path == &path_string);
+    let selected = matches!(selected_obj, Some(obj) if obj.name == object_name);
-    let color = if selected { appearance.emphasized_text_color } else { appearance.text_color };
+    let color = if selected {
-    if SelectableLabel::new(
+        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 +356,17 @@ fn display_object(
             .color(color),
     )
     .ui(ui)
-    .clicked()
+    .clicked();
-    {
+    // Always recreate ObjectConfig if selected, in case the project config changed.
-        *obj_path = Some(path_string);
+    // 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,
+        });
     }
 }
 
@@ -339,17 +381,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 +414,46 @@ 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) => {
+        ProjectObjectNode::File(_, object) => object.name() == selected_obj.name,
-            let path_string = object.path.to_string_lossy().to_string();
-            path == path_string
-        }
         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,
+) -> Option<ProjectObjectNode> {
     match node {
-        ProjectObjectNode::File(name, _) => {
+        ProjectObjectNode::File(name, object) => {
-            if name.to_ascii_lowercase().contains(search) {
+            if (search.is_empty() || name.to_ascii_lowercase().contains(search))
+                && (!filter_diffable || object.base_path.is_some())
+            {
                 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
+            {
                 return Some(node.clone());
             }
-            let new_children =
+            let new_children = children
-                children.iter().filter_map(|child| filter_node(child, search)).collect::<Vec<_>>();
+                .iter()
+                .filter_map(|child| filter_node(child, search, filter_diffable))
+                .collect::<Vec<_>>();
             if !new_children.is_empty() {
                 Some(ProjectObjectNode::Dir(name.clone(), new_children))
             } else {
@@ -444,11 +492,12 @@ fn pick_folder_ui(
     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"))
     });
     ui.label(format_path(dir, appearance));
     response.inner
@@ -506,6 +555,7 @@ fn split_obj_config_ui(
             ui.label(job);
         },
         appearance,
+        true,
     );
     if response.clicked() {
         if let Some(path) = rfd::FileDialog::new().pick_folder() {
@@ -566,6 +616,7 @@ fn split_obj_config_ui(
                 ui.label(job);
             },
             appearance,
+            !config.project_config_loaded,
         );
         if response.clicked() {
             if let Some(path) = rfd::FileDialog::new().set_directory(&project_dir).pick_folder() {
@@ -615,6 +666,7 @@ fn split_obj_config_ui(
                 ui.label(job);
             },
             appearance,
+            !config.project_config_loaded,
         );
         if response.clicked() {
             if let Some(path) = rfd::FileDialog::new().set_directory(&project_dir).pick_folder() {
@@ -626,7 +678,7 @@ fn split_obj_config_ui(
 
     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.",

src/views/data_diff.rs

@@ -132,31 +132,39 @@ fn split_diffs(diffs: &[ObjDataDiff]) -> Vec<Vec<ObjDataDiff>> {
 
 fn data_table_ui(
     table: TableBuilder<'_>,
-    left_obj: &ObjInfo,
+    left_obj: Option<&ObjInfo>,
-    right_obj: &ObjInfo,
+    right_obj: Option<&ObjInfo>,
     selected_symbol: &SymbolReference,
     config: &Appearance,
 ) -> Option<()> {
-    let left_section = find_section(left_obj, selected_symbol)?;
+    let left_section = left_obj.and_then(|obj| find_section(obj, selected_symbol));
-    let right_section = find_section(right_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 left_diffs = left_section.map(|section| split_diffs(&section.data_diff));
-    let right_diffs = split_diffs(&right_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| {
             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);
+                }
             });
         });
     });
@@ -243,15 +251,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 available_height = ui.available_height();
+    let table = TableBuilder::new(ui)
-        let table = TableBuilder::new(ui)
+        .striped(false)
-            .striped(false)
+        .cell_layout(Layout::left_to_right(Align::Min))
-            .cell_layout(Layout::left_to_right(Align::Min))
+        .columns(Column::exact(column_width).clip(true), 2)
-            .columns(Column::exact(column_width).clip(true), 2)
+        .resizable(false)
-            .resizable(false)
+        .auto_shrink([false, false])
-            .auto_shrink([false, false])
+        .min_scrolled_height(available_height);
-            .min_scrolled_height(available_height);
+    data_table_ui(
-        data_table_ui(table, left_obj, right_obj, selected_symbol, appearance);
+        table,
-    }
+        result.first_obj.as_ref(),
+        result.second_obj.as_ref(),
+        selected_symbol,
+        appearance,
+    );
 }

src/views/function_diff.rs

@@ -377,13 +377,13 @@ fn asm_row_ui(
 
 fn asm_table_ui(
     table: TableBuilder<'_>,
-    left_obj: &ObjInfo,
+    left_obj: Option<&ObjInfo>,
-    right_obj: &ObjInfo,
+    right_obj: Option<&ObjInfo>,
     selected_symbol: &SymbolReference,
     appearance: &Appearance,
 ) -> Option<()> {
-    let left_symbol = find_symbol(left_obj, selected_symbol);
+    let left_symbol = left_obj.and_then(|obj| find_symbol(obj, selected_symbol));
-    let right_symbol = find_symbol(right_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| {
@@ -492,7 +492,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 +503,19 @@ 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 available_height = ui.available_height();
+    let table = TableBuilder::new(ui)
-        let table = TableBuilder::new(ui)
+        .striped(false)
-            .striped(false)
+        .cell_layout(Layout::left_to_right(Align::Min))
-            .cell_layout(Layout::left_to_right(Align::Min))
+        .columns(Column::exact(column_width).clip(true), 2)
-            .columns(Column::exact(column_width).clip(true), 2)
+        .resizable(false)
-            .resizable(false)
+        .auto_shrink([false, false])
-            .auto_shrink([false, false])
+        .min_scrolled_height(available_height);
-            .min_scrolled_height(available_height);
+    asm_table_ui(
-        asm_table_ui(table, left_obj, right_obj, selected_symbol, appearance);
+        table,
-    }
+        result.first_obj.as_ref(),
+        result.second_obj.as_ref(),
+        selected_symbol,
+        appearance,
+    );
 }

src/views/jobs.rs

@@ -1,4 +1,4 @@
-use egui::{ProgressBar, Widget};
+use egui::{ProgressBar, RichText, Widget};
 
 use crate::{jobs::JobQueue, views::appearance::Appearance};
 
@@ -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/symbol_diff.rs

@@ -1,7 +1,7 @@
 use std::mem::take;
 
 use egui::{
-    text::LayoutJob, Align, CollapsingHeader, Color32, Layout, Rgba, ScrollArea, SelectableLabel,
+    text::LayoutJob, Align, CollapsingHeader, Color32, Layout, ScrollArea, SelectableLabel,
     TextEdit, Ui, Vec2, Widget,
 };
 use egui_extras::{Size, StripBuilder};
@@ -62,15 +62,10 @@ impl DiffViewState {
 
         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(obj_config) = &config.selected_obj {
-                if let Some(object) = config.objects.iter().find(|object| {
+                if let Some(value) = obj_config.reverse_fn_order {
-                    let path_string = object.path.to_string_lossy().to_string();
+                    self.symbol_state.reverse_fn_order = value;
-                    &path_string == obj_path
+                    self.symbol_state.disable_reverse_fn_order = true;
-                }) {
-                    if let Some(value) = object.reverse_fn_order {
-                        self.symbol_state.reverse_fn_order = value;
-                        self.symbol_state.disable_reverse_fn_order = true;
-                    }
                 }
             }
         }
@@ -268,6 +263,15 @@ fn build_log_ui(ui: &mut Ui, status: &BuildStatus, appearance: &Appearance) {
     });
 }
 
+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 +298,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,9 +325,13 @@ 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");
                         }
                     });
 
@@ -353,6 +365,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 +384,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);