Version v2.7.1

* Data reloc hover tooltip: Show relocation source address

* Refactor data relocation diffing to improve accuracy and fix bugs

.cargo/config.toml

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

.github/workflows/build.yaml

@@ -30,6 +30,8 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
         with:
           components: clippy
+      - name: Cache Rust workspace
+        uses: Swatinem/rust-cache@v2
       - name: Cargo check
         run: cargo check --all-features --all-targets
       - name: Cargo clippy
@@ -63,7 +65,7 @@ jobs:
     continue-on-error: ${{ matrix.checks == 'advisories' }}
     steps:
       - uses: actions/checkout@v4
-      - uses: EmbarkStudios/cargo-deny-action@v1
+      - uses: EmbarkStudios/cargo-deny-action@v2
         with:
           command: check ${{ matrix.checks }}
 
@@ -85,6 +87,8 @@ jobs:
         uses: actions/checkout@v4
       - name: Setup Rust toolchain
         uses: dtolnay/rust-toolchain@stable
+      - name: Cache Rust workspace
+        uses: Swatinem/rust-cache@v2
       - name: Cargo test
         run: cargo test --release --all-features
 
@@ -142,11 +146,19 @@ jobs:
         uses: actions/checkout@v4
       - name: Install cargo-zigbuild
         if: matrix.build == 'zigbuild'
-        run: pip install ziglang==0.13.0 cargo-zigbuild==0.19.1
+        run: |
+          python3 -m venv .venv
+          . .venv/bin/activate
+          echo PATH=$PATH >> $GITHUB_ENV
+          pip install ziglang==0.13.0 cargo-zigbuild==0.19.1
       - name: Setup Rust toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
           targets: ${{ matrix.target }}
+      - name: Cache Rust workspace
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ matrix.target }}
       - name: Cargo build
         run: >
           cargo ${{ matrix.build }} --profile ${{ env.BUILD_PROFILE }} --target ${{ matrix.target }} 
@@ -198,6 +210,10 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
         with:
           targets: ${{ matrix.target }}
+      - name: Cache Rust workspace
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ matrix.target }}
       - name: Cargo build
         run: >
           cargo build --profile ${{ env.BUILD_PROFILE }} --target ${{ matrix.target }} 

.gitignore

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

Cargo.toml

@@ -13,9 +13,9 @@ strip = "debuginfo"
 codegen-units = 1
 
 [workspace.package]
-version = "2.2.2"
+version = "2.7.1"
 authors = ["Luke Street <luke@street.dev>"]
 edition = "2021"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/encounter/objdiff"
-rust-version = "1.74"
+rust-version = "1.81"

README.md

@@ -20,6 +20,7 @@ Supports:
 - MIPS (N64, PS1, PS2, PSP)
 - x86 (COFF only at the moment)
 - ARM (GBA, DS, 3DS)
+- ARM64 (Switch, experimental)
 
 See [Usage](#usage) for more information.
 

config.schema.json

@@ -133,6 +133,13 @@
         },
         "metadata": {
           "ref": "#/$defs/metadata"
+        },
+        "symbol_mappings": {
+          "type": "object",
+          "description": "Manual symbol mappings from target to base.",
+          "additionalProperties": {
+            "type": "string"
+          }
         }
       }
     },

deny.toml

@@ -70,7 +70,6 @@ feature-depth = 1
 # A list of advisory IDs to ignore. Note that ignored advisories will still
 # output a note when they are encountered.
 ignore = [
-    "RUSTSEC-2024-0370",
     #{ id = "RUSTSEC-0000-0000", reason = "you can specify a reason the advisory is ignored" },
     #"a-crate-that-is-yanked@0.1.1", # you can also ignore yanked crate versions if you wish
     #{ crate = "a-crate-that-is-yanked@0.1.1", reason = "you can specify why you are ignoring the yanked crate" },
@@ -98,7 +97,7 @@ allow = [
     "BSL-1.0",
     "CC0-1.0",
     "MPL-2.0",
-    "Unicode-DFS-2016",
+    "Unicode-3.0",
     "Zlib",
     "0BSD",
     "OFL-1.1",
@@ -240,7 +239,7 @@ allow-git = []
 
 [sources.allow-org]
 # github.com organizations to allow git sources for
-github = ["encounter"]
+github = []
 # gitlab.com organizations to allow git sources for
 gitlab = []
 # bitbucket.org organizations to allow git sources for

objdiff-cli/Cargo.toml

@@ -14,13 +14,13 @@ publish = false
 
 [dependencies]
 anyhow = "1.0"
-argp = "0.3"
+argp = "0.4"
 crossterm = "0.28"
 enable-ansi-support = "0.2"
 memmap2 = "0.9"
 objdiff-core = { path = "../objdiff-core", features = ["all"] }
 prost = "0.13"
-ratatui = "0.28"
+ratatui = "0.29"
 rayon = "1.10"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

objdiff-cli/src/cmd/report.rs

@@ -94,7 +94,7 @@ fn generate(args: GenerateArgs) -> Result<()> {
     };
     info!(
         "Generating report for {} units (using {} threads)",
-        project.objects.len(),
+        project.units().len(),
         if args.deduplicate { 1 } else { rayon::current_num_threads() }
     );
 
@@ -103,7 +103,7 @@ fn generate(args: GenerateArgs) -> Result<()> {
     let mut existing_functions: HashSet<String> = HashSet::new();
     if args.deduplicate {
         // If deduplicating, we need to run single-threaded
-        for object in &mut project.objects {
+        for object in project.units.as_deref_mut().unwrap_or_default() {
             if let Some(unit) = report_object(
                 object,
                 project_dir,
@@ -116,7 +116,9 @@ fn generate(args: GenerateArgs) -> Result<()> {
         }
     } else {
         let vec = project
-            .objects
+            .units
+            .as_deref_mut()
+            .unwrap_or_default()
             .par_iter_mut()
             .map(|object| {
                 report_object(
@@ -132,7 +134,7 @@ fn generate(args: GenerateArgs) -> Result<()> {
     }
     let measures = units.iter().flat_map(|u| u.measures.into_iter()).collect();
     let mut categories = Vec::new();
-    for category in &project.progress_categories {
+    for category in project.progress_categories() {
         categories.push(ReportCategory {
             id: category.id.clone(),
             name: category.name.clone(),
@@ -167,22 +169,29 @@ fn report_object(
         }
         _ => {}
     }
-    let config = diff::DiffObjConfig { relax_reloc_diffs: true, ..Default::default() };
+    let diff_config = diff::DiffObjConfig {
+        function_reloc_diffs: diff::FunctionRelocDiffs::None,
+        ..Default::default()
+    };
+    let mapping_config = diff::MappingConfig::default();
     let target = object
         .target_path
         .as_ref()
         .map(|p| {
-            obj::read::read(p, &config).with_context(|| format!("Failed to open {}", p.display()))
+            obj::read::read(p, &diff_config)
+                .with_context(|| format!("Failed to open {}", p.display()))
         })
         .transpose()?;
     let base = object
         .base_path
         .as_ref()
         .map(|p| {
-            obj::read::read(p, &config).with_context(|| format!("Failed to open {}", p.display()))
+            obj::read::read(p, &diff_config)
+                .with_context(|| format!("Failed to open {}", p.display()))
         })
         .transpose()?;
-    let result = diff::diff_objs(&config, target.as_ref(), base.as_ref(), None)?;
+    let result =
+        diff::diff_objs(&diff_config, &mapping_config, target.as_ref(), base.as_ref(), None)?;
 
     let metadata = ReportUnitMetadata {
         complete: object.complete(),

objdiff-cli/src/main.rs

@@ -1,6 +1,7 @@
 mod argp_version;
 mod cmd;
 mod util;
+mod views;
 
 // musl's allocator is very slow, so use mimalloc when targeting musl.
 // Otherwise, use the system allocator to avoid extra code size.

objdiff-cli/src/views/function_diff.rs

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

objdiff-cli/src/views/mod.rs

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

objdiff-core/Cargo.toml

@@ -16,36 +16,125 @@ documentation = "https://docs.rs/objdiff-core"
 crate-type = ["cdylib", "rlib"]
 
 [features]
-all = ["config", "dwarf", "mips", "ppc", "x86", "arm", "bindings"]
-any-arch = [] # Implicit, used to check if any arch is enabled
-config = ["globset", "semver", "serde_json", "serde_yaml"]
-dwarf = ["gimli"]
-mips = ["any-arch", "rabbitizer"]
-ppc = ["any-arch", "cwdemangle", "cwextab", "ppc750cl"]
-x86 = ["any-arch", "cpp_demangle", "iced-x86", "msvc-demangler"]
-arm = ["any-arch", "cpp_demangle", "unarm", "arm-attr"]
-bindings = ["serde_json", "prost", "pbjson"]
-wasm = ["bindings", "console_error_panic_hook", "console_log"]
+all = [
+    # Features
+    "bindings",
+    "build",
+    "config",
+    "dwarf",
+    # Architectures
+    "mips",
+    "ppc",
+    "x86",
+    "arm",
+    "arm64",
+]
+# Implicit, used to check if any arch is enabled
+any-arch = [
+    "config",
+    "dep:bimap",
+    "dep:byteorder",
+    "dep:flagset",
+    "dep:heck",
+    "dep:log",
+    "dep:memmap2",
+    "dep:num-traits",
+    "dep:prettyplease",
+    "dep:proc-macro2",
+    "dep:quote",
+    "dep:serde",
+    "dep:serde_json",
+    "dep:similar",
+    "dep:strum",
+    "dep:syn",
+]
+bindings = [
+    "dep:pbjson",
+    "dep:pbjson-build",
+    "dep:prost",
+    "dep:prost-build",
+    "dep:serde",
+    "dep:serde_json",
+]
+build = [
+    "dep:notify",
+    "dep:notify-debouncer-full",
+    "dep:path-slash",
+    "dep:reqwest",
+    "dep:self_update",
+    "dep:shell-escape",
+    "dep:tempfile",
+    "dep:time",
+    "dep:winapi",
+]
+config = [
+    "dep:bimap",
+    "dep:filetime",
+    "dep:globset",
+    "dep:semver",
+    "dep:serde",
+    "dep:serde_json",
+    "dep:serde_yaml",
+]
+dwarf = ["dep:gimli"]
+mips = [
+    "any-arch",
+    "dep:rabbitizer",
+]
+ppc = [
+    "any-arch",
+    "dep:cwdemangle",
+    "dep:cwextab",
+    "dep:ppc750cl",
+]
+x86 = [
+    "any-arch",
+    "dep:cpp_demangle",
+    "dep:iced-x86",
+    "dep:msvc-demangler",
+]
+arm = [
+    "any-arch",
+    "dep:arm-attr",
+    "dep:cpp_demangle",
+    "dep:unarm",
+]
+arm64 = [
+    "any-arch",
+    "dep:cpp_demangle",
+    "dep:yaxpeax-arch",
+    "dep:yaxpeax-arm",
+]
+wasm = [
+    "any-arch",
+    "bindings",
+    "dep:console_error_panic_hook",
+    "dep:console_log",
+    "dep:log",
+    "dep:tsify-next",
+    "dep:wasm-bindgen",
+]
 
 [package.metadata.docs.rs]
 features = ["all"]
 
 [dependencies]
 anyhow = "1.0"
-byteorder = "1.5"
-filetime = "0.2"
-flagset = "0.4"
-log = "0.4"
-memmap2 = "0.9"
-num-traits = "0.2"
+bimap = { version = "0.6", features = ["serde"], optional = true }
+byteorder = { version = "1.5", optional = true }
+filetime = { version = "0.2", optional = true }
+flagset = { version = "0.4", optional = true }
+log = { version = "0.4", optional = true }
+memmap2 = { version = "0.9", optional = true }
+num-traits = { version = "0.2", optional = true }
 object = { version = "0.36", features = ["read_core", "std", "elf", "pe"], default-features = false }
 pbjson = { version = "0.7", optional = true }
 prost = { version = "0.13", optional = true }
-serde = { version = "1.0", features = ["derive"] }
-similar = { version = "2.6", default-features = false }
-strum = { version = "0.26", features = ["derive"] }
-wasm-bindgen = "0.2"
-tsify-next = { version = "0.5", default-features = false, features = ["js"] }
+serde = { version = "1.0", features = ["derive"], optional = true }
+similar = { version = "2.6", default-features = false, optional = true }
+strum = { version = "0.26", features = ["derive"], optional = true }
+wasm-bindgen = { version = "0.2", optional = true }
+tsify-next = { version = "0.5", default-features = false, features = ["js"], optional = true }
 console_log = { version = "1.0", optional = true }
 console_error_panic_hook = { version = "0.1", optional = true }
 
@@ -60,7 +149,7 @@ gimli = { version = "0.31", default-features = false, features = ["read-all"], o
 
 # ppc
 cwdemangle = { version = "1.0", optional = true }
-cwextab = { version = "1.0.2", optional = true }
+cwextab = { version = "1.0", optional = true }
 ppc750cl = { version = "0.3", optional = true }
 
 # mips
@@ -75,6 +164,38 @@ msvc-demangler = { version = "0.10", optional = true }
 unarm = { version = "1.6", optional = true }
 arm-attr = { version = "0.1", optional = true }
 
+# arm64
+yaxpeax-arch = { version = "0.3", default-features = false, features = ["std"], optional = true }
+yaxpeax-arm = { version = "0.3", default-features = false, features = ["std"], optional = true }
+
+# build
+notify = { version = "8.0.0", optional = true }
+notify-debouncer-full = { version = "0.5.0", optional = true }
+shell-escape = { version = "0.1", optional = true }
+tempfile = { version = "3.15", optional = true }
+time = { version = "0.3", optional = true }
+
+[target.'cfg(windows)'.dependencies]
+path-slash = { version = "0.2", optional = true }
+winapi = { version = "0.3", optional = true }
+
+# For Linux static binaries, use rustls
+[target.'cfg(target_os = "linux")'.dependencies]
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "multipart", "rustls-tls"], optional = true }
+self_update = { version = "0.42", default-features = false, features = ["rustls"], optional = true }
+
+# For all other platforms, use native TLS
+[target.'cfg(not(target_os = "linux"))'.dependencies]
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "multipart", "default-tls"], optional = true }
+self_update = { version = "0.42", optional = true }
+
 [build-dependencies]
-prost-build = "0.13"
-pbjson-build = "0.7"
+heck = { version = "0.5", optional = true }
+pbjson-build = { version = "0.7", optional = true }
+prettyplease = { version = "0.2", optional = true }
+proc-macro2 = { version = "1.0", optional = true }
+prost-build = { version = "0.13", optional = true }
+quote = { version = "1.0", optional = true }
+serde = { version = "1.0", features = ["derive"], optional = true }
+serde_json = { version = "1.0", optional = true }
+syn = { version = "2.0", optional = true }

objdiff-core/README.md

@@ -11,4 +11,5 @@ objdiff-core contains the core functionality of [objdiff](https://github.com/enc
 - **`ppc`**: Enables the PowerPC backend powered by [ppc750cl](https://github.com/encounter/ppc750cl).
 - **`x86`**: Enables the x86 backend powered by [iced-x86](https://crates.io/crates/iced-x86).
 - **`arm`**: Enables the ARM backend powered by [unarm](https://github.com/AetiasHax/unarm).
+- **`arm64`**: Enables the ARM64 backend powered by [yaxpeax-arm](https://github.com/iximeow/yaxpeax-arm).
 - **`bindings`**: Enables serialization and deserialization of objdiff data structures.

objdiff-core/build.rs

@@ -1,6 +1,16 @@
-use std::path::{Path, PathBuf};
+#[cfg(feature = "any-arch")]
+mod config_gen;
 
 fn main() {
+    #[cfg(feature = "bindings")]
+    compile_protos();
+    #[cfg(feature = "any-arch")]
+    config_gen::generate_diff_config();
+}
+
+#[cfg(feature = "bindings")]
+fn compile_protos() {
+    use std::path::{Path, PathBuf};
     let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("protos");
     let descriptor_path = root.join("proto_descriptor.bin");
     println!("cargo:rerun-if-changed={}", descriptor_path.display());

objdiff-core/config-schema.json

@@ -0,0 +1,248 @@
+{
+  "properties": [
+    {
+      "id": "functionRelocDiffs",
+      "type": "choice",
+      "default": "name_address",
+      "name": "Function relocation diffs",
+      "description": "How relocation targets will be diffed in the function view.",
+      "items": [
+        {
+          "value": "none",
+          "name": "None"
+        },
+        {
+          "value": "name_address",
+          "name": "Name or address"
+        },
+        {
+          "value": "data_value",
+          "name": "Data value"
+        },
+        {
+          "value": "all",
+          "name": "Name or address, data value"
+        }
+      ]
+    },
+    {
+      "id": "spaceBetweenArgs",
+      "type": "boolean",
+      "default": true,
+      "name": "Space between args",
+      "description": "Adds a space between arguments in the diff output."
+    },
+    {
+      "id": "combineDataSections",
+      "type": "boolean",
+      "default": false,
+      "name": "Combine data sections",
+      "description": "Combines data sections with equal names."
+    },
+    {
+      "id": "arm.archVersion",
+      "type": "choice",
+      "default": "auto",
+      "name": "Architecture version",
+      "description": "ARM architecture version to use for disassembly.",
+      "items": [
+        {
+          "value": "auto",
+          "name": "Auto"
+        },
+        {
+          "value": "v4t",
+          "name": "ARMv4T (GBA)"
+        },
+        {
+          "value": "v5te",
+          "name": "ARMv5TE (DS)"
+        },
+        {
+          "value": "v6k",
+          "name": "ARMv6K (3DS)"
+        }
+      ]
+    },
+    {
+      "id": "arm.unifiedSyntax",
+      "type": "boolean",
+      "default": false,
+      "name": "Unified syntax",
+      "description": "Disassemble as unified assembly language (UAL)."
+    },
+    {
+      "id": "arm.avRegisters",
+      "type": "boolean",
+      "default": false,
+      "name": "Use A/V registers",
+      "description": "Display R0-R3 as A1-A4 and R4-R11 as V1-V8."
+    },
+    {
+      "id": "arm.r9Usage",
+      "type": "choice",
+      "default": "generalPurpose",
+      "name": "Display R9 as",
+      "items": [
+        {
+          "value": "generalPurpose",
+          "name": "R9 or V6",
+          "description": "Use R9 as a general-purpose register."
+        },
+        {
+          "value": "sb",
+          "name": "SB (static base)",
+          "description": "Used for position-independent data (PID)."
+        },
+        {
+          "value": "tr",
+          "name": "TR (TLS register)",
+          "description": "Used for thread-local storage."
+        }
+      ]
+    },
+    {
+      "id": "arm.slUsage",
+      "type": "boolean",
+      "default": false,
+      "name": "Display R10 as SL",
+      "description": "Used for explicit stack limits."
+    },
+    {
+      "id": "arm.fpUsage",
+      "type": "boolean",
+      "default": false,
+      "name": "Display R11 as FP",
+      "description": "Used for frame pointers."
+    },
+    {
+      "id": "arm.ipUsage",
+      "type": "boolean",
+      "default": false,
+      "name": "Display R12 as IP",
+      "description": "Used for interworking and long branches."
+    },
+    {
+      "id": "mips.abi",
+      "type": "choice",
+      "default": "auto",
+      "name": "ABI",
+      "description": "MIPS ABI to use for disassembly.",
+      "items": [
+        {
+          "value": "auto",
+          "name": "Auto"
+        },
+        {
+          "value": "o32",
+          "name": "O32"
+        },
+        {
+          "value": "n32",
+          "name": "N32"
+        },
+        {
+          "value": "n64",
+          "name": "N64"
+        }
+      ]
+    },
+    {
+      "id": "mips.instrCategory",
+      "type": "choice",
+      "default": "auto",
+      "name": "Instruction category",
+      "description": "MIPS instruction category to use for disassembly.",
+      "items": [
+        {
+          "value": "auto",
+          "name": "Auto"
+        },
+        {
+          "value": "cpu",
+          "name": "CPU"
+        },
+        {
+          "value": "rsp",
+          "name": "RSP (N64)"
+        },
+        {
+          "value": "r3000gte",
+          "name": "R3000 GTE (PS1)"
+        },
+        {
+          "value": "r4000allegrex",
+          "name": "R4000 ALLEGREX (PSP)"
+        },
+        {
+          "value": "r5900",
+          "name": "R5900 EE (PS2)"
+        }
+      ]
+    },
+    {
+      "id": "x86.formatter",
+      "type": "choice",
+      "default": "intel",
+      "name": "Format",
+      "description": "x86 disassembly syntax.",
+      "items": [
+        {
+          "value": "intel",
+          "name": "Intel"
+        },
+        {
+          "value": "gas",
+          "name": "AT&T"
+        },
+        {
+          "value": "nasm",
+          "name": "NASM"
+        },
+        {
+          "value": "masm",
+          "name": "MASM"
+        }
+      ]
+    }
+  ],
+  "groups": [
+    {
+      "id": "general",
+      "name": "General",
+      "properties": [
+        "functionRelocDiffs",
+        "spaceBetweenArgs",
+        "combineDataSections"
+      ]
+    },
+    {
+      "id": "arm",
+      "name": "ARM",
+      "properties": [
+        "arm.archVersion",
+        "arm.unifiedSyntax",
+        "arm.avRegisters",
+        "arm.r9Usage",
+        "arm.slUsage",
+        "arm.fpUsage",
+        "arm.ipUsage"
+      ]
+    },
+    {
+      "id": "mips",
+      "name": "MIPS",
+      "properties": [
+        "mips.abi",
+        "mips.instrCategory"
+      ]
+    },
+    {
+      "id": "x86",
+      "name": "x86",
+      "properties": [
+        "x86.formatter"
+      ]
+    }
+  ]
+}

objdiff-core/config_gen.rs

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

objdiff-core/protos/diff.proto

@@ -21,9 +21,9 @@ enum SymbolFlag {
   SYMBOL_NONE = 0;
   SYMBOL_GLOBAL = 1;
   SYMBOL_LOCAL = 2;
-  SYMBOL_WEAK = 3;
-  SYMBOL_COMMON = 4;
-  SYMBOL_HIDDEN = 5;
+  SYMBOL_WEAK = 4;
+  SYMBOL_COMMON = 8;
+  SYMBOL_HIDDEN = 16;
 }
 
 // A single parsed instruction
@@ -122,10 +122,17 @@ message InstructionBranchTo {
   uint32 branch_index = 2;
 }
 
-message FunctionDiff {
+message SymbolRef {
+  optional uint32 section_index = 1;
+  uint32 symbol_index = 2;
+}
+
+message SymbolDiff {
   Symbol symbol = 1;
   repeated InstructionDiff instructions = 2;
   optional float match_percent = 3;
+  // The symbol ref in the _other_ object that this symbol was diffed against
+  optional SymbolRef target = 5;
 }
 
 message DataDiff {
@@ -140,7 +147,7 @@ message SectionDiff {
   SectionKind kind = 2;
   uint64 size = 3;
   uint64 address = 4;
-  repeated FunctionDiff functions = 5;
+  repeated SymbolDiff symbols = 5;
   repeated DataDiff data = 6;
   optional float match_percent = 7;
 }

objdiff-core/src/arch/arm.rs

@@ -124,11 +124,9 @@ impl ObjArch for ObjArchArm {
             .get(&SectionIndex(section_index))
             .map(|x| x.as_slice())
             .unwrap_or(&fallback_mappings);
-        let first_mapping_idx =
-            match mapping_symbols.binary_search_by_key(&start_addr, |x| x.address) {
-                Ok(idx) => idx,
-                Err(idx) => idx - 1,
-            };
+        let first_mapping_idx = mapping_symbols
+            .binary_search_by_key(&start_addr, |x| x.address)
+            .unwrap_or_else(|idx| idx - 1);
         let first_mapping = mapping_symbols[first_mapping_idx].mapping;
 
         let mut mappings_iter =
@@ -141,9 +139,9 @@ impl ObjArch for ObjArchArm {
 
         let version = match config.arm_arch_version {
             ArmArchVersion::Auto => self.detected_version.unwrap_or(ArmVersion::V5Te),
-            ArmArchVersion::V4T => ArmVersion::V4T,
-            ArmArchVersion::V5TE => ArmVersion::V5Te,
-            ArmArchVersion::V6K => ArmVersion::V6K,
+            ArmArchVersion::V4t => ArmVersion::V4T,
+            ArmArchVersion::V5te => ArmVersion::V5Te,
+            ArmArchVersion::V6k => ArmVersion::V6K,
         };
         let endian = match self.endianness {
             object::Endianness::Little => unarm::Endian::Little,
@@ -215,7 +213,7 @@ impl ObjArch for ObjArchArm {
                 address: address as u64,
                 size: (parser.address - address) as u8,
                 op: ins.opcode_id(),
-                mnemonic: parsed_ins.mnemonic.to_string(),
+                mnemonic: Cow::Borrowed(parsed_ins.mnemonic),
                 args,
                 reloc,
                 branch_dest,
@@ -234,7 +232,7 @@ impl ObjArch for ObjArchArm {
         section: &ObjSection,
         address: u64,
         reloc: &Relocation,
-    ) -> anyhow::Result<i64> {
+    ) -> Result<i64> {
         let address = address as usize;
         Ok(match reloc.flags() {
             // ARM calls
@@ -278,6 +276,19 @@ impl ObjArch for ObjArchArm {
     fn display_reloc(&self, flags: RelocationFlags) -> Cow<'static, str> {
         Cow::Owned(format!("<{flags:?}>"))
     }
+
+    fn get_reloc_byte_size(&self, flags: RelocationFlags) -> usize {
+        match flags {
+            RelocationFlags::Elf { r_type } => match r_type {
+                elf::R_ARM_ABS32 => 4,
+                elf::R_ARM_REL32 => 4,
+                elf::R_ARM_ABS16 => 2,
+                elf::R_ARM_ABS8 => 1,
+                _ => 1,
+            },
+            _ => 1,
+        }
+    }
 }
 
 #[derive(Clone, Copy, Debug)]

objdiff-core/src/arch/mips.rs

@@ -83,7 +83,7 @@ impl ObjArch for ObjArchMips {
         &self,
         address: u64,
         code: &[u8],
-        _section_index: usize,
+        section_index: usize,
         relocations: &[ObjReloc],
         line_info: &BTreeMap<u64, u32>,
         config: &DiffObjConfig,
@@ -99,8 +99,8 @@ impl ObjArch for ObjArchMips {
             MipsInstrCategory::Auto => self.instr_category,
             MipsInstrCategory::Cpu => InstrCategory::CPU,
             MipsInstrCategory::Rsp => InstrCategory::RSP,
-            MipsInstrCategory::R3000Gte => InstrCategory::R3000GTE,
-            MipsInstrCategory::R4000Allegrex => InstrCategory::R4000ALLEGREX,
+            MipsInstrCategory::R3000gte => InstrCategory::R3000GTE,
+            MipsInstrCategory::R4000allegrex => InstrCategory::R4000ALLEGREX,
             MipsInstrCategory::R5900 => InstrCategory::R5900,
         };
 
@@ -119,7 +119,7 @@ impl ObjArch for ObjArchMips {
             let op = instruction.unique_id as u16;
             ops.push(op);
 
-            let mnemonic = instruction.opcode_name().to_string();
+            let mnemonic = instruction.opcode_name();
             let is_branch = instruction.is_branch();
             let branch_offset = instruction.branch_offset();
             let mut branch_dest = if is_branch {
@@ -140,11 +140,18 @@ impl ObjArch for ObjArchMips {
                     | OperandType::cpu_label
                     | OperandType::cpu_branch_target_label => {
                         if let Some(reloc) = reloc {
-                            if matches!(&reloc.target_section, Some(s) if s == ".text")
-                                && reloc.target.address > start_address
-                                && reloc.target.address < end_address
+                            // If the relocation target is within the current function, we can
+                            // convert it into a relative branch target. Note that we check
+                            // target_address > start_address instead of >= so that recursive
+                            // tail calls are not considered branch targets.
+                            let target_address =
+                                reloc.target.address.checked_add_signed(reloc.addend);
+                            if reloc.target.orig_section_index == Some(section_index)
+                                && matches!(target_address, Some(addr) if addr > start_address && addr < end_address)
                             {
-                                args.push(ObjInsArg::BranchDest(reloc.target.address));
+                                let target_address = target_address.unwrap();
+                                args.push(ObjInsArg::BranchDest(target_address));
+                                branch_dest = Some(target_address);
                             } else {
                                 push_reloc(&mut args, reloc)?;
                                 branch_dest = None;
@@ -195,7 +202,7 @@ impl ObjArch for ObjArchMips {
                 address: cur_addr as u64,
                 size: 4,
                 op,
-                mnemonic,
+                mnemonic: Cow::Borrowed(mnemonic),
                 args,
                 reloc: reloc.cloned(),
                 branch_dest,
@@ -264,6 +271,17 @@ impl ObjArch for ObjArchMips {
             _ => Cow::Owned(format!("<{flags:?}>")),
         }
     }
+
+    fn get_reloc_byte_size(&self, flags: RelocationFlags) -> usize {
+        match flags {
+            RelocationFlags::Elf { r_type } => match r_type {
+                elf::R_MIPS_16 => 2,
+                elf::R_MIPS_32 => 4,
+                _ => 1,
+            },
+            _ => 1,
+        }
+    }
 }
 
 fn push_reloc(args: &mut Vec<ObjInsArg>, reloc: &ObjReloc) -> Result<()> {

objdiff-core/src/arch/mod.rs

@@ -12,6 +12,8 @@ use crate::{
 
 #[cfg(feature = "arm")]
 mod arm;
+#[cfg(feature = "arm64")]
+mod arm64;
 #[cfg(feature = "mips")]
 pub mod mips;
 #[cfg(feature = "ppc")]
@@ -35,8 +37,21 @@ pub enum DataType {
 impl DataType {
     pub fn display_bytes<Endian: ByteOrder>(&self, bytes: &[u8]) -> Option<String> {
         if self.required_len().is_some_and(|l| bytes.len() < l) {
+            log::warn!("Failed to display a symbol value for a symbol whose size is too small for instruction referencing it.");
             return None;
         }
+        let mut bytes = bytes;
+        if self.required_len().is_some_and(|l| bytes.len() > l) {
+            // If the symbol's size is larger a single instance of this data type, we take just the
+            // bytes necessary for one of them in order to display the first element of the array.
+            bytes = &bytes[0..self.required_len().unwrap()];
+            // TODO: Attempt to interpret large symbols as arrays of a smaller type and show all
+            // elements of the array instead. https://github.com/encounter/objdiff/issues/124
+            // However, note that the stride of an array can not always be determined just by the
+            // data type guessed by the single instruction accessing it. There can also be arrays of
+            // structs that contain multiple elements of different types, so if other elements after
+            // the first one were to be displayed in this manner, they may be inaccurate.
+        }
 
         match self {
             DataType::Int8 => {
@@ -80,10 +95,10 @@ impl DataType {
                 }
             }
             DataType::Float => {
-                format!("Float: {}", Endian::read_f32(bytes))
+                format!("Float: {:?}f", Endian::read_f32(bytes))
             }
             DataType::Double => {
-                format!("Double: {}", Endian::read_f64(bytes))
+                format!("Double: {:?}", Endian::read_f64(bytes))
             }
             DataType::Bytes => {
                 format!("Bytes: {:#?}", bytes)
@@ -133,6 +148,8 @@ pub trait ObjArch: Send + Sync {
 
     fn display_reloc(&self, flags: RelocationFlags) -> Cow<'static, str>;
 
+    fn get_reloc_byte_size(&self, flags: RelocationFlags) -> usize;
+
     fn symbol_address(&self, symbol: &Symbol) -> u64 { symbol.address() }
 
     fn guess_data_type(&self, _instruction: &ObjIns) -> Option<DataType> { None }
@@ -141,6 +158,17 @@ pub trait ObjArch: Send + Sync {
         Some(format!("Bytes: {:#x?}", bytes))
     }
 
+    fn display_ins_data(&self, ins: &ObjIns) -> Option<String> {
+        let reloc = ins.reloc.as_ref()?;
+        if reloc.addend >= 0 && reloc.target.bytes.len() > reloc.addend as usize {
+            self.guess_data_type(ins).and_then(|ty| {
+                self.display_data_type(ty, &reloc.target.bytes[reloc.addend as usize..])
+            })
+        } else {
+            None
+        }
+    }
+
     // Downcast methods
     #[cfg(feature = "ppc")]
     fn ppc(&self) -> Option<&ppc::ObjArchPpc> { None }
@@ -161,6 +189,8 @@ pub fn new_arch(object: &File) -> Result<Box<dyn ObjArch>> {
         Architecture::I386 | Architecture::X86_64 => Box::new(x86::ObjArchX86::new(object)?),
         #[cfg(feature = "arm")]
         Architecture::Arm => Box::new(arm::ObjArchArm::new(object)?),
+        #[cfg(feature = "arm64")]
+        Architecture::Aarch64 => Box::new(arm64::ObjArchArm64::new(object)?),
         arch => bail!("Unsupported architecture: {arch:?}"),
     })
 }

objdiff-core/src/arch/ppc.rs

@@ -1,4 +1,7 @@
-use std::{borrow::Cow, collections::BTreeMap};
+use std::{
+    borrow::Cow,
+    collections::{BTreeMap, HashMap, HashSet},
+};
 
 use anyhow::{bail, ensure, Result};
 use byteorder::BigEndian;
@@ -7,7 +10,7 @@ use object::{
     elf, File, Object, ObjectSection, ObjectSymbol, Relocation, RelocationFlags, RelocationTarget,
     Symbol, SymbolKind,
 };
-use ppc750cl::{Argument, InsIter, Opcode, GPR};
+use ppc750cl::{Argument, Arguments, Ins, InsIter, Opcode, ParsedIns, GPR};
 
 use crate::{
     arch::{DataType, ObjArch, ProcessCodeResult},
@@ -49,6 +52,8 @@ impl ObjArch for ObjArchPpc {
         let ins_count = code.len() / 4;
         let mut ops = Vec::<u16>::with_capacity(ins_count);
         let mut insts = Vec::<ObjIns>::with_capacity(ins_count);
+        let fake_pool_reloc_for_addr =
+            generate_fake_pool_reloc_for_addr_mapping(address, code, relocations);
         for (cur_addr, mut ins) in InsIter::new(code, address as u32) {
             let reloc = relocations.iter().find(|r| (r.address as u32 & !3) == cur_addr);
             if let Some(reloc) = reloc {
@@ -138,14 +143,23 @@ impl ObjArch for ObjArchPpc {
                 }
             }
 
+            if reloc.is_none() {
+                if let Some(fake_pool_reloc) = fake_pool_reloc_for_addr.get(&cur_addr) {
+                    // If this instruction has a fake pool relocation, show it as a fake argument
+                    // at the end of the line.
+                    args.push(ObjInsArg::PlainText(" ".into()));
+                    push_reloc(&mut args, fake_pool_reloc)?;
+                }
+            }
+
             ops.push(ins.op as u16);
             let line = line_info.range(..=cur_addr as u64).last().map(|(_, &b)| b);
             insts.push(ObjIns {
                 address: cur_addr as u64,
                 size: 4,
-                mnemonic: simplified.mnemonic.to_string(),
+                mnemonic: Cow::Borrowed(simplified.mnemonic),
                 args,
-                reloc: reloc.cloned(),
+                reloc: reloc.or(fake_pool_reloc_for_addr.get(&cur_addr)).cloned(),
                 op: ins.op as u16,
                 branch_dest,
                 line,
@@ -173,6 +187,7 @@ impl ObjArch for ObjArchPpc {
     fn display_reloc(&self, flags: RelocationFlags) -> Cow<'static, str> {
         match flags {
             RelocationFlags::Elf { r_type } => match r_type {
+                elf::R_PPC_NONE => Cow::Borrowed("R_PPC_NONE"), // We use this for fake pool relocs
                 elf::R_PPC_ADDR16_LO => Cow::Borrowed("R_PPC_ADDR16_LO"),
                 elf::R_PPC_ADDR16_HI => Cow::Borrowed("R_PPC_ADDR16_HI"),
                 elf::R_PPC_ADDR16_HA => Cow::Borrowed("R_PPC_ADDR16_HA"),
@@ -187,28 +202,23 @@ impl ObjArch for ObjArchPpc {
         }
     }
 
+    fn get_reloc_byte_size(&self, flags: RelocationFlags) -> usize {
+        match flags {
+            RelocationFlags::Elf { r_type } => match r_type {
+                elf::R_PPC_ADDR32 => 4,
+                elf::R_PPC_UADDR32 => 4,
+                _ => 1,
+            },
+            _ => 1,
+        }
+    }
+
     fn guess_data_type(&self, instruction: &ObjIns) -> Option<super::DataType> {
-        // Always shows the first string of the table. Not ideal, but it's really hard to find
-        // the actual string being referenced.
         if instruction.reloc.as_ref().is_some_and(|r| r.target.name.starts_with("@stringBase")) {
             return Some(DataType::String);
         }
 
-        match Opcode::from(instruction.op as u8) {
-            Opcode::Lbz | Opcode::Lbzu | Opcode::Lbzux | Opcode::Lbzx => Some(DataType::Int8),
-            Opcode::Lhz | Opcode::Lhzu | Opcode::Lhzux | Opcode::Lhzx => Some(DataType::Int16),
-            Opcode::Lha | Opcode::Lhau | Opcode::Lhaux | Opcode::Lhax => Some(DataType::Int16),
-            Opcode::Lwz | Opcode::Lwzu | Opcode::Lwzux | Opcode::Lwzx => Some(DataType::Int32),
-            Opcode::Lfs | Opcode::Lfsu | Opcode::Lfsux | Opcode::Lfsx => Some(DataType::Float),
-            Opcode::Lfd | Opcode::Lfdu | Opcode::Lfdux | Opcode::Lfdx => Some(DataType::Double),
-
-            Opcode::Stb | Opcode::Stbu | Opcode::Stbux | Opcode::Stbx => Some(DataType::Int8),
-            Opcode::Sth | Opcode::Sthu | Opcode::Sthux | Opcode::Sthx => Some(DataType::Int16),
-            Opcode::Stw | Opcode::Stwu | Opcode::Stwux | Opcode::Stwx => Some(DataType::Int32),
-            Opcode::Stfs | Opcode::Stfsu | Opcode::Stfsux | Opcode::Stfsx => Some(DataType::Float),
-            Opcode::Stfd | Opcode::Stfdu | Opcode::Stfdux | Opcode::Stfdx => Some(DataType::Double),
-            _ => None,
-        }
+        guess_data_type_from_load_store_inst_op(Opcode::from(instruction.op as u8))
     }
 
     fn display_data_type(&self, ty: DataType, bytes: &[u8]) -> Option<String> {
@@ -246,6 +256,12 @@ fn push_reloc(args: &mut Vec<ObjInsArg>, reloc: &ObjReloc) -> Result<()> {
             elf::R_PPC_ADDR32 | elf::R_PPC_UADDR32 | elf::R_PPC_REL24 | elf::R_PPC_REL14 => {
                 args.push(ObjInsArg::Reloc);
             }
+            elf::R_PPC_NONE => {
+                // Fake pool relocation.
+                args.push(ObjInsArg::PlainText("<".into()));
+                args.push(ObjInsArg::Reloc);
+                args.push(ObjInsArg::PlainText(">".into()));
+            }
             _ => bail!("Unsupported ELF PPC relocation type {r_type}"),
         },
         flags => bail!("Unsupported PPC relocation kind: {flags:?}"),
@@ -381,3 +397,345 @@ fn make_symbol_ref(symbol: &Symbol) -> Result<ExtabSymbolRef> {
     let demangled_name = cwdemangle::demangle(&name, &cwdemangle::DemangleOptions::default());
     Ok(ExtabSymbolRef { original_index: symbol.index().0, name, demangled_name })
 }
+
+fn guess_data_type_from_load_store_inst_op(inst_op: Opcode) -> Option<DataType> {
+    match inst_op {
+        Opcode::Lbz | Opcode::Lbzu | Opcode::Lbzux | Opcode::Lbzx => Some(DataType::Int8),
+        Opcode::Lhz | Opcode::Lhzu | Opcode::Lhzux | Opcode::Lhzx => Some(DataType::Int16),
+        Opcode::Lha | Opcode::Lhau | Opcode::Lhaux | Opcode::Lhax => Some(DataType::Int16),
+        Opcode::Lwz | Opcode::Lwzu | Opcode::Lwzux | Opcode::Lwzx => Some(DataType::Int32),
+        Opcode::Lfs | Opcode::Lfsu | Opcode::Lfsux | Opcode::Lfsx => Some(DataType::Float),
+        Opcode::Lfd | Opcode::Lfdu | Opcode::Lfdux | Opcode::Lfdx => Some(DataType::Double),
+
+        Opcode::Stb | Opcode::Stbu | Opcode::Stbux | Opcode::Stbx => Some(DataType::Int8),
+        Opcode::Sth | Opcode::Sthu | Opcode::Sthux | Opcode::Sthx => Some(DataType::Int16),
+        Opcode::Stw | Opcode::Stwu | Opcode::Stwux | Opcode::Stwx => Some(DataType::Int32),
+        Opcode::Stfs | Opcode::Stfsu | Opcode::Stfsux | Opcode::Stfsx => Some(DataType::Float),
+        Opcode::Stfd | Opcode::Stfdu | Opcode::Stfdux | Opcode::Stfdx => Some(DataType::Double),
+        _ => None,
+    }
+}
+
+// Given an instruction, determine if it could accessing data at the address in a register.
+// If so, return the offset added to the register's address, the register containing that address,
+// and (optionally) which destination register the address is being copied into.
+fn get_offset_and_addr_gpr_for_possible_pool_reference(
+    opcode: Opcode,
+    simplified: &ParsedIns,
+) -> Option<(i16, GPR, Option<GPR>)> {
+    let args = &simplified.args;
+    if guess_data_type_from_load_store_inst_op(opcode).is_some() {
+        match (args[1], args[2]) {
+            (Argument::Offset(offset), Argument::GPR(addr_src_gpr)) => {
+                // e.g. lwz. Immediate offset.
+                Some((offset.0, addr_src_gpr, None))
+            }
+            (Argument::GPR(addr_src_gpr), Argument::GPR(_offset_gpr)) => {
+                // e.g. lwzx. The offset is in a register and was likely calculated from an index.
+                // Treat the offset as being 0 in this case to show the first element of the array.
+                // It may be possible to show all elements by figuring out the stride of the array
+                // from the calculations performed on the index before it's put into offset_gpr, but
+                // this would be much more complicated, so it's not currently done.
+                Some((0, addr_src_gpr, None))
+            }
+            _ => None,
+        }
+    } else {
+        // If it's not a load/store instruction, there's two more possibilities we need to handle.
+        // 1. It could be loading a pointer to a string.
+        // 2. It could be moving the relocation address plus an offset into a different register to
+        //    load from later.
+        // If either of these match, we also want to return the destination register that the
+        // address is being copied into so that we can detect any future references to that new
+        // register as well.
+        match (opcode, args[0], args[1], args[2]) {
+            (
+                Opcode::Addi,
+                Argument::GPR(addr_dst_gpr),
+                Argument::GPR(addr_src_gpr),
+                Argument::Simm(simm),
+            ) => Some((simm.0, addr_src_gpr, Some(addr_dst_gpr))),
+            (
+                // `mr` or `mr.`
+                Opcode::Or,
+                Argument::GPR(addr_dst_gpr),
+                Argument::GPR(addr_src_gpr),
+                Argument::None,
+            ) => Some((0, addr_src_gpr, Some(addr_dst_gpr))),
+            (
+                Opcode::Add,
+                Argument::GPR(addr_dst_gpr),
+                Argument::GPR(addr_src_gpr),
+                Argument::GPR(_offset_gpr),
+            ) => Some((0, addr_src_gpr, Some(addr_dst_gpr))),
+            _ => None,
+        }
+    }
+}
+
+// Remove the relocation we're keeping track of in a particular register when an instruction reuses
+// that register to hold some other value, unrelated to pool relocation addresses.
+fn clear_overwritten_gprs(ins: Ins, gpr_pool_relocs: &mut HashMap<u8, ObjReloc>) {
+    let mut def_args = Arguments::default();
+    ins.parse_defs(&mut def_args);
+    for arg in def_args {
+        if let Argument::GPR(gpr) = arg {
+            if ins.op == Opcode::Lmw {
+                // `lmw` overwrites all registers from rd to r31.
+                // ppc750cl only returns rd itself, so we manually clear the rest of them.
+                for reg in gpr.0..31 {
+                    gpr_pool_relocs.remove(&reg);
+                }
+                break;
+            }
+            gpr_pool_relocs.remove(&gpr.0);
+        }
+    }
+}
+
+// We create a fake relocation for an instruction, vaguely simulating what the actual relocation
+// might have looked like if it wasn't pooled. This is so minimal changes are needed to display
+// pooled accesses vs non-pooled accesses. We set the relocation type to R_PPC_NONE to indicate that
+// there isn't really a relocation here, as copying the pool relocation's type wouldn't make sense.
+// Also, if this instruction is accessing the middle of a symbol instead of the start, we add an
+// addend to indicate that.
+fn make_fake_pool_reloc(offset: i16, cur_addr: u32, pool_reloc: &ObjReloc) -> Option<ObjReloc> {
+    let offset_from_pool = pool_reloc.addend + offset as i64;
+    let target_address = pool_reloc.target.address.checked_add_signed(offset_from_pool)?;
+    let target;
+    let addend;
+    if pool_reloc.target.orig_section_index.is_some() {
+        // If the target symbol is within this current object, then we also need to create a fake
+        // target symbol to go inside our fake relocation. This is because we don't have access to
+        // list of all symbols in this section, so we can't find the real symbol within the pool
+        // based on its address yet. Instead we make a placeholder that has the correct
+        // `orig_section_index` and `address` fields, and then later on when this information is
+        // displayed to the user, we can find the real symbol by searching through the object's
+        // section's symbols for one that contains this address.
+        target = ObjSymbol {
+            name: "".to_string(),
+            demangled_name: None,
+            address: target_address,
+            section_address: 0,
+            size: 0,
+            size_known: false,
+            kind: Default::default(),
+            flags: Default::default(),
+            orig_section_index: pool_reloc.target.orig_section_index,
+            virtual_address: None,
+            original_index: None,
+            bytes: vec![],
+        };
+        // The addend is also fake because we don't know yet if the `target_address` here is the exact
+        // start of the symbol or if it's in the middle of it.
+        addend = 0;
+    } else {
+        // But if the target symbol is in a different object (extern), then we simply copy the pool
+        // relocation's target. This is because it won't be possible to locate the actual symbol
+        // later on based only off of an offset without knowing the object or section it's in. And
+        // doing that for external symbols would also be unnecessary, because when the compiler
+        // generates an instruction that accesses an external "pool" plus some offset, that won't be
+        // a normal pool that contains other symbols within it that we want to display. It will be
+        // something like a vtable for a class with multiple inheritance (for example, dCcD_Cyl in
+        // The Wind Waker). So just showing that vtable symbol plus an addend to represent the
+        // offset into it works fine in this case, no fake symbol to hold an address is necessary.
+        target = pool_reloc.target.clone();
+        addend = pool_reloc.addend;
+    };
+    Some(ObjReloc {
+        flags: RelocationFlags::Elf { r_type: elf::R_PPC_NONE },
+        address: cur_addr as u64,
+        target,
+        addend,
+    })
+}
+
+// Searches through all instructions in a function, determining which registers have the addresses
+// of pooled data relocations in them, finding which instructions load data from those addresses,
+// and constructing a mapping of the address of that instruction to a "fake pool relocation" that
+// simulates what that instruction's relocation would look like if data hadn't been pooled.
+// This method tries to follow the function's proper control flow. It keeps track of a queue of
+// states it hasn't traversed yet, where each state holds an instruction address and a HashMap of
+// which registers hold which pool relocations at that point.
+// When a conditional or unconditional branch is encountered, the destination of the branch is added
+// to the queue. Conditional branches will traverse both the path where the branch is taken and the
+// one where it's not. Unconditional branches only follow the branch, ignoring any code immediately
+// after the branch instruction.
+// Limitations: This method cannot read jump tables. This is because the jump tables are located in
+// the .data section, but ObjArch.process_code only has access to the .text section. In order to
+// work around this limitation and avoid completely missing most code inside switch statements that
+// use jump tables, we instead guess that any parts of a function we missed were switch cases, and
+// traverse them as if the last `bctr` before that address had branched there. This should be fairly
+// accurate in practice - in testing the only instructions it seems to miss are double branches that
+// the compiler generates in error which can never be reached during normal execution anyway.
+fn generate_fake_pool_reloc_for_addr_mapping(
+    func_address: u64,
+    code: &[u8],
+    relocations: &[ObjReloc],
+) -> HashMap<u32, ObjReloc> {
+    let mut visited_ins_addrs = HashSet::new();
+    let mut pool_reloc_for_addr = HashMap::new();
+    let mut ins_iters_with_gpr_state =
+        vec![(InsIter::new(code, func_address as u32), HashMap::new())];
+    let mut gpr_state_at_bctr = BTreeMap::new();
+    while let Some((ins_iter, mut gpr_pool_relocs)) = ins_iters_with_gpr_state.pop() {
+        for (cur_addr, ins) in ins_iter {
+            if visited_ins_addrs.contains(&cur_addr) {
+                // Avoid getting stuck in an infinite loop when following looping branches.
+                break;
+            }
+            visited_ins_addrs.insert(cur_addr);
+
+            let simplified = ins.simplified();
+
+            // First handle traversing the function's control flow.
+            let mut branch_dest = None;
+            for arg in simplified.args_iter() {
+                if let Argument::BranchDest(dest) = arg {
+                    let dest = cur_addr.wrapping_add_signed(dest.0);
+                    branch_dest = Some(dest);
+                    break;
+                }
+            }
+            if let Some(branch_dest) = branch_dest {
+                if branch_dest >= func_address as u32
+                    && (branch_dest - func_address as u32) < code.len() as u32
+                {
+                    let dest_offset_into_func = branch_dest - func_address as u32;
+                    let dest_code_slice = &code[dest_offset_into_func as usize..];
+                    match ins.op {
+                        Opcode::Bc => {
+                            // Conditional branch.
+                            // Add the branch destination to the queue to do later.
+                            ins_iters_with_gpr_state.push((
+                                InsIter::new(dest_code_slice, branch_dest),
+                                gpr_pool_relocs.clone(),
+                            ));
+                            // Then continue on with the current iterator.
+                        }
+                        Opcode::B => {
+                            if simplified.mnemonic != "bl" {
+                                // Unconditional branch.
+                                // Add the branch destination to the queue.
+                                ins_iters_with_gpr_state.push((
+                                    InsIter::new(dest_code_slice, branch_dest),
+                                    gpr_pool_relocs.clone(),
+                                ));
+                                // Break out of the current iterator so we can do the newly added one.
+                                break;
+                            }
+                        }
+                        _ => unreachable!(),
+                    }
+                }
+            }
+            if let Opcode::Bcctr = ins.op {
+                if simplified.mnemonic == "bctr" {
+                    // Unconditional branch to count register.
+                    // Likely a jump table.
+                    gpr_state_at_bctr.insert(cur_addr, gpr_pool_relocs.clone());
+                }
+            }
+
+            // Then handle keeping track of which GPR contains which pool relocation.
+            let reloc = relocations.iter().find(|r| (r.address as u32 & !3) == cur_addr);
+            if let Some(reloc) = reloc {
+                // This instruction has a real relocation, so it may be a pool load we want to keep
+                // track of.
+                let args = &simplified.args;
+                match (ins.op, args[0], args[1], args[2]) {
+                    (
+                        // `lis` + `addi`
+                        Opcode::Addi,
+                        Argument::GPR(addr_dst_gpr),
+                        Argument::GPR(_addr_src_gpr),
+                        Argument::Simm(_simm),
+                    ) => {
+                        gpr_pool_relocs.insert(addr_dst_gpr.0, reloc.clone());
+                    }
+                    (
+                        // `lis` + `ori`
+                        Opcode::Ori,
+                        Argument::GPR(addr_dst_gpr),
+                        Argument::GPR(_addr_src_gpr),
+                        Argument::Uimm(_uimm),
+                    ) => {
+                        gpr_pool_relocs.insert(addr_dst_gpr.0, reloc.clone());
+                    }
+                    (Opcode::B, _, _, _) => {
+                        if simplified.mnemonic == "bl" {
+                            // When encountering a function call, clear any active pool relocations from
+                            // the volatile registers (r0, r3-r12), but not the nonvolatile registers.
+                            gpr_pool_relocs.remove(&0);
+                            for gpr in 3..12 {
+                                gpr_pool_relocs.remove(&gpr);
+                            }
+                        }
+                    }
+                    _ => {
+                        clear_overwritten_gprs(ins, &mut gpr_pool_relocs);
+                    }
+                }
+            } else if let Some((offset, addr_src_gpr, addr_dst_gpr)) =
+                get_offset_and_addr_gpr_for_possible_pool_reference(ins.op, &simplified)
+            {
+                // This instruction doesn't have a real relocation, so it may be a reference to one of
+                // the already-loaded pools.
+                if let Some(pool_reloc) = gpr_pool_relocs.get(&addr_src_gpr.0) {
+                    if let Some(fake_pool_reloc) =
+                        make_fake_pool_reloc(offset, cur_addr, pool_reloc)
+                    {
+                        pool_reloc_for_addr.insert(cur_addr, fake_pool_reloc);
+                    }
+                    if let Some(addr_dst_gpr) = addr_dst_gpr {
+                        // If the address of the pool relocation got copied into another register, we
+                        // need to keep track of it in that register too as future instructions may
+                        // reference the symbol indirectly via this new register, instead of the
+                        // register the symbol's address was originally loaded into.
+                        // For example, the start of the function might `lis` + `addi` the start of the
+                        // ...data pool into r25, and then later the start of a loop will `addi` r25
+                        // with the offset within the .data section of an array variable into r21.
+                        // Then the body of the loop will `lwzx` one of the array elements from r21.
+                        let mut new_reloc = pool_reloc.clone();
+                        new_reloc.addend += offset as i64;
+                        gpr_pool_relocs.insert(addr_dst_gpr.0, new_reloc);
+                    } else {
+                        clear_overwritten_gprs(ins, &mut gpr_pool_relocs);
+                    }
+                } else {
+                    clear_overwritten_gprs(ins, &mut gpr_pool_relocs);
+                }
+            } else {
+                clear_overwritten_gprs(ins, &mut gpr_pool_relocs);
+            }
+        }
+
+        // Finally, if we're about to finish the outer loop and don't have any more control flow to
+        // follow, we check if there are any instruction addresses in this function that we missed.
+        // If so, and if there were any `bctr` instructions before those points in this function,
+        // then we try to traverse those missing spots as switch cases.
+        if ins_iters_with_gpr_state.is_empty() {
+            let unseen_addrs = (func_address as u32..func_address as u32 + code.len() as u32)
+                .step_by(4)
+                .filter(|addr| !visited_ins_addrs.contains(addr));
+            for unseen_addr in unseen_addrs {
+                let prev_bctr_gpr_state = gpr_state_at_bctr
+                    .iter()
+                    .filter(|(&addr, _)| addr < unseen_addr)
+                    .min_by_key(|(&addr, _)| addr)
+                    .map(|(_, gpr_state)| gpr_state);
+                if let Some(gpr_pool_relocs) = prev_bctr_gpr_state {
+                    let dest_offset_into_func = unseen_addr - func_address as u32;
+                    let dest_code_slice = &code[dest_offset_into_func as usize..];
+                    ins_iters_with_gpr_state.push((
+                        InsIter::new(dest_code_slice, unseen_addr),
+                        gpr_pool_relocs.clone(),
+                    ));
+                    break;
+                }
+            }
+        }
+    }
+
+    pool_reloc_for_addr
+}

objdiff-core/src/arch/x86.rs

@@ -51,7 +51,7 @@ impl ObjArch for ObjArchX86 {
                 address: 0,
                 size: 0,
                 op: 0,
-                mnemonic: String::new(),
+                mnemonic: Cow::Borrowed("<invalid>"),
                 args: vec![],
                 reloc: None,
                 branch_dest: None,
@@ -76,7 +76,7 @@ impl ObjArch for ObjArchX86 {
                 address,
                 size: instruction.len() as u8,
                 op,
-                mnemonic: String::new(),
+                mnemonic: Cow::Borrowed("<invalid>"),
                 args: vec![],
                 reloc: reloc.cloned(),
                 branch_dest: None,
@@ -162,6 +162,19 @@ impl ObjArch for ObjArchX86 {
             _ => Cow::Owned(format!("<{flags:?}>")),
         }
     }
+
+    fn get_reloc_byte_size(&self, flags: RelocationFlags) -> usize {
+        match flags {
+            RelocationFlags::Coff { typ } => match typ {
+                pe::IMAGE_REL_I386_DIR16 => 2,
+                pe::IMAGE_REL_I386_REL16 => 2,
+                pe::IMAGE_REL_I386_DIR32 => 4,
+                pe::IMAGE_REL_I386_REL32 => 4,
+                _ => 1,
+            },
+            _ => 1,
+        }
+    }
 }
 
 fn replace_arg(
@@ -242,7 +255,8 @@ impl FormatterOutput for InstructionFormatterOutput {
 
     fn write_mnemonic(&mut self, _instruction: &Instruction, text: &str) {
         self.formatted.push_str(text);
-        self.ins.mnemonic = text.to_string();
+        // TODO: can iced-x86 guarantee 'static here?
+        self.ins.mnemonic = Cow::Owned(text.to_string());
     }
 
     fn write_number(

objdiff-core/src/bindings/diff.rs

@@ -1,8 +1,10 @@
+#![allow(clippy::needless_lifetimes)] // Generated serde code
 use crate::{
     diff::{
         ObjDataDiff, ObjDataDiffKind, ObjDiff, ObjInsArgDiff, ObjInsBranchFrom, ObjInsBranchTo,
         ObjInsDiff, ObjInsDiffKind, ObjSectionDiff, ObjSymbolDiff,
     },
+    obj,
     obj::{
         ObjInfo, ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc, ObjSectionKind, ObjSymbol,
         ObjSymbolFlagSet, ObjSymbolFlags,
@@ -38,14 +40,15 @@ impl ObjectDiff {
 impl SectionDiff {
     pub fn new(obj: &ObjInfo, section_index: usize, section_diff: &ObjSectionDiff) -> Self {
         let section = &obj.sections[section_index];
-        let functions = section_diff.symbols.iter().map(|d| FunctionDiff::new(obj, d)).collect();
+        let symbols = section_diff.symbols.iter().map(|d| SymbolDiff::new(obj, d)).collect();
         let data = section_diff.data_diff.iter().map(|d| DataDiff::new(obj, d)).collect();
+        // TODO: section_diff.reloc_diff
         Self {
             name: section.name.to_string(),
             kind: SectionKind::from(section.kind) as i32,
             size: section.size,
             address: section.address,
-            functions,
+            symbols,
             data,
             match_percent: section_diff.match_percent,
         }
@@ -63,19 +66,32 @@ impl From<ObjSectionKind> for SectionKind {
     }
 }
 
-impl FunctionDiff {
+impl From<obj::SymbolRef> for SymbolRef {
+    fn from(value: obj::SymbolRef) -> Self {
+        Self {
+            section_index: if value.section_idx == obj::SECTION_COMMON {
+                None
+            } else {
+                Some(value.section_idx as u32)
+            },
+            symbol_index: value.symbol_idx as u32,
+        }
+    }
+}
+
+impl SymbolDiff {
     pub fn new(object: &ObjInfo, symbol_diff: &ObjSymbolDiff) -> Self {
         let (_section, symbol) = object.section_symbol(symbol_diff.symbol_ref);
-        // let diff_symbol = symbol_diff.diff_symbol.map(|symbol_ref| {
-        //     let (_section, symbol) = object.section_symbol(symbol_ref);
-        //     Symbol::from(symbol)
-        // });
-        let instructions = symbol_diff.instructions.iter().map(InstructionDiff::from).collect();
+        let instructions = symbol_diff
+            .instructions
+            .iter()
+            .map(|ins_diff| InstructionDiff::new(object, ins_diff))
+            .collect();
         Self {
-            symbol: Some(Symbol::from(symbol)),
-            // diff_symbol,
+            symbol: Some(Symbol::new(symbol)),
             instructions,
             match_percent: symbol_diff.match_percent,
+            target: symbol_diff.target_symbol.map(SymbolRef::from),
         }
     }
 }
@@ -90,8 +106,8 @@ impl DataDiff {
     }
 }
 
-impl<'a> From<&'a ObjSymbol> for Symbol {
-    fn from(value: &'a ObjSymbol) -> Self {
+impl Symbol {
+    pub fn new(value: &ObjSymbol) -> Self {
         Self {
             name: value.name.to_string(),
             demangled_name: value.demangled_name.clone(),
@@ -105,7 +121,7 @@ impl<'a> From<&'a ObjSymbol> for Symbol {
 fn symbol_flags(value: ObjSymbolFlagSet) -> u32 {
     let mut flags = 0u32;
     if value.0.contains(ObjSymbolFlags::Global) {
-        flags |= SymbolFlag::SymbolNone as u32;
+        flags |= SymbolFlag::SymbolGlobal as u32;
     }
     if value.0.contains(ObjSymbolFlags::Local) {
         flags |= SymbolFlag::SymbolLocal as u32;
@@ -122,29 +138,29 @@ fn symbol_flags(value: ObjSymbolFlagSet) -> u32 {
     flags
 }
 
-impl<'a> From<&'a ObjIns> for Instruction {
-    fn from(value: &'a ObjIns) -> Self {
+impl Instruction {
+    pub fn new(object: &ObjInfo, instruction: &ObjIns) -> Self {
         Self {
-            address: value.address,
-            size: value.size as u32,
-            opcode: value.op as u32,
-            mnemonic: value.mnemonic.clone(),
-            formatted: value.formatted.clone(),
-            arguments: value.args.iter().map(Argument::from).collect(),
-            relocation: value.reloc.as_ref().map(Relocation::from),
-            branch_dest: value.branch_dest,
-            line_number: value.line,
-            original: value.orig.clone(),
+            address: instruction.address,
+            size: instruction.size as u32,
+            opcode: instruction.op as u32,
+            mnemonic: instruction.mnemonic.to_string(),
+            formatted: instruction.formatted.clone(),
+            arguments: instruction.args.iter().map(Argument::new).collect(),
+            relocation: instruction.reloc.as_ref().map(|reloc| Relocation::new(object, reloc)),
+            branch_dest: instruction.branch_dest,
+            line_number: instruction.line,
+            original: instruction.orig.clone(),
         }
     }
 }
 
-impl<'a> From<&'a ObjInsArg> for Argument {
-    fn from(value: &'a ObjInsArg) -> Self {
+impl Argument {
+    pub fn new(value: &ObjInsArg) -> Self {
         Self {
             value: Some(match value {
                 ObjInsArg::PlainText(s) => argument::Value::PlainText(s.to_string()),
-                ObjInsArg::Arg(v) => argument::Value::Argument(ArgumentValue::from(v)),
+                ObjInsArg::Arg(v) => argument::Value::Argument(ArgumentValue::new(v)),
                 ObjInsArg::Reloc => argument::Value::Relocation(ArgumentRelocation {}),
                 ObjInsArg::BranchDest(dest) => argument::Value::BranchDest(*dest),
             }),
@@ -152,8 +168,8 @@ impl<'a> From<&'a ObjInsArg> for Argument {
     }
 }
 
-impl From<&ObjInsArgValue> for ArgumentValue {
-    fn from(value: &ObjInsArgValue) -> Self {
+impl ArgumentValue {
+    pub fn new(value: &ObjInsArgValue) -> Self {
         Self {
             value: Some(match value {
                 ObjInsArgValue::Signed(v) => argument_value::Value::Signed(*v),
@@ -164,42 +180,39 @@ impl From<&ObjInsArgValue> for ArgumentValue {
     }
 }
 
-impl<'a> From<&'a ObjReloc> for Relocation {
-    fn from(value: &ObjReloc) -> Self {
+impl Relocation {
+    pub fn new(object: &ObjInfo, reloc: &ObjReloc) -> Self {
         Self {
-            r#type: match value.flags {
+            r#type: match reloc.flags {
                 object::RelocationFlags::Elf { r_type } => r_type,
                 object::RelocationFlags::MachO { r_type, .. } => r_type as u32,
                 object::RelocationFlags::Coff { typ } => typ as u32,
                 object::RelocationFlags::Xcoff { r_rtype, .. } => r_rtype as u32,
                 _ => unreachable!(),
             },
-            type_name: String::new(), // TODO
-            target: Some(RelocationTarget::from(&value.target)),
+            type_name: object.arch.display_reloc(reloc.flags).into_owned(),
+            target: Some(RelocationTarget {
+                symbol: Some(Symbol::new(&reloc.target)),
+                addend: reloc.addend,
+            }),
         }
     }
 }
 
-impl<'a> From<&'a ObjSymbol> for RelocationTarget {
-    fn from(value: &'a ObjSymbol) -> Self {
-        Self { symbol: Some(Symbol::from(value)), addend: value.addend }
-    }
-}
-
-impl<'a> From<&'a ObjInsDiff> for InstructionDiff {
-    fn from(value: &'a ObjInsDiff) -> Self {
+impl InstructionDiff {
+    pub fn new(object: &ObjInfo, instruction_diff: &ObjInsDiff) -> Self {
         Self {
-            instruction: value.ins.as_ref().map(Instruction::from),
-            diff_kind: DiffKind::from(value.kind) as i32,
-            branch_from: value.branch_from.as_ref().map(InstructionBranchFrom::from),
-            branch_to: value.branch_to.as_ref().map(InstructionBranchTo::from),
-            arg_diff: value.arg_diff.iter().map(ArgumentDiff::from).collect(),
+            instruction: instruction_diff.ins.as_ref().map(|ins| Instruction::new(object, ins)),
+            diff_kind: DiffKind::from(instruction_diff.kind) as i32,
+            branch_from: instruction_diff.branch_from.as_ref().map(InstructionBranchFrom::new),
+            branch_to: instruction_diff.branch_to.as_ref().map(InstructionBranchTo::new),
+            arg_diff: instruction_diff.arg_diff.iter().map(ArgumentDiff::new).collect(),
         }
     }
 }
 
-impl From<&Option<ObjInsArgDiff>> for ArgumentDiff {
-    fn from(value: &Option<ObjInsArgDiff>) -> Self {
+impl ArgumentDiff {
+    pub fn new(value: &Option<ObjInsArgDiff>) -> Self {
         Self { diff_index: value.as_ref().map(|v| v.idx as u32) }
     }
 }
@@ -228,8 +241,8 @@ impl From<ObjDataDiffKind> for DiffKind {
     }
 }
 
-impl<'a> From<&'a ObjInsBranchFrom> for InstructionBranchFrom {
-    fn from(value: &'a ObjInsBranchFrom) -> Self {
+impl InstructionBranchFrom {
+    pub fn new(value: &ObjInsBranchFrom) -> Self {
         Self {
             instruction_index: value.ins_idx.iter().map(|&x| x as u32).collect(),
             branch_index: value.branch_idx as u32,
@@ -237,8 +250,8 @@ impl<'a> From<&'a ObjInsBranchFrom> for InstructionBranchFrom {
     }
 }
 
-impl<'a> From<&'a ObjInsBranchTo> for InstructionBranchTo {
-    fn from(value: &'a ObjInsBranchTo) -> Self {
+impl InstructionBranchTo {
+    pub fn new(value: &ObjInsBranchTo) -> Self {
         Self { instruction_index: value.ins_idx as u32, branch_index: value.branch_idx as u32 }
     }
 }

objdiff-core/src/bindings/report.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::needless_lifetimes)] // Generated serde code
 use std::ops::AddAssign;
 
 use anyhow::{bail, Result};
@@ -173,8 +174,7 @@ impl Report {
                 continue;
             }
             fn is_sub_category(id: &str, parent: &str, sep: char) -> bool {
-                id.starts_with(parent)
-                    && id.get(parent.len()..).map_or(false, |s| s.starts_with(sep))
+                id.starts_with(parent) && id.get(parent.len()..).is_some_and(|s| s.starts_with(sep))
             }
             let mut sub_categories = self
                 .categories

objdiff-core/src/bindings/wasm.rs

@@ -13,20 +13,22 @@ fn parse_object(
 fn parse_and_run_diff(
     left: Option<Box<[u8]>>,
     right: Option<Box<[u8]>>,
-    config: diff::DiffObjConfig,
+    diff_config: diff::DiffObjConfig,
+    mapping_config: diff::MappingConfig,
 ) -> Result<DiffResult, JsError> {
-    let target = parse_object(left, &config)?;
-    let base = parse_object(right, &config)?;
-    run_diff(target.as_ref(), base.as_ref(), config)
+    let target = parse_object(left, &diff_config)?;
+    let base = parse_object(right, &diff_config)?;
+    run_diff(target.as_ref(), base.as_ref(), diff_config, mapping_config)
 }
 
 fn run_diff(
     left: Option<&obj::ObjInfo>,
     right: Option<&obj::ObjInfo>,
-    config: diff::DiffObjConfig,
+    diff_config: diff::DiffObjConfig,
+    mapping_config: diff::MappingConfig,
 ) -> Result<DiffResult, JsError> {
-    log::debug!("Running diff with config: {:?}", config);
-    let result = diff::diff_objs(&config, left, right, None).to_js()?;
+    log::debug!("Running diff with config: {:?}", diff_config);
+    let result = diff::diff_objs(&diff_config, &mapping_config, left, right, None).to_js()?;
     let left = left.and_then(|o| result.left.as_ref().map(|d| (o, d)));
     let right = right.and_then(|o| result.right.as_ref().map(|d| (o, d)));
     Ok(DiffResult::new(left, right))
@@ -46,9 +48,10 @@ fn run_diff(
 pub fn run_diff_proto(
     left: Option<Box<[u8]>>,
     right: Option<Box<[u8]>>,
-    config: diff::DiffObjConfig,
+    diff_config: diff::DiffObjConfig,
+    mapping_config: diff::MappingConfig,
 ) -> Result<Box<[u8]>, JsError> {
-    let out = parse_and_run_diff(left, right, config)?;
+    let out = parse_and_run_diff(left, right, diff_config, mapping_config)?;
     Ok(out.encode_to_vec().into_boxed_slice())
 }
 

objdiff-core/src/build/mod.rs

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

objdiff-core/src/build/watcher.rs

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

objdiff-core/src/config/mod.rs

@@ -1,6 +1,8 @@
 use std::{
+    collections::BTreeMap,
+    fs,
     fs::File,
-    io::{BufReader, Read},
+    io::{BufReader, BufWriter, Read},
     path::{Path, PathBuf},
 };
 
@@ -8,70 +10,107 @@ use anyhow::{anyhow, Context, Result};
 use filetime::FileTime;
 use globset::{Glob, GlobSet, GlobSetBuilder};
 
-#[inline]
-fn bool_true() -> bool { true }
-
-#[derive(Default, Clone, serde::Deserialize)]
+#[derive(Default, Clone, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "wasm", derive(tsify_next::Tsify), tsify(from_wasm_abi))]
 pub struct ProjectConfig {
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub min_version: Option<String>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub custom_make: Option<String>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub custom_args: Option<Vec<String>>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub target_dir: Option<PathBuf>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     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>,
-    #[serde(default)]
-    pub progress_categories: Vec<ProjectProgressCategory>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub build_base: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub build_target: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub watch_patterns: Option<Vec<String>>,
+    #[serde(default, alias = "objects", skip_serializing_if = "Option::is_none")]
+    pub units: Option<Vec<ProjectObject>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub progress_categories: Option<Vec<ProjectProgressCategory>>,
 }
 
-#[derive(Default, Clone, serde::Deserialize)]
+impl ProjectConfig {
+    #[inline]
+    pub fn units(&self) -> &[ProjectObject] { self.units.as_deref().unwrap_or_default() }
+
+    #[inline]
+    pub fn units_mut(&mut self) -> &mut Vec<ProjectObject> {
+        self.units.get_or_insert_with(Vec::new)
+    }
+
+    #[inline]
+    pub fn progress_categories(&self) -> &[ProjectProgressCategory] {
+        self.progress_categories.as_deref().unwrap_or_default()
+    }
+
+    #[inline]
+    pub fn progress_categories_mut(&mut self) -> &mut Vec<ProjectProgressCategory> {
+        self.progress_categories.get_or_insert_with(Vec::new)
+    }
+
+    pub fn build_watch_patterns(&self) -> Result<Vec<Glob>, globset::Error> {
+        Ok(if let Some(watch_patterns) = &self.watch_patterns {
+            watch_patterns
+                .iter()
+                .map(|s| Glob::new(s))
+                .collect::<Result<Vec<Glob>, globset::Error>>()?
+        } else {
+            DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect()
+        })
+    }
+}
+
+#[derive(Default, Clone, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "wasm", derive(tsify_next::Tsify), tsify(from_wasm_abi))]
 pub struct ProjectObject {
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub name: Option<String>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub path: Option<PathBuf>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub target_path: Option<PathBuf>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub base_path: Option<PathBuf>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     #[deprecated(note = "Use metadata.reverse_fn_order")]
     pub reverse_fn_order: Option<bool>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     #[deprecated(note = "Use metadata.complete")]
     pub complete: Option<bool>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub scratch: Option<ScratchConfig>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub metadata: Option<ProjectObjectMetadata>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub symbol_mappings: Option<SymbolMappings>,
 }
 
-#[derive(Default, Clone, serde::Deserialize)]
+#[cfg_attr(feature = "wasm", tsify_next::declare)]
+pub type SymbolMappings = BTreeMap<String, String>;
+
+#[derive(Default, Clone, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "wasm", derive(tsify_next::Tsify), tsify(from_wasm_abi))]
 pub struct ProjectObjectMetadata {
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub complete: Option<bool>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub reverse_fn_order: Option<bool>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub source_path: Option<String>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub progress_categories: Option<Vec<String>>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub auto_generated: Option<bool>,
 }
 
-#[derive(Default, Clone, serde::Deserialize)]
+#[derive(Default, Clone, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "wasm", derive(tsify_next::Tsify), tsify(from_wasm_abi))]
 pub struct ProjectProgressCategory {
     #[serde(default)]
     pub id: String,
@@ -112,12 +151,12 @@ impl ProjectObject {
     }
 
     pub fn complete(&self) -> Option<bool> {
-        #[allow(deprecated)]
+        #[expect(deprecated)]
         self.metadata.as_ref().and_then(|m| m.complete).or(self.complete)
     }
 
     pub fn reverse_fn_order(&self) -> Option<bool> {
-        #[allow(deprecated)]
+        #[expect(deprecated)]
         self.metadata.as_ref().and_then(|m| m.reverse_fn_order).or(self.reverse_fn_order)
     }
 
@@ -131,17 +170,20 @@ impl ProjectObject {
 }
 
 #[derive(Default, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[cfg_attr(feature = "wasm", derive(tsify_next::Tsify), tsify(from_wasm_abi))]
 pub struct ScratchConfig {
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub platform: Option<String>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub compiler: Option<String>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub c_flags: Option<String>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub ctx_path: Option<PathBuf>,
-    #[serde(default)]
-    pub build_ctx: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub build_ctx: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub preset_id: Option<u32>,
 }
 
 pub const CONFIG_FILENAMES: [&str; 3] = ["objdiff.json", "objdiff.yml", "objdiff.yaml"];
@@ -151,10 +193,14 @@ pub const DEFAULT_WATCH_PATTERNS: &[&str] = &[
     "*.inc", "*.py", "*.yml", "*.txt", "*.json",
 ];
 
+pub fn default_watch_patterns() -> Vec<Glob> {
+    DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect()
+}
+
 #[derive(Clone, Eq, PartialEq)]
 pub struct ProjectConfigInfo {
     pub path: PathBuf,
-    pub timestamp: FileTime,
+    pub timestamp: Option<FileTime>,
 }
 
 pub fn try_project_config(dir: &Path) -> Option<(Result<ProjectConfig>, ProjectConfigInfo)> {
@@ -180,12 +226,41 @@ pub fn try_project_config(dir: &Path) -> Option<(Result<ProjectConfig>, ProjectC
                     result = Err(e);
                 }
             }
-            return Some((result, ProjectConfigInfo { path: config_path, timestamp: ts }));
+            return Some((result, ProjectConfigInfo { path: config_path, timestamp: Some(ts) }));
         }
     }
     None
 }
 
+pub fn save_project_config(
+    config: &ProjectConfig,
+    info: &ProjectConfigInfo,
+) -> Result<ProjectConfigInfo> {
+    if let Some(last_ts) = info.timestamp {
+        // Check if the file has changed since we last read it
+        if let Ok(metadata) = fs::metadata(&info.path) {
+            let ts = FileTime::from_last_modification_time(&metadata);
+            if ts != last_ts {
+                return Err(anyhow!("Config file has changed since last read"));
+            }
+        }
+    }
+    let mut writer =
+        BufWriter::new(File::create(&info.path).context("Failed to create config file")?);
+    let ext = info.path.extension().and_then(|ext| ext.to_str()).unwrap_or("json");
+    match ext {
+        "json" => serde_json::to_writer_pretty(&mut writer, config).context("Failed to write JSON"),
+        "yml" | "yaml" => {
+            serde_yaml::to_writer(&mut writer, config).context("Failed to write YAML")
+        }
+        _ => Err(anyhow!("Unknown config file extension: {ext}")),
+    }?;
+    let file = writer.into_inner().context("Failed to flush file")?;
+    let metadata = file.metadata().context("Failed to get file metadata")?;
+    let ts = FileTime::from_last_modification_time(&metadata);
+    Ok(ProjectConfigInfo { path: info.path.clone(), timestamp: Some(ts) })
+}
+
 fn validate_min_version(config: &ProjectConfig) -> Result<()> {
     let Some(min_version) = &config.min_version else { return Ok(()) };
     let version = semver::Version::parse(env!("CARGO_PKG_VERSION"))

objdiff-core/src/diff/code.rs

@@ -3,13 +3,17 @@ use std::{cmp::max, collections::BTreeMap};
 use anyhow::{anyhow, Result};
 use similar::{capture_diff_slices_deadline, Algorithm};
 
+use super::FunctionRelocDiffs;
 use crate::{
     arch::ProcessCodeResult,
     diff::{
         DiffObjConfig, ObjInsArgDiff, ObjInsBranchFrom, ObjInsBranchTo, ObjInsDiff, ObjInsDiffKind,
         ObjSymbolDiff,
     },
-    obj::{ObjInfo, ObjInsArg, ObjReloc, ObjSymbol, ObjSymbolFlags, SymbolRef},
+    obj::{
+        ObjInfo, ObjIns, ObjInsArg, ObjReloc, ObjSection, ObjSymbol, ObjSymbolFlags, ObjSymbolKind,
+        SymbolRef,
+    },
 };
 
 pub fn process_code_symbol(
@@ -21,14 +25,30 @@ pub fn process_code_symbol(
     let section = section.ok_or_else(|| anyhow!("Code symbol section not found"))?;
     let code = &section.data
         [symbol.section_address as usize..(symbol.section_address + symbol.size) as usize];
-    obj.arch.process_code(
+    let mut res = obj.arch.process_code(
         symbol.address,
         code,
         section.orig_index,
         &section.relocations,
         &section.line_info,
         config,
-    )
+    )?;
+
+    for inst in res.insts.iter_mut() {
+        if let Some(reloc) = &mut inst.reloc {
+            if reloc.target.size == 0 && reloc.target.name.is_empty() {
+                // Fake target symbol we added as a placeholder. We need to find the real one.
+                if let Some(real_target) =
+                    find_symbol_matching_fake_symbol_in_sections(&reloc.target, &obj.sections)
+                {
+                    reloc.addend = (reloc.target.address - real_target.address) as i64;
+                    reloc.target = real_target;
+                }
+            }
+        }
+    }
+
+    Ok(res)
 }
 
 pub fn no_diff_code(out: &ProcessCodeResult, symbol_ref: SymbolRef) -> Result<ObjSymbolDiff> {
@@ -41,10 +61,12 @@ pub fn no_diff_code(out: &ProcessCodeResult, symbol_ref: SymbolRef) -> Result<Ob
         });
     }
     resolve_branches(&mut diff);
-    Ok(ObjSymbolDiff { symbol_ref, diff_symbol: None, instructions: diff, match_percent: None })
+    Ok(ObjSymbolDiff { symbol_ref, target_symbol: None, instructions: diff, match_percent: None })
 }
 
 pub fn diff_code(
+    left_obj: &ObjInfo,
+    right_obj: &ObjInfo,
     left_out: &ProcessCodeResult,
     right_out: &ProcessCodeResult,
     left_symbol_ref: SymbolRef,
@@ -60,14 +82,14 @@ pub fn diff_code(
 
     let mut diff_state = InsDiffState::default();
     for (left, right) in left_diff.iter_mut().zip(right_diff.iter_mut()) {
-        let result = compare_ins(config, left, right, &mut diff_state)?;
+        let result = compare_ins(config, left_obj, right_obj, 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 total = left_out.insts.len().max(right_out.insts.len());
     let percent = if diff_state.diff_count >= total {
         0.0
     } else {
@@ -77,13 +99,13 @@ pub fn diff_code(
     Ok((
         ObjSymbolDiff {
             symbol_ref: left_symbol_ref,
-            diff_symbol: Some(right_symbol_ref),
+            target_symbol: Some(right_symbol_ref),
             instructions: left_diff,
             match_percent: Some(percent),
         },
         ObjSymbolDiff {
             symbol_ref: right_symbol_ref,
-            diff_symbol: Some(left_symbol_ref),
+            target_symbol: Some(left_symbol_ref),
             instructions: right_diff,
             match_percent: Some(percent),
         },
@@ -170,73 +192,114 @@ fn resolve_branches(vec: &mut [ObjInsDiff]) {
     }
 }
 
-fn address_eq(left: &ObjSymbol, right: &ObjSymbol) -> bool {
-    left.address as i64 + left.addend == right.address as i64 + right.addend
+fn address_eq(left: &ObjReloc, right: &ObjReloc) -> bool {
+    left.target.address as i64 + left.addend == right.target.address as i64 + right.addend
+}
+
+pub fn section_name_eq(
+    left_obj: &ObjInfo,
+    right_obj: &ObjInfo,
+    left_orig_section_index: usize,
+    right_orig_section_index: usize,
+) -> bool {
+    let Some(left_section) =
+        left_obj.sections.iter().find(|s| s.orig_index == left_orig_section_index)
+    else {
+        return false;
+    };
+    let Some(right_section) =
+        right_obj.sections.iter().find(|s| s.orig_index == right_orig_section_index)
+    else {
+        return false;
+    };
+    left_section.name == right_section.name
 }
 
 fn reloc_eq(
     config: &DiffObjConfig,
-    left_reloc: Option<&ObjReloc>,
-    right_reloc: Option<&ObjReloc>,
+    left_obj: &ObjInfo,
+    right_obj: &ObjInfo,
+    left_ins: Option<&ObjIns>,
+    right_ins: Option<&ObjIns>,
 ) -> bool {
-    let (Some(left), Some(right)) = (left_reloc, right_reloc) else {
+    let (Some(left_ins), Some(right_ins)) = (left_ins, right_ins) else {
+        return false;
+    };
+    let (Some(left), Some(right)) = (&left_ins.reloc, &right_ins.reloc) else {
         return false;
     };
     if left.flags != right.flags {
         return false;
     }
-    if config.relax_reloc_diffs {
+    if config.function_reloc_diffs == FunctionRelocDiffs::None {
         return true;
     }
 
-    let name_matches = left.target.name == right.target.name;
-    match (&left.target_section, &right.target_section) {
+    let symbol_name_matches = left.target.name == right.target.name;
+    match (&left.target.orig_section_index, &right.target.orig_section_index) {
         (Some(sl), Some(sr)) => {
             // Match if section and name or address match
-            sl == sr && (name_matches || address_eq(&left.target, &right.target))
+            section_name_eq(left_obj, right_obj, *sl, *sr)
+                && (config.function_reloc_diffs == FunctionRelocDiffs::DataValue
+                    || symbol_name_matches
+                    || address_eq(left, right))
+                && (config.function_reloc_diffs == FunctionRelocDiffs::NameAddress
+                    || left.target.kind != ObjSymbolKind::Object
+                    || left_obj.arch.display_ins_data(left_ins)
+                        == left_obj.arch.display_ins_data(right_ins))
         }
         (Some(_), None) => false,
         (None, Some(_)) => {
             // Match if possibly stripped weak symbol
-            name_matches && right.target.flags.0.contains(ObjSymbolFlags::Weak)
+            symbol_name_matches && right.target.flags.0.contains(ObjSymbolFlags::Weak)
         }
-        (None, None) => name_matches,
+        (None, None) => symbol_name_matches,
     }
 }
 
 fn arg_eq(
     config: &DiffObjConfig,
+    left_obj: &ObjInfo,
+    right_obj: &ObjInfo,
     left: &ObjInsArg,
     right: &ObjInsArg,
     left_diff: &ObjInsDiff,
     right_diff: &ObjInsDiff,
 ) -> bool {
-    return match left {
+    match left {
         ObjInsArg::PlainText(l) => match right {
             ObjInsArg::PlainText(r) => l == r,
             _ => false,
         },
         ObjInsArg::Arg(l) => match right {
-            ObjInsArg::Arg(r) => l == r,
+            ObjInsArg::Arg(r) => l.loose_eq(r),
             // If relocations are relaxed, match if left is a constant and right is a reloc
             // Useful for instances where the target object is created without relocations
-            ObjInsArg::Reloc => config.relax_reloc_diffs,
+            ObjInsArg::Reloc => config.function_reloc_diffs == FunctionRelocDiffs::None,
             _ => false,
         },
         ObjInsArg::Reloc => {
             matches!(right, ObjInsArg::Reloc)
                 && reloc_eq(
                     config,
-                    left_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
-                    right_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
+                    left_obj,
+                    right_obj,
+                    left_diff.ins.as_ref(),
+                    right_diff.ins.as_ref(),
                 )
         }
-        ObjInsArg::BranchDest(_) => {
+        ObjInsArg::BranchDest(_) => match right {
             // 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)
-        }
-    };
+            ObjInsArg::BranchDest(_) => {
+                left_diff.branch_to.as_ref().map(|b| b.ins_idx)
+                    == right_diff.branch_to.as_ref().map(|b| b.ins_idx)
+            }
+            // If relocations are relaxed, match if left is a constant and right is a reloc
+            // Useful for instances where the target object is created without relocations
+            ObjInsArg::Reloc => config.function_reloc_diffs == FunctionRelocDiffs::None,
+            _ => false,
+        },
+    }
 }
 
 #[derive(Default)]
@@ -257,21 +320,18 @@ struct InsDiffResult {
 
 fn compare_ins(
     config: &DiffObjConfig,
+    left_obj: &ObjInfo,
+    right_obj: &ObjInfo,
     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
-            // Check if any PlainText segments differ (punctuation and spacing)
-            // This indicates a more significant difference than a simple arg mismatch
-            || !left_ins.args.iter().zip(&right_ins.args).all(|(a, b)| match (a, b) {
-                (ObjInsArg::PlainText(l), ObjInsArg::PlainText(r)) => l == r,
-                _ => true,
-            })
-        {
+        // Count only non-PlainText args
+        let left_args_count = left_ins.iter_args().count();
+        let right_args_count = right_ins.iter_args().count();
+        if left_args_count != right_args_count || left_ins.op != right_ins.op {
             // Totally different op
             result.kind = ObjInsDiffKind::Replace;
             state.diff_count += 1;
@@ -282,8 +342,8 @@ fn compare_ins(
             result.kind = ObjInsDiffKind::OpMismatch;
             state.diff_count += 1;
         }
-        for (a, b) in left_ins.args.iter().zip(&right_ins.args) {
-            if arg_eq(config, a, b, left, right) {
+        for (a, b) in left_ins.iter_args().zip(right_ins.iter_args()) {
+            if arg_eq(config, left_obj, right_obj, a, b, left, right) {
                 result.left_args_diff.push(None);
                 result.right_args_diff.push(None);
             } else {
@@ -294,8 +354,11 @@ fn compare_ins(
                 let a_str = match a {
                     ObjInsArg::PlainText(arg) => arg.to_string(),
                     ObjInsArg::Arg(arg) => arg.to_string(),
-                    ObjInsArg::Reloc => String::new(),
-                    ObjInsArg::BranchDest(arg) => format!("{arg}"),
+                    ObjInsArg::Reloc => left_ins
+                        .reloc
+                        .as_ref()
+                        .map_or_else(|| "<unknown>".to_string(), |r| r.target.name.clone()),
+                    ObjInsArg::BranchDest(arg) => arg.to_string(),
                 };
                 let a_diff = if let Some(idx) = state.left_args_idx.get(&a_str) {
                     ObjInsArgDiff { idx: *idx }
@@ -308,8 +371,11 @@ fn compare_ins(
                 let b_str = match b {
                     ObjInsArg::PlainText(arg) => arg.to_string(),
                     ObjInsArg::Arg(arg) => arg.to_string(),
-                    ObjInsArg::Reloc => String::new(),
-                    ObjInsArg::BranchDest(arg) => format!("{arg}"),
+                    ObjInsArg::Reloc => right_ins
+                        .reloc
+                        .as_ref()
+                        .map_or_else(|| "<unknown>".to_string(), |r| r.target.name.clone()),
+                    ObjInsArg::BranchDest(arg) => arg.to_string(),
                 };
                 let b_diff = if let Some(idx) = state.right_args_idx.get(&b_str) {
                     ObjInsArgDiff { idx: *idx }
@@ -332,3 +398,16 @@ fn compare_ins(
     }
     Ok(result)
 }
+
+fn find_symbol_matching_fake_symbol_in_sections(
+    fake_symbol: &ObjSymbol,
+    sections: &[ObjSection],
+) -> Option<ObjSymbol> {
+    let orig_section_index = fake_symbol.orig_section_index?;
+    let section = sections.iter().find(|s| s.orig_index == orig_section_index)?;
+    let real_symbol = section
+        .symbols
+        .iter()
+        .find(|s| s.size > 0 && (s.address..s.address + s.size).contains(&fake_symbol.address))?;
+    Some(real_symbol.clone())
+}

objdiff-core/src/diff/data.rs

@@ -1,11 +1,15 @@
-use std::cmp::{max, min, Ordering};
+use std::{
+    cmp::{max, min, Ordering},
+    ops::Range,
+};
 
 use anyhow::{anyhow, Result};
 use similar::{capture_diff_slices_deadline, get_diff_ratio, Algorithm};
 
+use super::code::section_name_eq;
 use crate::{
-    diff::{ObjDataDiff, ObjDataDiffKind, ObjSectionDiff, ObjSymbolDiff},
-    obj::{ObjInfo, ObjSection, SymbolRef},
+    diff::{ObjDataDiff, ObjDataDiffKind, ObjDataRelocDiff, ObjSectionDiff, ObjSymbolDiff},
+    obj::{ObjInfo, ObjReloc, ObjSection, ObjSymbolFlags, SymbolRef},
 };
 
 pub fn diff_bss_symbol(
@@ -20,13 +24,13 @@ pub fn diff_bss_symbol(
     Ok((
         ObjSymbolDiff {
             symbol_ref: left_symbol_ref,
-            diff_symbol: Some(right_symbol_ref),
+            target_symbol: Some(right_symbol_ref),
             instructions: vec![],
             match_percent: Some(percent),
         },
         ObjSymbolDiff {
             symbol_ref: right_symbol_ref,
-            diff_symbol: Some(left_symbol_ref),
+            target_symbol: Some(left_symbol_ref),
             instructions: vec![],
             match_percent: Some(percent),
         },
@@ -34,11 +38,113 @@ pub fn diff_bss_symbol(
 }
 
 pub fn no_diff_symbol(_obj: &ObjInfo, symbol_ref: SymbolRef) -> ObjSymbolDiff {
-    ObjSymbolDiff { symbol_ref, diff_symbol: None, instructions: vec![], match_percent: None }
+    ObjSymbolDiff { symbol_ref, target_symbol: None, instructions: vec![], match_percent: None }
+}
+
+fn address_eq(left: &ObjReloc, right: &ObjReloc) -> bool {
+    if right.target.size == 0 && left.target.size != 0 {
+        // The base relocation is against a pool but the target relocation isn't.
+        // This can happen in rare cases where the compiler will generate a pool+addend relocation
+        // in the base, but the one detected in the target is direct with no addend.
+        // Just check that the final address is the same so these count as a match.
+        left.target.address as i64 + left.addend == right.target.address as i64 + right.addend
+    } else {
+        // But otherwise, if the compiler isn't using a pool, we're more strict and check that the
+        // target symbol address and relocation addend both match exactly.
+        left.target.address == right.target.address && left.addend == right.addend
+    }
+}
+
+fn reloc_eq(left_obj: &ObjInfo, right_obj: &ObjInfo, left: &ObjReloc, right: &ObjReloc) -> bool {
+    if left.flags != right.flags {
+        return false;
+    }
+
+    let symbol_name_matches = left.target.name == right.target.name;
+    match (&left.target.orig_section_index, &right.target.orig_section_index) {
+        (Some(sl), Some(sr)) => {
+            // Match if section and name+addend or address match
+            section_name_eq(left_obj, right_obj, *sl, *sr)
+                && ((symbol_name_matches && left.addend == right.addend) || address_eq(left, right))
+        }
+        (Some(_), None) => false,
+        (None, Some(_)) => {
+            // Match if possibly stripped weak symbol
+            (symbol_name_matches && left.addend == right.addend)
+                && right.target.flags.0.contains(ObjSymbolFlags::Weak)
+        }
+        (None, None) => symbol_name_matches,
+    }
+}
+
+/// Compares relocations contained with a certain data range.
+/// The ObjDataDiffKind for each diff will either be `None`` (if the relocation matches),
+/// or `Replace` (if a relocation was changed, added, or removed).
+/// `Insert` and `Delete` are not used when a relocation is added or removed to avoid confusing diffs
+/// where it looks like the bytes themselves were changed but actually only the relocations changed.
+fn diff_data_relocs_for_range(
+    left_obj: &ObjInfo,
+    right_obj: &ObjInfo,
+    left: &ObjSection,
+    right: &ObjSection,
+    left_range: Range<usize>,
+    right_range: Range<usize>,
+) -> Vec<(ObjDataDiffKind, Option<ObjReloc>, Option<ObjReloc>)> {
+    let mut diffs = Vec::new();
+    for left_reloc in left.relocations.iter() {
+        if !left_range.contains(&(left_reloc.address as usize)) {
+            continue;
+        }
+        let left_offset = left_reloc.address as usize - left_range.start;
+        let Some(right_reloc) = right.relocations.iter().find(|r| {
+            if !right_range.contains(&(r.address as usize)) {
+                return false;
+            }
+            let right_offset = r.address as usize - right_range.start;
+            right_offset == left_offset
+        }) else {
+            diffs.push((ObjDataDiffKind::Delete, Some(left_reloc.clone()), None));
+            continue;
+        };
+        if reloc_eq(left_obj, right_obj, left_reloc, right_reloc) {
+            diffs.push((
+                ObjDataDiffKind::None,
+                Some(left_reloc.clone()),
+                Some(right_reloc.clone()),
+            ));
+        } else {
+            diffs.push((
+                ObjDataDiffKind::Replace,
+                Some(left_reloc.clone()),
+                Some(right_reloc.clone()),
+            ));
+        }
+    }
+    for right_reloc in right.relocations.iter() {
+        if !right_range.contains(&(right_reloc.address as usize)) {
+            continue;
+        }
+        let right_offset = right_reloc.address as usize - right_range.start;
+        let Some(_) = left.relocations.iter().find(|r| {
+            if !left_range.contains(&(r.address as usize)) {
+                return false;
+            }
+            let left_offset = r.address as usize - left_range.start;
+            left_offset == right_offset
+        }) else {
+            diffs.push((ObjDataDiffKind::Insert, None, Some(right_reloc.clone())));
+            continue;
+        };
+        // No need to check the cases for relocations being deleted or matching again.
+        // They were already handled in the loop over the left relocs.
+    }
+    diffs
 }
 
 /// Compare the data sections of two object files.
 pub fn diff_data_section(
+    left_obj: &ObjInfo,
+    right_obj: &ObjInfo,
     left: &ObjSection,
     right: &ObjSection,
     left_section_diff: &ObjSectionDiff,
@@ -121,16 +227,44 @@ pub fn diff_data_section(
         }
     }
 
+    let mut left_reloc_diffs = Vec::new();
+    let mut right_reloc_diffs = Vec::new();
+    for (diff_kind, left_reloc, right_reloc) in diff_data_relocs_for_range(
+        left_obj,
+        right_obj,
+        left,
+        right,
+        0..left_max as usize,
+        0..right_max as usize,
+    ) {
+        if let Some(left_reloc) = left_reloc {
+            let len = left_obj.arch.get_reloc_byte_size(left_reloc.flags);
+            let range = left_reloc.address as usize..left_reloc.address as usize + len;
+            left_reloc_diffs.push(ObjDataRelocDiff { reloc: left_reloc, kind: diff_kind, range });
+        }
+        if let Some(right_reloc) = right_reloc {
+            let len = right_obj.arch.get_reloc_byte_size(right_reloc.flags);
+            let range = right_reloc.address as usize..right_reloc.address as usize + len;
+            right_reloc_diffs.push(ObjDataRelocDiff { reloc: right_reloc, kind: diff_kind, range });
+        }
+    }
+
     let (mut left_section_diff, mut right_section_diff) =
         diff_generic_section(left, right, left_section_diff, right_section_diff)?;
+    let all_left_relocs_match = left_reloc_diffs.iter().all(|d| d.kind == ObjDataDiffKind::None);
     left_section_diff.data_diff = left_diff;
     right_section_diff.data_diff = right_diff;
-    // Use the highest match percent between two options:
-    // - Left symbols matching right symbols by name
-    // - Diff of the data itself
-    if left_section_diff.match_percent.unwrap_or(-1.0) < match_percent {
-        left_section_diff.match_percent = Some(match_percent);
-        right_section_diff.match_percent = Some(match_percent);
+    left_section_diff.reloc_diff = left_reloc_diffs;
+    right_section_diff.reloc_diff = right_reloc_diffs;
+    if all_left_relocs_match {
+        // Use the highest match percent between two options:
+        // - Left symbols matching right symbols by name
+        // - Diff of the data itself
+        // We only do this when all relocations on the left side match.
+        if left_section_diff.match_percent.unwrap_or(-1.0) < match_percent {
+            left_section_diff.match_percent = Some(match_percent);
+            right_section_diff.match_percent = Some(match_percent);
+        }
     }
     Ok((left_section_diff, right_section_diff))
 }
@@ -147,24 +281,65 @@ pub fn diff_data_symbol(
     let left_section = left_section.ok_or_else(|| anyhow!("Data symbol section not found"))?;
     let right_section = right_section.ok_or_else(|| anyhow!("Data symbol section not found"))?;
 
-    let left_data = &left_section.data[left_symbol.section_address as usize
-        ..(left_symbol.section_address + left_symbol.size) as usize];
-    let right_data = &right_section.data[right_symbol.section_address as usize
-        ..(right_symbol.section_address + right_symbol.size) as usize];
+    let left_range = left_symbol.section_address as usize
+        ..(left_symbol.section_address + left_symbol.size) as usize;
+    let right_range = right_symbol.section_address as usize
+        ..(right_symbol.section_address + right_symbol.size) as usize;
+    let left_data = &left_section.data[left_range.clone()];
+    let right_data = &right_section.data[right_range.clone()];
+
+    let reloc_diffs = diff_data_relocs_for_range(
+        left_obj,
+        right_obj,
+        left_section,
+        right_section,
+        left_range,
+        right_range,
+    );
 
     let ops = capture_diff_slices_deadline(Algorithm::Patience, left_data, right_data, None);
-    let match_percent = get_diff_ratio(&ops, left_data.len(), right_data.len()) * 100.0;
+    let bytes_match_ratio = get_diff_ratio(&ops, left_data.len(), right_data.len());
+
+    let mut match_ratio = bytes_match_ratio;
+    if !reloc_diffs.is_empty() {
+        let mut total_reloc_bytes = 0;
+        let mut matching_reloc_bytes = 0;
+        for (diff_kind, left_reloc, right_reloc) in reloc_diffs {
+            let reloc_diff_len = match (left_reloc, right_reloc) {
+                (None, None) => unreachable!(),
+                (None, Some(right_reloc)) => right_obj.arch.get_reloc_byte_size(right_reloc.flags),
+                (Some(left_reloc), _) => left_obj.arch.get_reloc_byte_size(left_reloc.flags),
+            };
+            total_reloc_bytes += reloc_diff_len;
+            if diff_kind == ObjDataDiffKind::None {
+                matching_reloc_bytes += reloc_diff_len;
+            }
+        }
+        if total_reloc_bytes > 0 {
+            let relocs_match_ratio = matching_reloc_bytes as f32 / total_reloc_bytes as f32;
+            // Adjust the overall match ratio to include relocation differences.
+            // We calculate it so that bytes that contain a relocation are counted twice: once for the
+            // byte's raw value, and once for its relocation.
+            // e.g. An 8 byte symbol that has 8 matching raw bytes and a single 4 byte relocation that
+            // doesn't match would show as 66% (weighted average of 100% and 0%).
+            match_ratio = ((bytes_match_ratio * (left_data.len() as f32))
+                + (relocs_match_ratio * total_reloc_bytes as f32))
+                / (left_data.len() + total_reloc_bytes) as f32;
+        }
+    }
+
+    let match_percent = match_ratio * 100.0;
 
     Ok((
         ObjSymbolDiff {
             symbol_ref: left_symbol_ref,
-            diff_symbol: Some(right_symbol_ref),
+            target_symbol: Some(right_symbol_ref),
             instructions: vec![],
             match_percent: Some(match_percent),
         },
         ObjSymbolDiff {
             symbol_ref: right_symbol_ref,
-            diff_symbol: Some(left_symbol_ref),
+            target_symbol: Some(left_symbol_ref),
             instructions: vec![],
             match_percent: Some(match_percent),
         },
@@ -190,8 +365,18 @@ pub fn diff_generic_section(
             / left.size as f32
     };
     Ok((
-        ObjSectionDiff { symbols: vec![], data_diff: vec![], match_percent: Some(match_percent) },
-        ObjSectionDiff { symbols: vec![], data_diff: vec![], match_percent: Some(match_percent) },
+        ObjSectionDiff {
+            symbols: vec![],
+            data_diff: vec![],
+            reloc_diff: vec![],
+            match_percent: Some(match_percent),
+        },
+        ObjSectionDiff {
+            symbols: vec![],
+            data_diff: vec![],
+            reloc_diff: vec![],
+            match_percent: Some(match_percent),
+        },
     ))
 }
 
@@ -216,7 +401,17 @@ pub fn diff_bss_section(
     }
 
     Ok((
-        ObjSectionDiff { symbols: vec![], data_diff: vec![], match_percent: Some(match_percent) },
-        ObjSectionDiff { symbols: vec![], data_diff: vec![], match_percent: Some(match_percent) },
+        ObjSectionDiff {
+            symbols: vec![],
+            data_diff: vec![],
+            reloc_diff: vec![],
+            match_percent: Some(match_percent),
+        },
+        ObjSectionDiff {
+            symbols: vec![],
+            data_diff: vec![],
+            reloc_diff: vec![],
+            match_percent: Some(match_percent),
+        },
     ))
 }

objdiff-core/src/diff/display.rs

@@ -22,14 +22,14 @@ pub enum DiffText<'a> {
     /// Branch destination
     BranchDest(u64, Option<&'a ObjInsArgDiff>),
     /// Symbol name
-    Symbol(&'a ObjSymbol),
+    Symbol(&'a ObjSymbol, Option<&'a ObjInsArgDiff>),
     /// Number of spaces
     Spacing(usize),
     /// End of line
     Eol,
 }
 
-#[derive(Default, Clone, PartialEq, Eq)]
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub enum HighlightKind {
     #[default]
     None,
@@ -58,20 +58,23 @@ pub fn display_diff<E>(
         cb(DiffText::Spacing(4))?;
     }
     cb(DiffText::Opcode(&ins.mnemonic, ins.op))?;
+    let mut arg_diff_idx = 0; // non-PlainText index
     for (i, arg) in ins.args.iter().enumerate() {
         if i == 0 {
             cb(DiffText::Spacing(1))?;
         }
-        let diff = ins_diff.arg_diff.get(i).and_then(|o| o.as_ref());
+        let diff = ins_diff.arg_diff.get(arg_diff_idx).and_then(|o| o.as_ref());
         match arg {
             ObjInsArg::PlainText(s) => {
                 cb(DiffText::Basic(s))?;
             }
             ObjInsArg::Arg(v) => {
                 cb(DiffText::Argument(v, diff))?;
+                arg_diff_idx += 1;
             }
             ObjInsArg::Reloc => {
-                display_reloc_name(ins.reloc.as_ref().unwrap(), &mut cb)?;
+                display_reloc_name(ins.reloc.as_ref().unwrap(), &mut cb, diff)?;
+                arg_diff_idx += 1;
             }
             ObjInsArg::BranchDest(dest) => {
                 if let Some(dest) = dest.checked_sub(base_addr) {
@@ -79,6 +82,7 @@ pub fn display_diff<E>(
                 } else {
                     cb(DiffText::Basic("<unknown>"))?;
                 }
+                arg_diff_idx += 1;
             }
         }
     }
@@ -92,11 +96,12 @@ pub fn display_diff<E>(
 fn display_reloc_name<E>(
     reloc: &ObjReloc,
     mut cb: impl FnMut(DiffText) -> Result<(), E>,
+    diff: Option<&ObjInsArgDiff>,
 ) -> Result<(), E> {
-    cb(DiffText::Symbol(&reloc.target))?;
-    match reloc.target.addend.cmp(&0i64) {
-        Ordering::Greater => cb(DiffText::Basic(&format!("+{:#x}", reloc.target.addend))),
-        Ordering::Less => cb(DiffText::Basic(&format!("-{:#x}", -reloc.target.addend))),
+    cb(DiffText::Symbol(&reloc.target, diff))?;
+    match reloc.addend.cmp(&0i64) {
+        Ordering::Greater => cb(DiffText::Basic(&format!("+{:#x}", reloc.addend))),
+        Ordering::Less => cb(DiffText::Basic(&format!("-{:#x}", -reloc.addend))),
         _ => Ok(()),
     }
 }
@@ -106,7 +111,7 @@ impl PartialEq<DiffText<'_>> for HighlightKind {
         match (self, other) {
             (HighlightKind::Opcode(a), DiffText::Opcode(_, b)) => a == b,
             (HighlightKind::Arg(a), DiffText::Argument(b, _)) => a.loose_eq(b),
-            (HighlightKind::Symbol(a), DiffText::Symbol(b)) => a == &b.name,
+            (HighlightKind::Symbol(a), DiffText::Symbol(b, _)) => a == &b.name,
             (HighlightKind::Address(a), DiffText::Address(b) | DiffText::BranchDest(b, _)) => {
                 a == b
             }
@@ -124,7 +129,7 @@ impl From<DiffText<'_>> for HighlightKind {
         match value {
             DiffText::Opcode(_, op) => HighlightKind::Opcode(op),
             DiffText::Argument(arg, _) => HighlightKind::Arg(arg.clone()),
-            DiffText::Symbol(sym) => HighlightKind::Symbol(sym.name.to_string()),
+            DiffText::Symbol(sym, _) => HighlightKind::Symbol(sym.name.to_string()),
             DiffText::Address(addr) | DiffText::BranchDest(addr, _) => HighlightKind::Address(addr),
             _ => HighlightKind::None,
         }

objdiff-core/src/diff/mod.rs

@@ -1,8 +1,9 @@
-use std::collections::HashSet;
+use std::{collections::HashSet, ops::Range};
 
 use anyhow::Result;
 
 use crate::{
+    config::SymbolMappings,
     diff::{
         code::{diff_code, no_diff_code, process_code_symbol},
         data::{
@@ -10,191 +11,16 @@ use crate::{
             diff_generic_section, no_diff_symbol,
         },
     },
-    obj::{ObjInfo, ObjIns, ObjSection, ObjSectionKind, ObjSymbol, SymbolRef},
+    obj::{
+        ObjInfo, ObjIns, ObjReloc, ObjSection, ObjSectionKind, ObjSymbol, SymbolRef, SECTION_COMMON,
+    },
 };
 
 pub mod code;
 pub mod data;
 pub mod display;
 
-#[derive(
-    Debug,
-    Copy,
-    Clone,
-    Default,
-    Eq,
-    PartialEq,
-    serde::Deserialize,
-    serde::Serialize,
-    strum::VariantArray,
-    strum::EnumMessage,
-    tsify_next::Tsify,
-)]
-pub enum X86Formatter {
-    #[default]
-    #[strum(message = "Intel (default)")]
-    Intel,
-    #[strum(message = "AT&T")]
-    Gas,
-    #[strum(message = "NASM")]
-    Nasm,
-    #[strum(message = "MASM")]
-    Masm,
-}
-
-#[derive(
-    Debug,
-    Copy,
-    Clone,
-    Default,
-    Eq,
-    PartialEq,
-    serde::Deserialize,
-    serde::Serialize,
-    strum::VariantArray,
-    strum::EnumMessage,
-    tsify_next::Tsify,
-)]
-pub enum MipsAbi {
-    #[default]
-    #[strum(message = "Auto (default)")]
-    Auto,
-    #[strum(message = "O32")]
-    O32,
-    #[strum(message = "N32")]
-    N32,
-    #[strum(message = "N64")]
-    N64,
-}
-
-#[derive(
-    Debug,
-    Copy,
-    Clone,
-    Default,
-    Eq,
-    PartialEq,
-    serde::Deserialize,
-    serde::Serialize,
-    strum::VariantArray,
-    strum::EnumMessage,
-    tsify_next::Tsify,
-)]
-pub enum MipsInstrCategory {
-    #[default]
-    #[strum(message = "Auto (default)")]
-    Auto,
-    #[strum(message = "CPU")]
-    Cpu,
-    #[strum(message = "RSP (N64)")]
-    Rsp,
-    #[strum(message = "R3000 GTE (PS1)")]
-    R3000Gte,
-    #[strum(message = "R4000 ALLEGREX (PSP)")]
-    R4000Allegrex,
-    #[strum(message = "R5900 EE (PS2)")]
-    R5900,
-}
-
-#[derive(
-    Debug,
-    Copy,
-    Clone,
-    Default,
-    Eq,
-    PartialEq,
-    serde::Deserialize,
-    serde::Serialize,
-    strum::VariantArray,
-    strum::EnumMessage,
-    tsify_next::Tsify,
-)]
-pub enum ArmArchVersion {
-    #[default]
-    #[strum(message = "Auto (default)")]
-    Auto,
-    #[strum(message = "ARMv4T (GBA)")]
-    V4T,
-    #[strum(message = "ARMv5TE (DS)")]
-    V5TE,
-    #[strum(message = "ARMv6K (3DS)")]
-    V6K,
-}
-
-#[derive(
-    Debug,
-    Copy,
-    Clone,
-    Default,
-    Eq,
-    PartialEq,
-    serde::Deserialize,
-    serde::Serialize,
-    strum::VariantArray,
-    strum::EnumMessage,
-    tsify_next::Tsify,
-)]
-pub enum ArmR9Usage {
-    #[default]
-    #[strum(
-        message = "R9 or V6 (default)",
-        detailed_message = "Use R9 as a general-purpose register."
-    )]
-    GeneralPurpose,
-    #[strum(
-        message = "SB (static base)",
-        detailed_message = "Used for position-independent data (PID)."
-    )]
-    Sb,
-    #[strum(message = "TR (TLS register)", detailed_message = "Used for thread-local storage.")]
-    Tr,
-}
-
-#[inline]
-const fn default_true() -> bool { true }
-
-#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize, tsify_next::Tsify)]
-#[tsify(from_wasm_abi)]
-#[serde(default)]
-pub struct DiffObjConfig {
-    pub relax_reloc_diffs: bool,
-    #[serde(default = "default_true")]
-    pub space_between_args: bool,
-    pub combine_data_sections: bool,
-    // x86
-    pub x86_formatter: X86Formatter,
-    // MIPS
-    pub mips_abi: MipsAbi,
-    pub mips_instr_category: MipsInstrCategory,
-    // ARM
-    pub arm_arch_version: ArmArchVersion,
-    pub arm_unified_syntax: bool,
-    pub arm_av_registers: bool,
-    pub arm_r9_usage: ArmR9Usage,
-    pub arm_sl_usage: bool,
-    pub arm_fp_usage: bool,
-    pub arm_ip_usage: bool,
-}
-
-impl Default for DiffObjConfig {
-    fn default() -> Self {
-        Self {
-            relax_reloc_diffs: false,
-            space_between_args: true,
-            combine_data_sections: false,
-            x86_formatter: Default::default(),
-            mips_abi: Default::default(),
-            mips_instr_category: Default::default(),
-            arm_arch_version: Default::default(),
-            arm_unified_syntax: true,
-            arm_av_registers: false,
-            arm_r9_usage: Default::default(),
-            arm_sl_usage: false,
-            arm_fp_usage: false,
-            arm_ip_usage: false,
-        }
-    }
-}
+include!(concat!(env!("OUT_DIR"), "/config.gen.rs"));
 
 impl DiffObjConfig {
     pub fn separator(&self) -> &'static str {
@@ -210,6 +36,7 @@ impl DiffObjConfig {
 pub struct ObjSectionDiff {
     pub symbols: Vec<ObjSymbolDiff>,
     pub data_diff: Vec<ObjDataDiff>,
+    pub reloc_diff: Vec<ObjDataRelocDiff>,
     pub match_percent: Option<f32>,
 }
 
@@ -217,14 +44,17 @@ impl ObjSectionDiff {
     fn merge(&mut self, other: ObjSectionDiff) {
         // symbols ignored
         self.data_diff = other.data_diff;
+        self.reloc_diff = other.reloc_diff;
         self.match_percent = other.match_percent;
     }
 }
 
 #[derive(Debug, Clone, Default)]
 pub struct ObjSymbolDiff {
+    /// The symbol ref this object
     pub symbol_ref: SymbolRef,
-    pub diff_symbol: Option<SymbolRef>,
+    /// The symbol ref in the _other_ object that this symbol was diffed against
+    pub target_symbol: Option<SymbolRef>,
     pub instructions: Vec<ObjInsDiff>,
     pub match_percent: Option<f32>,
 }
@@ -238,7 +68,7 @@ pub struct ObjInsDiff {
     pub branch_from: Option<ObjInsBranchFrom>,
     /// Branches to instruction
     pub branch_to: Option<ObjInsBranchTo>,
-    /// Arg diffs
+    /// Arg diffs (only contains non-PlainText args)
     pub arg_diff: Vec<Option<ObjInsArgDiff>>,
 }
 
@@ -261,6 +91,13 @@ pub struct ObjDataDiff {
     pub symbol: String,
 }
 
+#[derive(Debug, Clone)]
+pub struct ObjDataRelocDiff {
+    pub reloc: ObjReloc,
+    pub kind: ObjDataDiffKind,
+    pub range: Range<usize>,
+}
+
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
 pub enum ObjDataDiffKind {
     #[default]
@@ -294,8 +131,13 @@ pub struct ObjInsBranchTo {
 
 #[derive(Default)]
 pub struct ObjDiff {
+    /// A list of all section diffs in the object.
     pub sections: Vec<ObjSectionDiff>,
+    /// Common BSS symbols don't live in a section, so they're stored separately.
     pub common: Vec<ObjSymbolDiff>,
+    /// If `selecting_left` or `selecting_right` is set, this is the list of symbols
+    /// that are being mapped to the other object.
+    pub mapping_symbols: Vec<ObjSymbolDiff>,
 }
 
 impl ObjDiff {
@@ -303,13 +145,14 @@ impl ObjDiff {
         let mut result = Self {
             sections: Vec::with_capacity(obj.sections.len()),
             common: Vec::with_capacity(obj.common.len()),
+            mapping_symbols: vec![],
         };
         for (section_idx, section) in obj.sections.iter().enumerate() {
             let mut symbols = Vec::with_capacity(section.symbols.len());
             for (symbol_idx, _) in section.symbols.iter().enumerate() {
                 symbols.push(ObjSymbolDiff {
                     symbol_ref: SymbolRef { section_idx, symbol_idx },
-                    diff_symbol: None,
+                    target_symbol: None,
                     instructions: vec![],
                     match_percent: None,
                 });
@@ -322,13 +165,14 @@ impl ObjDiff {
                     len: section.data.len(),
                     symbol: section.name.clone(),
                 }],
+                reloc_diff: vec![],
                 match_percent: None,
             });
         }
         for (symbol_idx, _) in obj.common.iter().enumerate() {
             result.common.push(ObjSymbolDiff {
-                symbol_ref: SymbolRef { section_idx: obj.sections.len(), symbol_idx },
-                diff_symbol: None,
+                symbol_ref: SymbolRef { section_idx: SECTION_COMMON, symbol_idx },
+                target_symbol: None,
                 instructions: vec![],
                 match_percent: None,
             });
@@ -348,7 +192,7 @@ impl ObjDiff {
 
     #[inline]
     pub fn symbol_diff(&self, symbol_ref: SymbolRef) -> &ObjSymbolDiff {
-        if symbol_ref.section_idx == self.sections.len() {
+        if symbol_ref.section_idx == SECTION_COMMON {
             &self.common[symbol_ref.symbol_idx]
         } else {
             &self.section_diff(symbol_ref.section_idx).symbols[symbol_ref.symbol_idx]
@@ -357,7 +201,7 @@ impl ObjDiff {
 
     #[inline]
     pub fn symbol_diff_mut(&mut self, symbol_ref: SymbolRef) -> &mut ObjSymbolDiff {
-        if symbol_ref.section_idx == self.sections.len() {
+        if symbol_ref.section_idx == SECTION_COMMON {
             &mut self.common[symbol_ref.symbol_idx]
         } else {
             &mut self.section_diff_mut(symbol_ref.section_idx).symbols[symbol_ref.symbol_idx]
@@ -373,12 +217,13 @@ pub struct DiffObjsResult {
 }
 
 pub fn diff_objs(
-    config: &DiffObjConfig,
+    diff_config: &DiffObjConfig,
+    mapping_config: &MappingConfig,
     left: Option<&ObjInfo>,
     right: Option<&ObjInfo>,
     prev: Option<&ObjInfo>,
 ) -> Result<DiffObjsResult> {
-    let symbol_matches = matching_symbols(left, right, prev)?;
+    let symbol_matches = matching_symbols(left, right, prev, mapping_config)?;
     let section_matches = matching_sections(left, right)?;
     let mut left = left.map(|p| (p, ObjDiff::new_from_obj(p)));
     let mut right = right.map(|p| (p, ObjDiff::new_from_obj(p)));
@@ -396,27 +241,34 @@ pub fn diff_objs(
                 let (right_obj, right_out) = right.as_mut().unwrap();
                 match section_kind {
                     ObjSectionKind::Code => {
-                        let left_code = process_code_symbol(left_obj, left_symbol_ref, config)?;
-                        let right_code = process_code_symbol(right_obj, right_symbol_ref, config)?;
+                        let left_code =
+                            process_code_symbol(left_obj, left_symbol_ref, diff_config)?;
+                        let right_code =
+                            process_code_symbol(right_obj, right_symbol_ref, diff_config)?;
                         let (left_diff, right_diff) = diff_code(
+                            left_obj,
+                            right_obj,
                             &left_code,
                             &right_code,
                             left_symbol_ref,
                             right_symbol_ref,
-                            config,
+                            diff_config,
                         )?;
                         *left_out.symbol_diff_mut(left_symbol_ref) = left_diff;
                         *right_out.symbol_diff_mut(right_symbol_ref) = right_diff;
 
                         if let Some(prev_symbol_ref) = prev_symbol_ref {
                             let (prev_obj, prev_out) = prev.as_mut().unwrap();
-                            let prev_code = process_code_symbol(prev_obj, prev_symbol_ref, config)?;
+                            let prev_code =
+                                process_code_symbol(prev_obj, prev_symbol_ref, diff_config)?;
                             let (_, prev_diff) = diff_code(
+                                left_obj,
+                                right_obj,
                                 &right_code,
                                 &prev_code,
                                 right_symbol_ref,
                                 prev_symbol_ref,
-                                config,
+                                diff_config,
                             )?;
                             *prev_out.symbol_diff_mut(prev_symbol_ref) = prev_diff;
                         }
@@ -447,7 +299,7 @@ pub fn diff_objs(
                 let (left_obj, left_out) = left.as_mut().unwrap();
                 match section_kind {
                     ObjSectionKind::Code => {
-                        let code = process_code_symbol(left_obj, left_symbol_ref, config)?;
+                        let code = process_code_symbol(left_obj, left_symbol_ref, diff_config)?;
                         *left_out.symbol_diff_mut(left_symbol_ref) =
                             no_diff_code(&code, left_symbol_ref)?;
                     }
@@ -461,7 +313,7 @@ pub fn diff_objs(
                 let (right_obj, right_out) = right.as_mut().unwrap();
                 match section_kind {
                     ObjSectionKind::Code => {
-                        let code = process_code_symbol(right_obj, right_symbol_ref, config)?;
+                        let code = process_code_symbol(right_obj, right_symbol_ref, diff_config)?;
                         *right_out.symbol_diff_mut(right_symbol_ref) =
                             no_diff_code(&code, right_symbol_ref)?;
                     }
@@ -505,6 +357,8 @@ pub fn diff_objs(
                     let left_section_diff = left_out.section_diff(left_section_idx);
                     let right_section_diff = right_out.section_diff(right_section_idx);
                     let (left_diff, right_diff) = diff_data_section(
+                        left_obj,
+                        right_obj,
                         left_section,
                         right_section,
                         left_section_diff,
@@ -529,6 +383,17 @@ pub fn diff_objs(
         }
     }
 
+    if let (Some((right_obj, right_out)), Some((left_obj, left_out))) =
+        (right.as_mut(), left.as_mut())
+    {
+        if let Some(right_name) = &mapping_config.selecting_left {
+            generate_mapping_symbols(right_obj, right_name, left_obj, left_out, diff_config)?;
+        }
+        if let Some(left_name) = &mapping_config.selecting_right {
+            generate_mapping_symbols(left_obj, left_name, right_obj, right_out, diff_config)?;
+        }
+    }
+
     Ok(DiffObjsResult {
         left: left.map(|(_, o)| o),
         right: right.map(|(_, o)| o),
@@ -536,6 +401,63 @@ pub fn diff_objs(
     })
 }
 
+/// When we're selecting a symbol to use as a comparison, we'll create comparisons for all
+/// symbols in the other object that match the selected symbol's section and kind. This allows
+/// us to display match percentages for all symbols in the other object that could be selected.
+fn generate_mapping_symbols(
+    base_obj: &ObjInfo,
+    base_name: &str,
+    target_obj: &ObjInfo,
+    target_out: &mut ObjDiff,
+    config: &DiffObjConfig,
+) -> Result<()> {
+    let Some(base_symbol_ref) = symbol_ref_by_name(base_obj, base_name) else {
+        return Ok(());
+    };
+    let (base_section, _base_symbol) = base_obj.section_symbol(base_symbol_ref);
+    let Some(base_section) = base_section else {
+        return Ok(());
+    };
+    let base_code = match base_section.kind {
+        ObjSectionKind::Code => Some(process_code_symbol(base_obj, base_symbol_ref, config)?),
+        _ => None,
+    };
+    for (target_section_index, target_section) in
+        target_obj.sections.iter().enumerate().filter(|(_, s)| s.kind == base_section.kind)
+    {
+        for (target_symbol_index, _target_symbol) in target_section.symbols.iter().enumerate() {
+            let target_symbol_ref =
+                SymbolRef { section_idx: target_section_index, symbol_idx: target_symbol_index };
+            match base_section.kind {
+                ObjSectionKind::Code => {
+                    let target_code = process_code_symbol(target_obj, target_symbol_ref, config)?;
+                    let (left_diff, _right_diff) = diff_code(
+                        target_obj,
+                        base_obj,
+                        &target_code,
+                        base_code.as_ref().unwrap(),
+                        target_symbol_ref,
+                        base_symbol_ref,
+                        config,
+                    )?;
+                    target_out.mapping_symbols.push(left_diff);
+                }
+                ObjSectionKind::Data => {
+                    let (left_diff, _right_diff) =
+                        diff_data_symbol(target_obj, base_obj, target_symbol_ref, base_symbol_ref)?;
+                    target_out.mapping_symbols.push(left_diff);
+                }
+                ObjSectionKind::Bss => {
+                    let (left_diff, _right_diff) =
+                        diff_bss_symbol(target_obj, base_obj, target_symbol_ref, base_symbol_ref)?;
+                    target_out.mapping_symbols.push(left_diff);
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
 #[derive(Copy, Clone, Eq, PartialEq)]
 struct SymbolMatch {
     left: Option<SymbolRef>,
@@ -551,19 +473,117 @@ struct SectionMatch {
     section_kind: ObjSectionKind,
 }
 
+#[derive(Debug, Clone, Default, serde::Deserialize, serde::Serialize)]
+#[cfg_attr(feature = "wasm", derive(tsify_next::Tsify), tsify(from_wasm_abi))]
+#[serde(default)]
+pub struct MappingConfig {
+    /// Manual symbol mappings
+    pub mappings: SymbolMappings,
+    /// The right object symbol name that we're selecting a left symbol for
+    pub selecting_left: Option<String>,
+    /// The left object symbol name that we're selecting a right symbol for
+    pub selecting_right: Option<String>,
+}
+
+fn symbol_ref_by_name(obj: &ObjInfo, name: &str) -> Option<SymbolRef> {
+    for (section_idx, section) in obj.sections.iter().enumerate() {
+        for (symbol_idx, symbol) in section.symbols.iter().enumerate() {
+            if symbol.name == name {
+                return Some(SymbolRef { section_idx, symbol_idx });
+            }
+        }
+    }
+    None
+}
+
+fn apply_symbol_mappings(
+    left: &ObjInfo,
+    right: &ObjInfo,
+    mapping_config: &MappingConfig,
+    left_used: &mut HashSet<SymbolRef>,
+    right_used: &mut HashSet<SymbolRef>,
+    matches: &mut Vec<SymbolMatch>,
+) -> Result<()> {
+    // If we're selecting a symbol to use as a comparison, mark it as used
+    // This ensures that we don't match it to another symbol at any point
+    if let Some(left_name) = &mapping_config.selecting_left {
+        if let Some(left_symbol) = symbol_ref_by_name(left, left_name) {
+            left_used.insert(left_symbol);
+        }
+    }
+    if let Some(right_name) = &mapping_config.selecting_right {
+        if let Some(right_symbol) = symbol_ref_by_name(right, right_name) {
+            right_used.insert(right_symbol);
+        }
+    }
+
+    // Apply manual symbol mappings
+    for (left_name, right_name) in &mapping_config.mappings {
+        let Some(left_symbol) = symbol_ref_by_name(left, left_name) else {
+            continue;
+        };
+        if left_used.contains(&left_symbol) {
+            continue;
+        }
+        let Some(right_symbol) = symbol_ref_by_name(right, right_name) else {
+            continue;
+        };
+        if right_used.contains(&right_symbol) {
+            continue;
+        }
+        let left_section = &left.sections[left_symbol.section_idx];
+        let right_section = &right.sections[right_symbol.section_idx];
+        if left_section.kind != right_section.kind {
+            log::warn!(
+                "Symbol section kind mismatch: {} ({:?}) vs {} ({:?})",
+                left_name,
+                left_section.kind,
+                right_name,
+                right_section.kind
+            );
+            continue;
+        }
+        matches.push(SymbolMatch {
+            left: Some(left_symbol),
+            right: Some(right_symbol),
+            prev: None, // TODO
+            section_kind: left_section.kind,
+        });
+        left_used.insert(left_symbol);
+        right_used.insert(right_symbol);
+    }
+    Ok(())
+}
+
 /// Find matching symbols between each object.
 fn matching_symbols(
     left: Option<&ObjInfo>,
     right: Option<&ObjInfo>,
     prev: Option<&ObjInfo>,
+    mappings: &MappingConfig,
 ) -> Result<Vec<SymbolMatch>> {
     let mut matches = Vec::new();
+    let mut left_used = HashSet::new();
     let mut right_used = HashSet::new();
     if let Some(left) = left {
+        if let Some(right) = right {
+            apply_symbol_mappings(
+                left,
+                right,
+                mappings,
+                &mut left_used,
+                &mut right_used,
+                &mut matches,
+            )?;
+        }
         for (section_idx, section) in left.sections.iter().enumerate() {
             for (symbol_idx, symbol) in section.symbols.iter().enumerate() {
+                let symbol_ref = SymbolRef { section_idx, symbol_idx };
+                if left_used.contains(&symbol_ref) {
+                    continue;
+                }
                 let symbol_match = SymbolMatch {
-                    left: Some(SymbolRef { section_idx, symbol_idx }),
+                    left: Some(symbol_ref),
                     right: find_symbol(right, symbol, section, Some(&right_used)),
                     prev: find_symbol(prev, symbol, section, None),
                     section_kind: section.kind,
@@ -575,8 +595,12 @@ fn matching_symbols(
             }
         }
         for (symbol_idx, symbol) in left.common.iter().enumerate() {
+            let symbol_ref = SymbolRef { section_idx: SECTION_COMMON, symbol_idx };
+            if left_used.contains(&symbol_ref) {
+                continue;
+            }
             let symbol_match = SymbolMatch {
-                left: Some(SymbolRef { section_idx: left.sections.len(), symbol_idx }),
+                left: Some(symbol_ref),
                 right: find_common_symbol(right, symbol),
                 prev: find_common_symbol(prev, symbol),
                 section_kind: ObjSectionKind::Bss,
@@ -603,7 +627,7 @@ fn matching_symbols(
             }
         }
         for (symbol_idx, symbol) in right.common.iter().enumerate() {
-            let symbol_ref = SymbolRef { section_idx: right.sections.len(), symbol_idx };
+            let symbol_ref = SymbolRef { section_idx: SECTION_COMMON, symbol_idx };
             if right_used.contains(&symbol_ref) {
                 continue;
             }
@@ -696,7 +720,7 @@ fn find_common_symbol(obj: Option<&ObjInfo>, in_symbol: &ObjSymbol) -> Option<Sy
     let obj = obj?;
     for (symbol_idx, symbol) in obj.common.iter().enumerate() {
         if symbol.name == in_symbol.name {
-            return Some(SymbolRef { section_idx: obj.sections.len(), symbol_idx });
+            return Some(SymbolRef { section_idx: SECTION_COMMON, symbol_idx });
         }
     }
     None

objdiff-core/src/jobs/check_update.rs

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

objdiff-core/src/jobs/create_scratch.rs

@@ -1,14 +1,10 @@
-use std::{fs, path::PathBuf, sync::mpsc::Receiver};
+use std::{fs, path::PathBuf, sync::mpsc::Receiver, task::Waker};
 
 use anyhow::{anyhow, bail, Context, Result};
-use const_format::formatcp;
 
 use crate::{
-    app::AppConfig,
-    jobs::{
-        objdiff::{run_make, BuildConfig, BuildStatus},
-        start_job, update_status, Job, JobContext, JobResult, JobState,
-    },
+    build::{run_make, BuildConfig, BuildStatus},
+    jobs::{start_job, update_status, Job, JobContext, JobResult, JobState},
 };
 
 #[derive(Debug, Clone)]
@@ -23,37 +19,7 @@ pub struct CreateScratchConfig {
     pub compiler_flags: String,
     pub function_name: String,
     pub target_obj: PathBuf,
-}
-
-impl CreateScratchConfig {
-    pub(crate) fn from_config(config: &AppConfig, function_name: String) -> Result<Self> {
-        let Some(selected_obj) = &config.selected_obj else {
-            bail!("No object selected");
-        };
-        let Some(target_path) = &selected_obj.target_path else {
-            bail!("No target path for {}", selected_obj.name);
-        };
-        let Some(scratch_config) = &selected_obj.scratch else {
-            bail!("No scratch configuration for {}", selected_obj.name);
-        };
-        Ok(Self {
-            build_config: BuildConfig::from_config(config),
-            context_path: scratch_config.ctx_path.clone(),
-            build_context: scratch_config.build_ctx,
-            compiler: scratch_config.compiler.clone().unwrap_or_default(),
-            platform: scratch_config.platform.clone().unwrap_or_default(),
-            compiler_flags: scratch_config.c_flags.clone().unwrap_or_default(),
-            function_name,
-            target_obj: target_path.to_path_buf(),
-        })
-    }
-
-    pub fn is_available(config: &AppConfig) -> bool {
-        let Some(selected_obj) = &config.selected_obj else {
-            return false;
-        };
-        selected_obj.target_path.is_some() && selected_obj.scratch.is_some()
-    }
+    pub preset_id: Option<u32>,
 }
 
 #[derive(Default, Debug, Clone)]
@@ -97,22 +63,25 @@ fn run_create_scratch(
 
     update_status(status, "Creating scratch".to_string(), 1, 2, &cancel)?;
     let diff_flags = [format!("--disassemble={}", config.function_name)];
-    let diff_flags = serde_json::to_string(&diff_flags).unwrap();
+    let diff_flags = serde_json::to_string(&diff_flags)?;
     let obj_path = project_dir.join(&config.target_obj);
     let file = reqwest::blocking::multipart::Part::file(&obj_path)
         .with_context(|| format!("Failed to open {}", obj_path.display()))?;
-    let form = reqwest::blocking::multipart::Form::new()
+    let mut form = reqwest::blocking::multipart::Form::new()
         .text("compiler", config.compiler.clone())
         .text("platform", config.platform.clone())
         .text("compiler_flags", config.compiler_flags.clone())
         .text("diff_label", config.function_name.clone())
         .text("diff_flags", diff_flags)
         .text("context", context.unwrap_or_default())
-        .text("source_code", "// Move related code from Context tab to here")
-        .part("target_obj", file);
+        .text("source_code", "// Move related code from Context tab to here");
+    if let Some(preset) = config.preset_id {
+        form = form.text("preset", preset.to_string());
+    }
+    form = form.part("target_obj", file);
     let client = reqwest::blocking::Client::new();
     let response = client
-        .post(formatcp!("{API_HOST}/api/scratch"))
+        .post(format!("{API_HOST}/api/scratch"))
         .multipart(form)
         .send()
         .map_err(|e| anyhow!("Failed to send request: {}", e))?;
@@ -126,8 +95,8 @@ fn run_create_scratch(
     Ok(Box::from(CreateScratchResult { scratch_url }))
 }
 
-pub fn start_create_scratch(ctx: &egui::Context, config: CreateScratchConfig) -> JobState {
-    start_job(ctx, "Create scratch", Job::CreateScratch, move |context, cancel| {
+pub fn start_create_scratch(waker: Waker, config: CreateScratchConfig) -> JobState {
+    start_job(waker, "Create scratch", Job::CreateScratch, move |context, cancel| {
         run_create_scratch(&context, cancel, config)
             .map(|result| JobResult::CreateScratch(Some(result)))
     })

objdiff-core/src/jobs/mod.rs

@@ -4,6 +4,7 @@ use std::{
         mpsc::{Receiver, Sender, TryRecvError},
         Arc, RwLock,
     },
+    task::Waker,
     thread::JoinHandle,
 };
 
@@ -53,7 +54,6 @@ impl JobQueue {
     }
 
     /// Returns whether any job is running.
-    #[allow(dead_code)]
     pub fn any_running(&self) -> bool {
         self.jobs.iter().any(|job| {
             if let Some(handle) = &job.handle {
@@ -96,12 +96,53 @@ impl JobQueue {
 
     /// Removes a job from the queue given its ID.
     pub fn remove(&mut self, id: usize) { self.jobs.retain(|job| job.id != id); }
+
+    /// Collects the results of all finished jobs and handles any errors.
+    pub fn collect_results(&mut self) {
+        let mut results = vec![];
+        for (job, result) in self.iter_finished() {
+            match result {
+                Ok(result) => {
+                    match result {
+                        JobResult::None => {
+                            // Job context contains the error
+                        }
+                        _ => results.push(result),
+                    }
+                }
+                Err(err) => {
+                    let err = if let Some(msg) = err.downcast_ref::<&'static str>() {
+                        anyhow::Error::msg(*msg)
+                    } else if let Some(msg) = err.downcast_ref::<String>() {
+                        anyhow::Error::msg(msg.clone())
+                    } else {
+                        anyhow::Error::msg("Thread panicked")
+                    };
+                    let result = job.context.status.write();
+                    if let Ok(mut guard) = result {
+                        guard.error = Some(err);
+                    } else {
+                        drop(result);
+                        job.context.status = Arc::new(RwLock::new(JobStatus {
+                            title: "Error".to_string(),
+                            progress_percent: 0.0,
+                            progress_items: None,
+                            status: String::new(),
+                            error: Some(err),
+                        }));
+                    }
+                }
+            }
+        }
+        self.results.append(&mut results);
+        self.clear_finished();
+    }
 }
 
 #[derive(Clone)]
 pub struct JobContext {
     pub status: Arc<RwLock<JobStatus>>,
-    pub egui: egui::Context,
+    pub waker: Waker,
 }
 
 pub struct JobState {
@@ -137,7 +178,7 @@ fn should_cancel(rx: &Receiver<()>) -> bool {
 }
 
 fn start_job(
-    ctx: &egui::Context,
+    waker: Waker,
     title: &str,
     kind: Job,
     run: impl FnOnce(JobContext, Receiver<()>) -> Result<JobResult> + Send + 'static,
@@ -149,22 +190,20 @@ fn start_job(
         status: String::new(),
         error: None,
     }));
-    let context = JobContext { status: status.clone(), egui: ctx.clone() };
-    let context_inner = JobContext { status: status.clone(), egui: ctx.clone() };
+    let context = JobContext { status: status.clone(), waker: waker.clone() };
+    let context_inner = JobContext { status: status.clone(), waker };
     let (tx, rx) = std::sync::mpsc::channel();
-    let handle = std::thread::spawn(move || {
-        return match run(context_inner, rx) {
-            Ok(state) => state,
-            Err(e) => {
-                if let Ok(mut w) = status.write() {
-                    w.error = Some(e);
-                }
-                JobResult::None
+    let handle = std::thread::spawn(move || match run(context_inner, rx) {
+        Ok(state) => state,
+        Err(e) => {
+            if let Ok(mut w) = status.write() {
+                w.error = Some(e);
             }
-        };
+            JobResult::None
+        }
     });
     let id = JOB_ID.fetch_add(1, Ordering::Relaxed);
-    log::info!("Started job {}", id);
+    // log::info!("Started job {}", id); TODO
     JobState { id, kind, handle: Some(handle), context, cancel: tx }
 }
 
@@ -186,6 +225,6 @@ fn update_status(
         w.status = str;
     }
     drop(w);
-    context.egui.request_repaint();
+    context.waker.wake_by_ref();
     Ok(())
 }

objdiff-core/src/jobs/objdiff.rs

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

objdiff-core/src/jobs/update.rs

@@ -3,14 +3,19 @@ use std::{
     fs::File,
     path::PathBuf,
     sync::mpsc::Receiver,
+    task::Waker,
 };
 
 use anyhow::{Context, Result};
+pub use self_update; // Re-export self_update crate
+use self_update::update::ReleaseUpdate;
 
-use crate::{
-    jobs::{start_job, update_status, Job, JobContext, JobResult, JobState},
-    update::build_updater,
-};
+use crate::jobs::{start_job, update_status, Job, JobContext, JobResult, JobState};
+
+pub struct UpdateConfig {
+    pub build_updater: fn() -> Result<Box<dyn ReleaseUpdate>>,
+    pub bin_name: String,
+}
 
 pub struct UpdateResult {
     pub exe_path: PathBuf,
@@ -19,16 +24,15 @@ pub struct UpdateResult {
 fn run_update(
     status: &JobContext,
     cancel: Receiver<()>,
-    bin_name: String,
+    config: UpdateConfig,
 ) -> Result<Box<UpdateResult>> {
     update_status(status, "Fetching latest release".to_string(), 0, 3, &cancel)?;
-    let updater = build_updater().context("Failed to create release updater")?;
+    let updater = (config.build_updater)().context("Failed to create release updater")?;
     let latest_release = updater.get_latest_release()?;
-    let asset = latest_release
-        .assets
-        .iter()
-        .find(|a| a.name == bin_name)
-        .ok_or_else(|| anyhow::Error::msg(format!("No release asset for {bin_name}")))?;
+    let asset =
+        latest_release.assets.iter().find(|a| a.name == config.bin_name).ok_or_else(|| {
+            anyhow::Error::msg(format!("No release asset for {}", config.bin_name))
+        })?;
 
     update_status(status, "Downloading release".to_string(), 1, 3, &cancel)?;
     let tmp_dir = tempfile::Builder::new().prefix("update").tempdir_in(current_dir()?)?;
@@ -47,9 +51,7 @@ fn run_update(
     #[cfg(unix)]
     {
         use std::{fs, os::unix::fs::PermissionsExt};
-        let mut perms = fs::metadata(&target_file)?.permissions();
-        perms.set_mode(0o755);
-        fs::set_permissions(&target_file, perms)?;
+        fs::set_permissions(&target_file, fs::Permissions::from_mode(0o755))?;
     }
     tmp_dir.close()?;
 
@@ -57,8 +59,8 @@ fn run_update(
     Ok(Box::from(UpdateResult { exe_path: target_file }))
 }
 
-pub fn start_update(ctx: &egui::Context, bin_name: String) -> JobState {
-    start_job(ctx, "Update app", Job::Update, move |context, cancel| {
-        run_update(&context, cancel, bin_name).map(JobResult::Update)
+pub fn start_update(waker: Waker, config: UpdateConfig) -> JobState {
+    start_job(waker, "Update app", Job::Update, move |context, cancel| {
+        run_update(&context, cancel, config).map(JobResult::Update)
     })
 }

objdiff-core/src/lib.rs

@@ -2,10 +2,15 @@
 pub mod arch;
 #[cfg(feature = "bindings")]
 pub mod bindings;
+#[cfg(feature = "build")]
+pub mod build;
 #[cfg(feature = "config")]
 pub mod config;
 #[cfg(feature = "any-arch")]
 pub mod diff;
+#[cfg(feature = "build")]
+pub mod jobs;
 #[cfg(feature = "any-arch")]
 pub mod obj;
+#[cfg(feature = "any-arch")]
 pub mod util;

objdiff-core/src/obj/mod.rs

@@ -28,7 +28,7 @@ flags! {
         HasExtra,
     }
 }
-#[derive(Debug, Copy, Clone, Default)]
+#[derive(Debug, Copy, Clone, Default, PartialEq)]
 pub struct ObjSymbolFlagSet(pub FlagSet<ObjSymbolFlags>);
 
 #[derive(Debug, Clone)]
@@ -85,6 +85,9 @@ pub enum ObjInsArg {
 }
 
 impl ObjInsArg {
+    #[inline]
+    pub fn is_plain_text(&self) -> bool { matches!(self, ObjInsArg::PlainText(_)) }
+
     pub fn loose_eq(&self, other: &ObjInsArg) -> bool {
         match (self, other) {
             (ObjInsArg::Arg(a), ObjInsArg::Arg(b)) => a.loose_eq(b),
@@ -100,7 +103,7 @@ pub struct ObjIns {
     pub address: u64,
     pub size: u8,
     pub op: u16,
-    pub mnemonic: String,
+    pub mnemonic: Cow<'static, str>,
     pub args: Vec<ObjInsArg>,
     pub reloc: Option<ObjReloc>,
     pub branch_dest: Option<u64>,
@@ -112,7 +115,24 @@ pub struct ObjIns {
     pub orig: Option<String>,
 }
 
-#[derive(Debug, Clone)]
+impl ObjIns {
+    /// Iterate over non-PlainText arguments.
+    #[inline]
+    pub fn iter_args(&self) -> impl DoubleEndedIterator<Item = &ObjInsArg> {
+        self.args.iter().filter(|a| !a.is_plain_text())
+    }
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
+pub enum ObjSymbolKind {
+    #[default]
+    Unknown,
+    Function,
+    Object,
+    Section,
+}
+
+#[derive(Debug, Clone, PartialEq)]
 pub struct ObjSymbol {
     pub name: String,
     pub demangled_name: Option<String>,
@@ -120,8 +140,9 @@ pub struct ObjSymbol {
     pub section_address: u64,
     pub size: u64,
     pub size_known: bool,
+    pub kind: ObjSymbolKind,
     pub flags: ObjSymbolFlagSet,
-    pub addend: i64,
+    pub orig_section_index: Option<usize>,
     /// Original virtual address (from .note.split section)
     pub virtual_address: Option<u64>,
     /// Original index in object symbol table
@@ -140,12 +161,12 @@ pub struct ObjInfo {
     pub split_meta: Option<SplitMeta>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct ObjReloc {
     pub flags: RelocationFlags,
     pub address: u64,
     pub target: ObjSymbol,
-    pub target_section: Option<String>,
+    pub addend: i64,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
@@ -154,9 +175,11 @@ pub struct SymbolRef {
     pub symbol_idx: usize,
 }
 
+pub const SECTION_COMMON: usize = usize::MAX - 1;
+
 impl ObjInfo {
     pub fn section_symbol(&self, symbol_ref: SymbolRef) -> (Option<&ObjSection>, &ObjSymbol) {
-        if symbol_ref.section_idx == self.sections.len() {
+        if symbol_ref.section_idx == SECTION_COMMON {
             let symbol = &self.common[symbol_ref.symbol_idx];
             return (None, symbol);
         }

objdiff-core/src/obj/read.rs

@@ -13,8 +13,8 @@ use object::{
     endian::LittleEndian as LE,
     pe::{ImageAuxSymbolFunctionBeginEnd, ImageLinenumber},
     read::coff::{CoffFile, CoffHeader, ImageSymbol},
-    BinaryFormat, File, Object, ObjectSection, ObjectSymbol, RelocationTarget, SectionIndex,
-    SectionKind, Symbol, SymbolIndex, SymbolKind, SymbolScope, SymbolSection,
+    BinaryFormat, File, Object, ObjectSection, ObjectSymbol, RelocationTarget, Section,
+    SectionIndex, SectionKind, Symbol, SymbolIndex, SymbolKind, SymbolScope,
 };
 
 use crate::{
@@ -23,6 +23,7 @@ use crate::{
     obj::{
         split_meta::{SplitMeta, SPLITMETA_SECTION},
         ObjInfo, ObjReloc, ObjSection, ObjSectionKind, ObjSymbol, ObjSymbolFlagSet, ObjSymbolFlags,
+        ObjSymbolKind,
     },
     util::{read_u16, read_u32},
 };
@@ -40,7 +41,6 @@ fn to_obj_symbol(
     arch: &dyn ObjArch,
     obj_file: &File<'_>,
     symbol: &Symbol<'_, '_>,
-    addend: i64,
     split_meta: Option<&SplitMeta>,
 ) -> Result<ObjSymbol> {
     let mut name = symbol.name().context("Failed to process symbol name")?;
@@ -64,10 +64,8 @@ fn to_obj_symbol(
     if obj_file.format() == BinaryFormat::Elf && symbol.scope() == SymbolScope::Linkage {
         flags = ObjSymbolFlagSet(flags.0 | ObjSymbolFlags::Hidden);
     }
-    if arch
-        .ppc()
-        .and_then(|a| a.extab.as_ref())
-        .map_or(false, |e| e.contains_key(&symbol.index().0))
+    #[cfg(feature = "ppc")]
+    if arch.ppc().and_then(|a| a.extab.as_ref()).is_some_and(|e| e.contains_key(&symbol.index().0))
     {
         flags = ObjSymbolFlagSet(flags.0 | ObjSymbolFlags::HasExtra);
     }
@@ -94,6 +92,13 @@ fn to_obj_symbol(
         })
         .unwrap_or(&[]);
 
+    let kind = match symbol.kind() {
+        SymbolKind::Text => ObjSymbolKind::Function,
+        SymbolKind::Data => ObjSymbolKind::Object,
+        SymbolKind::Section => ObjSymbolKind::Section,
+        _ => ObjSymbolKind::Unknown,
+    };
+
     Ok(ObjSymbol {
         name: name.to_string(),
         demangled_name,
@@ -101,8 +106,9 @@ fn to_obj_symbol(
         section_address,
         size: symbol.size(),
         size_known: symbol.size() != 0,
+        kind,
         flags,
-        addend,
+        orig_section_index: symbol.section_index().map(|i| i.0),
         virtual_address,
         original_index: Some(symbol.index().0),
         bytes: bytes.to_vec(),
@@ -152,26 +158,23 @@ fn symbols_by_section(
     arch: &dyn ObjArch,
     obj_file: &File<'_>,
     section: &ObjSection,
+    section_symbols: &[Symbol<'_, '_>],
     split_meta: Option<&SplitMeta>,
     name_counts: &mut HashMap<String, u32>,
 ) -> Result<Vec<ObjSymbol>> {
     let mut result = Vec::<ObjSymbol>::new();
-    for symbol in obj_file.symbols() {
+    for symbol in section_symbols {
         if symbol.kind() == SymbolKind::Section {
             continue;
         }
-        if let Some(index) = symbol.section().index() {
-            if index.0 == section.orig_index {
-                if symbol.is_local() && section.kind == ObjSectionKind::Code {
-                    // TODO strip local syms in diff?
-                    let name = symbol.name().context("Failed to process symbol name")?;
-                    if symbol.size() == 0 || name.starts_with("lbl_") {
-                        continue;
-                    }
-                }
-                result.push(to_obj_symbol(arch, obj_file, &symbol, 0, split_meta)?);
+        if symbol.is_local() && section.kind == ObjSectionKind::Code {
+            // TODO strip local syms in diff?
+            let name = symbol.name().context("Failed to process symbol name")?;
+            if symbol.size() == 0 || name.starts_with("lbl_") {
+                continue;
             }
         }
+        result.push(to_obj_symbol(arch, obj_file, symbol, split_meta)?);
     }
     result.sort_by(|a, b| a.address.cmp(&b.address).then(a.size.cmp(&b.size)));
     let mut iter = result.iter_mut().peekable();
@@ -182,6 +185,13 @@ fn symbols_by_section(
             } else {
                 symbol.size = (section.address + section.size) - symbol.address;
             }
+            // Set symbol kind if we ended up with a non-zero size
+            if symbol.kind == ObjSymbolKind::Unknown && symbol.size > 0 {
+                symbol.kind = match section.kind {
+                    ObjSectionKind::Code => ObjSymbolKind::Function,
+                    ObjSectionKind::Data | ObjSectionKind::Bss => ObjSymbolKind::Object,
+                };
+            }
         }
     }
     if result.is_empty() {
@@ -199,8 +209,12 @@ fn symbols_by_section(
             section_address: 0,
             size: section.size,
             size_known: true,
+            kind: match section.kind {
+                ObjSectionKind::Code => ObjSymbolKind::Function,
+                ObjSectionKind::Data | ObjSectionKind::Bss => ObjSymbolKind::Object,
+            },
             flags: Default::default(),
-            addend: 0,
+            orig_section_index: Some(section.orig_index),
             virtual_address: None,
             original_index: None,
             bytes: Vec::new(),
@@ -217,51 +231,75 @@ fn common_symbols(
     obj_file
         .symbols()
         .filter(Symbol::is_common)
-        .map(|symbol| to_obj_symbol(arch, obj_file, &symbol, 0, split_meta))
+        .map(|symbol| to_obj_symbol(arch, obj_file, &symbol, split_meta))
         .collect::<Result<Vec<ObjSymbol>>>()
 }
 
+const LOW_PRIORITY_SYMBOLS: &[&str] =
+    &["__gnu_compiled_c", "__gnu_compiled_cplusplus", "gcc2_compiled."];
+
+fn best_symbol<'r, 'data, 'file>(
+    symbols: &'r [Symbol<'data, 'file>],
+    address: u64,
+) -> Option<&'r Symbol<'data, 'file>> {
+    let mut closest_symbol_index = match symbols.binary_search_by_key(&address, |s| s.address()) {
+        Ok(index) => Some(index),
+        Err(index) => index.checked_sub(1),
+    }?;
+    // The binary search may not find the first symbol at the address, so work backwards
+    let target_address = symbols[closest_symbol_index].address();
+    while let Some(prev_index) = closest_symbol_index.checked_sub(1) {
+        if symbols[prev_index].address() != target_address {
+            break;
+        }
+        closest_symbol_index = prev_index;
+    }
+    let mut best_symbol: Option<&'r Symbol<'data, 'file>> = None;
+    for symbol in symbols.iter().skip(closest_symbol_index) {
+        if symbol.address() > address {
+            break;
+        }
+        if symbol.kind() == SymbolKind::Section
+            || (symbol.size() > 0 && (symbol.address() + symbol.size()) <= address)
+        {
+            continue;
+        }
+        // TODO priority ranking with visibility, etc
+        if let Some(best) = best_symbol {
+            if LOW_PRIORITY_SYMBOLS.contains(&best.name().unwrap_or_default())
+                && !LOW_PRIORITY_SYMBOLS.contains(&symbol.name().unwrap_or_default())
+            {
+                best_symbol = Some(symbol);
+            }
+        } else {
+            best_symbol = Some(symbol);
+        }
+    }
+    best_symbol
+}
+
 fn find_section_symbol(
     arch: &dyn ObjArch,
     obj_file: &File<'_>,
-    target: &Symbol<'_, '_>,
+    section: &Section,
+    section_symbols: &[Symbol<'_, '_>],
     address: u64,
     split_meta: Option<&SplitMeta>,
 ) -> Result<ObjSymbol> {
-    let section_index =
-        target.section_index().ok_or_else(|| anyhow::Error::msg("Unknown section index"))?;
-    let section = obj_file.section_by_index(section_index)?;
-    let mut closest_symbol: Option<Symbol<'_, '_>> = None;
-    for symbol in obj_file.symbols() {
-        if !matches!(symbol.section_index(), Some(idx) if idx == section_index) {
-            continue;
-        }
-        if symbol.kind() == SymbolKind::Section || symbol.address() != address {
-            if symbol.address() < address
-                && symbol.size() != 0
-                && (closest_symbol.is_none()
-                    || matches!(&closest_symbol, Some(s) if s.address() <= symbol.address()))
-            {
-                closest_symbol = Some(symbol);
-            }
-            continue;
-        }
-        return to_obj_symbol(arch, obj_file, &symbol, 0, split_meta);
+    if let Some(symbol) = best_symbol(section_symbols, address) {
+        return to_obj_symbol(arch, obj_file, symbol, split_meta);
     }
-    let (name, offset) = closest_symbol
-        .and_then(|s| s.name().map(|n| (n, s.address())).ok())
-        .or_else(|| section.name().map(|n| (n, section.address())).ok())
-        .unwrap_or(("<unknown>", 0));
-    let offset_addr = address - offset;
+    // Fallback to section symbol
     Ok(ObjSymbol {
-        name: name.to_string(),
+        name: section.name()?.to_string(),
         demangled_name: None,
-        address: offset,
-        section_address: address - section.address(),
+        address: section.address(),
+        section_address: 0,
         size: 0,
         size_known: false,
+        kind: ObjSymbolKind::Section,
         flags: Default::default(),
-        addend: offset_addr as i64,
+        orig_section_index: Some(section.index().0),
         virtual_address: None,
         original_index: None,
         bytes: Vec::new(),
@@ -272,6 +310,7 @@ fn relocations_by_section(
     arch: &dyn ObjArch,
     obj_file: &File<'_>,
     section: &ObjSection,
+    section_symbols: &[Vec<Symbol<'_, '_>>],
     split_meta: Option<&SplitMeta>,
 ) -> Result<Vec<ObjReloc>> {
     let obj_section = obj_file.section_by_index(SectionIndex(section.orig_index))?;
@@ -293,33 +332,43 @@ fn relocations_by_section(
                 };
                 symbol
             }
+            RelocationTarget::Absolute => {
+                log::warn!("Ignoring absolute relocation @ {}:{:#x}", section.name, address);
+                continue;
+            }
             _ => bail!("Unhandled relocation target: {:?}", reloc.target()),
         };
         let flags = reloc.flags(); // TODO validate reloc here?
-        let target_section = match symbol.section() {
-            SymbolSection::Common => Some(".comm".to_string()),
-            SymbolSection::Section(idx) => {
-                obj_file.section_by_index(idx).and_then(|s| s.name().map(|s| s.to_string())).ok()
-            }
-            _ => None,
-        };
-        let addend = if reloc.has_implicit_addend() {
+        let mut addend = if reloc.has_implicit_addend() {
             arch.implcit_addend(obj_file, section, address, &reloc)?
         } else {
             reloc.addend()
         };
-        // println!("Reloc: {reloc:?}, symbol: {symbol:?}, addend: {addend:#x}");
         let target = match symbol.kind() {
             SymbolKind::Text | SymbolKind::Data | SymbolKind::Label | SymbolKind::Unknown => {
-                to_obj_symbol(arch, obj_file, &symbol, addend, split_meta)
+                to_obj_symbol(arch, obj_file, &symbol, split_meta)?
             }
             SymbolKind::Section => {
-                ensure!(addend >= 0, "Negative addend in reloc: {addend}");
-                find_section_symbol(arch, obj_file, &symbol, addend as u64, split_meta)
+                ensure!(addend >= 0, "Negative addend in section reloc: {addend}");
+                let section_index = symbol
+                    .section_index()
+                    .ok_or_else(|| anyhow!("Section symbol {symbol:?} has no section index"))?;
+                let section = obj_file.section_by_index(section_index)?;
+                let symbol = find_section_symbol(
+                    arch,
+                    obj_file,
+                    &section,
+                    &section_symbols[section_index.0],
+                    addend as u64,
+                    split_meta,
+                )?;
+                // Adjust addend to be relative to the selected symbol
+                addend = (symbol.address - section.address()) as i64;
+                symbol
             }
-            kind => Err(anyhow!("Unhandled relocation symbol type {kind:?}")),
-        }?;
-        relocations.push(ObjReloc { flags, address, target, target_section });
+            kind => bail!("Unhandled relocation symbol type {kind:?}"),
+        };
+        relocations.push(ObjReloc { flags, address, target, addend });
     }
     Ok(relocations)
 }
@@ -384,9 +433,9 @@ fn line_info(obj_file: &File<'_>, sections: &mut [ObjSection], obj_data: &[u8])
                 let mut text_sections =
                     obj_file.sections().filter(|s| s.kind() == SectionKind::Text);
                 let section_index = text_sections.next().map(|s| s.index().0);
-                let mut lines = section_index.map(|index| {
-                    &mut sections.iter_mut().find(|s| s.orig_index == index).unwrap().line_info
-                });
+                let mut lines = section_index
+                    .and_then(|index| sections.iter_mut().find(|s| s.orig_index == index))
+                    .map(|s| &mut s.line_info);
 
                 let mut rows = program.rows();
                 while let Some((_header, row)) = rows.next_row()? {
@@ -397,13 +446,9 @@ fn line_info(obj_file: &File<'_>, sections: &mut [ObjSection], obj_data: &[u8])
                         // The next row is the start of a new sequence, which means we must
                         // advance to the next .text section.
                         let section_index = text_sections.next().map(|s| s.index().0);
-                        lines = section_index.map(|index| {
-                            &mut sections
-                                .iter_mut()
-                                .find(|s| s.orig_index == index)
-                                .unwrap()
-                                .line_info
-                        });
+                        lines = section_index
+                            .and_then(|index| sections.iter_mut().find(|s| s.orig_index == index))
+                            .map(|s| &mut s.line_info);
                     }
                 }
             }
@@ -539,8 +584,9 @@ fn update_combined_symbol(symbol: ObjSymbol, address_change: i64) -> Result<ObjS
         section_address: (symbol.section_address as i64 + address_change).try_into()?,
         size: symbol.size,
         size_known: symbol.size_known,
+        kind: symbol.kind,
         flags: symbol.flags,
-        addend: symbol.addend,
+        orig_section_index: symbol.orig_section_index,
         virtual_address: if let Some(virtual_address) = symbol.virtual_address {
             Some((virtual_address as i64 + address_change).try_into()?)
         } else {
@@ -566,8 +612,8 @@ fn combine_sections(section: ObjSection, combine: ObjSection) -> Result<ObjSecti
         relocations.push(ObjReloc {
             flags: reloc.flags,
             address: (reloc.address as i64 + address_change).try_into()?,
-            target: reloc.target,                 // TODO: Should be updated?
-            target_section: reloc.target_section, // TODO: Same as above
+            target: reloc.target, // TODO: Should be updated?
+            addend: reloc.addend,
         });
     }
 
@@ -647,18 +693,40 @@ pub fn parse(data: &[u8], config: &DiffObjConfig) -> Result<ObjInfo> {
     let obj_file = File::parse(data)?;
     let arch = new_arch(&obj_file)?;
     let split_meta = split_meta(&obj_file)?;
+
+    // Create sorted symbol list for each section
+    let mut section_symbols = Vec::with_capacity(obj_file.sections().count());
+    for section in obj_file.sections() {
+        let mut symbols = obj_file
+            .symbols()
+            .filter(|s| s.section_index() == Some(section.index()))
+            .collect::<Vec<_>>();
+        symbols.sort_by_key(|s| s.address());
+        let section_index = section.index().0;
+        if section_index >= section_symbols.len() {
+            section_symbols.resize_with(section_index + 1, Vec::new);
+        }
+        section_symbols[section_index] = symbols;
+    }
+
     let mut sections = filter_sections(&obj_file, split_meta.as_ref())?;
-    let mut name_counts: HashMap<String, u32> = HashMap::new();
+    let mut section_name_counts: HashMap<String, u32> = HashMap::new();
     for section in &mut sections {
         section.symbols = symbols_by_section(
             arch.as_ref(),
             &obj_file,
             section,
+            &section_symbols[section.orig_index],
+            split_meta.as_ref(),
+            &mut section_name_counts,
+        )?;
+        section.relocations = relocations_by_section(
+            arch.as_ref(),
+            &obj_file,
+            section,
+            &section_symbols,
             split_meta.as_ref(),
-            &mut name_counts,
         )?;
-        section.relocations =
-            relocations_by_section(arch.as_ref(), &obj_file, section, split_meta.as_ref())?;
     }
     if config.combine_data_sections {
         combine_data_sections(&mut sections)?;

objdiff-gui/Cargo.toml

@@ -25,24 +25,23 @@ wsl = []
 
 [dependencies]
 anyhow = "1.0"
-bytes = "1.7"
+bytes = "1.9"
 cfg-if = "1.0"
 const_format = "0.2"
 cwdemangle = "1.0"
-cwextab = "1.0.2"
+cwextab = "1.0"
 dirs = "5.0"
-egui = "0.29"
-egui_extras = "0.29"
+egui = "0.30"
+egui_extras = "0.30"
 filetime = "0.2"
 float-ord = "0.3"
 font-kit = "0.14"
 globset = { version = "0.4", features = ["serde1"] }
 log = "0.4"
-notify = { git = "https://github.com/notify-rs/notify", rev = "128bf6230c03d39dbb7f301ff7b20e594e34c3a2" }
 objdiff-core = { path = "../objdiff-core", features = ["all"] }
 open = "5.3"
 png = "0.17"
-pollster = "0.3"
+pollster = "0.4"
 regex = "1.11"
 rfd = { version = "0.15" } #, default-features = false, features = ['xdg-portal']
 rlwinmdec = "1.0"
@@ -51,12 +50,11 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 shell-escape = "0.1"
 strum = { version = "0.26", features = ["derive"] }
-tempfile = "3.13"
 time = { version = "0.3", features = ["formatting", "local-offset"] }
 
 # Keep version in sync with egui
 [dependencies.eframe]
-version = "0.29"
+version = "0.30"
 features = [
     "default_fonts",
     "persistence",
@@ -67,7 +65,7 @@ default-features = false
 
 # Keep version in sync with eframe
 [dependencies.wgpu]
-version = "22.1"
+version = "23.0"
 features = [
     "dx12",
     "metal",
@@ -76,18 +74,7 @@ features = [
 optional = true
 default-features = false
 
-# For Linux static binaries, use rustls
-[target.'cfg(target_os = "linux")'.dependencies]
-reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "multipart", "rustls-tls"] }
-self_update = { version = "0.41", default-features = false, features = ["rustls"] }
-
-# For all other platforms, use native TLS
-[target.'cfg(not(target_os = "linux"))'.dependencies]
-reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "multipart", "default-tls"] }
-self_update = "0.41"
-
 [target.'cfg(windows)'.dependencies]
-path-slash = "0.2"
 winapi = "0.3"
 
 [target.'cfg(unix)'.dependencies]
@@ -95,7 +82,7 @@ exec = "0.3"
 
 # native:
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-tracing-subscriber = "0.3"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
 # web:
 [target.'cfg(target_arch = "wasm32")'.dependencies]
@@ -106,4 +93,4 @@ tracing-wasm = "0.2"
 anyhow = "1.0"
 
 [target.'cfg(windows)'.build-dependencies]
-tauri-winres = "0.1"
+tauri-winres = "0.2"

objdiff-gui/src/app.rs

@@ -11,27 +11,27 @@ use std::{
 };
 
 use filetime::FileTime;
-use globset::{Glob, GlobSet};
-use notify::{RecursiveMode, Watcher};
+use globset::Glob;
 use objdiff_core::{
+    build::watcher::{create_watcher, Watcher},
     config::{
-        build_globset, ProjectConfigInfo, ProjectObject, ScratchConfig, DEFAULT_WATCH_PATTERNS,
+        build_globset, default_watch_patterns, save_project_config, ProjectConfig,
+        ProjectConfigInfo, ProjectObject, ScratchConfig, SymbolMappings, DEFAULT_WATCH_PATTERNS,
     },
     diff::DiffObjConfig,
+    jobs::{Job, JobQueue, JobResult},
 };
 use time::UtcOffset;
 
 use crate::{
     app_config::{deserialize_config, AppConfigVersion},
     config::{load_project_config, ProjectObjectNode},
-    jobs::{
-        objdiff::{start_build, ObjDiffConfig},
-        Job, JobQueue, JobResult, JobStatus,
-    },
+    jobs::{create_objdiff_config, egui_waker, start_build},
     views::{
         appearance::{appearance_window, Appearance},
         config::{
-            arch_config_window, config_ui, project_window, ConfigViewState, CONFIG_DISABLED_TEXT,
+            arch_config_window, config_ui, general_config_ui, project_window, ConfigViewState,
+            CONFIG_DISABLED_TEXT,
         },
         data_diff::data_diff_ui,
         debug::debug_window,
@@ -42,11 +42,10 @@ use crate::{
         graphics::{graphics_window, GraphicsConfig, GraphicsViewState},
         jobs::{jobs_menu_ui, jobs_window},
         rlwinm::{rlwinm_decode_window, RlwinmDecodeViewState},
-        symbol_diff::{symbol_diff_ui, DiffViewState, View},
+        symbol_diff::{symbol_diff_ui, DiffViewAction, DiffViewNavigation, DiffViewState, View},
     },
 };
 
-#[derive(Default)]
 pub struct ViewState {
     pub jobs: JobQueue,
     pub config_state: ConfigViewState,
@@ -63,10 +62,34 @@ pub struct ViewState {
     pub show_debug: bool,
     pub show_graphics: bool,
     pub show_jobs: bool,
+    pub show_side_panel: bool,
+}
+
+impl Default for ViewState {
+    fn default() -> Self {
+        Self {
+            jobs: Default::default(),
+            config_state: Default::default(),
+            demangle_state: Default::default(),
+            rlwinm_decode_state: Default::default(),
+            diff_state: Default::default(),
+            graphics_state: Default::default(),
+            frame_history: Default::default(),
+            show_appearance_config: false,
+            show_demangle: false,
+            show_rlwinm_decode: false,
+            show_project_config: false,
+            show_arch_config: false,
+            show_debug: false,
+            show_graphics: false,
+            show_jobs: false,
+            show_side_panel: true,
+        }
+    }
 }
 
 /// The configuration for a single object file.
-#[derive(Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[derive(Default, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
 pub struct ObjectConfig {
     pub name: String,
     pub target_path: Option<PathBuf>,
@@ -75,16 +98,28 @@ pub struct ObjectConfig {
     pub complete: Option<bool>,
     pub scratch: Option<ScratchConfig>,
     pub source_path: Option<String>,
+    #[serde(default)]
+    pub symbol_mappings: SymbolMappings,
+}
+
+impl From<&ProjectObject> for ObjectConfig {
+    fn from(object: &ProjectObject) -> Self {
+        Self {
+            name: object.name().to_string(),
+            target_path: object.target_path.clone(),
+            base_path: object.base_path.clone(),
+            reverse_fn_order: object.reverse_fn_order(),
+            complete: object.complete(),
+            scratch: object.scratch.clone(),
+            source_path: object.source_path().cloned(),
+            symbol_mappings: object.symbol_mappings.clone().unwrap_or_default(),
+        }
+    }
 }
 
 #[inline]
 fn bool_true() -> bool { true }
 
-#[inline]
-fn default_watch_patterns() -> Vec<Glob> {
-    DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect()
-}
-
 pub struct AppState {
     pub config: AppConfig,
     pub objects: Vec<ProjectObject>,
@@ -94,8 +129,14 @@ pub struct AppState {
     pub obj_change: bool,
     pub queue_build: bool,
     pub queue_reload: bool,
+    pub current_project_config: Option<ProjectConfig>,
     pub project_config_info: Option<ProjectConfigInfo>,
     pub last_mod_check: Instant,
+    /// The right object symbol name that we're selecting a left symbol for
+    pub selecting_left: Option<String>,
+    /// The left object symbol name that we're selecting a right symbol for
+    pub selecting_right: Option<String>,
+    pub config_error: Option<String>,
 }
 
 impl Default for AppState {
@@ -109,8 +150,12 @@ impl Default for AppState {
             obj_change: false,
             queue_build: false,
             queue_reload: false,
+            current_project_config: None,
             project_config_info: None,
             last_mod_check: Instant::now(),
+            selecting_left: None,
+            selecting_right: None,
+            config_error: None,
         }
     }
 }
@@ -191,7 +236,10 @@ impl AppState {
         self.config_change = true;
         self.obj_change = true;
         self.queue_build = false;
+        self.current_project_config = None;
         self.project_config_info = None;
+        self.selecting_left = None;
+        self.selecting_right = None;
     }
 
     pub fn set_target_obj_dir(&mut self, path: PathBuf) {
@@ -199,6 +247,8 @@ impl AppState {
         self.config.selected_obj = None;
         self.obj_change = true;
         self.queue_build = false;
+        self.selecting_left = None;
+        self.selecting_right = None;
     }
 
     pub fn set_base_obj_dir(&mut self, path: PathBuf) {
@@ -206,12 +256,130 @@ impl AppState {
         self.config.selected_obj = None;
         self.obj_change = true;
         self.queue_build = false;
+        self.selecting_left = None;
+        self.selecting_right = None;
     }
 
-    pub fn set_selected_obj(&mut self, object: ObjectConfig) {
-        self.config.selected_obj = Some(object);
+    pub fn set_selected_obj(&mut self, config: ObjectConfig) {
+        let mut unit_changed = true;
+        if let Some(existing) = self.config.selected_obj.as_ref() {
+            if existing == &config {
+                // Don't reload the object if there were no changes
+                return;
+            }
+            if existing.name == config.name {
+                unit_changed = false;
+            }
+        }
+        self.config.selected_obj = Some(config);
+        if unit_changed {
+            self.obj_change = true;
+            self.queue_build = false;
+            self.selecting_left = None;
+            self.selecting_right = None;
+        } else {
+            self.queue_build = true;
+        }
+    }
+
+    pub fn clear_selected_obj(&mut self) {
+        self.config.selected_obj = None;
         self.obj_change = true;
         self.queue_build = false;
+        self.selecting_left = None;
+        self.selecting_right = None;
+    }
+
+    pub fn set_selecting_left(&mut self, right: &str) {
+        let Some(object) = self.config.selected_obj.as_mut() else {
+            return;
+        };
+        object.symbol_mappings.retain(|_, r| r != right);
+        self.selecting_left = Some(right.to_string());
+        self.queue_reload = true;
+        self.save_config();
+    }
+
+    pub fn set_selecting_right(&mut self, left: &str) {
+        let Some(object) = self.config.selected_obj.as_mut() else {
+            return;
+        };
+        object.symbol_mappings.retain(|l, _| l != left);
+        self.selecting_right = Some(left.to_string());
+        self.queue_reload = true;
+        self.save_config();
+    }
+
+    pub fn set_symbol_mapping(&mut self, left: String, right: String) {
+        let Some(object) = self.config.selected_obj.as_mut() else {
+            log::warn!("No selected object");
+            return;
+        };
+        self.selecting_left = None;
+        self.selecting_right = None;
+        object.symbol_mappings.retain(|l, r| l != &left && r != &right);
+        if left != right {
+            object.symbol_mappings.insert(left.clone(), right.clone());
+        }
+        self.queue_reload = true;
+        self.save_config();
+    }
+
+    pub fn clear_selection(&mut self) {
+        self.selecting_left = None;
+        self.selecting_right = None;
+        self.queue_reload = true;
+    }
+
+    pub fn clear_mappings(&mut self) {
+        self.selecting_left = None;
+        self.selecting_right = None;
+        if let Some(object) = self.config.selected_obj.as_mut() {
+            object.symbol_mappings.clear();
+        }
+        self.queue_reload = true;
+        self.save_config();
+    }
+
+    pub fn is_selecting_symbol(&self) -> bool {
+        self.selecting_left.is_some() || self.selecting_right.is_some()
+    }
+
+    pub fn save_config(&mut self) {
+        let (Some(config), Some(info)) =
+            (self.current_project_config.as_mut(), self.project_config_info.as_mut())
+        else {
+            return;
+        };
+        // Update the project config with the current state
+        if let Some(object) = self.config.selected_obj.as_ref() {
+            if let Some(existing) = config.units.as_mut().and_then(|v| {
+                v.iter_mut().find(|u| u.name.as_ref().is_some_and(|n| n == &object.name))
+            }) {
+                existing.symbol_mappings = if object.symbol_mappings.is_empty() {
+                    None
+                } else {
+                    Some(object.symbol_mappings.clone())
+                };
+            }
+            if let Some(existing) =
+                self.objects.iter_mut().find(|u| u.name.as_ref().is_some_and(|n| n == &object.name))
+            {
+                existing.symbol_mappings = if object.symbol_mappings.is_empty() {
+                    None
+                } else {
+                    Some(object.symbol_mappings.clone())
+                };
+            }
+        }
+        // Save the updated project config
+        match save_project_config(config, info) {
+            Ok(new_info) => *info = new_info,
+            Err(e) => {
+                log::error!("Failed to save project config: {e}");
+                self.config_error = Some(format!("Failed to save project config: {e}"));
+            }
+        }
     }
 }
 
@@ -223,7 +391,7 @@ pub struct App {
     view_state: ViewState,
     state: AppStateRef,
     modified: Arc<AtomicBool>,
-    watcher: Option<notify::RecommendedWatcher>,
+    watcher: Option<Watcher>,
     app_path: Option<PathBuf>,
     relaunch_path: Rc<Mutex<Option<PathBuf>>>,
     should_relaunch: bool,
@@ -298,83 +466,61 @@ impl App {
 
         let ViewState { jobs, diff_state, config_state, .. } = &mut self.view_state;
 
-        let mut results = vec![];
-        for (job, result) in jobs.iter_finished() {
-            match result {
-                Ok(result) => {
-                    log::info!("Job {} finished", job.id);
-                    match result {
-                        JobResult::None => {
-                            if let Some(err) = &job.context.status.read().unwrap().error {
-                                log::error!("{:?}", err);
-                            }
-                        }
-                        JobResult::Update(state) => {
-                            if let Ok(mut guard) = self.relaunch_path.lock() {
-                                *guard = Some(state.exe_path);
-                                self.should_relaunch = true;
-                            }
-                        }
-                        _ => results.push(result),
-                    }
-                }
-                Err(err) => {
-                    let err = if let Some(msg) = err.downcast_ref::<&'static str>() {
-                        anyhow::Error::msg(*msg)
-                    } else if let Some(msg) = err.downcast_ref::<String>() {
-                        anyhow::Error::msg(msg.clone())
-                    } else {
-                        anyhow::Error::msg("Thread panicked")
-                    };
-                    let result = job.context.status.write();
-                    if let Ok(mut guard) = result {
-                        guard.error = Some(err);
-                    } else {
-                        drop(result);
-                        job.context.status = Arc::new(RwLock::new(JobStatus {
-                            title: "Error".to_string(),
-                            progress_percent: 0.0,
-                            progress_items: None,
-                            status: String::new(),
-                            error: Some(err),
-                        }));
-                    }
+        jobs.collect_results();
+        jobs.results.retain(|result| match result {
+            JobResult::Update(state) => {
+                if let Ok(mut guard) = self.relaunch_path.lock() {
+                    *guard = Some(state.exe_path.clone());
+                    self.should_relaunch = true;
                 }
+                false
             }
-        }
-        jobs.results.append(&mut results);
-        jobs.clear_finished();
-
+            _ => true,
+        });
         diff_state.pre_update(jobs, &self.state);
         config_state.pre_update(jobs, &self.state);
         debug_assert!(jobs.results.is_empty());
     }
 
-    fn post_update(&mut self, ctx: &egui::Context) {
+    fn post_update(&mut self, ctx: &egui::Context, action: Option<DiffViewAction>) {
+        if action.is_some() {
+            ctx.request_repaint();
+        }
+
         self.appearance.post_update(ctx);
 
         let ViewState { jobs, diff_state, config_state, graphics_state, .. } = &mut self.view_state;
         config_state.post_update(ctx, jobs, &self.state);
-        diff_state.post_update(ctx, jobs, &self.state);
+        diff_state.post_update(action, ctx, jobs, &self.state);
 
         let Ok(mut state) = self.state.write() else {
             return;
         };
         let state = &mut *state;
 
-        if let Some(info) = &state.project_config_info {
-            if file_modified(&info.path, info.timestamp) {
-                state.config_change = true;
+        let mut mod_check = false;
+        if state.last_mod_check.elapsed().as_millis() >= 500 {
+            state.last_mod_check = Instant::now();
+            mod_check = true;
+        }
+
+        if mod_check {
+            if let Some(info) = &state.project_config_info {
+                if let Some(last_ts) = info.timestamp {
+                    if file_modified(&info.path, last_ts) {
+                        state.config_change = true;
+                    }
+                }
             }
         }
 
         if state.config_change {
             state.config_change = false;
             match load_project_config(state) {
-                Ok(()) => config_state.load_error = None,
+                Ok(()) => state.config_error = None,
                 Err(e) => {
                     log::error!("Failed to load project config: {e}");
-                    config_state.load_error = Some(format!("{e}"));
+                    state.config_error = Some(format!("{e}"));
                 }
             }
         }
@@ -386,7 +532,7 @@ impl App {
                 match build_globset(&state.config.watch_patterns)
                     .map_err(anyhow::Error::new)
                     .and_then(|globset| {
-                        create_watcher(ctx.clone(), self.modified.clone(), project_dir, globset)
+                        create_watcher(self.modified.clone(), project_dir, globset, egui_waker(ctx))
                             .map_err(anyhow::Error::new)
                     }) {
                     Ok(watcher) => self.watcher = Some(watcher),
@@ -409,8 +555,7 @@ impl App {
         }
 
         if let Some(result) = &diff_state.build {
-            if state.last_mod_check.elapsed().as_millis() >= 500 {
-                state.last_mod_check = Instant::now();
+            if mod_check {
                 if let Some((obj, _)) = &result.first_obj {
                     if let (Some(path), Some(timestamp)) = (&obj.path, obj.timestamp) {
                         if file_modified(path, timestamp) {
@@ -434,15 +579,15 @@ impl App {
             && state.config.selected_obj.is_some()
             && !jobs.is_running(Job::ObjDiff)
         {
-            jobs.push(start_build(ctx, ObjDiffConfig::from_config(&state.config)));
+            start_build(ctx, jobs, create_objdiff_config(state));
             state.queue_build = false;
             state.queue_reload = false;
         } else if state.queue_reload && !jobs.is_running(Job::ObjDiff) {
-            let mut diff_config = ObjDiffConfig::from_config(&state.config);
+            let mut diff_config = create_objdiff_config(state);
             // Don't build, just reload the current files
             diff_config.build_base = false;
             diff_config.build_target = false;
-            jobs.push(start_build(ctx, diff_config));
+            start_build(ctx, jobs, diff_config);
             state.queue_reload = false;
         }
 
@@ -485,12 +630,26 @@ impl eframe::App for App {
             show_debug,
             show_graphics,
             show_jobs,
+            show_side_panel,
         } = view_state;
 
         frame_history.on_new_frame(ctx.input(|i| i.time), frame.info().cpu_usage);
 
+        let side_panel_available = diff_state.current_view == View::SymbolDiff;
+
         egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
             egui::menu::bar(ui, |ui| {
+                if ui
+                    .add_enabled(
+                        side_panel_available,
+                        egui::Button::new(if *show_side_panel { "⏴" } else { "⏵" }),
+                    )
+                    .on_hover_text("Toggle side panel")
+                    .clicked()
+                {
+                    *show_side_panel = !*show_side_panel;
+                }
+                ui.separator();
                 ui.menu_button("File", |ui| {
                     #[cfg(debug_assertions)]
                     if ui.button("Debug…").clicked() {
@@ -568,35 +727,12 @@ impl eframe::App for App {
                         &mut diff_state.symbol_state.show_hidden_symbols,
                         "Show hidden symbols",
                     );
-                    if ui
-                        .checkbox(
-                            &mut state.config.diff_obj_config.relax_reloc_diffs,
-                            "Relax relocation diffs",
-                        )
-                        .on_hover_text(
-                            "Ignores differences in relocation targets. (Address, name, etc)",
-                        )
-                        .changed()
-                    {
-                        state.queue_reload = true;
-                    }
-                    if ui
-                        .checkbox(
-                            &mut state.config.diff_obj_config.space_between_args,
-                            "Space between args",
-                        )
-                        .changed()
-                    {
-                        state.queue_reload = true;
-                    }
-                    if ui
-                        .checkbox(
-                            &mut state.config.diff_obj_config.combine_data_sections,
-                            "Combine data sections",
-                        )
-                        .on_hover_text("Combines data sections with equal names.")
-                        .changed()
-                    {
+                    ui.separator();
+                    general_config_ui(ui, &mut state);
+                    ui.separator();
+                    if ui.button("Clear custom symbol mappings").clicked() {
+                        state.clear_mappings();
+                        diff_state.post_build_nav = Some(DiffViewNavigation::symbol_diff());
                         state.queue_reload = true;
                     }
                 });
@@ -607,31 +743,28 @@ impl eframe::App for App {
             });
         });
 
-        let build_success = matches!(&diff_state.build, Some(b) if b.first_status.success && b.second_status.success);
-        if diff_state.current_view == View::FunctionDiff && build_success {
-            egui::CentralPanel::default().show(ctx, |ui| {
-                function_diff_ui(ui, diff_state, appearance);
-            });
-        } else if diff_state.current_view == View::DataDiff && build_success {
-            egui::CentralPanel::default().show(ctx, |ui| {
-                data_diff_ui(ui, diff_state, appearance);
-            });
-        } else if diff_state.current_view == View::ExtabDiff && build_success {
-            egui::CentralPanel::default().show(ctx, |ui| {
-                extab_diff_ui(ui, diff_state, appearance);
-            });
-        } else {
-            egui::SidePanel::left("side_panel").show(ctx, |ui| {
+        if side_panel_available {
+            egui::SidePanel::left("side_panel").show_animated(ctx, *show_side_panel, |ui| {
                 egui::ScrollArea::both().show(ui, |ui| {
                     config_ui(ui, state, show_project_config, config_state, appearance);
                 });
             });
-
-            egui::CentralPanel::default().show(ctx, |ui| {
-                symbol_diff_ui(ui, diff_state, appearance);
-            });
         }
 
+        let mut action = None;
+        egui::CentralPanel::default().show(ctx, |ui| {
+            let build_success = matches!(&diff_state.build, Some(b) if b.first_status.success && b.second_status.success);
+            action = if diff_state.current_view == View::FunctionDiff && build_success {
+                function_diff_ui(ui, diff_state, appearance)
+            } else if diff_state.current_view == View::DataDiff && build_success {
+                data_diff_ui(ui, diff_state, appearance)
+            } else if diff_state.current_view == View::ExtabDiff && build_success {
+                extab_diff_ui(ui, diff_state, appearance)
+            } else {
+                symbol_diff_ui(ui, diff_state, appearance)
+            };
+        });
+
         project_window(ctx, state, show_project_config, config_state, appearance);
         appearance_window(ctx, show_appearance_config, appearance);
         demangle_window(ctx, show_demangle, demangle_state, appearance);
@@ -641,10 +774,10 @@ impl eframe::App for App {
         graphics_window(ctx, show_graphics, frame_history, graphics_state, appearance);
         jobs_window(ctx, show_jobs, jobs, appearance);
 
-        self.post_update(ctx);
+        self.post_update(ctx, action);
     }
 
-    /// Called by the frame work to save state before shutdown.
+    /// Called by the framework to save state before shutdown.
     fn save(&mut self, storage: &mut dyn eframe::Storage) {
         if let Ok(state) = self.state.read() {
             eframe::set_value(storage, CONFIG_KEY, &state.config);
@@ -653,40 +786,6 @@ impl eframe::App for App {
     }
 }
 
-fn create_watcher(
-    ctx: egui::Context,
-    modified: Arc<AtomicBool>,
-    project_dir: &Path,
-    patterns: GlobSet,
-) -> notify::Result<notify::RecommendedWatcher> {
-    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(..)
-                        | notify::EventKind::Create(..)
-                        | notify::EventKind::Remove(..)
-                ) {
-                    for path in &event.paths {
-                        let Ok(path) = path.strip_prefix(&base_dir) else {
-                            continue;
-                        };
-                        if patterns.is_match(path) {
-                            log::info!("File modified: {}", path.display());
-                            modified.store(true, Ordering::Relaxed);
-                            ctx.request_repaint();
-                        }
-                    }
-                }
-            }
-            Err(e) => log::error!("watch error: {e:?}"),
-        })?;
-    watcher.watch(project_dir, RecursiveMode::Recursive)?;
-    Ok(watcher)
-}
-
 #[inline]
 fn file_modified(path: &Path, last_ts: FileTime) -> bool {
     if let Ok(metadata) = fs::metadata(path) {

objdiff-gui/src/app_config.rs

@@ -2,6 +2,13 @@ use std::path::PathBuf;
 
 use eframe::Storage;
 use globset::Glob;
+use objdiff_core::{
+    config::{ScratchConfig, SymbolMappings},
+    diff::{
+        ArmArchVersion, ArmR9Usage, DiffObjConfig, FunctionRelocDiffs, MipsAbi, MipsInstrCategory,
+        X86Formatter,
+    },
+};
 
 use crate::app::{AppConfig, ObjectConfig, CONFIG_KEY};
 
@@ -11,7 +18,7 @@ pub struct AppConfigVersion {
 }
 
 impl Default for AppConfigVersion {
-    fn default() -> Self { Self { version: 1 } }
+    fn default() -> Self { Self { version: 3 } }
 }
 
 /// Deserialize the AppConfig from storage, handling upgrades from older versions.
@@ -19,7 +26,9 @@ 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),
+            3 => from_str::<AppConfig>(&str),
+            2 => from_str::<AppConfigV2>(&str).map(|c| c.into_config()),
+            1 => from_str::<AppConfigV1>(&str).map(|c| c.into_config()),
             _ => {
                 log::warn!("Unknown config version: {}", version.version);
                 None
@@ -44,6 +53,297 @@ where T: serde::de::DeserializeOwned {
     }
 }
 
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct ScratchConfigV2 {
+    #[serde(default)]
+    pub platform: Option<String>,
+    #[serde(default)]
+    pub compiler: Option<String>,
+    #[serde(default)]
+    pub c_flags: Option<String>,
+    #[serde(default)]
+    pub ctx_path: Option<PathBuf>,
+    #[serde(default)]
+    pub build_ctx: Option<bool>,
+    #[serde(default)]
+    pub preset_id: Option<u32>,
+}
+
+impl ScratchConfigV2 {
+    fn into_config(self) -> ScratchConfig {
+        ScratchConfig {
+            platform: self.platform,
+            compiler: self.compiler,
+            c_flags: self.c_flags,
+            ctx_path: self.ctx_path,
+            build_ctx: self.build_ctx,
+            preset_id: self.preset_id,
+        }
+    }
+}
+
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct ObjectConfigV2 {
+    pub name: String,
+    pub target_path: Option<PathBuf>,
+    pub base_path: Option<PathBuf>,
+    pub reverse_fn_order: Option<bool>,
+    pub complete: Option<bool>,
+    pub scratch: Option<ScratchConfigV2>,
+    pub source_path: Option<String>,
+    #[serde(default)]
+    pub symbol_mappings: SymbolMappings,
+}
+
+impl ObjectConfigV2 {
+    fn into_config(self) -> ObjectConfig {
+        ObjectConfig {
+            name: self.name,
+            target_path: self.target_path,
+            base_path: self.base_path,
+            reverse_fn_order: self.reverse_fn_order,
+            complete: self.complete,
+            scratch: self.scratch.map(|scratch| scratch.into_config()),
+            source_path: self.source_path,
+            symbol_mappings: self.symbol_mappings,
+        }
+    }
+}
+
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct AppConfigV2 {
+    pub version: u32,
+    #[serde(default)]
+    pub custom_make: Option<String>,
+    #[serde(default)]
+    pub custom_args: Option<Vec<String>>,
+    #[serde(default)]
+    pub selected_wsl_distro: Option<String>,
+    #[serde(default)]
+    pub project_dir: Option<PathBuf>,
+    #[serde(default)]
+    pub target_obj_dir: Option<PathBuf>,
+    #[serde(default)]
+    pub base_obj_dir: Option<PathBuf>,
+    #[serde(default)]
+    pub selected_obj: Option<ObjectConfigV2>,
+    #[serde(default = "bool_true")]
+    pub build_base: bool,
+    #[serde(default)]
+    pub build_target: bool,
+    #[serde(default = "bool_true")]
+    pub rebuild_on_changes: bool,
+    #[serde(default)]
+    pub auto_update_check: bool,
+    #[serde(default)]
+    pub watch_patterns: Vec<Glob>,
+    #[serde(default)]
+    pub recent_projects: Vec<PathBuf>,
+    #[serde(default)]
+    pub diff_obj_config: DiffObjConfigV1,
+}
+
+impl AppConfigV2 {
+    fn into_config(self) -> AppConfig {
+        log::info!("Upgrading configuration from v2");
+        AppConfig {
+            custom_make: self.custom_make,
+            custom_args: self.custom_args,
+            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_base: self.build_base,
+            build_target: self.build_target,
+            rebuild_on_changes: self.rebuild_on_changes,
+            auto_update_check: self.auto_update_check,
+            watch_patterns: self.watch_patterns,
+            recent_projects: self.recent_projects,
+            diff_obj_config: self.diff_obj_config.into_config(),
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct ScratchConfigV1 {
+    #[serde(default)]
+    pub platform: Option<String>,
+    #[serde(default)]
+    pub compiler: Option<String>,
+    #[serde(default)]
+    pub c_flags: Option<String>,
+    #[serde(default)]
+    pub ctx_path: Option<PathBuf>,
+    #[serde(default)]
+    pub build_ctx: bool,
+}
+
+impl ScratchConfigV1 {
+    fn into_config(self) -> ScratchConfig {
+        ScratchConfig {
+            platform: self.platform,
+            compiler: self.compiler,
+            c_flags: self.c_flags,
+            ctx_path: self.ctx_path,
+            build_ctx: self.build_ctx.then_some(true),
+            preset_id: None,
+        }
+    }
+}
+
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct ObjectConfigV1 {
+    pub name: String,
+    pub target_path: Option<PathBuf>,
+    pub base_path: Option<PathBuf>,
+    pub reverse_fn_order: Option<bool>,
+    pub complete: Option<bool>,
+    pub scratch: Option<ScratchConfigV1>,
+    pub source_path: Option<String>,
+}
+
+impl ObjectConfigV1 {
+    fn into_config(self) -> ObjectConfig {
+        ObjectConfig {
+            name: self.name,
+            target_path: self.target_path,
+            base_path: self.base_path,
+            reverse_fn_order: self.reverse_fn_order,
+            complete: self.complete,
+            scratch: self.scratch.map(|scratch| scratch.into_config()),
+            source_path: self.source_path,
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(serde::Deserialize, serde::Serialize)]
+#[serde(default)]
+pub struct DiffObjConfigV1 {
+    pub relax_reloc_diffs: bool,
+    #[serde(default = "bool_true")]
+    pub space_between_args: bool,
+    pub combine_data_sections: bool,
+    // x86
+    pub x86_formatter: X86Formatter,
+    // MIPS
+    pub mips_abi: MipsAbi,
+    pub mips_instr_category: MipsInstrCategory,
+    // ARM
+    pub arm_arch_version: ArmArchVersion,
+    pub arm_unified_syntax: bool,
+    pub arm_av_registers: bool,
+    pub arm_r9_usage: ArmR9Usage,
+    pub arm_sl_usage: bool,
+    pub arm_fp_usage: bool,
+    pub arm_ip_usage: bool,
+}
+
+impl Default for DiffObjConfigV1 {
+    fn default() -> Self {
+        Self {
+            relax_reloc_diffs: false,
+            space_between_args: true,
+            combine_data_sections: false,
+            x86_formatter: Default::default(),
+            mips_abi: Default::default(),
+            mips_instr_category: Default::default(),
+            arm_arch_version: Default::default(),
+            arm_unified_syntax: true,
+            arm_av_registers: false,
+            arm_r9_usage: Default::default(),
+            arm_sl_usage: false,
+            arm_fp_usage: false,
+            arm_ip_usage: false,
+        }
+    }
+}
+
+impl DiffObjConfigV1 {
+    fn into_config(self) -> DiffObjConfig {
+        DiffObjConfig {
+            function_reloc_diffs: if self.relax_reloc_diffs {
+                FunctionRelocDiffs::None
+            } else {
+                FunctionRelocDiffs::default()
+            },
+            space_between_args: self.space_between_args,
+            combine_data_sections: self.combine_data_sections,
+            x86_formatter: self.x86_formatter,
+            mips_abi: self.mips_abi,
+            mips_instr_category: self.mips_instr_category,
+            arm_arch_version: self.arm_arch_version,
+            arm_unified_syntax: self.arm_unified_syntax,
+            arm_av_registers: self.arm_av_registers,
+            arm_r9_usage: self.arm_r9_usage,
+            arm_sl_usage: self.arm_sl_usage,
+            arm_fp_usage: self.arm_fp_usage,
+            arm_ip_usage: self.arm_ip_usage,
+        }
+    }
+}
+
+#[inline]
+fn bool_true() -> bool { true }
+
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct AppConfigV1 {
+    pub version: u32,
+    #[serde(default)]
+    pub custom_make: Option<String>,
+    #[serde(default)]
+    pub custom_args: Option<Vec<String>>,
+    #[serde(default)]
+    pub selected_wsl_distro: Option<String>,
+    #[serde(default)]
+    pub project_dir: Option<PathBuf>,
+    #[serde(default)]
+    pub target_obj_dir: Option<PathBuf>,
+    #[serde(default)]
+    pub base_obj_dir: Option<PathBuf>,
+    #[serde(default)]
+    pub selected_obj: Option<ObjectConfigV1>,
+    #[serde(default = "bool_true")]
+    pub build_base: bool,
+    #[serde(default)]
+    pub build_target: bool,
+    #[serde(default = "bool_true")]
+    pub rebuild_on_changes: bool,
+    #[serde(default)]
+    pub auto_update_check: bool,
+    #[serde(default)]
+    pub watch_patterns: Vec<Glob>,
+    #[serde(default)]
+    pub recent_projects: Vec<PathBuf>,
+    #[serde(default)]
+    pub diff_obj_config: DiffObjConfigV1,
+}
+
+impl AppConfigV1 {
+    fn into_config(self) -> AppConfig {
+        log::info!("Upgrading configuration from v1");
+        AppConfig {
+            custom_make: self.custom_make,
+            custom_args: self.custom_args,
+            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_base: self.build_base,
+            build_target: self.build_target,
+            rebuild_on_changes: self.rebuild_on_changes,
+            auto_update_check: self.auto_update_check,
+            watch_patterns: self.watch_patterns,
+            recent_projects: self.recent_projects,
+            diff_obj_config: self.diff_obj_config.into_config(),
+            ..Default::default()
+        }
+    }
+}
+
 #[derive(serde::Deserialize, serde::Serialize)]
 pub struct ObjectConfigV0 {
     pub name: String,
@@ -59,9 +359,7 @@ impl ObjectConfigV0 {
             target_path: Some(self.target_path),
             base_path: Some(self.base_path),
             reverse_fn_order: self.reverse_fn_order,
-            complete: None,
-            scratch: None,
-            source_path: None,
+            ..Default::default()
         }
     }
 }

objdiff-gui/src/config.rs

@@ -4,14 +4,29 @@ use anyhow::Result;
 use globset::Glob;
 use objdiff_core::config::{try_project_config, ProjectObject, DEFAULT_WATCH_PATTERNS};
 
-use crate::app::AppState;
+use crate::app::{AppState, ObjectConfig};
 
 #[derive(Clone)]
 pub enum ProjectObjectNode {
-    File(String, Box<ProjectObject>),
+    Unit(String, usize),
     Dir(String, Vec<ProjectObjectNode>),
 }
 
+fn join_single_dir_entries(nodes: &mut Vec<ProjectObjectNode>) {
+    for node in nodes {
+        if let ProjectObjectNode::Dir(my_name, my_nodes) = node {
+            join_single_dir_entries(my_nodes);
+            // If this directory consists of a single sub-directory...
+            if let [ProjectObjectNode::Dir(sub_name, sub_nodes)] = &mut my_nodes[..] {
+                // ... join the two names with a path separator and eliminate the layer
+                *my_name += "/";
+                *my_name += sub_name;
+                *my_nodes = std::mem::take(sub_nodes);
+            }
+        }
+    }
+}
+
 fn find_dir<'a>(
     name: &str,
     nodes: &'a mut Vec<ProjectObjectNode>,
@@ -33,17 +48,18 @@ fn find_dir<'a>(
 }
 
 fn build_nodes(
-    objects: &[ProjectObject],
+    units: &mut [ProjectObject],
     project_dir: &Path,
     target_obj_dir: Option<&Path>,
     base_obj_dir: Option<&Path>,
 ) -> Vec<ProjectObjectNode> {
     let mut nodes = vec![];
-    for object in objects {
+    for (idx, unit) in units.iter_mut().enumerate() {
+        unit.resolve_paths(project_dir, target_obj_dir, base_obj_dir);
         let mut out_nodes = &mut nodes;
-        let path = if let Some(name) = &object.name {
+        let path = if let Some(name) = &unit.name {
             Path::new(name)
-        } else if let Some(path) = &object.path {
+        } else if let Some(path) = &unit.path {
             path
         } else {
             continue;
@@ -56,11 +72,17 @@ fn build_nodes(
                 }
             }
         }
-        let mut object = Box::new(object.clone());
-        object.resolve_paths(project_dir, target_obj_dir, base_obj_dir);
         let filename = path.file_name().unwrap().to_str().unwrap().to_string();
-        out_nodes.push(ProjectObjectNode::File(filename, object));
+        out_nodes.push(ProjectObjectNode::Unit(filename, idx));
     }
+    // Within the top-level module directories, join paths. Leave the
+    // top-level name intact though since it's the module name.
+    for node in &mut nodes {
+        if let ProjectObjectNode::Dir(_, sub_nodes) = node {
+            join_single_dir_entries(sub_nodes);
+        }
+    }
+
     nodes
 }
 
@@ -70,24 +92,42 @@ pub fn load_project_config(state: &mut AppState) -> Result<()> {
     };
     if let Some((result, info)) = try_project_config(project_dir) {
         let project_config = result?;
-        state.config.custom_make = project_config.custom_make;
-        state.config.custom_args = project_config.custom_args;
-        state.config.target_obj_dir = project_config.target_dir.map(|p| project_dir.join(p));
-        state.config.base_obj_dir = project_config.base_dir.map(|p| project_dir.join(p));
-        state.config.build_base = project_config.build_base;
-        state.config.build_target = project_config.build_target;
-        state.config.watch_patterns = project_config.watch_patterns.unwrap_or_else(|| {
-            DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect()
-        });
+        state.config.custom_make = project_config.custom_make.clone();
+        state.config.custom_args = project_config.custom_args.clone();
+        state.config.target_obj_dir =
+            project_config.target_dir.as_deref().map(|p| project_dir.join(p));
+        state.config.base_obj_dir = project_config.base_dir.as_deref().map(|p| project_dir.join(p));
+        state.config.build_base = project_config.build_base.unwrap_or(true);
+        state.config.build_target = project_config.build_target.unwrap_or(false);
+        if let Some(watch_patterns) = &project_config.watch_patterns {
+            state.config.watch_patterns = watch_patterns
+                .iter()
+                .map(|s| Glob::new(s))
+                .collect::<Result<Vec<Glob>, globset::Error>>()?;
+        } else {
+            state.config.watch_patterns =
+                DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect();
+        }
         state.watcher_change = true;
-        state.objects = project_config.objects;
+        state.objects = project_config.units.clone().unwrap_or_default();
         state.object_nodes = build_nodes(
-            &state.objects,
+            &mut state.objects,
             project_dir,
             state.config.target_obj_dir.as_deref(),
             state.config.base_obj_dir.as_deref(),
         );
+        state.current_project_config = Some(project_config);
         state.project_config_info = Some(info);
+
+        // Reload selected object
+        if let Some(selected_obj) = &state.config.selected_obj {
+            if let Some(obj) = state.objects.iter().find(|o| o.name() == selected_obj.name) {
+                let config = ObjectConfig::from(obj);
+                state.set_selected_obj(config);
+            } else {
+                state.clear_selected_obj();
+            }
+        }
     }
     Ok(())
 }

objdiff-gui/src/fonts/mod.rs

@@ -96,7 +96,7 @@ pub fn load_font_if_needed(
     let default_font = family.handles.get(family.default_index).unwrap();
     let default_font_data = load_font(default_font).unwrap();
     log::info!("Loaded font family '{}'", family.family_name);
-    fonts.font_data.insert(default_font_ref.full_name(), default_font_data.font_data);
+    fonts.font_data.insert(default_font_ref.full_name(), Arc::new(default_font_data.font_data));
     fonts
         .families
         .entry(egui::FontFamily::Name(Arc::from(family.family_name)))

objdiff-gui/src/hotkeys.rs

@@ -0,0 +1,108 @@
+use egui::{
+    style::ScrollAnimation, vec2, Context, Key, KeyboardShortcut, Modifiers, PointerButton,
+};
+
+fn any_widget_focused(ctx: &Context) -> bool { ctx.memory(|mem| mem.focused().is_some()) }
+
+pub fn enter_pressed(ctx: &Context) -> bool {
+    if any_widget_focused(ctx) {
+        return false;
+    }
+    ctx.input_mut(|i| {
+        i.key_pressed(Key::Enter)
+            || i.key_pressed(Key::Space)
+            || i.pointer.button_pressed(PointerButton::Extra2)
+    })
+}
+
+pub fn back_pressed(ctx: &Context) -> bool {
+    if any_widget_focused(ctx) {
+        return false;
+    }
+    ctx.input_mut(|i| {
+        i.key_pressed(Key::Backspace)
+            || i.key_pressed(Key::Escape)
+            || i.pointer.button_pressed(PointerButton::Extra1)
+    })
+}
+
+pub fn up_pressed(ctx: &Context) -> bool {
+    if any_widget_focused(ctx) {
+        return false;
+    }
+    ctx.input_mut(|i| i.key_pressed(Key::ArrowUp) || i.key_pressed(Key::W))
+}
+
+pub fn down_pressed(ctx: &Context) -> bool {
+    if any_widget_focused(ctx) {
+        return false;
+    }
+    ctx.input_mut(|i| i.key_pressed(Key::ArrowDown) || i.key_pressed(Key::S))
+}
+
+pub fn page_up_pressed(ctx: &Context) -> bool { ctx.input_mut(|i| i.key_pressed(Key::PageUp)) }
+
+pub fn page_down_pressed(ctx: &Context) -> bool { ctx.input_mut(|i| i.key_pressed(Key::PageDown)) }
+
+pub fn home_pressed(ctx: &Context) -> bool { ctx.input_mut(|i| i.key_pressed(Key::Home)) }
+
+pub fn end_pressed(ctx: &Context) -> bool { ctx.input_mut(|i| i.key_pressed(Key::End)) }
+
+pub fn check_scroll_hotkeys(ui: &mut egui::Ui, include_small_increments: bool) {
+    let ui_height = ui.available_rect_before_wrap().height();
+    if up_pressed(ui.ctx()) && include_small_increments {
+        ui.scroll_with_delta_animation(vec2(0.0, ui_height / 10.0), ScrollAnimation::none());
+    } else if down_pressed(ui.ctx()) && include_small_increments {
+        ui.scroll_with_delta_animation(vec2(0.0, -ui_height / 10.0), ScrollAnimation::none());
+    } else if page_up_pressed(ui.ctx()) {
+        ui.scroll_with_delta_animation(vec2(0.0, ui_height), ScrollAnimation::none());
+    } else if page_down_pressed(ui.ctx()) {
+        ui.scroll_with_delta_animation(vec2(0.0, -ui_height), ScrollAnimation::none());
+    } else if home_pressed(ui.ctx()) {
+        ui.scroll_with_delta_animation(vec2(0.0, f32::INFINITY), ScrollAnimation::none());
+    } else if end_pressed(ui.ctx()) {
+        ui.scroll_with_delta_animation(vec2(0.0, -f32::INFINITY), ScrollAnimation::none());
+    }
+}
+
+pub fn consume_up_key(ctx: &Context) -> bool {
+    if any_widget_focused(ctx) {
+        return false;
+    }
+    ctx.input_mut(|i| {
+        i.consume_key(Modifiers::NONE, Key::ArrowUp) || i.consume_key(Modifiers::NONE, Key::W)
+    })
+}
+
+pub fn consume_down_key(ctx: &Context) -> bool {
+    if any_widget_focused(ctx) {
+        return false;
+    }
+    ctx.input_mut(|i| {
+        i.consume_key(Modifiers::NONE, Key::ArrowDown) || i.consume_key(Modifiers::NONE, Key::S)
+    })
+}
+
+const OBJECT_FILTER_SHORTCUT: KeyboardShortcut = KeyboardShortcut::new(Modifiers::CTRL, Key::F);
+
+pub fn consume_object_filter_shortcut(ctx: &Context) -> bool {
+    ctx.input_mut(|i| i.consume_shortcut(&OBJECT_FILTER_SHORTCUT))
+}
+
+const SYMBOL_FILTER_SHORTCUT: KeyboardShortcut = KeyboardShortcut::new(Modifiers::CTRL, Key::S);
+
+pub fn consume_symbol_filter_shortcut(ctx: &Context) -> bool {
+    ctx.input_mut(|i| i.consume_shortcut(&SYMBOL_FILTER_SHORTCUT))
+}
+
+const CHANGE_TARGET_SHORTCUT: KeyboardShortcut = KeyboardShortcut::new(Modifiers::CTRL, Key::T);
+
+pub fn consume_change_target_shortcut(ctx: &Context) -> bool {
+    ctx.input_mut(|i| i.consume_shortcut(&CHANGE_TARGET_SHORTCUT))
+}
+
+const CHANGE_BASE_SHORTCUT: KeyboardShortcut = KeyboardShortcut::new(Modifiers::CTRL, Key::B);
+
+pub fn consume_change_base_shortcut(ctx: &Context) -> bool {
+    ctx.input_mut(|i| i.consume_shortcut(&CHANGE_BASE_SHORTCUT))
+}

objdiff-gui/src/jobs.rs

@@ -0,0 +1,141 @@
+use std::{
+    sync::Arc,
+    task::{Wake, Waker},
+};
+
+use anyhow::{bail, Result};
+use jobs::create_scratch;
+use objdiff_core::{
+    build::BuildConfig,
+    diff::MappingConfig,
+    jobs,
+    jobs::{check_update::CheckUpdateConfig, objdiff, update::UpdateConfig, Job, JobQueue},
+};
+
+use crate::{
+    app::{AppConfig, AppState},
+    update::{build_updater, BIN_NAME_NEW, BIN_NAME_OLD},
+};
+
+struct EguiWaker(egui::Context);
+
+impl Wake for EguiWaker {
+    fn wake(self: Arc<Self>) { self.0.request_repaint(); }
+
+    fn wake_by_ref(self: &Arc<Self>) { self.0.request_repaint(); }
+}
+
+pub fn egui_waker(ctx: &egui::Context) -> Waker { Waker::from(Arc::new(EguiWaker(ctx.clone()))) }
+
+pub fn is_create_scratch_available(config: &AppConfig) -> bool {
+    let Some(selected_obj) = &config.selected_obj else {
+        return false;
+    };
+    selected_obj.target_path.is_some() && selected_obj.scratch.is_some()
+}
+
+pub fn start_create_scratch(
+    ctx: &egui::Context,
+    jobs: &mut JobQueue,
+    state: &AppState,
+    function_name: String,
+) {
+    match create_scratch_config(state, function_name) {
+        Ok(config) => {
+            jobs.push_once(Job::CreateScratch, || {
+                create_scratch::start_create_scratch(egui_waker(ctx), config)
+            });
+        }
+        Err(err) => {
+            log::error!("Failed to create scratch config: {err}");
+        }
+    }
+}
+
+fn create_scratch_config(
+    state: &AppState,
+    function_name: String,
+) -> Result<create_scratch::CreateScratchConfig> {
+    let Some(selected_obj) = &state.config.selected_obj else {
+        bail!("No object selected");
+    };
+    let Some(target_path) = &selected_obj.target_path else {
+        bail!("No target path for {}", selected_obj.name);
+    };
+    let Some(scratch_config) = &selected_obj.scratch else {
+        bail!("No scratch configuration for {}", selected_obj.name);
+    };
+    Ok(create_scratch::CreateScratchConfig {
+        build_config: BuildConfig::from(&state.config),
+        context_path: scratch_config.ctx_path.clone(),
+        build_context: scratch_config.build_ctx.unwrap_or(false),
+        compiler: scratch_config.compiler.clone().unwrap_or_default(),
+        platform: scratch_config.platform.clone().unwrap_or_default(),
+        compiler_flags: scratch_config.c_flags.clone().unwrap_or_default(),
+        function_name,
+        target_obj: target_path.to_path_buf(),
+        preset_id: scratch_config.preset_id,
+    })
+}
+
+impl From<&AppConfig> for BuildConfig {
+    fn from(config: &AppConfig) -> Self {
+        Self {
+            project_dir: config.project_dir.clone(),
+            custom_make: config.custom_make.clone(),
+            custom_args: config.custom_args.clone(),
+            selected_wsl_distro: config.selected_wsl_distro.clone(),
+        }
+    }
+}
+
+pub fn create_objdiff_config(state: &AppState) -> objdiff::ObjDiffConfig {
+    objdiff::ObjDiffConfig {
+        build_config: BuildConfig::from(&state.config),
+        build_base: state.config.build_base,
+        build_target: state.config.build_target,
+        target_path: state
+            .config
+            .selected_obj
+            .as_ref()
+            .and_then(|obj| obj.target_path.as_ref())
+            .cloned(),
+        base_path: state
+            .config
+            .selected_obj
+            .as_ref()
+            .and_then(|obj| obj.base_path.as_ref())
+            .cloned(),
+        diff_obj_config: state.config.diff_obj_config.clone(),
+        mapping_config: MappingConfig {
+            mappings: state
+                .config
+                .selected_obj
+                .as_ref()
+                .map(|obj| &obj.symbol_mappings)
+                .cloned()
+                .unwrap_or_default(),
+            selecting_left: state.selecting_left.clone(),
+            selecting_right: state.selecting_right.clone(),
+        },
+    }
+}
+
+pub fn start_build(ctx: &egui::Context, jobs: &mut JobQueue, config: objdiff::ObjDiffConfig) {
+    jobs.push_once(Job::ObjDiff, || objdiff::start_build(egui_waker(ctx), config));
+}
+
+pub fn start_check_update(ctx: &egui::Context, jobs: &mut JobQueue) {
+    jobs.push_once(Job::Update, || {
+        jobs::check_update::start_check_update(egui_waker(ctx), CheckUpdateConfig {
+            build_updater,
+            bin_names: vec![BIN_NAME_NEW.to_string(), BIN_NAME_OLD.to_string()],
+        })
+    });
+}
+
+pub fn start_update(ctx: &egui::Context, jobs: &mut JobQueue, bin_name: String) {
+    jobs.push_once(Job::Update, || {
+        jobs::update::start_update(egui_waker(ctx), UpdateConfig { build_updater, bin_name })
+    });
+}

objdiff-gui/src/jobs/check_update.rs

@@ -1,39 +0,0 @@
-use std::sync::mpsc::Receiver;
-
-use anyhow::{Context, Result};
-use self_update::{cargo_crate_version, update::Release};
-
-use crate::{
-    jobs::{start_job, update_status, Job, JobContext, JobResult, JobState},
-    update::{build_updater, BIN_NAME_NEW, BIN_NAME_OLD},
-};
-
-pub struct CheckUpdateResult {
-    pub update_available: bool,
-    pub latest_release: Release,
-    pub found_binary: Option<String>,
-}
-
-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)?;
-    // Find the binary name in the release assets
-    let found_binary = latest_release
-        .assets
-        .iter()
-        .find(|a| a.name == BIN_NAME_NEW)
-        .or_else(|| latest_release.assets.iter().find(|a| a.name == BIN_NAME_OLD))
-        .map(|a| a.name.clone());
-
-    update_status(context, "Complete".to_string(), 1, 1, &cancel)?;
-    Ok(Box::new(CheckUpdateResult { update_available, latest_release, found_binary }))
-}
-
-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)))
-    })
-}

objdiff-gui/src/jobs/objdiff.rs

@@ -1,317 +0,0 @@
-use std::{
-    path::{Path, PathBuf},
-    process::Command,
-    sync::mpsc::Receiver,
-};
-
-use anyhow::{anyhow, Error, Result};
-use objdiff_core::{
-    diff::{diff_objs, DiffObjConfig, ObjDiff},
-    obj::{read, ObjInfo},
-};
-use time::OffsetDateTime;
-
-use crate::{
-    app::{AppConfig, ObjectConfig},
-    jobs::{start_job, update_status, Job, JobContext, JobResult, JobState},
-};
-
-pub struct BuildStatus {
-    pub success: bool,
-    pub cmdline: String,
-    pub stdout: String,
-    pub stderr: String,
-}
-
-impl Default for BuildStatus {
-    fn default() -> Self {
-        BuildStatus {
-            success: true,
-            cmdline: String::new(),
-            stdout: String::new(),
-            stderr: String::new(),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct BuildConfig {
-    pub project_dir: Option<PathBuf>,
-    pub custom_make: Option<String>,
-    pub custom_args: Option<Vec<String>>,
-    #[allow(unused)]
-    pub selected_wsl_distro: Option<String>,
-}
-
-impl BuildConfig {
-    pub(crate) fn from_config(config: &AppConfig) -> Self {
-        Self {
-            project_dir: config.project_dir.clone(),
-            custom_make: config.custom_make.clone(),
-            custom_args: config.custom_args.clone(),
-            selected_wsl_distro: config.selected_wsl_distro.clone(),
-        }
-    }
-}
-
-pub struct ObjDiffConfig {
-    pub build_config: BuildConfig,
-    pub build_base: bool,
-    pub build_target: bool,
-    pub selected_obj: Option<ObjectConfig>,
-    pub diff_obj_config: DiffObjConfig,
-}
-
-impl ObjDiffConfig {
-    pub(crate) fn from_config(config: &AppConfig) -> Self {
-        Self {
-            build_config: BuildConfig::from_config(config),
-            build_base: config.build_base,
-            build_target: config.build_target,
-            selected_obj: config.selected_obj.clone(),
-            diff_obj_config: config.diff_obj_config.clone(),
-        }
-    }
-}
-
-pub struct ObjDiffResult {
-    pub first_status: BuildStatus,
-    pub second_status: BuildStatus,
-    pub first_obj: Option<(ObjInfo, ObjDiff)>,
-    pub second_obj: Option<(ObjInfo, ObjDiff)>,
-    pub time: OffsetDateTime,
-}
-
-pub(crate) fn run_make(config: &BuildConfig, arg: &Path) -> BuildStatus {
-    let Some(cwd) = &config.project_dir else {
-        return BuildStatus {
-            success: false,
-            stderr: "Missing project dir".to_string(),
-            ..Default::default()
-        };
-    };
-    let make = config.custom_make.as_deref().unwrap_or("make");
-    let make_args = config.custom_args.as_deref().unwrap_or(&[]);
-    #[cfg(not(windows))]
-    let mut command = {
-        let mut command = Command::new(make);
-        command.current_dir(cwd).args(make_args).arg(arg);
-        command
-    };
-    #[cfg(windows)]
-    let mut command = {
-        use std::os::windows::process::CommandExt;
-
-        use path_slash::PathExt;
-        let mut command = if config.selected_wsl_distro.is_some() {
-            Command::new("wsl")
-        } else {
-            Command::new(make)
-        };
-        if let Some(distro) = &config.selected_wsl_distro {
-            // Strip distro root prefix \\wsl.localhost\{distro}
-            let wsl_path_prefix = format!("\\\\wsl.localhost\\{}", distro);
-            let cwd = match cwd.strip_prefix(wsl_path_prefix) {
-                Ok(new_cwd) => format!("/{}", new_cwd.to_slash_lossy().as_ref()),
-                Err(_) => cwd.to_string_lossy().to_string(),
-            };
-
-            command
-                .arg("--cd")
-                .arg(cwd)
-                .arg("-d")
-                .arg(distro)
-                .arg("--")
-                .arg(make)
-                .args(make_args)
-                .arg(arg.to_slash_lossy().as_ref());
-        } else {
-            command.current_dir(cwd).args(make_args).arg(arg.to_slash_lossy().as_ref());
-        }
-        command.creation_flags(winapi::um::winbase::CREATE_NO_WINDOW);
-        command
-    };
-    let mut cmdline = shell_escape::escape(command.get_program().to_string_lossy()).into_owned();
-    for arg in command.get_args() {
-        cmdline.push(' ');
-        cmdline.push_str(shell_escape::escape(arg.to_string_lossy()).as_ref());
-    }
-    let output = match command.output() {
-        Ok(output) => output,
-        Err(e) => {
-            return BuildStatus {
-                success: false,
-                cmdline,
-                stdout: Default::default(),
-                stderr: e.to_string(),
-            };
-        }
-    };
-    // Try from_utf8 first to avoid copying the buffer if it's valid, then fall back to from_utf8_lossy
-    let stdout = String::from_utf8(output.stdout)
-        .unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned());
-    let stderr = String::from_utf8(output.stderr)
-        .unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned());
-    BuildStatus { success: output.status.success(), cmdline, stdout, stderr }
-}
-
-fn run_build(
-    context: &JobContext,
-    cancel: Receiver<()>,
-    config: ObjDiffConfig,
-) -> Result<Box<ObjDiffResult>> {
-    let obj_config = config.selected_obj.as_ref().ok_or_else(|| Error::msg("Missing obj path"))?;
-    let project_dir = config
-        .build_config
-        .project_dir
-        .as_ref()
-        .ok_or_else(|| Error::msg("Missing project dir"))?;
-    let target_path_rel = if let Some(target_path) = &obj_config.target_path {
-        Some(target_path.strip_prefix(project_dir).map_err(|_| {
-            anyhow!(
-                "Target path '{}' doesn't begin with '{}'",
-                target_path.display(),
-                project_dir.display()
-            )
-        })?)
-    } else {
-        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
-    };
-
-    let mut total = 1;
-    if config.build_target && target_path_rel.is_some() {
-        total += 1;
-    }
-    if config.build_base && base_path_rel.is_some() {
-        total += 1;
-    }
-    if target_path_rel.is_some() {
-        total += 1;
-    }
-    if base_path_rel.is_some() {
-        total += 1;
-    }
-
-    let mut step_idx = 0;
-    let mut first_status = match target_path_rel {
-        Some(target_path_rel) if config.build_target => {
-            update_status(
-                context,
-                format!("Building target {}", target_path_rel.display()),
-                step_idx,
-                total,
-                &cancel,
-            )?;
-            step_idx += 1;
-            run_make(&config.build_config, target_path_rel)
-        }
-        _ => BuildStatus::default(),
-    };
-
-    let mut second_status = match base_path_rel {
-        Some(base_path_rel) if config.build_base => {
-            update_status(
-                context,
-                format!("Building base {}", base_path_rel.display()),
-                step_idx,
-                total,
-                &cancel,
-            )?;
-            step_idx += 1;
-            run_make(&config.build_config, base_path_rel)
-        }
-        _ => BuildStatus::default(),
-    };
-
-    let time = OffsetDateTime::now_utc();
-
-    let 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()),
-                step_idx,
-                total,
-                &cancel,
-            )?;
-            step_idx += 1;
-            match read::read(target_path, &config.diff_obj_config) {
-                Ok(obj) => Some(obj),
-                Err(e) => {
-                    first_status = BuildStatus {
-                        success: false,
-                        stdout: format!("Loading object '{}'", target_path.display()),
-                        stderr: format!("{:#}", e),
-                        ..Default::default()
-                    };
-                    None
-                }
-            }
-        }
-        Some(_) => {
-            step_idx += 1;
-            None
-        }
-        _ => None,
-    };
-
-    let 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()),
-                step_idx,
-                total,
-                &cancel,
-            )?;
-            step_idx += 1;
-            match read::read(base_path, &config.diff_obj_config) {
-                Ok(obj) => Some(obj),
-                Err(e) => {
-                    second_status = BuildStatus {
-                        success: false,
-                        stdout: format!("Loading object '{}'", base_path.display()),
-                        stderr: format!("{:#}", e),
-                        ..Default::default()
-                    };
-                    None
-                }
-            }
-        }
-        Some(_) => {
-            step_idx += 1;
-            None
-        }
-        _ => None,
-    };
-
-    update_status(context, "Performing diff".to_string(), step_idx, total, &cancel)?;
-    step_idx += 1;
-    let result = diff_objs(&config.diff_obj_config, first_obj.as_ref(), second_obj.as_ref(), None)?;
-
-    update_status(context, "Complete".to_string(), step_idx, total, &cancel)?;
-    Ok(Box::new(ObjDiffResult {
-        first_status,
-        second_status,
-        first_obj: first_obj.and_then(|o| result.left.map(|d| (o, d))),
-        second_obj: second_obj.and_then(|o| result.right.map(|d| (o, d))),
-        time,
-    }))
-}
-
-pub fn start_build(ctx: &egui::Context, config: ObjDiffConfig) -> JobState {
-    start_job(ctx, "Build", Job::ObjDiff, move |context, cancel| {
-        run_build(&context, cancel, config).map(|result| JobResult::ObjDiff(Some(result)))
-    })
-}

objdiff-gui/src/main.rs

@@ -4,6 +4,7 @@ mod app;
 mod app_config;
 mod config;
 mod fonts;
+mod hotkeys;
 mod jobs;
 mod update;
 mod views;
@@ -87,14 +88,29 @@ fn main() -> ExitCode {
     }
     #[cfg(feature = "wgpu")]
     {
-        use eframe::egui_wgpu::wgpu::Backends;
+        use eframe::egui_wgpu::{wgpu::Backends, WgpuSetup};
         if graphics_config.desired_backend.is_supported() {
-            native_options.wgpu_options.supported_backends = match graphics_config.desired_backend {
-                GraphicsBackend::Auto => native_options.wgpu_options.supported_backends,
-                GraphicsBackend::Dx12 => Backends::DX12,
-                GraphicsBackend::Metal => Backends::METAL,
-                GraphicsBackend::Vulkan => Backends::VULKAN,
-                GraphicsBackend::OpenGL => Backends::GL,
+            native_options.wgpu_options.wgpu_setup = match native_options.wgpu_options.wgpu_setup {
+                WgpuSetup::CreateNew {
+                    supported_backends: backends,
+                    power_preference,
+                    device_descriptor,
+                } => {
+                    let backend = match graphics_config.desired_backend {
+                        GraphicsBackend::Auto => backends,
+                        GraphicsBackend::Dx12 => Backends::DX12,
+                        GraphicsBackend::Metal => Backends::METAL,
+                        GraphicsBackend::Vulkan => Backends::VULKAN,
+                        GraphicsBackend::OpenGL => Backends::GL,
+                    };
+                    WgpuSetup::CreateNew {
+                        supported_backends: backend,
+                        power_preference,
+                        device_descriptor,
+                    }
+                }
+                // WgpuConfiguration::Default is CreateNew until we call run_eframe()
+                _ => unreachable!(),
             };
         }
     }
@@ -111,6 +127,8 @@ fn main() -> ExitCode {
     }
     #[cfg(feature = "wgpu")]
     if let Some(e) = eframe_error {
+        use eframe::egui_wgpu::WgpuConfiguration;
+
         // Attempt to relaunch using wgpu auto backend if the desired backend failed
         #[allow(unused_mut)]
         let mut should_relaunch = graphics_config.desired_backend != GraphicsBackend::Auto;
@@ -122,7 +140,7 @@ fn main() -> ExitCode {
         if should_relaunch {
             log::warn!("Failed to launch application: {e:?}");
             log::warn!("Attempting to relaunch using auto-detected backend");
-            native_options.wgpu_options.supported_backends = Default::default();
+            native_options.wgpu_options.wgpu_setup = WgpuConfiguration::default().wgpu_setup;
             if let Err(e) = run_eframe(
                 native_options.clone(),
                 utc_offset,

objdiff-gui/src/update.rs

@@ -1,5 +1,7 @@
+use anyhow::Result;
 use cfg_if::cfg_if;
 use const_format::formatcp;
+use objdiff_core::jobs::update::self_update;
 use self_update::{cargo_crate_version, update::ReleaseUpdate};
 
 pub const OS: &str = std::env::consts::OS;
@@ -26,8 +28,8 @@ pub const BIN_NAME_OLD: &str = formatcp!("objdiff-{}-{}{}", OS, ARCH, std::env::
 pub const RELEASE_URL: &str =
     formatcp!("https://github.com/{}/{}/releases/latest", GITHUB_USER, GITHUB_REPO);
 
-pub fn build_updater() -> self_update::errors::Result<Box<dyn ReleaseUpdate>> {
-    self_update::backends::github::Update::configure()
+pub fn build_updater() -> Result<Box<dyn ReleaseUpdate>> {
+    Ok(self_update::backends::github::Update::configure()
         .repo_owner(GITHUB_USER)
         .repo_name(GITHUB_REPO)
         // bin_name is required, but unused?
@@ -35,5 +37,5 @@ pub fn build_updater() -> self_update::errors::Result<Box<dyn ReleaseUpdate>> {
         .no_confirm(true)
         .show_output(false)
         .current_version(cargo_crate_version!())
-        .build()
+        .build()?)
 }

objdiff-gui/src/views/appearance.rs

@@ -205,7 +205,7 @@ pub const DEFAULT_COLOR_ROTATION: [Color32; 9] = [
     Color32::from_rgb(255, 0, 0),
     Color32::from_rgb(255, 255, 0),
     Color32::from_rgb(255, 192, 203),
-    Color32::from_rgb(0, 0, 255),
+    Color32::from_rgb(128, 128, 255),
     Color32::from_rgb(0, 255, 0),
     Color32::from_rgb(213, 138, 138),
 ];

objdiff-gui/src/views/column_layout.rs

@@ -0,0 +1,82 @@
+use egui::{Align, Layout, Sense, Vec2};
+use egui_extras::{Column, Size, StripBuilder, TableBuilder, TableRow};
+
+pub fn render_header(
+    ui: &mut egui::Ui,
+    available_width: f32,
+    num_columns: usize,
+    mut add_contents: impl FnMut(&mut egui::Ui, usize),
+) {
+    let column_width = available_width / num_columns as f32;
+    ui.allocate_ui_with_layout(
+        Vec2 { x: available_width, y: 100.0 },
+        Layout::left_to_right(Align::Min),
+        |ui| {
+            ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Truncate);
+            for i in 0..num_columns {
+                ui.allocate_ui_with_layout(
+                    Vec2 { x: column_width, y: 100.0 },
+                    Layout::top_down(Align::Min),
+                    |ui| {
+                        ui.set_width(column_width);
+                        add_contents(ui, i);
+                    },
+                );
+            }
+        },
+    );
+    ui.separator();
+}
+
+pub fn render_table(
+    ui: &mut egui::Ui,
+    available_width: f32,
+    num_columns: usize,
+    row_height: f32,
+    total_rows: usize,
+    mut add_contents: impl FnMut(&mut TableRow, usize),
+) {
+    ui.style_mut().interaction.selectable_labels = false;
+    let column_width = available_width / num_columns as f32;
+    let available_height = ui.available_height();
+    let table = TableBuilder::new(ui)
+        .striped(false)
+        .cell_layout(Layout::left_to_right(Align::Min))
+        .columns(Column::exact(column_width).clip(true), num_columns)
+        .resizable(false)
+        .auto_shrink([false, false])
+        .min_scrolled_height(available_height)
+        .sense(Sense::click());
+    table.body(|body| {
+        body.rows(row_height, total_rows, |mut row| {
+            row.set_hovered(false); // Disable hover effect
+            for i in 0..num_columns {
+                add_contents(&mut row, i);
+            }
+        });
+    });
+}
+
+pub fn render_strips(
+    ui: &mut egui::Ui,
+    available_width: f32,
+    num_columns: usize,
+    mut add_contents: impl FnMut(&mut egui::Ui, usize),
+) {
+    let column_width = available_width / num_columns as f32;
+    StripBuilder::new(ui).size(Size::remainder()).clip(true).vertical(|mut strip| {
+        strip.strip(|builder| {
+            builder.sizes(Size::exact(column_width), num_columns).clip(true).horizontal(
+                |mut strip| {
+                    for i in 0..num_columns {
+                        strip.cell(|ui| {
+                            ui.push_id(i, |ui| {
+                                add_contents(ui, i);
+                            });
+                        });
+                    }
+                },
+            );
+        });
+    });
+}

objdiff-gui/src/views/config.rs

@@ -14,18 +14,18 @@ use egui::{
 use globset::Glob;
 use objdiff_core::{
     config::{ProjectObject, DEFAULT_WATCH_PATTERNS},
-    diff::{ArmArchVersion, ArmR9Usage, MipsAbi, MipsInstrCategory, X86Formatter},
+    diff::{
+        ConfigEnum, ConfigEnumVariantInfo, ConfigPropertyId, ConfigPropertyKind,
+        ConfigPropertyValue, CONFIG_GROUPS,
+    },
+    jobs::{check_update::CheckUpdateResult, Job, JobQueue, JobResult},
 };
-use strum::{EnumMessage, VariantArray};
 
 use crate::{
     app::{AppConfig, AppState, AppStateRef, ObjectConfig},
     config::ProjectObjectNode,
-    jobs::{
-        check_update::{start_check_update, CheckUpdateResult},
-        update::start_update,
-        Job, JobQueue, JobResult,
-    },
+    hotkeys,
+    jobs::{start_check_update, start_update},
     update::RELEASE_URL,
     views::{
         appearance::Appearance,
@@ -43,7 +43,6 @@ pub struct ConfigViewState {
     pub build_running: bool,
     pub queue_build: bool,
     pub watch_pattern_text: String,
-    pub load_error: Option<String>,
     pub object_search: String,
     pub filter_diffable: bool,
     pub filter_incomplete: bool,
@@ -93,10 +92,7 @@ impl ConfigViewState {
                             name: obj_path.display().to_string(),
                             target_path: Some(target_path),
                             base_path: Some(path),
-                            reverse_fn_order: None,
-                            complete: None,
-                            scratch: None,
-                            source_path: None,
+                            ..Default::default()
                         });
                     } else if let Ok(obj_path) = path.strip_prefix(target_dir) {
                         let base_path = base_dir.join(obj_path);
@@ -104,10 +100,7 @@ impl ConfigViewState {
                             name: obj_path.display().to_string(),
                             target_path: Some(path),
                             base_path: Some(base_path),
-                            reverse_fn_order: None,
-                            complete: None,
-                            scratch: None,
-                            source_path: None,
+                            ..Default::default()
                         });
                     }
                 }
@@ -125,11 +118,11 @@ impl ConfigViewState {
 
         if self.queue_check_update {
             self.queue_check_update = false;
-            jobs.push_once(Job::CheckUpdate, || start_check_update(ctx));
+            start_check_update(ctx, jobs);
         }
 
         if let Some(bin_name) = self.queue_update.take() {
-            jobs.push_once(Job::Update, || start_update(ctx, bin_name));
+            start_update(ctx, jobs, bin_name);
         }
     }
 }
@@ -230,7 +223,10 @@ pub fn config_ui(
         }
     });
 
-    let mut new_selected_obj = selected_obj.clone();
+    let selected_index = selected_obj.as_ref().and_then(|selected_obj| {
+        objects.iter().position(|obj| obj.name.as_ref() == Some(&selected_obj.name))
+    });
+    let mut new_selected_index = selected_index;
     if objects.is_empty() {
         if let (Some(_base_dir), Some(target_dir)) = (base_obj_dir, target_obj_dir) {
             if ui.button("Select object").clicked() {
@@ -258,7 +254,11 @@ pub fn config_ui(
         }
     } else {
         let had_search = !config_state.object_search.is_empty();
-        egui::TextEdit::singleline(&mut config_state.object_search).hint_text("Filter").ui(ui);
+        let response =
+            egui::TextEdit::singleline(&mut config_state.object_search).hint_text("Filter").ui(ui);
+        if hotkeys::consume_object_filter_shortcut(ui.ctx()) {
+            response.request_focus();
+        }
 
         let mut root_open = None;
         let mut node_open = NodeOpen::Default;
@@ -316,6 +316,7 @@ pub fn config_ui(
             ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Extend);
             for node in object_nodes.iter().filter_map(|node| {
                 filter_node(
+                    objects,
                     node,
                     &search,
                     config_state.filter_diffable,
@@ -325,8 +326,9 @@ pub fn config_ui(
             }) {
                 display_node(
                     ui,
-                    &mut new_selected_obj,
+                    &mut new_selected_index,
                     project_dir.as_deref(),
+                    objects,
                     &node,
                     appearance,
                     node_open,
@@ -334,10 +336,11 @@ pub fn config_ui(
             }
         });
     }
-    if new_selected_obj != *selected_obj {
-        if let Some(obj) = new_selected_obj {
+    if new_selected_index != selected_index {
+        if let Some(idx) = new_selected_index {
             // Will set obj_changed, which will trigger a rebuild
-            state_guard.set_selected_obj(obj);
+            let config = ObjectConfig::from(&objects[idx]);
+            state_guard.set_selected_obj(config);
         }
     }
     if state_guard.config.selected_obj.is_some()
@@ -347,16 +350,17 @@ pub fn config_ui(
     }
 }
 
-fn display_object(
+fn display_unit(
     ui: &mut egui::Ui,
-    selected_obj: &mut Option<ObjectConfig>,
+    selected_obj: &mut Option<usize>,
     project_dir: Option<&Path>,
     name: &str,
-    object: &ProjectObject,
+    units: &[ProjectObject],
+    index: usize,
     appearance: &Appearance,
 ) {
-    let object_name = object.name();
-    let selected = matches!(selected_obj, Some(obj) if obj.name == object_name);
+    let object = &units[index];
+    let selected = *selected_obj == Some(index);
     let color = if selected {
         appearance.emphasized_text_color
     } else if let Some(complete) = object.complete() {
@@ -381,18 +385,8 @@ fn display_object(
     if get_source_path(project_dir, object).is_some() {
         response.context_menu(|ui| object_context_ui(ui, object, project_dir));
     }
-    // Always recreate ObjectConfig if selected, in case the project config changed.
-    // ObjectConfig is compared using equality, so this won't unnecessarily trigger a rebuild.
-    if selected || response.clicked() {
-        *selected_obj = Some(ObjectConfig {
-            name: object_name.to_string(),
-            target_path: object.target_path.clone(),
-            base_path: object.base_path.clone(),
-            reverse_fn_order: object.reverse_fn_order(),
-            complete: object.complete(),
-            scratch: object.scratch.clone(),
-            source_path: object.source_path().cloned(),
-        });
+    if response.clicked() {
+        *selected_obj = Some(index);
     }
 }
 
@@ -427,18 +421,19 @@ enum NodeOpen {
 
 fn display_node(
     ui: &mut egui::Ui,
-    selected_obj: &mut Option<ObjectConfig>,
+    selected_obj: &mut Option<usize>,
     project_dir: Option<&Path>,
+    units: &[ProjectObject],
     node: &ProjectObjectNode,
     appearance: &Appearance,
     node_open: NodeOpen,
 ) {
     match node {
-        ProjectObjectNode::File(name, object) => {
-            display_object(ui, selected_obj, project_dir, name, object, appearance);
+        ProjectObjectNode::Unit(name, idx) => {
+            display_unit(ui, selected_obj, project_dir, name, units, *idx, appearance);
         }
         ProjectObjectNode::Dir(name, children) => {
-            let contains_obj = selected_obj.as_ref().map(|path| contains_node(node, path));
+            let contains_obj = selected_obj.map(|idx| contains_node(node, idx));
             let open = match node_open {
                 NodeOpen::Default => None,
                 NodeOpen::Open => Some(true),
@@ -461,16 +456,16 @@ fn display_node(
             .open(open)
             .show(ui, |ui| {
                 for node in children {
-                    display_node(ui, selected_obj, project_dir, node, appearance, node_open);
+                    display_node(ui, selected_obj, project_dir, units, node, appearance, node_open);
                 }
             });
         }
     }
 }
 
-fn contains_node(node: &ProjectObjectNode, selected_obj: &ObjectConfig) -> bool {
+fn contains_node(node: &ProjectObjectNode, selected_obj: usize) -> bool {
     match node {
-        ProjectObjectNode::File(_, object) => object.name() == selected_obj.name,
+        ProjectObjectNode::Unit(_, idx) => *idx == selected_obj,
         ProjectObjectNode::Dir(_, children) => {
             children.iter().any(|node| contains_node(node, selected_obj))
         }
@@ -478,6 +473,7 @@ fn contains_node(node: &ProjectObjectNode, selected_obj: &ObjectConfig) -> bool
 }
 
 fn filter_node(
+    units: &[ProjectObject],
     node: &ProjectObjectNode,
     search: &str,
     filter_diffable: bool,
@@ -485,12 +481,12 @@ fn filter_node(
     show_hidden: bool,
 ) -> Option<ProjectObjectNode> {
     match node {
-        ProjectObjectNode::File(name, object) => {
+        ProjectObjectNode::Unit(name, idx) => {
+            let unit = &units[*idx];
             if (search.is_empty() || name.to_ascii_lowercase().contains(search))
-                && (!filter_diffable
-                    || (object.base_path.is_some() && object.target_path.is_some()))
-                && (!filter_incomplete || matches!(object.complete(), None | Some(false)))
-                && (show_hidden || !object.hidden())
+                && (!filter_diffable || (unit.base_path.is_some() && unit.target_path.is_some()))
+                && (!filter_incomplete || matches!(unit.complete(), None | Some(false)))
+                && (show_hidden || !unit.hidden())
             {
                 Some(node.clone())
             } else {
@@ -501,7 +497,14 @@ fn filter_node(
             let new_children = children
                 .iter()
                 .filter_map(|child| {
-                    filter_node(child, search, filter_diffable, filter_incomplete, show_hidden)
+                    filter_node(
+                        units,
+                        child,
+                        search,
+                        filter_diffable,
+                        filter_incomplete,
+                        show_hidden,
+                    )
                 })
                 .collect::<Vec<_>>();
             if !new_children.is_empty() {
@@ -570,14 +573,14 @@ pub fn project_window(
         split_obj_config_ui(ui, &mut state_guard, config_state, appearance);
     });
 
-    if let Some(error) = &config_state.load_error {
+    if let Some(error) = &state_guard.config_error {
         let mut open = true;
         egui::Window::new("Error").open(&mut open).show(ctx, |ui| {
             ui.label("Failed to load project config:");
             ui.colored_label(appearance.delete_color, error);
         });
         if !open {
-            config_state.load_error = None;
+            state_guard.config_error = None;
         }
     }
 }
@@ -873,121 +876,102 @@ pub fn arch_config_window(
     });
 }
 
+fn config_property_ui(
+    ui: &mut egui::Ui,
+    state: &mut AppState,
+    property_id: ConfigPropertyId,
+) -> bool {
+    let mut changed = false;
+    let current_value = state.config.diff_obj_config.get_property_value(property_id);
+    match (property_id.kind(), current_value) {
+        (ConfigPropertyKind::Boolean, ConfigPropertyValue::Boolean(mut checked)) => {
+            let mut response = ui.checkbox(&mut checked, property_id.name());
+            if let Some(description) = property_id.description() {
+                response = response.on_hover_text(description);
+            }
+            if response.changed() {
+                state
+                    .config
+                    .diff_obj_config
+                    .set_property_value(property_id, ConfigPropertyValue::Boolean(checked))
+                    .expect("Failed to set property value");
+                changed = true;
+            }
+        }
+        (ConfigPropertyKind::Choice(variants), ConfigPropertyValue::Choice(selected)) => {
+            fn variant_name(variant: &ConfigEnumVariantInfo) -> String {
+                if variant.is_default {
+                    format!("{} (default)", variant.name)
+                } else {
+                    variant.name.to_string()
+                }
+            }
+            let selected_variant = variants
+                .iter()
+                .find(|v| v.value == selected)
+                .or_else(|| variants.iter().find(|v| v.is_default))
+                .expect("Invalid choice variant");
+            let response = egui::ComboBox::new(property_id.name(), property_id.name())
+                .selected_text(variant_name(selected_variant))
+                .show_ui(ui, |ui| {
+                    for variant in variants {
+                        let mut response =
+                            ui.selectable_label(selected == variant.value, variant_name(variant));
+                        if let Some(description) = variant.description {
+                            response = response.on_hover_text(description);
+                        }
+                        if response.clicked() {
+                            state
+                                .config
+                                .diff_obj_config
+                                .set_property_value(
+                                    property_id,
+                                    ConfigPropertyValue::Choice(variant.value),
+                                )
+                                .expect("Failed to set property value");
+                            changed = true;
+                        }
+                    }
+                })
+                .response;
+            if let Some(description) = property_id.description() {
+                response.on_hover_text(description);
+            }
+        }
+        _ => panic!("Incompatible property kind and value"),
+    }
+    changed
+}
+
 fn arch_config_ui(ui: &mut egui::Ui, state: &mut AppState, _appearance: &Appearance) {
-    ui.heading("x86");
-    egui::ComboBox::new("x86_formatter", "Format")
-        .selected_text(state.config.diff_obj_config.x86_formatter.get_message().unwrap())
-        .show_ui(ui, |ui| {
-            for &formatter in X86Formatter::VARIANTS {
-                if ui
-                    .selectable_label(
-                        state.config.diff_obj_config.x86_formatter == formatter,
-                        formatter.get_message().unwrap(),
-                    )
-                    .clicked()
-                {
-                    state.config.diff_obj_config.x86_formatter = formatter;
-                    state.queue_reload = true;
-                }
-            }
-        });
-    ui.separator();
-    ui.heading("MIPS");
-    egui::ComboBox::new("mips_abi", "ABI")
-        .selected_text(state.config.diff_obj_config.mips_abi.get_message().unwrap())
-        .show_ui(ui, |ui| {
-            for &abi in MipsAbi::VARIANTS {
-                if ui
-                    .selectable_label(
-                        state.config.diff_obj_config.mips_abi == abi,
-                        abi.get_message().unwrap(),
-                    )
-                    .clicked()
-                {
-                    state.config.diff_obj_config.mips_abi = abi;
-                    state.queue_reload = true;
-                }
-            }
-        });
-    egui::ComboBox::new("mips_instr_category", "Instruction Category")
-        .selected_text(state.config.diff_obj_config.mips_instr_category.get_message().unwrap())
-        .show_ui(ui, |ui| {
-            for &category in MipsInstrCategory::VARIANTS {
-                if ui
-                    .selectable_label(
-                        state.config.diff_obj_config.mips_instr_category == category,
-                        category.get_message().unwrap(),
-                    )
-                    .clicked()
-                {
-                    state.config.diff_obj_config.mips_instr_category = category;
-                    state.queue_reload = true;
-                }
-            }
-        });
-    ui.separator();
-    ui.heading("ARM");
-    egui::ComboBox::new("arm_arch_version", "Architecture Version")
-        .selected_text(state.config.diff_obj_config.arm_arch_version.get_message().unwrap())
-        .show_ui(ui, |ui| {
-            for &version in ArmArchVersion::VARIANTS {
-                if ui
-                    .selectable_label(
-                        state.config.diff_obj_config.arm_arch_version == version,
-                        version.get_message().unwrap(),
-                    )
-                    .clicked()
-                {
-                    state.config.diff_obj_config.arm_arch_version = version;
-                    state.queue_reload = true;
-                }
-            }
-        });
-    let response = ui
-        .checkbox(&mut state.config.diff_obj_config.arm_unified_syntax, "Unified syntax")
-        .on_hover_text("Disassemble as unified assembly language (UAL).");
-    if response.changed() {
-        state.queue_reload = true;
+    let mut first = true;
+    let mut changed = false;
+    for group in CONFIG_GROUPS {
+        if group.id == "general" {
+            continue;
+        }
+        if first {
+            first = false;
+        } else {
+            ui.separator();
+        }
+        ui.heading(group.name);
+        for property_id in group.properties.iter().cloned() {
+            changed |= config_property_ui(ui, state, property_id);
+        }
     }
-    let response = ui
-        .checkbox(&mut state.config.diff_obj_config.arm_av_registers, "Use A/V registers")
-        .on_hover_text("Display R0-R3 as A1-A4 and R4-R11 as V1-V8");
-    if response.changed() {
-        state.queue_reload = true;
-    }
-    egui::ComboBox::new("arm_r9_usage", "Display R9 as")
-        .selected_text(state.config.diff_obj_config.arm_r9_usage.get_message().unwrap())
-        .show_ui(ui, |ui| {
-            for &usage in ArmR9Usage::VARIANTS {
-                if ui
-                    .selectable_label(
-                        state.config.diff_obj_config.arm_r9_usage == usage,
-                        usage.get_message().unwrap(),
-                    )
-                    .on_hover_text(usage.get_detailed_message().unwrap())
-                    .clicked()
-                {
-                    state.config.diff_obj_config.arm_r9_usage = usage;
-                    state.queue_reload = true;
-                }
-            }
-        });
-    let response = ui
-        .checkbox(&mut state.config.diff_obj_config.arm_sl_usage, "Display R10 as SL")
-        .on_hover_text("Used for explicit stack limits.");
-    if response.changed() {
-        state.queue_reload = true;
-    }
-    let response = ui
-        .checkbox(&mut state.config.diff_obj_config.arm_fp_usage, "Display R11 as FP")
-        .on_hover_text("Used for frame pointers.");
-    if response.changed() {
-        state.queue_reload = true;
-    }
-    let response = ui
-        .checkbox(&mut state.config.diff_obj_config.arm_ip_usage, "Display R12 as IP")
-        .on_hover_text("Used for interworking and long branches.");
-    if response.changed() {
+    if changed {
+        state.queue_reload = true;
+    }
+}
+
+pub fn general_config_ui(ui: &mut egui::Ui, state: &mut AppState) {
+    let mut changed = false;
+    let group = CONFIG_GROUPS.iter().find(|group| group.id == "general").unwrap();
+    for property_id in group.properties.iter().cloned() {
+        changed |= config_property_ui(ui, state, property_id);
+    }
+    if changed {
         state.queue_reload = true;
     }
 }

objdiff-gui/src/views/data_diff.rs

@@ -1,27 +1,137 @@
-use std::{cmp::min, default::Default, mem::take};
+use std::{
+    cmp::{min, Ordering},
+    default::Default,
+    mem::take,
+};
 
-use egui::{text::LayoutJob, Align, Label, Layout, Sense, Vec2, Widget};
-use egui_extras::{Column, TableBuilder};
+use egui::{text::LayoutJob, Id, Label, RichText, Sense, Widget};
 use objdiff_core::{
-    diff::{ObjDataDiff, ObjDataDiffKind, ObjDiff},
+    diff::{ObjDataDiff, ObjDataDiffKind, ObjDataRelocDiff, ObjDiff},
     obj::ObjInfo,
 };
 use time::format_description;
 
-use crate::views::{
-    appearance::Appearance,
-    symbol_diff::{DiffViewState, SymbolRefByName, View},
-    write_text,
+use crate::{
+    hotkeys,
+    views::{
+        appearance::Appearance,
+        column_layout::{render_header, render_table},
+        symbol_diff::{DiffViewAction, DiffViewNavigation, DiffViewState},
+        write_text,
+    },
 };
 
 const BYTES_PER_ROW: usize = 16;
 
-fn find_section(obj: &ObjInfo, selected_symbol: &SymbolRefByName) -> Option<usize> {
-    obj.sections.iter().position(|section| section.name == selected_symbol.section_name)
+fn find_section(obj: &ObjInfo, section_name: &str) -> Option<usize> {
+    obj.sections.iter().position(|section| section.name == section_name)
 }
 
-fn data_row_ui(ui: &mut egui::Ui, address: usize, diffs: &[ObjDataDiff], appearance: &Appearance) {
-    if diffs.iter().any(|d| d.kind != ObjDataDiffKind::None) {
+fn data_row_hover_ui(
+    ui: &mut egui::Ui,
+    obj: &ObjInfo,
+    diffs: &[(ObjDataDiff, Vec<ObjDataRelocDiff>)],
+    appearance: &Appearance,
+) {
+    ui.scope(|ui| {
+        ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
+        ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Extend);
+
+        let reloc_diffs = diffs.iter().flat_map(|(_, reloc_diffs)| reloc_diffs);
+        let mut prev_reloc = None;
+        for reloc_diff in reloc_diffs {
+            let reloc = &reloc_diff.reloc;
+            if prev_reloc == Some(reloc) {
+                // Avoid showing consecutive duplicate relocations.
+                // We do this because a single relocation can span across multiple diffs if the
+                // bytes in the relocation changed (e.g. first byte is added, second is unchanged).
+                continue;
+            }
+            prev_reloc = Some(reloc);
+
+            let color = get_color_for_diff_kind(reloc_diff.kind, appearance);
+
+            // TODO: Most of this code is copy-pasted from ins_hover_ui.
+            // Try to separate this out into a shared function.
+            ui.label(format!("Relocation type: {}", obj.arch.display_reloc(reloc.flags)));
+            ui.label(format!("Relocation address: {:x}", reloc.address));
+            let addend_str = match reloc.addend.cmp(&0i64) {
+                Ordering::Greater => format!("+{:x}", reloc.addend),
+                Ordering::Less => format!("-{:x}", -reloc.addend),
+                _ => "".to_string(),
+            };
+            ui.colored_label(color, format!("Name: {}{}", reloc.target.name, addend_str));
+            if let Some(orig_section_index) = reloc.target.orig_section_index {
+                if let Some(section) =
+                    obj.sections.iter().find(|s| s.orig_index == orig_section_index)
+                {
+                    ui.colored_label(color, format!("Section: {}", section.name));
+                }
+                ui.colored_label(
+                    color,
+                    format!("Address: {:x}{}", reloc.target.address, addend_str),
+                );
+                ui.colored_label(color, format!("Size: {:x}", reloc.target.size));
+                if reloc.addend >= 0 && reloc.target.bytes.len() > reloc.addend as usize {}
+            } else {
+                ui.colored_label(color, "Extern".to_string());
+            }
+        }
+    });
+}
+
+fn data_row_context_menu(ui: &mut egui::Ui, diffs: &[(ObjDataDiff, Vec<ObjDataRelocDiff>)]) {
+    ui.scope(|ui| {
+        ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
+        ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Extend);
+
+        let reloc_diffs = diffs.iter().flat_map(|(_, reloc_diffs)| reloc_diffs);
+        let mut prev_reloc = None;
+        for reloc_diff in reloc_diffs {
+            let reloc = &reloc_diff.reloc;
+            if prev_reloc == Some(reloc) {
+                // Avoid showing consecutive duplicate relocations.
+                // We do this because a single relocation can span across multiple diffs if the
+                // bytes in the relocation changed (e.g. first byte is added, second is unchanged).
+                continue;
+            }
+            prev_reloc = Some(reloc);
+
+            // TODO: This code is copy-pasted from ins_context_menu.
+            // Try to separate this out into a shared function.
+            if let Some(name) = &reloc.target.demangled_name {
+                if ui.button(format!("Copy \"{name}\"")).clicked() {
+                    ui.output_mut(|output| output.copied_text.clone_from(name));
+                    ui.close_menu();
+                }
+            }
+            if ui.button(format!("Copy \"{}\"", reloc.target.name)).clicked() {
+                ui.output_mut(|output| output.copied_text.clone_from(&reloc.target.name));
+                ui.close_menu();
+            }
+        }
+    });
+}
+
+fn get_color_for_diff_kind(diff_kind: ObjDataDiffKind, appearance: &Appearance) -> egui::Color32 {
+    match diff_kind {
+        ObjDataDiffKind::None => appearance.text_color,
+        ObjDataDiffKind::Replace => appearance.replace_color,
+        ObjDataDiffKind::Delete => appearance.delete_color,
+        ObjDataDiffKind::Insert => appearance.insert_color,
+    }
+}
+
+fn data_row_ui(
+    ui: &mut egui::Ui,
+    obj: Option<&ObjInfo>,
+    address: usize,
+    diffs: &[(ObjDataDiff, Vec<ObjDataRelocDiff>)],
+    appearance: &Appearance,
+) {
+    if diffs.iter().any(|(dd, rds)| {
+        dd.kind != ObjDataDiffKind::None || rds.iter().any(|rd| rd.kind != ObjDataDiffKind::None)
+    }) {
         ui.painter().rect_filled(ui.available_rect_before_wrap(), 0.0, ui.visuals().faint_bg_color);
     }
     let mut job = LayoutJob::default();
@@ -31,29 +141,34 @@ fn data_row_ui(ui: &mut egui::Ui, address: usize, diffs: &[ObjDataDiff], appeara
         &mut job,
         appearance.code_font.clone(),
     );
+    // The offset shown on the side of the GUI, shifted by insertions/deletions.
     let mut cur_addr = 0usize;
-    for diff in diffs {
-        let base_color = match diff.kind {
-            ObjDataDiffKind::None => appearance.text_color,
-            ObjDataDiffKind::Replace => appearance.replace_color,
-            ObjDataDiffKind::Delete => appearance.delete_color,
-            ObjDataDiffKind::Insert => appearance.insert_color,
-        };
+    // The offset into the actual bytes of the section on this side, ignoring differences.
+    let mut cur_addr_actual = address;
+    for (diff, reloc_diffs) in diffs {
+        let base_color = get_color_for_diff_kind(diff.kind, appearance);
         if diff.data.is_empty() {
             let mut str = "   ".repeat(diff.len);
             str.push_str(" ".repeat(diff.len / 8).as_str());
             write_text(str.as_str(), base_color, &mut job, appearance.code_font.clone());
             cur_addr += diff.len;
         } else {
-            let mut text = String::new();
             for byte in &diff.data {
-                text.push_str(format!("{byte:02x} ").as_str());
+                let mut byte_color = base_color;
+                if let Some(reloc_diff) = reloc_diffs.iter().find(|reloc_diff| {
+                    reloc_diff.kind != ObjDataDiffKind::None
+                        && reloc_diff.range.contains(&cur_addr_actual)
+                }) {
+                    byte_color = get_color_for_diff_kind(reloc_diff.kind, appearance);
+                }
+                let byte_text = format!("{byte:02x} ");
+                write_text(byte_text.as_str(), byte_color, &mut job, appearance.code_font.clone());
                 cur_addr += 1;
+                cur_addr_actual += 1;
                 if cur_addr % 8 == 0 {
-                    text.push(' ');
+                    write_text(" ", base_color, &mut job, appearance.code_font.clone());
                 }
             }
-            write_text(text.as_str(), base_color, &mut job, appearance.code_font.clone());
         }
     }
     if cur_addr < BYTES_PER_ROW {
@@ -64,13 +179,8 @@ fn data_row_ui(ui: &mut egui::Ui, address: usize, diffs: &[ObjDataDiff], appeara
         write_text(str.as_str(), appearance.text_color, &mut job, appearance.code_font.clone());
     }
     write_text(" ", appearance.text_color, &mut job, appearance.code_font.clone());
-    for diff in diffs {
-        let base_color = match diff.kind {
-            ObjDataDiffKind::None => appearance.text_color,
-            ObjDataDiffKind::Replace => appearance.replace_color,
-            ObjDataDiffKind::Delete => appearance.delete_color,
-            ObjDataDiffKind::Insert => appearance.insert_color,
-        };
+    for (diff, _) in diffs {
+        let base_color = get_color_for_diff_kind(diff.kind, appearance);
         if diff.data.is_empty() {
             write_text(
                 " ".repeat(diff.len).as_str(),
@@ -91,22 +201,33 @@ fn data_row_ui(ui: &mut egui::Ui, address: usize, diffs: &[ObjDataDiff], appeara
             write_text(text.as_str(), base_color, &mut job, appearance.code_font.clone());
         }
     }
-    Label::new(job).sense(Sense::click()).ui(ui);
-    //     .on_hover_ui_at_pointer(|ui| ins_hover_ui(ui, ins))
-    //     .context_menu(|ui| ins_context_menu(ui, ins));
+
+    let response = Label::new(job).sense(Sense::click()).ui(ui);
+    if let Some(obj) = obj {
+        response
+            .on_hover_ui_at_pointer(|ui| data_row_hover_ui(ui, obj, diffs, appearance))
+            .context_menu(|ui| data_row_context_menu(ui, diffs));
+    }
 }
 
-fn split_diffs(diffs: &[ObjDataDiff]) -> Vec<Vec<ObjDataDiff>> {
-    let mut split_diffs = Vec::<Vec<ObjDataDiff>>::new();
-    let mut row_diffs = Vec::<ObjDataDiff>::new();
+fn split_diffs(
+    diffs: &[ObjDataDiff],
+    reloc_diffs: &[ObjDataRelocDiff],
+) -> Vec<Vec<(ObjDataDiff, Vec<ObjDataRelocDiff>)>> {
+    let mut split_diffs = Vec::<Vec<(ObjDataDiff, Vec<ObjDataRelocDiff>)>>::new();
+    let mut row_diffs = Vec::<(ObjDataDiff, Vec<ObjDataRelocDiff>)>::new();
+    // The offset shown on the side of the GUI, shifted by insertions/deletions.
     let mut cur_addr = 0usize;
+    // The offset into the actual bytes of the section on this side, ignoring differences.
+    let mut cur_addr_actual = 0usize;
     for diff in diffs {
         let mut cur_len = 0usize;
         while cur_len < diff.len {
             let remaining_len = diff.len - cur_len;
             let mut remaining_in_row = BYTES_PER_ROW - (cur_addr % BYTES_PER_ROW);
             let len = min(remaining_len, remaining_in_row);
-            row_diffs.push(ObjDataDiff {
+
+            let data_diff = ObjDataDiff {
                 data: if diff.data.is_empty() {
                     Vec::new()
                 } else {
@@ -114,9 +235,28 @@ fn split_diffs(diffs: &[ObjDataDiff]) -> Vec<Vec<ObjDataDiff>> {
                 },
                 kind: diff.kind,
                 len,
-                // TODO
-                symbol: String::new(),
-            });
+                symbol: String::new(), // TODO
+            };
+            let row_reloc_diffs: Vec<ObjDataRelocDiff> = if diff.data.is_empty() {
+                Vec::new()
+            } else {
+                let diff_range = cur_addr_actual + cur_len..cur_addr_actual + cur_len + len;
+                reloc_diffs
+                    .iter()
+                    .filter_map(|reloc_diff| {
+                        if reloc_diff.range.start < diff_range.end
+                            && diff_range.start < reloc_diff.range.end
+                        {
+                            Some(reloc_diff.clone())
+                        } else {
+                            None
+                        }
+                    })
+                    .collect()
+            };
+            let row_diff = (data_diff, row_reloc_diffs);
+
+            row_diffs.push(row_diff);
             remaining_in_row -= len;
             cur_len += len;
             cur_addr += len;
@@ -124,6 +264,7 @@ fn split_diffs(diffs: &[ObjDataDiff]) -> Vec<Vec<ObjDataDiff>> {
                 split_diffs.push(take(&mut row_diffs));
             }
         }
+        cur_addr_actual += diff.data.len();
     }
     if !row_diffs.is_empty() {
         split_diffs.push(take(&mut row_diffs));
@@ -131,20 +272,39 @@ fn split_diffs(diffs: &[ObjDataDiff]) -> Vec<Vec<ObjDataDiff>> {
     split_diffs
 }
 
+#[derive(Clone, Copy)]
+struct SectionDiffContext<'a> {
+    obj: &'a ObjInfo,
+    diff: &'a ObjDiff,
+    section_index: Option<usize>,
+}
+
+impl<'a> SectionDiffContext<'a> {
+    pub fn new(obj: Option<&'a (ObjInfo, ObjDiff)>, section_name: Option<&str>) -> Option<Self> {
+        obj.map(|(obj, diff)| Self {
+            obj,
+            diff,
+            section_index: section_name.and_then(|section_name| find_section(obj, section_name)),
+        })
+    }
+
+    #[inline]
+    pub fn has_section(&self) -> bool { self.section_index.is_some() }
+}
+
 fn data_table_ui(
-    table: TableBuilder<'_>,
-    left_obj: Option<&(ObjInfo, ObjDiff)>,
-    right_obj: Option<&(ObjInfo, ObjDiff)>,
-    selected_symbol: &SymbolRefByName,
+    ui: &mut egui::Ui,
+    available_width: f32,
+    left_ctx: Option<SectionDiffContext<'_>>,
+    right_ctx: Option<SectionDiffContext<'_>>,
     config: &Appearance,
 ) -> Option<()> {
-    let left_section = left_obj.and_then(|(obj, diff)| {
-        find_section(obj, selected_symbol).map(|i| (&obj.sections[i], &diff.sections[i]))
-    });
-    let right_section = right_obj.and_then(|(obj, diff)| {
-        find_section(obj, selected_symbol).map(|i| (&obj.sections[i], &diff.sections[i]))
-    });
-
+    let left_obj = left_ctx.map(|ctx| ctx.obj);
+    let right_obj = right_ctx.map(|ctx| ctx.obj);
+    let left_section = left_ctx
+        .and_then(|ctx| ctx.section_index.map(|i| (&ctx.obj.sections[i], &ctx.diff.sections[i])));
+    let right_section = right_ctx
+        .and_then(|ctx| ctx.section_index.map(|i| (&ctx.obj.sections[i], &ctx.diff.sections[i])));
     let total_bytes = left_section
         .or(right_section)?
         .1
@@ -156,121 +316,124 @@ fn data_table_ui(
     }
     let total_rows = (total_bytes - 1) / BYTES_PER_ROW + 1;
 
-    let left_diffs = left_section.map(|(_, section)| split_diffs(&section.data_diff));
-    let right_diffs = right_section.map(|(_, section)| split_diffs(&section.data_diff));
+    let left_diffs =
+        left_section.map(|(_, section)| split_diffs(&section.data_diff, &section.reloc_diff));
+    let right_diffs =
+        right_section.map(|(_, section)| split_diffs(&section.data_diff, &section.reloc_diff));
 
-    table.body(|body| {
-        body.rows(config.code_font.size, total_rows, |mut row| {
-            let row_index = row.index();
-            let address = row_index * BYTES_PER_ROW;
-            row.col(|ui| {
+    hotkeys::check_scroll_hotkeys(ui, true);
+
+    render_table(ui, available_width, 2, config.code_font.size, total_rows, |row, column| {
+        let i = row.index();
+        let address = i * BYTES_PER_ROW;
+        row.col(|ui| {
+            if column == 0 {
                 if let Some(left_diffs) = &left_diffs {
-                    data_row_ui(ui, address, &left_diffs[row_index], config);
+                    data_row_ui(ui, left_obj, address, &left_diffs[i], config);
                 }
-            });
-            row.col(|ui| {
+            } else if column == 1 {
                 if let Some(right_diffs) = &right_diffs {
-                    data_row_ui(ui, address, &right_diffs[row_index], config);
+                    data_row_ui(ui, right_obj, address, &right_diffs[i], config);
                 }
-            });
+            }
         });
     });
     Some(())
 }
 
-pub fn data_diff_ui(ui: &mut egui::Ui, state: &mut DiffViewState, appearance: &Appearance) {
-    let (Some(result), Some(selected_symbol)) = (&state.build, &state.symbol_state.selected_symbol)
-    else {
-        return;
+#[must_use]
+pub fn data_diff_ui(
+    ui: &mut egui::Ui,
+    state: &DiffViewState,
+    appearance: &Appearance,
+) -> Option<DiffViewAction> {
+    let mut ret = None;
+    let Some(result) = &state.build else {
+        return ret;
     };
 
+    let section_name =
+        state.symbol_state.left_symbol.as_ref().and_then(|s| s.section_name.as_deref()).or_else(
+            || state.symbol_state.right_symbol.as_ref().and_then(|s| s.section_name.as_deref()),
+        );
+    let left_ctx = SectionDiffContext::new(result.first_obj.as_ref(), section_name);
+    let right_ctx = SectionDiffContext::new(result.second_obj.as_ref(), section_name);
+
+    // If both sides are missing a symbol, switch to symbol diff view
+    if !right_ctx.is_some_and(|ctx| ctx.has_section())
+        && !left_ctx.is_some_and(|ctx| ctx.has_section())
+    {
+        return Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
+    }
+
     // Header
     let available_width = ui.available_width();
-    let column_width = available_width / 2.0;
-    ui.allocate_ui_with_layout(
-        Vec2 { x: available_width, y: 100.0 },
-        Layout::left_to_right(Align::Min),
-        |ui| {
-            ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Truncate);
-
+    render_header(ui, available_width, 2, |ui, column| {
+        if column == 0 {
             // Left column
-            ui.allocate_ui_with_layout(
-                Vec2 { x: column_width, y: 100.0 },
-                Layout::top_down(Align::Min),
-                |ui| {
-                    ui.set_width(column_width);
-
-                    if ui.button("⏴ Back").clicked() {
-                        state.current_view = View::SymbolDiff;
-                    }
-
-                    ui.scope(|ui| {
-                        ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
-                        ui.colored_label(appearance.highlight_color, &selected_symbol.symbol_name);
-                        ui.label("Diff target:");
-                    });
-                },
-            );
+            if ui.button("⏴ Back").clicked() || hotkeys::back_pressed(ui.ctx()) {
+                ret = Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
+            }
 
+            if let Some(section) =
+                left_ctx.and_then(|ctx| ctx.section_index.map(|i| &ctx.obj.sections[i]))
+            {
+                ui.label(
+                    RichText::new(section.name.clone())
+                        .font(appearance.code_font.clone())
+                        .color(appearance.highlight_color),
+                );
+            } else {
+                ui.label(
+                    RichText::new("Missing")
+                        .font(appearance.code_font.clone())
+                        .color(appearance.replace_color),
+                );
+            }
+        } else if column == 1 {
             // Right column
-            ui.allocate_ui_with_layout(
-                Vec2 { x: column_width, y: 100.0 },
-                Layout::top_down(Align::Min),
-                |ui| {
-                    ui.set_width(column_width);
+            ui.horizontal(|ui| {
+                if ui.add_enabled(!state.build_running, egui::Button::new("Build")).clicked() {
+                    ret = Some(DiffViewAction::Build);
+                }
+                ui.scope(|ui| {
+                    ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
+                    if state.build_running {
+                        ui.colored_label(appearance.replace_color, "Building…");
+                    } else {
+                        ui.label("Last built:");
+                        let format = format_description::parse("[hour]:[minute]:[second]").unwrap();
+                        ui.label(
+                            result.time.to_offset(appearance.utc_offset).format(&format).unwrap(),
+                        );
+                    }
+                });
+            });
 
-                    ui.horizontal(|ui| {
-                        if ui
-                            .add_enabled(!state.build_running, egui::Button::new("Build"))
-                            .clicked()
-                        {
-                            state.queue_build = true;
-                        }
-                        ui.scope(|ui| {
-                            ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
-                            if state.build_running {
-                                ui.colored_label(appearance.replace_color, "Building…");
-                            } else {
-                                ui.label("Last built:");
-                                let format =
-                                    format_description::parse("[hour]:[minute]:[second]").unwrap();
-                                ui.label(
-                                    result
-                                        .time
-                                        .to_offset(appearance.utc_offset)
-                                        .format(&format)
-                                        .unwrap(),
-                                );
-                            }
-                        });
-                    });
-
-                    ui.scope(|ui| {
-                        ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
-                        ui.label("");
-                        ui.label("Diff base:");
-                    });
-                },
-            );
-        },
-    );
-    ui.separator();
+            if let Some(section) =
+                right_ctx.and_then(|ctx| ctx.section_index.map(|i| &ctx.obj.sections[i]))
+            {
+                ui.label(
+                    RichText::new(section.name.clone())
+                        .font(appearance.code_font.clone())
+                        .color(appearance.highlight_color),
+                );
+            } else {
+                ui.label(
+                    RichText::new("Missing")
+                        .font(appearance.code_font.clone())
+                        .color(appearance.replace_color),
+                );
+            }
+        }
+    });
 
     // Table
-    ui.style_mut().interaction.selectable_labels = false;
-    let available_height = ui.available_height();
-    let table = TableBuilder::new(ui)
-        .striped(false)
-        .cell_layout(Layout::left_to_right(Align::Min))
-        .columns(Column::exact(column_width).clip(true), 2)
-        .resizable(false)
-        .auto_shrink([false, false])
-        .min_scrolled_height(available_height);
-    data_table_ui(
-        table,
-        result.first_obj.as_ref(),
-        result.second_obj.as_ref(),
-        selected_symbol,
-        appearance,
-    );
+    let id =
+        Id::new(state.symbol_state.left_symbol.as_ref().and_then(|s| s.section_name.as_deref()))
+            .with(state.symbol_state.right_symbol.as_ref().and_then(|s| s.section_name.as_deref()));
+    ui.push_id(id, |ui| {
+        data_table_ui(ui, available_width, left_ctx, right_ctx, appearance);
+    });
+    ret
 }

objdiff-gui/src/views/extab_diff.rs

@@ -1,28 +1,23 @@
-use egui::{Align, Layout, ScrollArea, Ui, Vec2};
-use egui_extras::{Size, StripBuilder};
+use egui::{RichText, ScrollArea};
 use objdiff_core::{
     arch::ppc::ExceptionInfo,
-    diff::ObjDiff,
-    obj::{ObjInfo, ObjSymbol, SymbolRef},
+    obj::{ObjInfo, ObjSymbol},
 };
 use time::format_description;
 
-use crate::views::{
-    appearance::Appearance,
-    symbol_diff::{match_color_for_symbol, DiffViewState, SymbolRefByName, View},
+use crate::{
+    hotkeys,
+    views::{
+        appearance::Appearance,
+        column_layout::{render_header, render_strips},
+        function_diff::FunctionDiffContext,
+        symbol_diff::{
+            match_color_for_symbol, DiffViewAction, DiffViewNavigation, DiffViewState,
+            SymbolRefByName, View,
+        },
+    },
 };
 
-fn find_symbol(obj: &ObjInfo, selected_symbol: &SymbolRefByName) -> Option<SymbolRef> {
-    for (section_idx, section) in obj.sections.iter().enumerate() {
-        for (symbol_idx, symbol) in section.symbols.iter().enumerate() {
-            if symbol.name == selected_symbol.symbol_name {
-                return Some(SymbolRef { section_idx, symbol_idx });
-            }
-        }
-    }
-    None
-}
-
 fn decode_extab(extab: &ExceptionInfo) -> String {
     let mut text = String::from("");
 
@@ -48,14 +43,12 @@ fn find_extab_entry<'a>(obj: &'a ObjInfo, symbol: &ObjSymbol) -> Option<&'a Exce
 }
 
 fn extab_text_ui(
-    ui: &mut Ui,
-    obj: &(ObjInfo, ObjDiff),
-    symbol_ref: SymbolRef,
+    ui: &mut egui::Ui,
+    ctx: FunctionDiffContext<'_>,
+    symbol: &ObjSymbol,
     appearance: &Appearance,
 ) -> Option<()> {
-    let (_section, symbol) = obj.0.section_symbol(symbol_ref);
-
-    if let Some(extab_entry) = find_extab_entry(&obj.0, symbol) {
+    if let Some(extab_entry) = find_extab_entry(ctx.obj, symbol) {
         let text = decode_extab(extab_entry);
         ui.colored_label(appearance.replace_color, &text);
         return Some(());
@@ -65,137 +58,196 @@ fn extab_text_ui(
 }
 
 fn extab_ui(
-    ui: &mut Ui,
-    obj: Option<&(ObjInfo, ObjDiff)>,
-    selected_symbol: &SymbolRefByName,
+    ui: &mut egui::Ui,
+    ctx: FunctionDiffContext<'_>,
     appearance: &Appearance,
-    _left: bool,
+    _column: usize,
 ) {
     ScrollArea::both().auto_shrink([false, false]).show(ui, |ui| {
         ui.scope(|ui| {
             ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
             ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Extend);
 
-            let symbol = obj.and_then(|(obj, _)| find_symbol(obj, selected_symbol));
-
-            if let (Some(object), Some(symbol_ref)) = (obj, symbol) {
-                extab_text_ui(ui, object, symbol_ref, appearance);
+            if let Some((_section, symbol)) =
+                ctx.symbol_ref.map(|symbol_ref| ctx.obj.section_symbol(symbol_ref))
+            {
+                extab_text_ui(ui, ctx, symbol, appearance);
             }
         });
     });
 }
 
-pub fn extab_diff_ui(ui: &mut egui::Ui, state: &mut DiffViewState, appearance: &Appearance) {
-    let (Some(result), Some(selected_symbol)) = (&state.build, &state.symbol_state.selected_symbol)
-    else {
-        return;
+#[must_use]
+pub fn extab_diff_ui(
+    ui: &mut egui::Ui,
+    state: &DiffViewState,
+    appearance: &Appearance,
+) -> Option<DiffViewAction> {
+    let mut ret = None;
+    let Some(result) = &state.build else {
+        return ret;
     };
 
+    let mut left_ctx = FunctionDiffContext::new(
+        result.first_obj.as_ref(),
+        state.symbol_state.left_symbol.as_ref(),
+    );
+    let mut right_ctx = FunctionDiffContext::new(
+        result.second_obj.as_ref(),
+        state.symbol_state.right_symbol.as_ref(),
+    );
+
+    // If one side is missing a symbol, but the diff process found a match, use that symbol
+    let left_diff_symbol = left_ctx.and_then(|ctx| {
+        ctx.symbol_ref.and_then(|symbol_ref| ctx.diff.symbol_diff(symbol_ref).target_symbol)
+    });
+    let right_diff_symbol = right_ctx.and_then(|ctx| {
+        ctx.symbol_ref.and_then(|symbol_ref| ctx.diff.symbol_diff(symbol_ref).target_symbol)
+    });
+    if left_diff_symbol.is_some() && right_ctx.is_some_and(|ctx| !ctx.has_symbol()) {
+        let (right_section, right_symbol) =
+            right_ctx.unwrap().obj.section_symbol(left_diff_symbol.unwrap());
+        let symbol_ref = SymbolRefByName::new(right_symbol, right_section);
+        right_ctx = FunctionDiffContext::new(result.second_obj.as_ref(), Some(&symbol_ref));
+        ret = Some(DiffViewAction::Navigate(DiffViewNavigation {
+            view: Some(View::FunctionDiff),
+            left_symbol: state.symbol_state.left_symbol.clone(),
+            right_symbol: Some(symbol_ref),
+        }));
+    } else if right_diff_symbol.is_some() && left_ctx.is_some_and(|ctx| !ctx.has_symbol()) {
+        let (left_section, left_symbol) =
+            left_ctx.unwrap().obj.section_symbol(right_diff_symbol.unwrap());
+        let symbol_ref = SymbolRefByName::new(left_symbol, left_section);
+        left_ctx = FunctionDiffContext::new(result.first_obj.as_ref(), Some(&symbol_ref));
+        ret = Some(DiffViewAction::Navigate(DiffViewNavigation {
+            view: Some(View::FunctionDiff),
+            left_symbol: Some(symbol_ref),
+            right_symbol: state.symbol_state.right_symbol.clone(),
+        }));
+    }
+
+    // If both sides are missing a symbol, switch to symbol diff view
+    if right_ctx.is_some_and(|ctx| !ctx.has_symbol())
+        && left_ctx.is_some_and(|ctx| !ctx.has_symbol())
+    {
+        return Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
+    }
+
     // Header
     let available_width = ui.available_width();
-    let column_width = available_width / 2.0;
-    ui.allocate_ui_with_layout(
-        Vec2 { x: available_width, y: 100.0 },
-        Layout::left_to_right(Align::Min),
-        |ui| {
-            ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Truncate);
-
+    render_header(ui, available_width, 2, |ui, column| {
+        if column == 0 {
             // Left column
-            ui.allocate_ui_with_layout(
-                Vec2 { x: column_width, y: 100.0 },
-                Layout::top_down(Align::Min),
-                |ui| {
-                    ui.set_width(column_width);
-
-                    ui.horizontal(|ui| {
-                        if ui.button("⏴ Back").clicked() {
-                            state.current_view = View::SymbolDiff;
-                        }
-                    });
-
-                    let name = selected_symbol
-                        .demangled_symbol_name
-                        .as_deref()
-                        .unwrap_or(&selected_symbol.symbol_name);
-                    ui.scope(|ui| {
-                        ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
-                        ui.colored_label(appearance.highlight_color, name);
-                        ui.label("Diff target:");
-                    });
-                },
-            );
+            ui.horizontal(|ui| {
+                if ui.button("⏴ Back").clicked() || hotkeys::back_pressed(ui.ctx()) {
+                    ret = Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
+                }
+                ui.separator();
+                if ui
+                    .add_enabled(
+                        !state.scratch_running
+                            && state.scratch_available
+                            && left_ctx.is_some_and(|ctx| ctx.has_symbol()),
+                        egui::Button::new("📲 decomp.me"),
+                    )
+                    .on_hover_text_at_pointer("Create a new scratch on decomp.me (beta)")
+                    .on_disabled_hover_text("Scratch configuration missing")
+                    .clicked()
+                {
+                    if let Some((_section, symbol)) = left_ctx.and_then(|ctx| {
+                        ctx.symbol_ref.map(|symbol_ref| ctx.obj.section_symbol(symbol_ref))
+                    }) {
+                        ret = Some(DiffViewAction::CreateScratch(symbol.name.clone()));
+                    }
+                }
+            });
 
+            if let Some((_section, symbol)) = left_ctx
+                .and_then(|ctx| ctx.symbol_ref.map(|symbol_ref| ctx.obj.section_symbol(symbol_ref)))
+            {
+                let name = symbol.demangled_name.as_deref().unwrap_or(&symbol.name);
+                ui.label(
+                    RichText::new(name)
+                        .font(appearance.code_font.clone())
+                        .color(appearance.highlight_color),
+                );
+            } else {
+                ui.label(
+                    RichText::new("Missing")
+                        .font(appearance.code_font.clone())
+                        .color(appearance.replace_color),
+                );
+            }
+        } else if column == 1 {
             // Right column
-            ui.allocate_ui_with_layout(
-                Vec2 { x: column_width, y: 100.0 },
-                Layout::top_down(Align::Min),
-                |ui| {
-                    ui.set_width(column_width);
+            ui.horizontal(|ui| {
+                if ui.add_enabled(!state.build_running, egui::Button::new("Build")).clicked() {
+                    ret = Some(DiffViewAction::Build);
+                }
+                ui.scope(|ui| {
+                    ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
+                    if state.build_running {
+                        ui.colored_label(appearance.replace_color, "Building…");
+                    } else {
+                        ui.label("Last built:");
+                        let format = format_description::parse("[hour]:[minute]:[second]").unwrap();
+                        ui.label(
+                            result.time.to_offset(appearance.utc_offset).format(&format).unwrap(),
+                        );
+                    }
+                });
+                ui.separator();
+                if ui
+                    .add_enabled(state.source_path_available, egui::Button::new("🖹 Source file"))
+                    .on_hover_text_at_pointer("Open the source file in the default editor")
+                    .on_disabled_hover_text("Source file metadata missing")
+                    .clicked()
+                {
+                    ret = Some(DiffViewAction::OpenSourcePath);
+                }
+            });
 
-                    ui.horizontal(|ui| {
-                        if ui
-                            .add_enabled(!state.build_running, egui::Button::new("Build"))
-                            .clicked()
-                        {
-                            state.queue_build = true;
-                        }
-                        ui.scope(|ui| {
-                            ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
-                            if state.build_running {
-                                ui.colored_label(appearance.replace_color, "Building…");
-                            } else {
-                                ui.label("Last built:");
-                                let format =
-                                    format_description::parse("[hour]:[minute]:[second]").unwrap();
-                                ui.label(
-                                    result
-                                        .time
-                                        .to_offset(appearance.utc_offset)
-                                        .format(&format)
-                                        .unwrap(),
-                                );
-                            }
-                        });
-                    });
+            if let Some(((_section, symbol), symbol_diff)) = right_ctx.and_then(|ctx| {
+                ctx.symbol_ref.map(|symbol_ref| {
+                    (ctx.obj.section_symbol(symbol_ref), ctx.diff.symbol_diff(symbol_ref))
+                })
+            }) {
+                let name = symbol.demangled_name.as_deref().unwrap_or(&symbol.name);
+                ui.label(
+                    RichText::new(name)
+                        .font(appearance.code_font.clone())
+                        .color(appearance.highlight_color),
+                );
+                if let Some(match_percent) = symbol_diff.match_percent {
+                    ui.label(
+                        RichText::new(format!("{:.0}%", match_percent.floor()))
+                            .font(appearance.code_font.clone())
+                            .color(match_color_for_symbol(match_percent, appearance)),
+                    );
+                }
+            } else {
+                ui.label(
+                    RichText::new("Missing")
+                        .font(appearance.code_font.clone())
+                        .color(appearance.replace_color),
+                );
+            }
+        }
+    });
 
-                    ui.scope(|ui| {
-                        ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
-                        if let Some(match_percent) = result
-                            .second_obj
-                            .as_ref()
-                            .and_then(|(obj, diff)| {
-                                find_symbol(obj, selected_symbol).map(|sref| {
-                                    &diff.sections[sref.section_idx].symbols[sref.symbol_idx]
-                                })
-                            })
-                            .and_then(|symbol| symbol.match_percent)
-                        {
-                            ui.colored_label(
-                                match_color_for_symbol(match_percent, appearance),
-                                format!("{match_percent:.0}%"),
-                            );
-                        } else {
-                            ui.colored_label(appearance.replace_color, "Missing");
-                        }
-                        ui.label("Diff base:");
-                    });
-                },
-            );
-        },
-    );
-    ui.separator();
+    hotkeys::check_scroll_hotkeys(ui, true);
 
     // Table
-    StripBuilder::new(ui).size(Size::remainder()).vertical(|mut strip| {
-        strip.strip(|builder| {
-            builder.sizes(Size::remainder(), 2).horizontal(|mut strip| {
-                strip.cell(|ui| {
-                    extab_ui(ui, result.first_obj.as_ref(), selected_symbol, appearance, true);
-                });
-                strip.cell(|ui| {
-                    extab_ui(ui, result.second_obj.as_ref(), selected_symbol, appearance, false);
-                });
-            });
-        });
+    render_strips(ui, available_width, 2, |ui, column| {
+        if column == 0 {
+            if let Some(ctx) = left_ctx {
+                extab_ui(ui, ctx, appearance, column);
+            }
+        } else if column == 1 {
+            if let Some(ctx) = right_ctx {
+                extab_ui(ui, ctx, appearance, column);
+            }
+        }
     });
+    ret
 }

objdiff-gui/src/views/function_diff.rs

@@ -1,28 +1,31 @@
-use std::default::Default;
+use std::{cmp::Ordering, default::Default};
 
-use egui::{text::LayoutJob, Align, Label, Layout, Response, Sense, Vec2, Widget};
-use egui_extras::{Column, TableBuilder, TableRow};
+use egui::{text::LayoutJob, Id, Label, Layout, Response, RichText, Sense, Widget};
+use egui_extras::TableRow;
 use objdiff_core::{
-    arch::ObjArch,
     diff::{
         display::{display_diff, DiffText, HighlightKind},
         ObjDiff, ObjInsDiff, ObjInsDiffKind,
     },
-    obj::{ObjInfo, ObjIns, ObjInsArg, ObjInsArgValue, ObjSection, ObjSymbol, SymbolRef},
+    obj::{
+        ObjInfo, ObjIns, ObjInsArg, ObjInsArgValue, ObjSection, ObjSectionKind, ObjSymbol,
+        SymbolRef,
+    },
 };
 use time::format_description;
 
-use crate::views::{
-    appearance::Appearance,
-    symbol_diff::{match_color_for_symbol, DiffViewState, SymbolRefByName, View},
+use crate::{
+    hotkeys,
+    views::{
+        appearance::Appearance,
+        column_layout::{render_header, render_strips, render_table},
+        symbol_diff::{
+            match_color_for_symbol, symbol_list_ui, DiffViewAction, DiffViewNavigation,
+            DiffViewState, SymbolDiffContext, SymbolFilter, SymbolRefByName, SymbolViewState, View,
+        },
+    },
 };
 
-#[derive(Copy, Clone, Eq, PartialEq)]
-enum ColumnId {
-    Left,
-    Right,
-}
-
 #[derive(Default)]
 pub struct FunctionViewState {
     left_highlight: HighlightKind,
@@ -30,16 +33,17 @@ pub struct FunctionViewState {
 }
 
 impl FunctionViewState {
-    fn highlight(&self, column: ColumnId) -> &HighlightKind {
+    pub fn highlight(&self, column: usize) -> &HighlightKind {
         match column {
-            ColumnId::Left => &self.left_highlight,
-            ColumnId::Right => &self.right_highlight,
+            0 => &self.left_highlight,
+            1 => &self.right_highlight,
+            _ => &HighlightKind::None,
         }
     }
 
-    fn set_highlight(&mut self, column: ColumnId, highlight: HighlightKind) {
+    pub fn set_highlight(&mut self, column: usize, highlight: HighlightKind) {
         match column {
-            ColumnId::Left => {
+            0 => {
                 if highlight == self.left_highlight {
                     if highlight == self.right_highlight {
                         self.left_highlight = HighlightKind::None;
@@ -51,7 +55,7 @@ impl FunctionViewState {
                     self.left_highlight = highlight;
                 }
             }
-            ColumnId::Right => {
+            1 => {
                 if highlight == self.right_highlight {
                     if highlight == self.left_highlight {
                         self.left_highlight = HighlightKind::None;
@@ -63,13 +67,19 @@ impl FunctionViewState {
                     self.right_highlight = highlight;
                 }
             }
+            _ => {}
         }
     }
+
+    pub fn clear_highlight(&mut self) {
+        self.left_highlight = HighlightKind::None;
+        self.right_highlight = HighlightKind::None;
+    }
 }
 
 fn ins_hover_ui(
     ui: &mut egui::Ui,
-    arch: &dyn ObjArch,
+    obj: &ObjInfo,
     section: &ObjSection,
     ins: &ObjIns,
     symbol: &ObjSymbol,
@@ -112,28 +122,44 @@ fn ins_hover_ui(
         }
 
         if let Some(reloc) = &ins.reloc {
-            ui.label(format!("Relocation type: {}", arch.display_reloc(reloc.flags)));
-            ui.colored_label(appearance.highlight_color, format!("Name: {}", reloc.target.name));
-            if let Some(section) = &reloc.target_section {
-                ui.colored_label(appearance.highlight_color, format!("Section: {section}"));
+            ui.label(format!("Relocation type: {}", obj.arch.display_reloc(reloc.flags)));
+            let addend_str = match reloc.addend.cmp(&0i64) {
+                Ordering::Greater => format!("+{:x}", reloc.addend),
+                Ordering::Less => format!("-{:x}", -reloc.addend),
+                _ => "".to_string(),
+            };
+            ui.colored_label(
+                appearance.highlight_color,
+                format!("Name: {}{}", reloc.target.name, addend_str),
+            );
+            if let Some(orig_section_index) = reloc.target.orig_section_index {
+                if let Some(section) =
+                    obj.sections.iter().find(|s| s.orig_index == orig_section_index)
+                {
+                    ui.colored_label(
+                        appearance.highlight_color,
+                        format!("Section: {}", section.name),
+                    );
+                }
                 ui.colored_label(
                     appearance.highlight_color,
-                    format!("Address: {:x}", reloc.target.address),
+                    format!("Address: {:x}{}", reloc.target.address, addend_str),
                 );
                 ui.colored_label(
                     appearance.highlight_color,
                     format!("Size: {:x}", reloc.target.size),
                 );
-                if let Some(s) = arch
-                    .guess_data_type(ins)
-                    .and_then(|ty| arch.display_data_type(ty, &reloc.target.bytes))
-                {
+                if let Some(s) = obj.arch.display_ins_data(ins) {
                     ui.colored_label(appearance.highlight_color, s);
                 }
             } else {
                 ui.colored_label(appearance.highlight_color, "Extern".to_string());
             }
         }
+
+        if let Some(decoded) = rlwinmdec::decode(&ins.formatted) {
+            ui.colored_label(appearance.highlight_color, decoded.trim());
+        }
     });
 }
 
@@ -218,17 +244,19 @@ fn find_symbol(obj: &ObjInfo, selected_symbol: &SymbolRefByName) -> Option<Symbo
     None
 }
 
-#[allow(clippy::too_many_arguments)]
+#[must_use]
+#[expect(clippy::too_many_arguments)]
 fn diff_text_ui(
     ui: &mut egui::Ui,
     text: DiffText<'_>,
     ins_diff: &ObjInsDiff,
     appearance: &Appearance,
-    ins_view_state: &mut FunctionViewState,
-    column: ColumnId,
+    ins_view_state: &FunctionViewState,
+    column: usize,
     space_width: f32,
     response_cb: impl Fn(Response) -> Response,
-) {
+) -> Option<DiffViewAction> {
+    let mut ret = None;
     let label_text;
     let mut base_color = match ins_diff.kind {
         ObjInsDiffKind::None | ObjInsDiffKind::OpMismatch | ObjInsDiffKind::ArgMismatch => {
@@ -275,14 +303,18 @@ fn diff_text_ui(
                 base_color = appearance.diff_colors[diff.idx % appearance.diff_colors.len()]
             }
         }
-        DiffText::Symbol(sym) => {
+        DiffText::Symbol(sym, diff) => {
             let name = sym.demangled_name.as_ref().unwrap_or(&sym.name);
             label_text = name.clone();
-            base_color = appearance.emphasized_text_color;
+            if let Some(diff) = diff {
+                base_color = appearance.diff_colors[diff.idx % appearance.diff_colors.len()]
+            } else {
+                base_color = appearance.emphasized_text_color;
+            }
         }
         DiffText::Spacing(n) => {
             ui.add_space(n as f32 * space_width);
-            return;
+            return ret;
         }
         DiffText::Eol => {
             label_text = "\n".to_string();
@@ -299,22 +331,25 @@ fn diff_text_ui(
     .ui(ui);
     response = response_cb(response);
     if response.clicked() {
-        ins_view_state.set_highlight(column, text.into());
+        ret = Some(DiffViewAction::SetDiffHighlight(column, text.into()));
     }
     if len < pad_to {
         ui.add_space((pad_to - len) as f32 * space_width);
     }
+    ret
 }
 
+#[must_use]
 fn asm_row_ui(
     ui: &mut egui::Ui,
     ins_diff: &ObjInsDiff,
     symbol: &ObjSymbol,
     appearance: &Appearance,
-    ins_view_state: &mut FunctionViewState,
-    column: ColumnId,
+    ins_view_state: &FunctionViewState,
+    column: usize,
     response_cb: impl Fn(Response) -> Response,
-) {
+) -> Option<DiffViewAction> {
+    let mut ret = None;
     ui.spacing_mut().item_spacing.x = 0.0;
     ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Extend);
     if ins_diff.kind != ObjInsDiffKind::None {
@@ -322,7 +357,7 @@ fn asm_row_ui(
     }
     let space_width = ui.fonts(|f| f.glyph_width(&appearance.code_font, ' '));
     display_diff(ins_diff, symbol.address, |text| {
-        diff_text_ui(
+        if let Some(action) = diff_text_ui(
             ui,
             text,
             ins_diff,
@@ -331,241 +366,507 @@ fn asm_row_ui(
             column,
             space_width,
             &response_cb,
-        );
+        ) {
+            ret = Some(action);
+        }
         Ok::<_, ()>(())
     })
     .unwrap();
+    ret
 }
 
+#[must_use]
 fn asm_col_ui(
     row: &mut TableRow<'_, '_>,
-    obj: &(ObjInfo, ObjDiff),
-    symbol_ref: SymbolRef,
+    ctx: FunctionDiffContext<'_>,
     appearance: &Appearance,
-    ins_view_state: &mut FunctionViewState,
-    column: ColumnId,
-) {
-    let (section, symbol) = obj.0.section_symbol(symbol_ref);
-    let section = section.unwrap();
-    let ins_diff = &obj.1.symbol_diff(symbol_ref).instructions[row.index()];
+    ins_view_state: &FunctionViewState,
+    column: usize,
+) -> Option<DiffViewAction> {
+    let mut ret = None;
+    let symbol_ref = ctx.symbol_ref?;
+    let (section, symbol) = ctx.obj.section_symbol(symbol_ref);
+    let section = section?;
+    let ins_diff = &ctx.diff.symbol_diff(symbol_ref).instructions[row.index()];
     let response_cb = |response: Response| {
         if let Some(ins) = &ins_diff.ins {
             response.context_menu(|ui| ins_context_menu(ui, section, ins, symbol));
             response.on_hover_ui_at_pointer(|ui| {
-                ins_hover_ui(ui, obj.0.arch.as_ref(), section, ins, symbol, appearance)
+                ins_hover_ui(ui, ctx.obj, section, ins, symbol, appearance)
             })
         } else {
             response
         }
     };
     let (_, response) = row.col(|ui| {
-        asm_row_ui(ui, ins_diff, symbol, appearance, ins_view_state, column, response_cb);
+        if let Some(action) =
+            asm_row_ui(ui, ins_diff, symbol, appearance, ins_view_state, column, response_cb)
+        {
+            ret = Some(action);
+        }
     });
     response_cb(response);
+    ret
 }
 
-fn empty_col_ui(row: &mut TableRow<'_, '_>) {
-    row.col(|ui| {
-        ui.label("");
-    });
-}
-
+#[must_use]
+#[expect(clippy::too_many_arguments)]
 fn asm_table_ui(
-    table: TableBuilder<'_>,
-    left_obj: Option<&(ObjInfo, ObjDiff)>,
-    right_obj: Option<&(ObjInfo, ObjDiff)>,
-    selected_symbol: &SymbolRefByName,
+    ui: &mut egui::Ui,
+    available_width: f32,
+    left_ctx: Option<FunctionDiffContext<'_>>,
+    right_ctx: Option<FunctionDiffContext<'_>>,
     appearance: &Appearance,
-    ins_view_state: &mut FunctionViewState,
-) -> Option<()> {
-    let left_symbol = left_obj.and_then(|(obj, _)| find_symbol(obj, selected_symbol));
-    let right_symbol = right_obj.and_then(|(obj, _)| find_symbol(obj, selected_symbol));
-    let instructions_len = match (left_symbol, right_symbol) {
-        (Some(left_symbol_ref), Some(right_symbol_ref)) => {
-            let left_len = left_obj.unwrap().1.symbol_diff(left_symbol_ref).instructions.len();
-            let right_len = right_obj.unwrap().1.symbol_diff(right_symbol_ref).instructions.len();
-            debug_assert_eq!(left_len, right_len);
+    ins_view_state: &FunctionViewState,
+    symbol_state: &SymbolViewState,
+    open_sections: (Option<bool>, Option<bool>),
+) -> Option<DiffViewAction> {
+    let mut ret = None;
+    let left_len = left_ctx.and_then(|ctx| {
+        ctx.symbol_ref.map(|symbol_ref| ctx.diff.symbol_diff(symbol_ref).instructions.len())
+    });
+    let right_len = right_ctx.and_then(|ctx| {
+        ctx.symbol_ref.map(|symbol_ref| ctx.diff.symbol_diff(symbol_ref).instructions.len())
+    });
+    let instructions_len = match (left_len, right_len) {
+        (Some(left_len), Some(right_len)) => {
+            if left_len != right_len {
+                ui.label("Instruction count mismatch");
+                return None;
+            }
             left_len
         }
-        (Some(left_symbol_ref), None) => {
-            left_obj.unwrap().1.symbol_diff(left_symbol_ref).instructions.len()
+        (Some(left_len), None) => left_len,
+        (None, Some(right_len)) => right_len,
+        (None, None) => {
+            ui.label("No symbol selected");
+            return None;
         }
-        (None, Some(right_symbol_ref)) => {
-            right_obj.unwrap().1.symbol_diff(right_symbol_ref).instructions.len()
-        }
-        (None, None) => return None,
     };
-    table.body(|body| {
-        body.rows(appearance.code_font.size, instructions_len, |mut row| {
-            if let (Some(left_obj), Some(left_symbol_ref)) = (left_obj, left_symbol) {
-                asm_col_ui(
-                    &mut row,
-                    left_obj,
-                    left_symbol_ref,
-                    appearance,
-                    ins_view_state,
-                    ColumnId::Left,
-                );
-            } else {
-                empty_col_ui(&mut row);
-            }
-            if let (Some(right_obj), Some(right_symbol_ref)) = (right_obj, right_symbol) {
-                asm_col_ui(
-                    &mut row,
-                    right_obj,
-                    right_symbol_ref,
-                    appearance,
-                    ins_view_state,
-                    ColumnId::Right,
-                );
-            } else {
-                empty_col_ui(&mut row);
+    if left_len.is_some() && right_len.is_some() {
+        // Joint view
+        hotkeys::check_scroll_hotkeys(ui, true);
+        render_table(
+            ui,
+            available_width,
+            2,
+            appearance.code_font.size,
+            instructions_len,
+            |row, column| {
+                if column == 0 {
+                    if let Some(ctx) = left_ctx {
+                        if let Some(action) =
+                            asm_col_ui(row, ctx, appearance, ins_view_state, column)
+                        {
+                            ret = Some(action);
+                        }
+                    }
+                } else if column == 1 {
+                    if let Some(ctx) = right_ctx {
+                        if let Some(action) =
+                            asm_col_ui(row, ctx, appearance, ins_view_state, column)
+                        {
+                            ret = Some(action);
+                        }
+                    }
+                    if row.response().clicked() {
+                        ret = Some(DiffViewAction::ClearDiffHighlight);
+                    }
+                }
+            },
+        );
+    } else {
+        // Split view, one side is the symbol list
+        render_strips(ui, available_width, 2, |ui, column| {
+            if column == 0 {
+                if let Some(ctx) = left_ctx {
+                    if ctx.has_symbol() {
+                        hotkeys::check_scroll_hotkeys(ui, false);
+                        render_table(
+                            ui,
+                            available_width / 2.0,
+                            1,
+                            appearance.code_font.size,
+                            instructions_len,
+                            |row, column| {
+                                if let Some(action) =
+                                    asm_col_ui(row, ctx, appearance, ins_view_state, column)
+                                {
+                                    ret = Some(action);
+                                }
+                                if row.response().clicked() {
+                                    ret = Some(DiffViewAction::ClearDiffHighlight);
+                                }
+                            },
+                        );
+                    } else if let Some((right_ctx, right_symbol_ref)) =
+                        right_ctx.and_then(|ctx| ctx.symbol_ref.map(|symbol_ref| (ctx, symbol_ref)))
+                    {
+                        if let Some(action) = symbol_list_ui(
+                            ui,
+                            SymbolDiffContext { obj: ctx.obj, diff: ctx.diff },
+                            None,
+                            symbol_state,
+                            SymbolFilter::Mapping(right_symbol_ref),
+                            appearance,
+                            column,
+                            open_sections.0,
+                        ) {
+                            match action {
+                                DiffViewAction::Navigate(DiffViewNavigation {
+                                    left_symbol: Some(left_symbol_ref),
+                                    ..
+                                }) => {
+                                    let (right_section, right_symbol) =
+                                        right_ctx.obj.section_symbol(right_symbol_ref);
+                                    ret = Some(DiffViewAction::SetMapping(
+                                        match right_section.map(|s| s.kind) {
+                                            Some(ObjSectionKind::Code) => View::FunctionDiff,
+                                            _ => View::SymbolDiff,
+                                        },
+                                        left_symbol_ref,
+                                        SymbolRefByName::new(right_symbol, right_section),
+                                    ));
+                                }
+                                _ => {
+                                    ret = Some(action);
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    ui.label("No left object");
+                }
+            } else if column == 1 {
+                if let Some(ctx) = right_ctx {
+                    if ctx.has_symbol() {
+                        hotkeys::check_scroll_hotkeys(ui, false);
+                        render_table(
+                            ui,
+                            available_width / 2.0,
+                            1,
+                            appearance.code_font.size,
+                            instructions_len,
+                            |row, column| {
+                                if let Some(action) =
+                                    asm_col_ui(row, ctx, appearance, ins_view_state, column)
+                                {
+                                    ret = Some(action);
+                                }
+                                if row.response().clicked() {
+                                    ret = Some(DiffViewAction::ClearDiffHighlight);
+                                }
+                            },
+                        );
+                    } else if let Some((left_ctx, left_symbol_ref)) =
+                        left_ctx.and_then(|ctx| ctx.symbol_ref.map(|symbol_ref| (ctx, symbol_ref)))
+                    {
+                        if let Some(action) = symbol_list_ui(
+                            ui,
+                            SymbolDiffContext { obj: ctx.obj, diff: ctx.diff },
+                            None,
+                            symbol_state,
+                            SymbolFilter::Mapping(left_symbol_ref),
+                            appearance,
+                            column,
+                            open_sections.1,
+                        ) {
+                            match action {
+                                DiffViewAction::Navigate(DiffViewNavigation {
+                                    right_symbol: Some(right_symbol_ref),
+                                    ..
+                                }) => {
+                                    let (left_section, left_symbol) =
+                                        left_ctx.obj.section_symbol(left_symbol_ref);
+                                    ret = Some(DiffViewAction::SetMapping(
+                                        match left_section.map(|s| s.kind) {
+                                            Some(ObjSectionKind::Code) => View::FunctionDiff,
+                                            _ => View::SymbolDiff,
+                                        },
+                                        SymbolRefByName::new(left_symbol, left_section),
+                                        right_symbol_ref,
+                                    ));
+                                }
+                                _ => {
+                                    ret = Some(action);
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    ui.label("No right object");
+                }
             }
         });
-    });
-    Some(())
+    }
+    ret
 }
 
-pub fn function_diff_ui(ui: &mut egui::Ui, state: &mut DiffViewState, appearance: &Appearance) {
-    let (Some(result), Some(selected_symbol)) = (&state.build, &state.symbol_state.selected_symbol)
-    else {
-        return;
+#[derive(Clone, Copy)]
+pub struct FunctionDiffContext<'a> {
+    pub obj: &'a ObjInfo,
+    pub diff: &'a ObjDiff,
+    pub symbol_ref: Option<SymbolRef>,
+}
+
+impl<'a> FunctionDiffContext<'a> {
+    pub fn new(
+        obj: Option<&'a (ObjInfo, ObjDiff)>,
+        selected_symbol: Option<&SymbolRefByName>,
+    ) -> Option<Self> {
+        obj.map(|(obj, diff)| Self {
+            obj,
+            diff,
+            symbol_ref: selected_symbol.and_then(|s| find_symbol(obj, s)),
+        })
+    }
+
+    #[inline]
+    pub fn has_symbol(&self) -> bool { self.symbol_ref.is_some() }
+}
+
+#[must_use]
+pub fn function_diff_ui(
+    ui: &mut egui::Ui,
+    state: &DiffViewState,
+    appearance: &Appearance,
+) -> Option<DiffViewAction> {
+    let mut ret = None;
+    let Some(result) = &state.build else {
+        return ret;
     };
 
+    let mut left_ctx = FunctionDiffContext::new(
+        result.first_obj.as_ref(),
+        state.symbol_state.left_symbol.as_ref(),
+    );
+    let mut right_ctx = FunctionDiffContext::new(
+        result.second_obj.as_ref(),
+        state.symbol_state.right_symbol.as_ref(),
+    );
+
+    // If one side is missing a symbol, but the diff process found a match, use that symbol
+    let left_diff_symbol = left_ctx.and_then(|ctx| {
+        ctx.symbol_ref.and_then(|symbol_ref| ctx.diff.symbol_diff(symbol_ref).target_symbol)
+    });
+    let right_diff_symbol = right_ctx.and_then(|ctx| {
+        ctx.symbol_ref.and_then(|symbol_ref| ctx.diff.symbol_diff(symbol_ref).target_symbol)
+    });
+    if left_diff_symbol.is_some() && right_ctx.is_some_and(|ctx| !ctx.has_symbol()) {
+        let (right_section, right_symbol) =
+            right_ctx.unwrap().obj.section_symbol(left_diff_symbol.unwrap());
+        let symbol_ref = SymbolRefByName::new(right_symbol, right_section);
+        right_ctx = FunctionDiffContext::new(result.second_obj.as_ref(), Some(&symbol_ref));
+        ret = Some(DiffViewAction::Navigate(DiffViewNavigation {
+            view: Some(View::FunctionDiff),
+            left_symbol: state.symbol_state.left_symbol.clone(),
+            right_symbol: Some(symbol_ref),
+        }));
+    } else if right_diff_symbol.is_some() && left_ctx.is_some_and(|ctx| !ctx.has_symbol()) {
+        let (left_section, left_symbol) =
+            left_ctx.unwrap().obj.section_symbol(right_diff_symbol.unwrap());
+        let symbol_ref = SymbolRefByName::new(left_symbol, left_section);
+        left_ctx = FunctionDiffContext::new(result.first_obj.as_ref(), Some(&symbol_ref));
+        ret = Some(DiffViewAction::Navigate(DiffViewNavigation {
+            view: Some(View::FunctionDiff),
+            left_symbol: Some(symbol_ref),
+            right_symbol: state.symbol_state.right_symbol.clone(),
+        }));
+    }
+
+    // If both sides are missing a symbol, switch to symbol diff view
+    if right_ctx.is_some_and(|ctx| !ctx.has_symbol())
+        && left_ctx.is_some_and(|ctx| !ctx.has_symbol())
+    {
+        return Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
+    }
+
     // Header
     let available_width = ui.available_width();
-    let column_width = available_width / 2.0;
-    ui.allocate_ui_with_layout(
-        Vec2 { x: available_width, y: 100.0 },
-        Layout::left_to_right(Align::Min),
-        |ui| {
-            ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Truncate);
-
+    let mut open_sections = (None, None);
+    render_header(ui, available_width, 2, |ui, column| {
+        if column == 0 {
             // Left column
-            ui.allocate_ui_with_layout(
-                Vec2 { x: column_width, y: 100.0 },
-                Layout::top_down(Align::Min),
-                |ui| {
-                    ui.set_width(column_width);
+            ui.horizontal(|ui| {
+                if ui.button("⏴ Back").clicked() || hotkeys::back_pressed(ui.ctx()) {
+                    ret = Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
+                }
+                ui.separator();
+                if ui
+                    .add_enabled(
+                        !state.scratch_running
+                            && state.scratch_available
+                            && left_ctx.is_some_and(|ctx| ctx.has_symbol()),
+                        egui::Button::new("📲 decomp.me"),
+                    )
+                    .on_hover_text_at_pointer("Create a new scratch on decomp.me (beta)")
+                    .on_disabled_hover_text("Scratch configuration missing")
+                    .clicked()
+                {
+                    if let Some((_section, symbol)) = left_ctx.and_then(|ctx| {
+                        ctx.symbol_ref.map(|symbol_ref| ctx.obj.section_symbol(symbol_ref))
+                    }) {
+                        ret = Some(DiffViewAction::CreateScratch(symbol.name.clone()));
+                    }
+                }
+            });
 
-                    ui.horizontal(|ui| {
-                        if ui.button("⏴ Back").clicked() {
-                            state.current_view = View::SymbolDiff;
+            if let Some((_section, symbol)) = left_ctx
+                .and_then(|ctx| ctx.symbol_ref.map(|symbol_ref| ctx.obj.section_symbol(symbol_ref)))
+            {
+                let name = symbol.demangled_name.as_deref().unwrap_or(&symbol.name);
+                ui.label(
+                    RichText::new(name)
+                        .font(appearance.code_font.clone())
+                        .color(appearance.highlight_color),
+                );
+                if right_ctx.is_some_and(|m| m.has_symbol())
+                    && (ui
+                        .button("Change target")
+                        .on_hover_text_at_pointer("Choose a different symbol to use as the target")
+                        .clicked()
+                        || hotkeys::consume_change_target_shortcut(ui.ctx()))
+                {
+                    if let Some(symbol_ref) = state.symbol_state.right_symbol.as_ref() {
+                        ret = Some(DiffViewAction::SelectingLeft(symbol_ref.clone()));
+                    }
+                }
+            } else {
+                ui.label(
+                    RichText::new("Missing")
+                        .font(appearance.code_font.clone())
+                        .color(appearance.replace_color),
+                );
+
+                ui.horizontal(|ui| {
+                    ui.label(
+                        RichText::new("Choose target symbol")
+                            .font(appearance.code_font.clone())
+                            .color(appearance.highlight_color),
+                    );
+
+                    ui.with_layout(Layout::right_to_left(egui::Align::TOP), |ui| {
+                        if ui.small_button("⏷").on_hover_text_at_pointer("Expand all").clicked() {
+                            open_sections.0 = Some(true);
                         }
-                        ui.separator();
-                        if ui
-                            .add_enabled(
-                                !state.scratch_running && state.scratch_available,
-                                egui::Button::new("📲 decomp.me"),
-                            )
-                            .on_hover_text_at_pointer("Create a new scratch on decomp.me (beta)")
-                            .on_disabled_hover_text("Scratch configuration missing")
-                            .clicked()
+                        if ui.small_button("⏶").on_hover_text_at_pointer("Collapse all").clicked()
                         {
-                            state.queue_scratch = true;
+                            open_sections.0 = Some(false);
                         }
-                    });
-
-                    let name = selected_symbol
-                        .demangled_symbol_name
-                        .as_deref()
-                        .unwrap_or(&selected_symbol.symbol_name);
-                    ui.scope(|ui| {
-                        ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
-                        ui.colored_label(appearance.highlight_color, name);
-                        ui.label("Diff target:");
-                    });
-                },
-            );
-
+                    })
+                });
+            }
+        } else if column == 1 {
             // Right column
-            ui.allocate_ui_with_layout(
-                Vec2 { x: column_width, y: 100.0 },
-                Layout::top_down(Align::Min),
-                |ui| {
-                    ui.set_width(column_width);
+            ui.horizontal(|ui| {
+                if ui.add_enabled(!state.build_running, egui::Button::new("Build")).clicked() {
+                    ret = Some(DiffViewAction::Build);
+                }
+                ui.scope(|ui| {
+                    ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
+                    if state.build_running {
+                        ui.colored_label(appearance.replace_color, "Building…");
+                    } else {
+                        ui.label("Last built:");
+                        let format = format_description::parse("[hour]:[minute]:[second]").unwrap();
+                        ui.label(
+                            result.time.to_offset(appearance.utc_offset).format(&format).unwrap(),
+                        );
+                    }
+                });
+                ui.separator();
+                if ui
+                    .add_enabled(state.source_path_available, egui::Button::new("🖹 Source file"))
+                    .on_hover_text_at_pointer("Open the source file in the default editor")
+                    .on_disabled_hover_text("Source file metadata missing")
+                    .clicked()
+                {
+                    ret = Some(DiffViewAction::OpenSourcePath);
+                }
+            });
 
-                    ui.horizontal(|ui| {
-                        if ui
-                            .add_enabled(!state.build_running, egui::Button::new("Build"))
-                            .clicked()
-                        {
-                            state.queue_build = true;
-                        }
-                        ui.scope(|ui| {
-                            ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
-                            if state.build_running {
-                                ui.colored_label(appearance.replace_color, "Building…");
-                            } else {
-                                ui.label("Last built:");
-                                let format =
-                                    format_description::parse("[hour]:[minute]:[second]").unwrap();
-                                ui.label(
-                                    result
-                                        .time
-                                        .to_offset(appearance.utc_offset)
-                                        .format(&format)
-                                        .unwrap(),
-                                );
-                            }
-                        });
+            if let Some(((_section, symbol), symbol_diff)) = right_ctx.and_then(|ctx| {
+                ctx.symbol_ref.map(|symbol_ref| {
+                    (ctx.obj.section_symbol(symbol_ref), ctx.diff.symbol_diff(symbol_ref))
+                })
+            }) {
+                let name = symbol.demangled_name.as_deref().unwrap_or(&symbol.name);
+                ui.label(
+                    RichText::new(name)
+                        .font(appearance.code_font.clone())
+                        .color(appearance.highlight_color),
+                );
+                ui.horizontal(|ui| {
+                    if let Some(match_percent) = symbol_diff.match_percent {
+                        ui.label(
+                            RichText::new(format!("{:.0}%", match_percent.floor()))
+                                .font(appearance.code_font.clone())
+                                .color(match_color_for_symbol(match_percent, appearance)),
+                        );
+                    }
+                    if left_ctx.is_some_and(|m| m.has_symbol()) {
                         ui.separator();
                         if ui
-                            .add_enabled(
-                                state.source_path_available,
-                                egui::Button::new("🖹 Source file"),
+                            .button("Change base")
+                            .on_hover_text_at_pointer(
+                                "Choose a different symbol to use as the base",
                             )
-                            .on_hover_text_at_pointer("Open the source file in the default editor")
-                            .on_disabled_hover_text("Source file metadata missing")
                             .clicked()
+                            || hotkeys::consume_change_base_shortcut(ui.ctx())
                         {
-                            state.queue_open_source_path = true;
+                            if let Some(symbol_ref) = state.symbol_state.left_symbol.as_ref() {
+                                ret = Some(DiffViewAction::SelectingRight(symbol_ref.clone()));
+                            }
                         }
-                    });
+                    }
+                });
+            } else {
+                ui.label(
+                    RichText::new("Missing")
+                        .font(appearance.code_font.clone())
+                        .color(appearance.replace_color),
+                );
 
-                    ui.scope(|ui| {
-                        ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
-                        if let Some(match_percent) = result
-                            .second_obj
-                            .as_ref()
-                            .and_then(|(obj, diff)| {
-                                find_symbol(obj, selected_symbol).map(|sref| {
-                                    &diff.sections[sref.section_idx].symbols[sref.symbol_idx]
-                                })
-                            })
-                            .and_then(|symbol| symbol.match_percent)
-                        {
-                            ui.colored_label(
-                                match_color_for_symbol(match_percent, appearance),
-                                format!("{match_percent:.0}%"),
-                            );
-                        } else {
-                            ui.colored_label(appearance.replace_color, "Missing");
+                ui.horizontal(|ui| {
+                    ui.label(
+                        RichText::new("Choose base symbol")
+                            .font(appearance.code_font.clone())
+                            .color(appearance.highlight_color),
+                    );
+
+                    ui.with_layout(Layout::right_to_left(egui::Align::TOP), |ui| {
+                        if ui.small_button("⏷").on_hover_text_at_pointer("Expand all").clicked() {
+                            open_sections.1 = Some(true);
                         }
-                        ui.label("Diff base:");
-                    });
-                },
-            );
-        },
-    );
-    ui.separator();
+                        if ui.small_button("⏶").on_hover_text_at_pointer("Collapse all").clicked()
+                        {
+                            open_sections.1 = Some(false);
+                        }
+                    })
+                });
+            }
+        }
+    });
 
     // Table
-    ui.style_mut().interaction.selectable_labels = false;
-    let available_height = ui.available_height();
-    let table = TableBuilder::new(ui)
-        .striped(false)
-        .cell_layout(Layout::left_to_right(Align::Min))
-        .columns(Column::exact(column_width).clip(true), 2)
-        .resizable(false)
-        .auto_shrink([false, false])
-        .min_scrolled_height(available_height);
-    asm_table_ui(
-        table,
-        result.first_obj.as_ref(),
-        result.second_obj.as_ref(),
-        selected_symbol,
-        appearance,
-        &mut state.function_state,
-    );
+    let id = Id::new(state.symbol_state.left_symbol.as_ref().map(|s| s.symbol_name.as_str()))
+        .with(state.symbol_state.right_symbol.as_ref().map(|s| s.symbol_name.as_str()));
+    if let Some(action) = ui
+        .push_id(id, |ui| {
+            asm_table_ui(
+                ui,
+                available_width,
+                left_ctx,
+                right_ctx,
+                appearance,
+                &state.function_state,
+                &state.symbol_state,
+                open_sections,
+            )
+        })
+        .inner
+    {
+        ret = Some(action);
+    }
+    ret
 }

objdiff-gui/src/views/jobs.rs

@@ -1,11 +1,9 @@
 use std::cmp::Ordering;
 
 use egui::{ProgressBar, RichText, Widget};
+use objdiff_core::jobs::{JobQueue, JobStatus};
 
-use crate::{
-    jobs::{JobQueue, JobStatus},
-    views::appearance::Appearance,
-};
+use crate::views::appearance::Appearance;
 
 pub fn jobs_ui(ui: &mut egui::Ui, jobs: &mut JobQueue, appearance: &Appearance) {
     if ui.button("Clear").clicked() {

objdiff-gui/src/views/mod.rs

@@ -1,6 +1,7 @@
 use egui::{text::LayoutJob, Color32, FontId, TextFormat};
 
 pub(crate) mod appearance;
+pub(crate) mod column_layout;
 pub(crate) mod config;
 pub(crate) mod data_diff;
 pub(crate) mod debug;

objdiff-gui/src/views/rlwinm.rs

@@ -16,13 +16,13 @@ pub fn rlwinm_decode_window(
     egui::Window::new("Rlwinm Decoder").open(show).show(ctx, |ui| {
         ui.text_edit_singleline(&mut state.text);
         ui.add_space(10.0);
-        if let Some(demangled) = rlwinmdec::decode(&state.text) {
+        if let Some(decoded) = rlwinmdec::decode(&state.text) {
             ui.scope(|ui| {
                 ui.style_mut().override_text_style = Some(TextStyle::Monospace);
-                ui.colored_label(appearance.replace_color, &demangled);
+                ui.colored_label(appearance.replace_color, decoded.trim());
             });
             if ui.button("Copy").clicked() {
-                ui.output_mut(|output| output.copied_text = demangled);
+                ui.output_mut(|output| output.copied_text = decoded);
             }
         } else {
             ui.scope(|ui| {

objdiff-wasm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objdiff-wasm",
-  "version": "2.0.0",
+  "version": "2.6.0",
   "description": "A local diffing tool for decompilation projects.",
   "author": {
     "name": "Luke Street",
@@ -21,7 +21,7 @@
     "build": "tsup",
     "build:all": "npm run build:wasm && npm run build:proto && npm run build",
     "build:proto": "protoc --ts_out=gen --ts_opt add_pb_suffix,eslint_disable,ts_nocheck,use_proto_field_name --proto_path=../objdiff-core/protos ../objdiff-core/protos/*.proto",
-    "build:wasm": "cd ../objdiff-core && wasm-pack build --out-dir ../objdiff-wasm/pkg --target web -- --features arm,dwarf,ppc,x86,wasm"
+    "build:wasm": "cd ../objdiff-core && wasm-pack build --out-dir ../objdiff-wasm/pkg --target web -- --features arm,arm64,dwarf,config,ppc,x86,wasm"
   },
   "dependencies": {
     "@protobuf-ts/runtime": "^2.9.4"

objdiff-wasm/src/main.ts

@@ -111,12 +111,12 @@ async function defer<T>(message: AnyHandlerData, worker?: Worker): Promise<T> {
     return promise;
 }
 
-export async function runDiff(left: Uint8Array | undefined, right: Uint8Array | undefined, config?: DiffObjConfig): Promise<DiffResult> {
+export async function runDiff(left: Uint8Array | undefined, right: Uint8Array | undefined, diff_config?: DiffObjConfig): Promise<DiffResult> {
     const data = await defer<Uint8Array>({
         type: 'run_diff_proto',
         left,
         right,
-        config
+        diff_config
     });
     const parseStart = performance.now();
     const result = DiffResult.fromBinary(data, {readUnknownField: false});
@@ -194,12 +194,17 @@ export function displayDiff(diff: InstructionDiff, baseAddr: bigint, cb: (text:
         cb({type: 'spacing', count: 4});
     }
     cb({type: 'opcode', mnemonic: ins.mnemonic, opcode: ins.opcode});
+    let arg_diff_idx = 0; // non-PlainText argument index
     for (let i = 0; i < ins.arguments.length; i++) {
         if (i === 0) {
             cb({type: 'spacing', count: 1});
         }
         const arg = ins.arguments[i].value;
-        const diff_index = diff.arg_diff[i]?.diff_index;
+        let diff_index: number | undefined;
+        if (arg.oneofKind !== 'plain_text') {
+            diff_index = diff.arg_diff[arg_diff_idx]?.diff_index;
+            arg_diff_idx++;
+        }
         switch (arg.oneofKind) {
             case "plain_text":
                 cb({type: 'basic', text: arg.plain_text, diff_index});

objdiff-wasm/src/worker.ts

@@ -38,13 +38,15 @@ async function initIfNeeded() {
 //     return exports.run_diff_json(left, right, cfg);
 // }
 
-async function run_diff_proto({left, right, config}: {
+async function run_diff_proto({left, right, diff_config, mapping_config}: {
     left: Uint8Array | undefined,
     right: Uint8Array | undefined,
-    config?: exports.DiffObjConfig,
+    diff_config?: exports.DiffObjConfig,
+    mapping_config?: exports.MappingConfig,
 }): Promise<Uint8Array> {
-    config = config || {};
-    return exports.run_diff_proto(left, right, config);
+    diff_config = diff_config || {};
+    mapping_config = mapping_config || {};
+    return exports.run_diff_proto(left, right, diff_config, mapping_config);
 }
 
 export type AnyHandlerData = HandlerData[keyof HandlerData];
@@ -73,12 +75,19 @@ self.onmessage = (event: MessageEvent<InMessage>) => {
             const result = await handler(data as never);
             const end = performance.now();
             console.debug(`Worker message ${data.messageId} took ${end - start}ms`);
+            let transfer: Transferable[] = [];
+            if (result instanceof Uint8Array) {
+                console.log("Transferring!", result.byteLength);
+                transfer = [result.buffer];
+            } else {
+                console.log("Didn't transfer", typeof result);
+            }
             self.postMessage({
                 type: 'result',
                 result: result,
                 error: null,
                 messageId,
-            } as OutMessage);
+            } as OutMessage, {transfer});
         } else {
             throw new Error(`No handler for ${data.type}`);
         }