Add scratch preset_id field for decomp.me

Resolves #133
Combine nested otherwise empty directories in objects view (#137 )
2025-12-15 16:16:15 +00:00 · 2024-11-07 09:27:13 -07:00 · 2024-11-07 08:21:39 -07:00 · 2024-10-31 17:39:12 -06:00 · 2024-10-31 17:27:27 -06:00 · 2024-10-31 17:26:59 -06:00
42 changed files with 5677 additions and 1192 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -0,0 +1,5 @@
+[target.x86_64-pc-windows-msvc]
+linker = "rust-lld"
+
+[target.aarch64-pc-windows-msvc]
+linker = "rust-lld"
--- a/.github/workflows/build.yaml
+++ b/.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
@@ -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 }} 
--- a/.gitignore
+++ b/.gitignore
@@ -3,10 +3,6 @@ target/
 **/*.rs.bk
 generated/

-# cargo-mobile
-.cargo/
-/gen
-
 # macOS
 .DS_Store

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -395,6 +395,15 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"

+[[package]]
+name = "bimap"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "230c5f1ca6a325a32553f8640d31ac9b49f2411e901e427570154868b46da4f7"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "bit-set"
 version = "0.6.0"
@@ -425,6 +434,18 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
 [[package]]
 name = "block"
 version = "0.1.6"
@@ -1505,6 +1526,12 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
 [[package]]
 name = "futures-channel"
 version = "0.3.30"
@@ -1517,15 +1544,15 @@ dependencies = [

 [[package]]
 name = "futures-core"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"

 [[package]]
 name = "futures-io"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"

 [[package]]
 name = "futures-lite"
@@ -1542,9 +1569,9 @@ dependencies = [

 [[package]]
 name = "futures-macro"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1553,21 +1580,21 @@ dependencies = [

 [[package]]
 name = "futures-sink"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"

 [[package]]
 name = "futures-task"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"

 [[package]]
 name = "futures-util"
-version = "0.3.30"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
 "futures-core",
 "futures-io",
@@ -2852,7 +2879,7 @@ dependencies = [

 [[package]]
 name = "objdiff-cli"
-version = "2.2.2"
+version = "2.4.0"
 dependencies = [
 "anyhow",
 "argp",
@@ -2874,10 +2901,11 @@ dependencies = [

 [[package]]
 name = "objdiff-core"
-version = "2.2.2"
+version = "2.4.0"
 dependencies = [
 "anyhow",
 "arm-attr",
+ "bimap",
 "byteorder",
 "console_error_panic_hook",
 "console_log",
@@ -2909,11 +2937,13 @@ dependencies = [
 "tsify-next",
 "unarm",
 "wasm-bindgen",
+ "yaxpeax-arch",
+ "yaxpeax-arm",
 ]

 [[package]]
 name = "objdiff-gui"
-version = "2.2.2"
+version = "2.4.0"
 dependencies = [
 "anyhow",
 "bytes",
@@ -3485,6 +3515,12 @@ dependencies = [
 "num_enum 0.5.11",
 ]

+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
 [[package]]
 name = "rand"
 version = "0.8.5"
@@ -4280,6 +4316,12 @@ dependencies = [
 "futures-core",
 ]

+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
 [[package]]
 name = "tauri-winres"
 version = "0.1.1"
@@ -5515,6 +5557,15 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
 [[package]]
 name = "x11-dl"
 version = "2.21.0"
@@ -5588,6 +5639,25 @@ version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af4e2e2f7cba5a093896c1e150fbfe177d1883e7448200efb81d40b9d339ef26"

+[[package]]
+name = "yaxpeax-arch"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36274fcc5403da2a7636ffda4d02eca12a1b2b8267b9d2e04447bd2ccfc72082"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "yaxpeax-arm"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1c6a2af41f88546a08df3bc77aadf7263884d6dffdac5b32dea7dc2df23f241"
+dependencies = [
+ "bitvec",
+ "yaxpeax-arch",
+]
+
 [[package]]
 name = "yeslogic-fontconfig-sys"
 version = "6.0.0"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@ strip = "debuginfo"
 codegen-units = 1

 [workspace.package]
-version = "2.2.2"
+version = "2.4.0"
 authors = ["Luke Street <luke@street.dev>"]
 edition = "2021"
 license = "MIT OR Apache-2.0"
--- a/README.md
+++ b/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.

--- a/config.schema.json
+++ b/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"
+          }
        }
      }
    },
--- a/deny.toml
+++ b/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" },
@@ -240,7 +239,7 @@ allow-git = []

 [sources.allow-org]
 # github.com organizations to allow git sources for
-github = ["encounter"]
+github = ["notify-rs"]
 # gitlab.com organizations to allow git sources for
 gitlab = []
 # bitbucket.org organizations to allow git sources for
--- a/objdiff-cli/src/cmd/diff.rs
+++ b/objdiff-cli/src/cmd/diff.rs
@@ -102,26 +102,32 @@ pub fn run(args: Args) -> Result<()> {
                    let unit_path =
                        PathBuf::from_str(u).ok().and_then(|p| fs::canonicalize(p).ok());

-                    let Some(object) = project_config.objects.iter_mut().find_map(|obj| {
-                        if obj.name.as_deref() == Some(u) {
+                    let Some(object) = project_config
+                        .units
+                        .as_deref_mut()
+                        .unwrap_or_default()
+                        .iter_mut()
+                        .find_map(|obj| {
+                            if obj.name.as_deref() == Some(u) {
+                                resolve_paths(obj);
+                                return Some(obj);
+                            }
+
+                            let up = unit_path.as_deref()?;
+
                            resolve_paths(obj);
-                            return Some(obj);
-                        }

-                        let up = unit_path.as_deref()?;
+                            if [&obj.base_path, &obj.target_path]
+                                .into_iter()
+                                .filter_map(|p| p.as_ref().and_then(|p| p.canonicalize().ok()))
+                                .any(|p| p == up)
+                            {
+                                return Some(obj);
+                            }

-                        resolve_paths(obj);
-
-                        if [&obj.base_path, &obj.target_path]
-                            .into_iter()
-                            .filter_map(|p| p.as_ref().and_then(|p| p.canonicalize().ok()))
-                            .any(|p| p == up)
-                        {
-                            return Some(obj);
-                        }
-
-                        None
-                    }) else {
+                            None
+                        })
+                    else {
                        bail!("Unit not found: {}", u)
                    };

@@ -129,7 +135,13 @@ pub fn run(args: Args) -> Result<()> {
                } else if let Some(symbol_name) = &args.symbol {
                    let mut idx = None;
                    let mut count = 0usize;
-                    for (i, obj) in project_config.objects.iter_mut().enumerate() {
+                    for (i, obj) in project_config
+                        .units
+                        .as_deref_mut()
+                        .unwrap_or_default()
+                        .iter_mut()
+                        .enumerate()
+                    {
                        resolve_paths(obj);

                        if obj
@@ -148,7 +160,7 @@ pub fn run(args: Args) -> Result<()> {
                    }
                    match (count, idx) {
                        (0, None) => bail!("Symbol not found: {}", symbol_name),
-                        (1, Some(i)) => &mut project_config.objects[i],
+                        (1, Some(i)) => &mut project_config.units_mut()[i],
                        (2.., Some(_)) => bail!(
                            "Multiple instances of {} were found, try specifying a unit",
                            symbol_name
@@ -303,7 +315,7 @@ fn find_function(obj: &ObjInfo, name: &str) -> Option<SymbolRef> {
    None
 }

-#[allow(dead_code)]
+#[expect(dead_code)]
 struct FunctionDiffUi {
    relax_reloc_diffs: bool,
    left_highlight: HighlightKind,
@@ -758,7 +770,7 @@ impl FunctionDiffUi {
        self.scroll_y += self.per_page / if half { 2 } else { 1 };
    }

-    #[allow(clippy::too_many_arguments)]
+    #[expect(clippy::too_many_arguments)]
    fn print_sym(
        &self,
        out: &mut Text<'static>,
@@ -832,10 +844,14 @@ impl FunctionDiffUi {
                            base_color = COLOR_ROTATION[diff.idx % COLOR_ROTATION.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 = Color::White;
+                        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)));
--- a/objdiff-cli/src/cmd/report.rs
+++ b/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(),
--- a/objdiff-core/Cargo.toml
+++ b/objdiff-core/Cargo.toml
@@ -16,36 +16,38 @@ 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 = ["config", "dwarf", "mips", "ppc", "x86", "arm", "arm64", "bindings"]
+any-arch = ["config", "dep:bimap", "dep:strum", "dep:similar", "dep:flagset", "dep:log", "dep:memmap2", "dep:byteorder", "dep:num-traits"] # Implicit, used to check if any arch is enabled
+config = ["dep:bimap", "dep:globset", "dep:semver", "dep:serde_json", "dep:serde_yaml", "dep:serde", "dep:filetime"]
+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:cpp_demangle", "dep:unarm", "dep:arm-attr"]
+arm64 = ["any-arch", "dep:cpp_demangle", "dep:yaxpeax-arch", "dep:yaxpeax-arm"]
+bindings = ["dep:serde_json", "dep:prost", "dep:pbjson", "dep:serde", "dep:prost-build", "dep:pbjson-build"]
+wasm = ["bindings", "any-arch", "dep:console_error_panic_hook", "dep:console_log", "dep:wasm-bindgen", "dep:tsify-next", "dep:log"]

 [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 }

@@ -75,6 +77,10 @@ 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-dependencies]
-prost-build = "0.13"
-pbjson-build = "0.7"
+prost-build = { version = "0.13", optional = true }
+pbjson-build = { version = "0.7", optional = true }
--- a/objdiff-core/README.md
+++ b/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.
--- a/objdiff-core/build.rs
+++ b/objdiff-core/build.rs
@@ -1,6 +1,11 @@
-use std::path::{Path, PathBuf};
-
 fn main() {
+    #[cfg(feature = "bindings")]
+    compile_protos();
+}
+
+#[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());
--- a/objdiff-core/src/arch/arm.rs
+++ b/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 =
@@ -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
--- a/objdiff-core/src/arch/arm64.rs
+++ b/objdiff-core/src/arch/arm64.rs
--- a/objdiff-core/src/arch/mips.rs
+++ b/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,
@@ -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,
--- a/objdiff-core/src/arch/mod.rs
+++ b/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")]
@@ -34,7 +36,11 @@ 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) {
+        // TODO: Attempt to interpret large symbols as arrays of a smaller type,
+        // fallback to intrepreting it as bytes.
+        // https://github.com/encounter/objdiff/issues/124
+        if self.required_len().is_some_and(|l| bytes.len() != l) {
+            log::warn!("Failed to display a symbol value for a symbol whose size doesn't match the instruction referencing it.");
            return None;
        }

@@ -161,6 +167,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:?}"),
    })
 }
--- a/objdiff-core/src/arch/ppc.rs
+++ b/objdiff-core/src/arch/ppc.rs
@@ -143,7 +143,7 @@ impl ObjArch for ObjArchPpc {
            insts.push(ObjIns {
                address: cur_addr as u64,
                size: 4,
-                mnemonic: simplified.mnemonic.to_string(),
+                mnemonic: Cow::Borrowed(simplified.mnemonic),
                args,
                reloc: reloc.cloned(),
                op: ins.op as u16,
--- a/objdiff-core/src/arch/x86.rs
+++ b/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,
@@ -242,7 +242,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(
--- a/objdiff-core/src/bindings/diff.rs
+++ b/objdiff-core/src/bindings/diff.rs
@@ -70,9 +70,13 @@ impl FunctionDiff {
        //     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)),
+            symbol: Some(Symbol::new(symbol)),
            // diff_symbol,
            instructions,
            match_percent: symbol_diff.match_percent,
@@ -90,8 +94,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(),
@@ -122,29 +126,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 +156,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 +168,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 +229,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 +238,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 }
    }
 }
--- a/objdiff-core/src/config/mod.rs
+++ b/objdiff-core/src/config/mod.rs
@@ -1,77 +1,100 @@
 use std::{
+    fs,
    fs::File,
-    io::{BufReader, Read},
+    io::{BufReader, BufWriter, Read},
    path::{Path, PathBuf},
 };

 use anyhow::{anyhow, Context, Result};
+use bimap::BiBTreeMap;
 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)]
 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)]
+    #[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<Glob>>,
-    #[serde(default, alias = "units")]
-    pub objects: Vec<ProjectObject>,
-    #[serde(default)]
-    pub progress_categories: Vec<ProjectProgressCategory>,
+    #[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)
+    }
+}
+
+#[derive(Default, Clone, serde::Serialize, serde::Deserialize)]
 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)]
+pub type SymbolMappings = BiBTreeMap<String, String>;
+
+#[derive(Default, Clone, serde::Serialize, serde::Deserialize)]
 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)]
 pub struct ProjectProgressCategory {
    #[serde(default)]
    pub id: String,
@@ -112,12 +135,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)
    }

@@ -132,16 +155,18 @@ impl ProjectObject {

 #[derive(Default, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
 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"];
@@ -154,7 +179,7 @@ pub const DEFAULT_WATCH_PATTERNS: &[&str] = &[
 #[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 +205,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"))
--- a/objdiff-core/src/diff/code.rs
+++ b/objdiff-core/src/diff/code.rs
@@ -9,7 +9,7 @@ use crate::{
        DiffObjConfig, ObjInsArgDiff, ObjInsBranchFrom, ObjInsBranchTo, ObjInsDiff, ObjInsDiffKind,
        ObjSymbolDiff,
    },
-    obj::{ObjInfo, ObjInsArg, ObjReloc, ObjSymbol, ObjSymbolFlags, SymbolRef},
+    obj::{ObjInfo, ObjInsArg, ObjReloc, ObjSymbolFlags, SymbolRef},
 };

 pub fn process_code_symbol(
@@ -41,10 +41,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 +62,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 +79,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,12 +172,33 @@ 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
+}
+
+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_obj: &ObjInfo,
+    right_obj: &ObjInfo,
    left_reloc: Option<&ObjReloc>,
    right_reloc: Option<&ObjReloc>,
 ) -> bool {
@@ -189,29 +212,32 @@ fn reloc_eq(
        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)
+                && (symbol_name_matches || address_eq(left, right))
        }
        (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,
@@ -227,16 +253,24 @@ fn arg_eq(
            matches!(right, ObjInsArg::Reloc)
                && reloc_eq(
                    config,
+                    left_obj,
+                    right_obj,
                    left_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
                    right_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
                )
        }
-        ObjInsArg::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.relax_reloc_diffs,
+            _ => false,
+        },
+    }
 }

 #[derive(Default)]
@@ -257,21 +291,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 +313,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 +325,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 +342,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 }
--- a/objdiff-core/src/diff/data.rs
+++ b/objdiff-core/src/diff/data.rs
@@ -20,13 +20,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,7 +34,7 @@ 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 }
 }

 /// Compare the data sections of two object files.
@@ -158,13 +158,13 @@ pub fn diff_data_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(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),
        },
--- a/objdiff-core/src/diff/display.rs
+++ b/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,
        }
--- a/objdiff-core/src/diff/mod.rs
+++ b/objdiff-core/src/diff/mod.rs
@@ -3,6 +3,7 @@ use std::collections::HashSet;
 use anyhow::Result;

 use crate::{
+    config::SymbolMappings,
    diff::{
        code::{diff_code, no_diff_code, process_code_symbol},
        data::{
@@ -10,7 +11,7 @@ use crate::{
            diff_generic_section, no_diff_symbol,
        },
    },
-    obj::{ObjInfo, ObjIns, ObjSection, ObjSectionKind, ObjSymbol, SymbolRef},
+    obj::{ObjInfo, ObjIns, ObjSection, ObjSectionKind, ObjSymbol, SymbolRef, SECTION_COMMON},
 };

 pub mod code;
@@ -28,8 +29,8 @@ pub mod display;
    serde::Serialize,
    strum::VariantArray,
    strum::EnumMessage,
-    tsify_next::Tsify,
 )]
+#[cfg_attr(feature = "wasm", derive(tsify_next::Tsify))]
 pub enum X86Formatter {
    #[default]
    #[strum(message = "Intel (default)")]
@@ -53,8 +54,8 @@ pub enum X86Formatter {
    serde::Serialize,
    strum::VariantArray,
    strum::EnumMessage,
-    tsify_next::Tsify,
 )]
+#[cfg_attr(feature = "wasm", derive(tsify_next::Tsify))]
 pub enum MipsAbi {
    #[default]
    #[strum(message = "Auto (default)")]
@@ -78,8 +79,8 @@ pub enum MipsAbi {
    serde::Serialize,
    strum::VariantArray,
    strum::EnumMessage,
-    tsify_next::Tsify,
 )]
+#[cfg_attr(feature = "wasm", derive(tsify_next::Tsify))]
 pub enum MipsInstrCategory {
    #[default]
    #[strum(message = "Auto (default)")]
@@ -107,8 +108,8 @@ pub enum MipsInstrCategory {
    serde::Serialize,
    strum::VariantArray,
    strum::EnumMessage,
-    tsify_next::Tsify,
 )]
+#[cfg_attr(feature = "wasm", derive(tsify_next::Tsify))]
 pub enum ArmArchVersion {
    #[default]
    #[strum(message = "Auto (default)")]
@@ -132,8 +133,8 @@ pub enum ArmArchVersion {
    serde::Serialize,
    strum::VariantArray,
    strum::EnumMessage,
-    tsify_next::Tsify,
 )]
+#[cfg_attr(feature = "wasm", derive(tsify_next::Tsify))]
 pub enum ArmR9Usage {
    #[default]
    #[strum(
@@ -153,14 +154,17 @@ pub enum ArmR9Usage {
 #[inline]
 const fn default_true() -> bool { true }

-#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize, tsify_next::Tsify)]
-#[tsify(from_wasm_abi)]
+#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[cfg_attr(feature = "wasm", derive(tsify_next::Tsify))]
+#[cfg_attr(feature = "wasm", 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,
+    #[serde(default)]
+    pub symbol_mappings: MappingConfig,
    // x86
    pub x86_formatter: X86Formatter,
    // MIPS
@@ -182,6 +186,7 @@ impl Default for DiffObjConfig {
            relax_reloc_diffs: false,
            space_between_args: true,
            combine_data_sections: false,
+            symbol_mappings: Default::default(),
            x86_formatter: Default::default(),
            mips_abi: Default::default(),
            mips_instr_category: Default::default(),
@@ -223,8 +228,10 @@ impl ObjSectionDiff {

 #[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 +245,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>>,
 }

@@ -294,8 +301,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 +315,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,
                });
@@ -327,8 +340,8 @@ impl ObjDiff {
        }
        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 +361,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 +370,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]
@@ -378,7 +391,7 @@ pub fn diff_objs(
    right: Option<&ObjInfo>,
    prev: Option<&ObjInfo>,
 ) -> Result<DiffObjsResult> {
-    let symbol_matches = matching_symbols(left, right, prev)?;
+    let symbol_matches = matching_symbols(left, right, prev, &config.symbol_mappings)?;
    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)));
@@ -399,6 +412,8 @@ pub fn diff_objs(
                        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_diff, right_diff) = diff_code(
+                            left_obj,
+                            right_obj,
                            &left_code,
                            &right_code,
                            left_symbol_ref,
@@ -412,6 +427,8 @@ pub fn diff_objs(
                            let (prev_obj, prev_out) = prev.as_mut().unwrap();
                            let prev_code = process_code_symbol(prev_obj, prev_symbol_ref, config)?;
                            let (_, prev_diff) = diff_code(
+                                left_obj,
+                                right_obj,
                                &right_code,
                                &prev_code,
                                right_symbol_ref,
@@ -529,6 +546,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) = &config.symbol_mappings.selecting_left {
+            generate_mapping_symbols(right_obj, right_name, left_obj, left_out, config)?;
+        }
+        if let Some(left_name) = &config.symbol_mappings.selecting_right {
+            generate_mapping_symbols(left_obj, left_name, right_obj, right_out, config)?;
+        }
+    }
+
    Ok(DiffObjsResult {
        left: left.map(|(_, o)| o),
        right: right.map(|(_, o)| o),
@@ -536,6 +564,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 +636,115 @@ struct SectionMatch {
    section_kind: ObjSectionKind,
 }

+#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, serde::Deserialize, serde::Serialize)]
+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 +756,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 +788,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 +881,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
--- a/objdiff-core/src/lib.rs
+++ b/objdiff-core/src/lib.rs
@@ -8,4 +8,5 @@ pub mod config;
 pub mod diff;
 #[cfg(feature = "any-arch")]
 pub mod obj;
+#[cfg(feature = "any-arch")]
 pub mod util;
--- a/objdiff-core/src/obj/mod.rs
+++ b/objdiff-core/src/obj/mod.rs
@@ -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,6 +115,23 @@ pub struct ObjIns {
    pub orig: Option<String>,
 }

+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)]
 pub struct ObjSymbol {
    pub name: 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
@@ -145,7 +166,7 @@ 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);
        }
--- a/objdiff-core/src/obj/read.rs
+++ b/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,6 +64,7 @@ fn to_obj_symbol(
    if obj_file.format() == BinaryFormat::Elf && symbol.scope() == SymbolScope::Linkage {
        flags = ObjSymbolFlagSet(flags.0 | ObjSymbolFlags::Hidden);
    }
+    #[cfg(feature = "ppc")]
    if arch
        .ppc()
        .and_then(|a| a.extab.as_ref())
@@ -94,6 +95,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 +109,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 +161,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 +188,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 +212,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 +234,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 +313,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 +335,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 +436,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 +449,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 +587,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 +615,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 +696,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)?;
--- a/objdiff-gui/src/app.rs
+++ b/objdiff-gui/src/app.rs
@@ -15,7 +15,8 @@ use globset::{Glob, GlobSet};
 use notify::{RecursiveMode, Watcher};
 use objdiff_core::{
    config::{
-        build_globset, ProjectConfigInfo, ProjectObject, ScratchConfig, DEFAULT_WATCH_PATTERNS,
+        build_globset, save_project_config, ProjectConfig, ProjectConfigInfo, ProjectObject,
+        ScratchConfig, SymbolMappings, DEFAULT_WATCH_PATTERNS,
    },
    diff::DiffObjConfig,
 };
@@ -42,11 +43,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 +63,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,6 +99,23 @@ 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]
@@ -94,8 +135,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 +156,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 +242,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 +253,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 +262,132 @@ 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.remove_by_right(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.remove_by_left(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;
+        if left == right {
+            object.symbol_mappings.remove_by_left(&left);
+            object.symbol_mappings.remove_by_right(&right);
+        } else {
+            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}"));
+            }
+        }
    }
 }

@@ -350,31 +526,41 @@ impl App {
        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>) {
        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}"));
                }
            }
        }
@@ -409,8 +595,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,11 +619,11 @@ impl App {
            && state.config.selected_obj.is_some()
            && !jobs.is_running(Job::ObjDiff)
        {
-            jobs.push(start_build(ctx, ObjDiffConfig::from_config(&state.config)));
+            jobs.push(start_build(ctx, ObjDiffConfig::from_state(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 = ObjDiffConfig::from_state(state);
            // Don't build, just reload the current files
            diff_config.build_base = false;
            diff_config.build_target = false;
@@ -485,12 +670,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() {
@@ -599,6 +798,11 @@ impl eframe::App for App {
                    {
                        state.queue_reload = true;
                    }
+                    if ui.button("Clear custom symbol mappings").clicked() {
+                        state.clear_mappings();
+                        diff_state.post_build_nav = Some(DiffViewNavigation::symbol_diff());
+                        state.queue_reload = true;
+                    }
                });
                ui.separator();
                if jobs_menu_ui(ui, jobs, appearance) {
@@ -607,31 +811,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 +842,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);
--- a/objdiff-gui/src/app_config.rs
+++ b/objdiff-gui/src/app_config.rs
@@ -2,6 +2,10 @@ use std::path::PathBuf;

 use eframe::Storage;
 use globset::Glob;
+use objdiff_core::{
+    config::ScratchConfig,
+    diff::{ArmArchVersion, ArmR9Usage, DiffObjConfig, MipsAbi, MipsInstrCategory, X86Formatter},
+};

 use crate::app::{AppConfig, ObjectConfig, CONFIG_KEY};

@@ -11,7 +15,7 @@ pub struct AppConfigVersion {
 }

 impl Default for AppConfigVersion {
-    fn default() -> Self { Self { version: 1 } }
+    fn default() -> Self { Self { version: 2 } }
 }

 /// Deserialize the AppConfig from storage, handling upgrades from older versions.
@@ -19,7 +23,8 @@ 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),
+            2 => from_str::<AppConfig>(&str),
+            1 => from_str::<AppConfigV1>(&str).map(|c| c.into_config()),
            _ => {
                log::warn!("Unknown config version: {}", version.version);
                None
@@ -44,6 +49,181 @@ where T: serde::de::DeserializeOwned {
    }
 }

+#[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 {
+            relax_reloc_diffs: self.relax_reloc_diffs,
+            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,
+            ..Default::default()
+        }
+    }
+}
+
+#[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 +239,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()
        }
    }
 }
--- a/objdiff-gui/src/config.rs
+++ b/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,36 @@ 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(|| {
+        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);
+        state.config.watch_patterns = project_config.watch_patterns.clone().unwrap_or_else(|| {
            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(())
 }
--- a/objdiff-gui/src/jobs/create_scratch.rs
+++ b/objdiff-gui/src/jobs/create_scratch.rs
@@ -23,6 +23,7 @@ pub struct CreateScratchConfig {
    pub compiler_flags: String,
    pub function_name: String,
    pub target_obj: PathBuf,
+    pub preset_id: Option<u32>,
 }

 impl CreateScratchConfig {
@@ -39,12 +40,13 @@ impl CreateScratchConfig {
        Ok(Self {
            build_config: BuildConfig::from_config(config),
            context_path: scratch_config.ctx_path.clone(),
-            build_context: scratch_config.build_ctx,
+            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,
        })
    }

@@ -101,15 +103,18 @@ fn run_create_scratch(
    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"))
--- a/objdiff-gui/src/jobs/mod.rs
+++ b/objdiff-gui/src/jobs/mod.rs
@@ -53,7 +53,7 @@ impl JobQueue {
    }

    /// Returns whether any job is running.
-    #[allow(dead_code)]
+    #[expect(dead_code)]
    pub fn any_running(&self) -> bool {
        self.jobs.iter().any(|job| {
            if let Some(handle) = &job.handle {
--- a/objdiff-gui/src/jobs/objdiff.rs
+++ b/objdiff-gui/src/jobs/objdiff.rs
@@ -6,13 +6,13 @@ use std::{

 use anyhow::{anyhow, Error, Result};
 use objdiff_core::{
-    diff::{diff_objs, DiffObjConfig, ObjDiff},
+    diff::{diff_objs, DiffObjConfig, MappingConfig, ObjDiff},
    obj::{read, ObjInfo},
 };
 use time::OffsetDateTime;

 use crate::{
-    app::{AppConfig, ObjectConfig},
+    app::{AppConfig, AppState, ObjectConfig},
    jobs::{start_job, update_status, Job, JobContext, JobResult, JobState},
 };

@@ -60,16 +60,20 @@ pub struct ObjDiffConfig {
    pub build_target: bool,
    pub selected_obj: Option<ObjectConfig>,
    pub diff_obj_config: DiffObjConfig,
+    pub selecting_left: Option<String>,
+    pub selecting_right: Option<String>,
 }

 impl ObjDiffConfig {
-    pub(crate) fn from_config(config: &AppConfig) -> Self {
+    pub(crate) fn from_state(state: &AppState) -> 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(),
+            build_config: BuildConfig::from_config(&state.config),
+            build_base: state.config.build_base,
+            build_target: state.config.build_target,
+            selected_obj: state.config.selected_obj.clone(),
+            diff_obj_config: state.config.diff_obj_config.clone(),
+            selecting_left: state.selecting_left.clone(),
+            selecting_right: state.selecting_right.clone(),
        }
    }
 }
@@ -158,9 +162,16 @@ pub(crate) fn run_make(config: &BuildConfig, arg: &Path) -> BuildStatus {
 fn run_build(
    context: &JobContext,
    cancel: Receiver<()>,
-    config: ObjDiffConfig,
+    mut config: ObjDiffConfig,
 ) -> Result<Box<ObjDiffResult>> {
-    let obj_config = config.selected_obj.as_ref().ok_or_else(|| Error::msg("Missing obj path"))?;
+    let obj_config = config.selected_obj.ok_or_else(|| Error::msg("Missing obj path"))?;
+    // Use the per-object symbol mappings, we don't set mappings globally
+    config.diff_obj_config.symbol_mappings = MappingConfig {
+        mappings: obj_config.symbol_mappings,
+        selecting_left: config.selecting_left,
+        selecting_right: config.selecting_right,
+    };
+
    let project_dir = config
        .build_config
        .project_dir
--- a/objdiff-gui/src/views/appearance.rs
+++ b/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),
 ];
--- a/objdiff-gui/src/views/column_layout.rs
+++ b/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);
+                            });
+                        });
+                    }
+                },
+            );
+        });
+    });
+}
--- a/objdiff-gui/src/views/config.rs
+++ b/objdiff-gui/src/views/config.rs
@@ -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()
                        });
                    }
                }
@@ -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() {
@@ -316,6 +312,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 +322,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 +332,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 +346,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 +381,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 +417,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 +452,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 +469,7 @@ fn contains_node(node: &ProjectObjectNode, selected_obj: &ObjectConfig) -> bool
 }

 fn filter_node(
+    units: &[ProjectObject],
    node: &ProjectObjectNode,
    search: &str,
    filter_diffable: bool,
@@ -485,12 +477,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 +493,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 +569,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;
        }
    }
 }
--- a/objdiff-gui/src/views/data_diff.rs
+++ b/objdiff-gui/src/views/data_diff.rs
@@ -1,7 +1,6 @@
 use std::{cmp::min, 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},
    obj::ObjInfo,
@@ -10,14 +9,15 @@ use time::format_description;

 use crate::views::{
    appearance::Appearance,
-    symbol_diff::{DiffViewState, SymbolRefByName, View},
+    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) {
@@ -131,20 +131,37 @@ 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_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
@@ -159,118 +176,117 @@ fn data_table_ui(
    let left_diffs = left_section.map(|(_, section)| split_diffs(&section.data_diff));
    let right_diffs = right_section.map(|(_, section)| split_diffs(&section.data_diff));

-    table.body(|body| {
-        body.rows(config.code_font.size, total_rows, |mut row| {
-            let row_index = row.index();
-            let address = row_index * BYTES_PER_ROW;
-            row.col(|ui| {
+    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, 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, 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.map_or(false, |ctx| ctx.has_section())
+        && !left_ctx.map_or(false, |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() {
+                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
 }
--- a/objdiff-gui/src/views/extab_diff.rs
+++ b/objdiff-gui/src/views/extab_diff.rs
@@ -1,28 +1,20 @@
-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},
+    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 +40,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 +55,194 @@ 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.map_or(false, |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.map_or(false, |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.map_or(false, |ctx| !ctx.has_symbol())
+        && left_ctx.map_or(false, |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() {
+                    ret = Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
+                }
+                ui.separator();
+                if ui
+                    .add_enabled(
+                        !state.scratch_running
+                            && state.scratch_available
+                            && left_ctx.map_or(false, |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(),
-                                );
-                            }
-                        });
-                    });
-
-                    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();
+            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),
+                );
+            }
+        }
+    });

    // 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
 }
--- a/objdiff-gui/src/views/function_diff.rs
+++ b/objdiff-gui/src/views/function_diff.rs
@@ -1,28 +1,28 @@
 use std::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, 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},
+    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 +30,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 +52,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 +64,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,10 +119,17 @@ fn ins_hover_ui(
        }

        if let Some(reloc) = &ins.reloc {
-            ui.label(format!("Relocation type: {}", arch.display_reloc(reloc.flags)));
+            ui.label(format!("Relocation type: {}", obj.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}"));
+            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),
@@ -124,9 +138,10 @@ fn ins_hover_ui(
                    appearance.highlight_color,
                    format!("Size: {:x}", reloc.target.size),
                );
-                if let Some(s) = arch
+                if let Some(s) = obj
+                    .arch
                    .guess_data_type(ins)
-                    .and_then(|ty| arch.display_data_type(ty, &reloc.target.bytes))
+                    .and_then(|ty| obj.arch.display_data_type(ty, &reloc.target.bytes))
                {
                    ui.colored_label(appearance.highlight_color, s);
                }
@@ -218,17 +233,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 +292,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 +320,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 +346,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 +355,476 @@ 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]
 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,
+) -> 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
+        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() {
+                        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,
+                        ) {
+                            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),
+                                    ));
+                                }
+                                DiffViewAction::SetSymbolHighlight(_, _) => {
+                                    // Ignore
+                                }
+                                _ => {
+                                    ret = Some(action);
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    ui.label("No left object");
+                }
+            } else if column == 1 {
+                if let Some(ctx) = right_ctx {
+                    if ctx.has_symbol() {
+                        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,
+                        ) {
+                            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,
+                                    ));
+                                }
+                                DiffViewAction::SetSymbolHighlight(_, _) => {
+                                    // Ignore
+                                }
+                                _ => {
+                                    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.map_or(false, |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.map_or(false, |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.map_or(false, |ctx| !ctx.has_symbol())
+        && left_ctx.map_or(false, |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;
-                        }
-                        ui.separator();
-                        if ui
-                            .add_enabled(
-                                !state.scratch_running && state.scratch_available,
-                                egui::Button::new("📲 decomp.me"),
-                            )
-                            .on_hover_text_at_pointer("Create a new scratch on decomp.me (beta)")
-                            .on_disabled_hover_text("Scratch configuration missing")
-                            .clicked()
-                        {
-                            state.queue_scratch = true;
-                        }
-                    });
-
-                    let 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() {
+                    ret = Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
+                }
+                ui.separator();
+                if ui
+                    .add_enabled(
+                        !state.scratch_running
+                            && state.scratch_available
+                            && left_ctx.map_or(false, |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),
+                );
+                if right_ctx.map_or(false, |m| m.has_symbol())
+                    && ui
+                        .button("Change target")
+                        .on_hover_text_at_pointer("Choose a different symbol to use as the target")
+                        .clicked()
+                {
+                    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.label(
+                    RichText::new("Choose target symbol")
+                        .font(appearance.code_font.clone())
+                        .color(appearance.highlight_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),
+                );
+                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.map_or(false, |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()
                        {
-                            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()));
+                            }
                        }
-                    });
-
-                    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();
+                    }
+                });
+            } else {
+                ui.label(
+                    RichText::new("Missing")
+                        .font(appearance.code_font.clone())
+                        .color(appearance.replace_color),
+                );
+                ui.label(
+                    RichText::new("Choose base symbol")
+                        .font(appearance.code_font.clone())
+                        .color(appearance.highlight_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);
-    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,
+            )
+        })
+        .inner
+    {
+        ret = Some(action);
+    }
+    ret
 }
--- a/objdiff-gui/src/views/mod.rs
+++ b/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;
--- a/objdiff-gui/src/views/symbol_diff.rs
+++ b/objdiff-gui/src/views/symbol_diff.rs
Author	SHA1	Message	Date
Luke Street	a119d9a6dd	Add scratch preset_id field for decomp.me Resolves #133	2024-11-07 09:27:13 -07:00
robojumper	ebf653816a	Combine nested otherwise empty directories in objects view (#137 )	2024-11-07 08:21:39 -07:00
Luke Street	424434edd6	Experimental ARM64 support Based on yaxpeax-arm, but with a heavy dose of custom code to work around its limitations. Please report any issues or unhandled relocations.	2024-10-31 17:39:12 -06:00
Luke Street	7f14b684bf	Ignore PlainText segments when diffing	2024-10-31 17:27:27 -06:00
Luke Street	c5da7f7dd5	Show diff color when symbols differ	2024-10-31 17:26:59 -06:00
Luke Street	2fd655850a	Ignore Absolute relocations and log warning	2024-10-31 17:24:49 -06:00
Luke Street	79bd7317c1	Match BranchDest->Reloc with relaxed relocation diffs	2024-10-31 17:24:33 -06:00
Luke Street	21f8f2407c	Relax symbol comparison logic The Ghidra delinker plugin emits functions with type STT_OBJECT, rather than STT_FUNC. The current logic was preventing these from being compared based on their symbol type. Relax this condition for now.	2024-10-29 22:46:02 -06:00
Luke Street	d2b7a9ef25	Fix missing common BSS symbols Resolves #128	2024-10-28 17:54:49 -06:00
Luke Street	2cf9cf24d6	Version v2.3.3	2024-10-20 20:01:35 -07:00
Anghelo Carvajal	5ef3416457	Improve dependency gating on objdiff-core (#126 ) * Reduce dependencies for no features * Add missing deps to every feature * Add missing `dep:`s * Gate even more deps behind features Removes dependency on tsify-next / wasm-bindgen unless compiling with the wasm feature by using `#[cfg_attr]` * Fix wasm --------- Co-authored-by: Luke Street <luke@street.dev>	2024-10-20 19:04:29 -07:00
Aetias	6ff8d002f7	Fix panic when parsing DWARF 2 line info for empty section (#125 ) * Fix panic when parsing DWARF 2 line info for empty section * Fix panic when parsing DWARF 2 line info for empty section May as well remove both unwraps :p	2024-10-19 09:39:18 -06:00
Luke Street	9ca157d717	Lighten default blue diff color The old default was very dark and blended in with the dark theme's background.	2024-10-18 17:51:29 -06:00
Steven Casper	67b63311fc	Fix data tooltip panic (#123 ) * Fix data tooltip panic Prevents panicing when attempting to display the data tooltip for a symbol that is too large by just using as many bytes as needed from the begging of the symbol. * Don't attempt to interpret wrongly sized data * Reference data display improvment issue * Log failure to display a symbol's value	2024-10-14 22:03:30 -06:00
Luke Street	72ea1c8911	ci: Use rust-lld on Windows	2024-10-12 18:57:49 -06:00
Luke Street	d4a540857d	ci: Add Rust workspace cache	2024-10-12 18:41:42 -06:00
Luke Street	676488433f	Fix resolving symbols for section-relative relocations Also fixes MIPS `j` handling when jumping within the function. Reworks `ObjReloc` struct to be a little more sensible.	2024-10-11 18:09:18 -06:00
Luke Street	83de98b5ee	Version v2.3.1	2024-10-10 22:58:33 -06:00
Luke Street	c1ba4e91d1	ci: Setup python venv for cargo-zigbuild	2024-10-10 22:39:31 -06:00
Luke Street	575900024d	Avoid resetting diff state on unit config reload	2024-10-10 22:31:04 -06:00
Luke Street	cbe299e859	Fix logic issue with 0-sized symbols Fixes #119	2024-10-10 22:20:48 -06:00
Luke Street	741d93e211	Add symbol mapping feature (#118 ) This allows users to "map" (or "link") symbols with different names so that they can be compared without having to update either the target or base objects. Symbol mappings are persisted in objdiff.json, so generators will need to ensure that they're preserved when updating. (Example: `d1334bb79e`) Resolves #117	2024-10-09 21:44:18 -06:00
Luke Street	603dbd6882	Round match percent down before display Ensures that 100% isn't displayed until it's a perfect match.	2024-10-07 20:17:56 -06:00
Luke Street	6fb0a63de2	Click on empty space in row to clear highlight Resolves #116	2024-10-07 19:53:16 -06:00
Luke Street	ab2e84a2c6	Deprioritize generated GCC symbols in find_section_symbol Resolves #115	2024-10-07 19:49:52 -06:00
Luke Street	9596051cb4	Allow collapsing sidebar in symbols view	2024-10-07 19:46:16 -06:00