Split into objdiff-core / objdiff-gui; update egui to 0.26.2

objdiff-core/src/diff/code.rs

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

objdiff-core/src/diff/data.rs

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

objdiff-core/src/diff/editops.rs

@@ -0,0 +1,162 @@
+/// Adapted from https://crates.io/crates/rapidfuzz
+// Copyright 2020 maxbachmann
+//
+// Permission is hereby granted, free of charge, to any
+// person obtaining a copy of this software and associated
+// documentation files (the "Software"), to deal in the
+// Software without restriction, including without
+// limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software
+// is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice
+// shall be included in all copies or substantial portions
+// of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum LevEditType {
+    Replace,
+    Insert,
+    Delete,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct LevEditOp {
+    pub op_type: LevEditType, /* editing operation type */
+    pub first_start: usize,   /* source block position */
+    pub second_start: usize,  /* destination position */
+}
+
+pub fn editops_find<T>(query: &[T], choice: &[T]) -> Vec<LevEditOp>
+where T: PartialEq {
+    let Affix { prefix_len, suffix_len } = Affix::find(query, choice);
+
+    let first_string = &query[prefix_len..query.len() - suffix_len];
+    let second_string = &choice[prefix_len..choice.len() - suffix_len];
+
+    let matrix_columns = first_string.len() + 1;
+    let matrix_rows = second_string.len() + 1;
+
+    // TODO maybe use an actual matrix for readability
+    let mut cache_matrix: Vec<usize> = vec![0; matrix_rows * matrix_columns];
+    for (i, elem) in cache_matrix.iter_mut().enumerate().take(matrix_rows) {
+        *elem = i;
+    }
+    for i in 1..matrix_columns {
+        cache_matrix[matrix_rows * i] = i;
+    }
+
+    for (i, char1) in first_string.iter().enumerate() {
+        let mut prev = i * matrix_rows;
+        let current = prev + matrix_rows;
+        let mut x = i + 1;
+        for (p, char2p) in second_string.iter().enumerate() {
+            let mut c3 = cache_matrix[prev] + (char1 != char2p) as usize;
+            prev += 1;
+            x += 1;
+            if x >= c3 {
+                x = c3;
+            }
+            c3 = cache_matrix[prev] + 1;
+            if x > c3 {
+                x = c3;
+            }
+            cache_matrix[current + 1 + p] = x;
+        }
+    }
+    editops_from_cost_matrix(matrix_columns, matrix_rows, prefix_len, cache_matrix)
+}
+
+fn editops_from_cost_matrix(
+    len1: usize,
+    len2: usize,
+    prefix_len: usize,
+    cache_matrix: Vec<usize>,
+) -> Vec<LevEditOp> {
+    let mut ops = Vec::with_capacity(cache_matrix[len1 * len2 - 1]);
+    let mut dir = 0;
+    let mut i = len1 - 1;
+    let mut j = len2 - 1;
+    let mut p = len1 * len2 - 1;
+
+    //TODO this is still pretty ugly
+    while i > 0 || j > 0 {
+        let current_value = cache_matrix[p];
+
+        // More than one operation can be possible at a time. We use `dir` to
+        // decide when ambiguous.
+        let is_insert = j > 0 && current_value == cache_matrix[p - 1] + 1;
+        let is_delete = i > 0 && current_value == cache_matrix[p - len2] + 1;
+        let is_replace = i > 0 && j > 0 && current_value == cache_matrix[p - len2 - 1] + 1;
+
+        let (op_type, new_dir) = match (dir, is_insert, is_delete, is_replace) {
+            (_, false, false, false) => (None, 0),
+            (-1, true, _, _) => (Some(LevEditType::Insert), -1),
+            (1, _, true, _) => (Some(LevEditType::Delete), 1),
+            (_, _, _, true) => (Some(LevEditType::Replace), 0),
+            (0, true, _, _) => (Some(LevEditType::Insert), -1),
+            (0, _, true, _) => (Some(LevEditType::Delete), 1),
+            _ => panic!("something went terribly wrong"),
+        };
+
+        match new_dir {
+            -1 => {
+                j -= 1;
+                p -= 1;
+            }
+            1 => {
+                i -= 1;
+                p -= len2;
+            }
+            0 => {
+                i -= 1;
+                j -= 1;
+                p -= len2 + 1;
+            }
+            _ => panic!("something went terribly wrong"),
+        };
+        dir = new_dir;
+
+        if let Some(op_type) = op_type {
+            ops.insert(0, LevEditOp {
+                op_type,
+                first_start: i + prefix_len,
+                second_start: j + prefix_len,
+            });
+        }
+    }
+
+    ops
+}
+
+pub struct Affix {
+    pub prefix_len: usize,
+    pub suffix_len: usize,
+}
+
+impl Affix {
+    pub fn find<T>(s1: &[T], s2: &[T]) -> Affix
+    where T: PartialEq {
+        let prefix_len = s1.iter().zip(s2.iter()).take_while(|t| t.0 == t.1).count();
+        let suffix_len = s1[prefix_len..]
+            .iter()
+            .rev()
+            .zip(s2[prefix_len..].iter().rev())
+            .take_while(|t| t.0 == t.1)
+            .count();
+
+        Affix { prefix_len, suffix_len }
+    }
+}

objdiff-core/src/diff/mod.rs

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

objdiff-core/src/lib.rs

@@ -0,0 +1,6 @@
+pub mod diff;
+pub mod obj;
+pub mod util;
+
+#[cfg(not(feature = "any-arch"))]
+compile_error!("At least one architecture feature must be enabled.");

objdiff-core/src/obj/elf.rs

@@ -0,0 +1,360 @@
+use std::{borrow::Cow, collections::BTreeMap, fs, io::Cursor, path::Path};
+
+use anyhow::{anyhow, bail, ensure, Context, Result};
+use byteorder::{BigEndian, ReadBytesExt};
+use filetime::FileTime;
+use flagset::Flags;
+use object::{
+    elf, Architecture, Endianness, File, Object, ObjectSection, ObjectSymbol, RelocationKind,
+    RelocationTarget, SectionIndex, SectionKind, Symbol, SymbolKind, SymbolScope, SymbolSection,
+};
+
+use crate::obj::{
+    ObjArchitecture, ObjInfo, ObjReloc, ObjRelocKind, ObjSection, ObjSectionKind, ObjSymbol,
+    ObjSymbolFlagSet, ObjSymbolFlags,
+};
+
+fn to_obj_section_kind(kind: SectionKind) -> Option<ObjSectionKind> {
+    match kind {
+        SectionKind::Text => Some(ObjSectionKind::Code),
+        SectionKind::Data | SectionKind::ReadOnlyData => Some(ObjSectionKind::Data),
+        SectionKind::UninitializedData => Some(ObjSectionKind::Bss),
+        _ => None,
+    }
+}
+
+fn to_obj_symbol(obj_file: &File<'_>, symbol: &Symbol<'_, '_>, addend: i64) -> Result<ObjSymbol> {
+    let mut name = symbol.name().context("Failed to process symbol name")?;
+    if name.is_empty() {
+        log::warn!("Found empty sym: {symbol:?}");
+        name = "?";
+    }
+    let mut flags = ObjSymbolFlagSet(ObjSymbolFlags::none());
+    if symbol.is_global() {
+        flags = ObjSymbolFlagSet(flags.0 | ObjSymbolFlags::Global);
+    }
+    if symbol.is_local() {
+        flags = ObjSymbolFlagSet(flags.0 | ObjSymbolFlags::Local);
+    }
+    if symbol.is_common() {
+        flags = ObjSymbolFlagSet(flags.0 | ObjSymbolFlags::Common);
+    }
+    if symbol.is_weak() {
+        flags = ObjSymbolFlagSet(flags.0 | ObjSymbolFlags::Weak);
+    }
+    if symbol.scope() == SymbolScope::Linkage {
+        flags = ObjSymbolFlagSet(flags.0 | ObjSymbolFlags::Hidden);
+    }
+    let section_address = if let Some(section) =
+        symbol.section_index().and_then(|idx| obj_file.section_by_index(idx).ok())
+    {
+        symbol.address() - section.address()
+    } else {
+        symbol.address()
+    };
+    let mut demangled_name = None;
+    #[cfg(feature = "ppc")]
+    if obj_file.architecture() == Architecture::PowerPc {
+        demangled_name = cwdemangle::demangle(name, &Default::default());
+    }
+    Ok(ObjSymbol {
+        name: name.to_string(),
+        demangled_name,
+        address: symbol.address(),
+        section_address,
+        size: symbol.size(),
+        size_known: symbol.size() != 0,
+        flags,
+        addend,
+        diff_symbol: None,
+        instructions: vec![],
+        match_percent: None,
+    })
+}
+
+fn filter_sections(obj_file: &File<'_>) -> Result<Vec<ObjSection>> {
+    let mut result = Vec::<ObjSection>::new();
+    for section in obj_file.sections() {
+        if section.size() == 0 {
+            continue;
+        }
+        let Some(kind) = to_obj_section_kind(section.kind()) else {
+            continue;
+        };
+        let name = section.name().context("Failed to process section name")?;
+        let data = section.uncompressed_data().context("Failed to read section data")?;
+        result.push(ObjSection {
+            name: name.to_string(),
+            kind,
+            address: section.address(),
+            size: section.size(),
+            data: data.to_vec(),
+            index: section.index().0,
+            symbols: Vec::new(),
+            relocations: Vec::new(),
+            data_diff: vec![],
+            match_percent: 0.0,
+        });
+    }
+    result.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(result)
+}
+
+fn symbols_by_section(obj_file: &File<'_>, section: &ObjSection) -> Result<Vec<ObjSymbol>> {
+    let mut result = Vec::<ObjSymbol>::new();
+    for symbol in obj_file.symbols() {
+        if symbol.kind() == SymbolKind::Section {
+            continue;
+        }
+        if let Some(index) = symbol.section().index() {
+            if index.0 == section.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(obj_file, &symbol, 0)?);
+            }
+        }
+    }
+    result.sort_by_key(|v| v.address);
+    let mut iter = result.iter_mut().peekable();
+    while let Some(symbol) = iter.next() {
+        if symbol.size == 0 {
+            if let Some(next_symbol) = iter.peek() {
+                symbol.size = next_symbol.address - symbol.address;
+            } else {
+                symbol.size = (section.address + section.size) - symbol.address;
+            }
+        }
+    }
+    Ok(result)
+}
+
+fn common_symbols(obj_file: &File<'_>) -> Result<Vec<ObjSymbol>> {
+    obj_file
+        .symbols()
+        .filter(Symbol::is_common)
+        .map(|symbol| to_obj_symbol(obj_file, &symbol, 0))
+        .collect::<Result<Vec<ObjSymbol>>>()
+}
+
+fn find_section_symbol(
+    obj_file: &File<'_>,
+    target: &Symbol<'_, '_>,
+    address: u64,
+) -> 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(obj_file, &symbol, 0);
+    }
+    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;
+    Ok(ObjSymbol {
+        name: name.to_string(),
+        demangled_name: None,
+        address: offset,
+        section_address: address - section.address(),
+        size: 0,
+        size_known: false,
+        flags: Default::default(),
+        addend: offset_addr as i64,
+        diff_symbol: None,
+        instructions: vec![],
+        match_percent: None,
+    })
+}
+
+fn relocations_by_section(
+    arch: ObjArchitecture,
+    obj_file: &File<'_>,
+    section: &ObjSection,
+) -> Result<Vec<ObjReloc>> {
+    let obj_section = obj_file.section_by_index(SectionIndex(section.index))?;
+    let mut relocations = Vec::<ObjReloc>::new();
+    for (address, reloc) in obj_section.relocations() {
+        let symbol = match reloc.target() {
+            RelocationTarget::Symbol(idx) => obj_file
+                .symbol_by_index(idx)
+                .context("Failed to locate relocation target symbol")?,
+            _ => bail!("Unhandled relocation target: {:?}", reloc.target()),
+        };
+        let kind = match reloc.kind() {
+            RelocationKind::Absolute => ObjRelocKind::Absolute,
+            RelocationKind::Elf(kind) => match arch {
+                #[cfg(feature = "ppc")]
+                ObjArchitecture::PowerPc => match kind {
+                    elf::R_PPC_ADDR16_LO => ObjRelocKind::PpcAddr16Lo,
+                    elf::R_PPC_ADDR16_HI => ObjRelocKind::PpcAddr16Hi,
+                    elf::R_PPC_ADDR16_HA => ObjRelocKind::PpcAddr16Ha,
+                    elf::R_PPC_REL24 => ObjRelocKind::PpcRel24,
+                    elf::R_PPC_REL14 => ObjRelocKind::PpcRel14,
+                    elf::R_PPC_EMB_SDA21 => ObjRelocKind::PpcEmbSda21,
+                    _ => bail!("Unhandled PPC relocation type: {kind}"),
+                },
+                #[cfg(feature = "mips")]
+                ObjArchitecture::Mips => match kind {
+                    elf::R_MIPS_26 => ObjRelocKind::Mips26,
+                    elf::R_MIPS_HI16 => ObjRelocKind::MipsHi16,
+                    elf::R_MIPS_LO16 => ObjRelocKind::MipsLo16,
+                    elf::R_MIPS_GOT16 => ObjRelocKind::MipsGot16,
+                    elf::R_MIPS_CALL16 => ObjRelocKind::MipsCall16,
+                    elf::R_MIPS_GPREL16 => ObjRelocKind::MipsGpRel16,
+                    elf::R_MIPS_GPREL32 => ObjRelocKind::MipsGpRel32,
+                    _ => bail!("Unhandled MIPS relocation type: {kind}"),
+                },
+            },
+            _ => bail!("Unhandled relocation type: {:?}", reloc.kind()),
+        };
+        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 addend = u32::from_be_bytes(
+                section.data[address as usize..address as usize + 4].try_into()?,
+            );
+            match kind {
+                ObjRelocKind::Absolute => addend as i64,
+                #[cfg(feature = "mips")]
+                ObjRelocKind::MipsHi16 => ((addend & 0x0000FFFF) << 16) as i32 as i64,
+                #[cfg(feature = "mips")]
+                ObjRelocKind::MipsLo16
+                | ObjRelocKind::MipsGot16
+                | ObjRelocKind::MipsCall16
+                | ObjRelocKind::MipsGpRel16 => (addend & 0x0000FFFF) as i16 as i64,
+                #[cfg(feature = "mips")]
+                ObjRelocKind::MipsGpRel32 => addend as i32 as i64,
+                #[cfg(feature = "mips")]
+                ObjRelocKind::Mips26 => ((addend & 0x03FFFFFF) << 2) as i64,
+                _ => bail!("Unsupported implicit relocation {kind:?}"),
+            }
+        } 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(obj_file, &symbol, addend)
+            }
+            SymbolKind::Section => {
+                ensure!(addend >= 0, "Negative addend in reloc: {addend}");
+                find_section_symbol(obj_file, &symbol, addend as u64)
+            }
+            kind => Err(anyhow!("Unhandled relocation symbol type {kind:?}")),
+        }?;
+        relocations.push(ObjReloc { kind, address, target, target_section });
+    }
+    Ok(relocations)
+}
+
+fn line_info(obj_file: &File<'_>) -> Result<Option<BTreeMap<u64, u64>>> {
+    // DWARF 1.1
+    let mut map = BTreeMap::new();
+    if let Some(section) = obj_file.section_by_name(".line") {
+        if section.size() == 0 {
+            return Ok(None);
+        }
+        let data = section.uncompressed_data()?;
+        let mut reader = Cursor::new(data.as_ref());
+
+        let size = reader.read_u32::<BigEndian>()?;
+        let base_address = reader.read_u32::<BigEndian>()? as u64;
+        while reader.position() < size as u64 {
+            let line_number = reader.read_u32::<BigEndian>()? as u64;
+            let statement_pos = reader.read_u16::<BigEndian>()?;
+            if statement_pos != 0xFFFF {
+                log::warn!("Unhandled statement pos {}", statement_pos);
+            }
+            let address_delta = reader.read_u32::<BigEndian>()? as u64;
+            map.insert(base_address + address_delta, line_number);
+        }
+    }
+
+    // DWARF 2+
+    #[cfg(feature = "dwarf")]
+    {
+        let dwarf_cow = gimli::Dwarf::load(|id| {
+            Ok::<_, gimli::Error>(
+                obj_file
+                    .section_by_name(id.name())
+                    .and_then(|section| section.uncompressed_data().ok())
+                    .unwrap_or(Cow::Borrowed(&[][..])),
+            )
+        })?;
+        let endian = match obj_file.endianness() {
+            Endianness::Little => gimli::RunTimeEndian::Little,
+            Endianness::Big => gimli::RunTimeEndian::Big,
+        };
+        let dwarf = dwarf_cow.borrow(|section| gimli::EndianSlice::new(section, endian));
+        let mut iter = dwarf.units();
+        while let Some(header) = iter.next()? {
+            let unit = dwarf.unit(header)?;
+            if let Some(program) = unit.line_program.clone() {
+                let mut rows = program.rows();
+                while let Some((_header, row)) = rows.next_row()? {
+                    if let Some(line) = row.line() {
+                        map.insert(row.address(), line.get());
+                    }
+                }
+            }
+        }
+    }
+    if map.is_empty() {
+        return Ok(None);
+    }
+    Ok(Some(map))
+}
+
+pub fn read(obj_path: &Path) -> Result<ObjInfo> {
+    let (data, timestamp) = {
+        let file = fs::File::open(obj_path)?;
+        let timestamp = FileTime::from_last_modification_time(&file.metadata()?);
+        (unsafe { memmap2::Mmap::map(&file) }?, timestamp)
+    };
+    let obj_file = File::parse(&*data)?;
+    let architecture = match obj_file.architecture() {
+        #[cfg(feature = "ppc")]
+        Architecture::PowerPc => ObjArchitecture::PowerPc,
+        #[cfg(feature = "mips")]
+        Architecture::Mips => ObjArchitecture::Mips,
+        _ => bail!("Unsupported architecture: {:?}", obj_file.architecture()),
+    };
+    let mut result = ObjInfo {
+        architecture,
+        path: obj_path.to_owned(),
+        timestamp,
+        sections: filter_sections(&obj_file)?,
+        common: common_symbols(&obj_file)?,
+        line_info: line_info(&obj_file)?,
+    };
+    for section in &mut result.sections {
+        section.symbols = symbols_by_section(&obj_file, section)?;
+        section.relocations = relocations_by_section(architecture, &obj_file, section)?;
+    }
+    Ok(result)
+}

objdiff-core/src/obj/mips.rs

@@ -0,0 +1,107 @@
+use std::collections::BTreeMap;
+
+use anyhow::Result;
+use rabbitizer::{config, Abi, InstrCategory, Instruction, OperandType};
+
+use crate::{
+    diff::ProcessCodeResult,
+    obj::{ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc},
+};
+
+fn configure_rabbitizer() {
+    unsafe {
+        config::RabbitizerConfig_Cfg.reg_names.fpr_abi_names = Abi::O32;
+    }
+}
+
+pub fn process_code(
+    data: &[u8],
+    start_address: u64,
+    end_address: u64,
+    relocs: &[ObjReloc],
+    line_info: &Option<BTreeMap<u64, u64>>,
+) -> Result<ProcessCodeResult> {
+    configure_rabbitizer();
+
+    let ins_count = data.len() / 4;
+    let mut ops = Vec::<u8>::with_capacity(ins_count);
+    let mut insts = Vec::<ObjIns>::with_capacity(ins_count);
+    let mut cur_addr = start_address as u32;
+    for chunk in data.chunks_exact(4) {
+        let reloc = relocs.iter().find(|r| (r.address as u32 & !3) == cur_addr);
+        let code = u32::from_be_bytes(chunk.try_into()?);
+        let instruction = Instruction::new(code, cur_addr, InstrCategory::CPU);
+
+        let op = instruction.unique_id as u8;
+        ops.push(op);
+
+        let mnemonic = instruction.opcode_name().to_string();
+        let is_branch = instruction.is_branch();
+        let branch_offset = instruction.branch_offset();
+        let branch_dest =
+            if is_branch { Some((cur_addr as i32 + branch_offset) as u32) } else { None };
+
+        let operands = instruction.get_operands_slice();
+        let mut args = Vec::with_capacity(operands.len() + 1);
+        for op in operands {
+            match op {
+                OperandType::cpu_immediate
+                | OperandType::cpu_label
+                | OperandType::cpu_branch_target_label => {
+                    if is_branch {
+                        args.push(ObjInsArg::BranchOffset(branch_offset));
+                    } else 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
+                        {
+                            // Inter-function reloc, convert to branch offset
+                            args.push(ObjInsArg::BranchOffset(
+                                reloc.target.address as i32 - cur_addr as i32,
+                            ));
+                        } else {
+                            args.push(ObjInsArg::Reloc);
+                        }
+                    } else {
+                        args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
+                            op.disassemble(&instruction, None),
+                        )));
+                    }
+                }
+                OperandType::cpu_immediate_base => {
+                    if reloc.is_some() {
+                        args.push(ObjInsArg::RelocWithBase);
+                    } else {
+                        args.push(ObjInsArg::ArgWithBase(ObjInsArgValue::Opaque(
+                            OperandType::cpu_immediate.disassemble(&instruction, None),
+                        )));
+                    }
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
+                        OperandType::cpu_rs.disassemble(&instruction, None),
+                    )));
+                }
+                _ => {
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
+                        op.disassemble(&instruction, None),
+                    )));
+                }
+            }
+        }
+        let line = line_info
+            .as_ref()
+            .and_then(|map| map.range(..=cur_addr as u64).last().map(|(_, &b)| b));
+        insts.push(ObjIns {
+            address: cur_addr,
+            code,
+            op,
+            mnemonic,
+            args,
+            reloc: reloc.cloned(),
+            branch_dest,
+            line,
+            orig: None,
+        });
+        cur_addr += 4;
+    }
+    Ok(ProcessCodeResult { ops, insts })
+}

objdiff-core/src/obj/mod.rs

@@ -0,0 +1,258 @@
+pub mod elf;
+#[cfg(feature = "mips")]
+pub mod mips;
+#[cfg(feature = "ppc")]
+pub mod ppc;
+
+use std::{collections::BTreeMap, fmt, path::PathBuf};
+
+use filetime::FileTime;
+use flagset::{flags, FlagSet};
+
+use crate::util::ReallySigned;
+
+#[derive(Debug, Eq, PartialEq, Copy, Clone)]
+pub enum ObjSectionKind {
+    Code,
+    Data,
+    Bss,
+}
+flags! {
+    pub enum ObjSymbolFlags: u8 {
+        Global,
+        Local,
+        Weak,
+        Common,
+        Hidden,
+    }
+}
+#[derive(Debug, Copy, Clone, Default)]
+pub struct ObjSymbolFlagSet(pub FlagSet<ObjSymbolFlags>);
+
+#[derive(Debug, Clone)]
+pub struct ObjSection {
+    pub name: String,
+    pub kind: ObjSectionKind,
+    pub address: u64,
+    pub size: u64,
+    pub data: Vec<u8>,
+    pub index: usize,
+    pub symbols: Vec<ObjSymbol>,
+    pub relocations: Vec<ObjReloc>,
+
+    // Diff
+    pub data_diff: Vec<ObjDataDiff>,
+    pub match_percent: f32,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum ObjInsArgValue {
+    Signed(i16),
+    Unsigned(u16),
+    Opaque(String),
+}
+
+impl ObjInsArgValue {
+    pub fn loose_eq(&self, other: &ObjInsArgValue) -> bool {
+        match (self, other) {
+            (ObjInsArgValue::Signed(a), ObjInsArgValue::Signed(b)) => a == b,
+            (ObjInsArgValue::Unsigned(a), ObjInsArgValue::Unsigned(b)) => a == b,
+            (ObjInsArgValue::Signed(a), ObjInsArgValue::Unsigned(b))
+            | (ObjInsArgValue::Unsigned(b), ObjInsArgValue::Signed(a)) => *a as u16 == *b,
+            (ObjInsArgValue::Opaque(a), ObjInsArgValue::Opaque(b)) => a == b,
+            _ => false,
+        }
+    }
+}
+
+impl fmt::Display for ObjInsArgValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ObjInsArgValue::Signed(v) => write!(f, "{:#x}", ReallySigned(*v)),
+            ObjInsArgValue::Unsigned(v) => write!(f, "{:#x}", v),
+            ObjInsArgValue::Opaque(v) => write!(f, "{}", v),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum ObjInsArg {
+    Arg(ObjInsArgValue),
+    ArgWithBase(ObjInsArgValue),
+    Reloc,
+    RelocWithBase,
+    BranchOffset(i32),
+}
+
+impl ObjInsArg {
+    pub fn loose_eq(&self, other: &ObjInsArg) -> bool {
+        match (self, other) {
+            (ObjInsArg::Arg(a), ObjInsArg::Arg(b)) => a.loose_eq(b),
+            (ObjInsArg::ArgWithBase(a), ObjInsArg::ArgWithBase(b)) => a.loose_eq(b),
+            (ObjInsArg::Reloc, ObjInsArg::Reloc) => true,
+            (ObjInsArg::RelocWithBase, ObjInsArg::RelocWithBase) => true,
+            (ObjInsArg::BranchOffset(a), ObjInsArg::BranchOffset(b)) => a == b,
+            _ => false,
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct ObjInsArgDiff {
+    /// Incrementing index for coloring
+    pub idx: usize,
+}
+
+#[derive(Debug, Clone)]
+pub struct ObjInsBranchFrom {
+    /// Source instruction indices
+    pub ins_idx: Vec<usize>,
+    /// Incrementing index for coloring
+    pub branch_idx: usize,
+}
+
+#[derive(Debug, Clone)]
+pub struct ObjInsBranchTo {
+    /// Target instruction index
+    pub ins_idx: usize,
+    /// Incrementing index for coloring
+    pub branch_idx: usize,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
+pub enum ObjInsDiffKind {
+    #[default]
+    None,
+    OpMismatch,
+    ArgMismatch,
+    Replace,
+    Delete,
+    Insert,
+}
+
+#[derive(Debug, Clone)]
+pub struct ObjIns {
+    pub address: u32,
+    pub code: u32,
+    pub op: u8,
+    pub mnemonic: String,
+    pub args: Vec<ObjInsArg>,
+    pub reloc: Option<ObjReloc>,
+    pub branch_dest: Option<u32>,
+    /// Line info
+    pub line: Option<u64>,
+    /// Original (unsimplified) instruction
+    pub orig: Option<String>,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ObjInsDiff {
+    pub ins: Option<ObjIns>,
+    /// Diff kind
+    pub kind: ObjInsDiffKind,
+    /// Branches from instruction
+    pub branch_from: Option<ObjInsBranchFrom>,
+    /// Branches to instruction
+    pub branch_to: Option<ObjInsBranchTo>,
+    /// Arg diffs
+    pub arg_diff: Vec<Option<ObjInsArgDiff>>,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
+pub enum ObjDataDiffKind {
+    #[default]
+    None,
+    Replace,
+    Delete,
+    Insert,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ObjDataDiff {
+    pub data: Vec<u8>,
+    pub kind: ObjDataDiffKind,
+    pub len: usize,
+    pub symbol: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct ObjSymbol {
+    pub name: String,
+    pub demangled_name: Option<String>,
+    pub address: u64,
+    pub section_address: u64,
+    pub size: u64,
+    pub size_known: bool,
+    pub flags: ObjSymbolFlagSet,
+    pub addend: i64,
+
+    // Diff
+    pub diff_symbol: Option<String>,
+    pub instructions: Vec<ObjInsDiff>,
+    pub match_percent: Option<f32>,
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum ObjArchitecture {
+    #[cfg(feature = "ppc")]
+    PowerPc,
+    #[cfg(feature = "mips")]
+    Mips,
+}
+
+#[derive(Debug, Clone)]
+pub struct ObjInfo {
+    pub architecture: ObjArchitecture,
+    pub path: PathBuf,
+    pub timestamp: FileTime,
+    pub sections: Vec<ObjSection>,
+    pub common: Vec<ObjSymbol>,
+    pub line_info: Option<BTreeMap<u64, u64>>,
+}
+
+#[derive(Debug, Eq, PartialEq, Copy, Clone)]
+pub enum ObjRelocKind {
+    Absolute,
+    #[cfg(feature = "ppc")]
+    PpcAddr16Hi,
+    #[cfg(feature = "ppc")]
+    PpcAddr16Ha,
+    #[cfg(feature = "ppc")]
+    PpcAddr16Lo,
+    // #[cfg(feature = "ppc")]
+    // PpcAddr32,
+    // #[cfg(feature = "ppc")]
+    // PpcRel32,
+    // #[cfg(feature = "ppc")]
+    // PpcAddr24,
+    #[cfg(feature = "ppc")]
+    PpcRel24,
+    // #[cfg(feature = "ppc")]
+    // PpcAddr14,
+    #[cfg(feature = "ppc")]
+    PpcRel14,
+    #[cfg(feature = "ppc")]
+    PpcEmbSda21,
+    #[cfg(feature = "mips")]
+    Mips26,
+    #[cfg(feature = "mips")]
+    MipsHi16,
+    #[cfg(feature = "mips")]
+    MipsLo16,
+    #[cfg(feature = "mips")]
+    MipsGot16,
+    #[cfg(feature = "mips")]
+    MipsCall16,
+    #[cfg(feature = "mips")]
+    MipsGpRel16,
+    #[cfg(feature = "mips")]
+    MipsGpRel32,
+}
+
+#[derive(Debug, Clone)]
+pub struct ObjReloc {
+    pub kind: ObjRelocKind,
+    pub address: u64,
+    pub target: ObjSymbol,
+    pub target_section: Option<String>,
+}

objdiff-core/src/obj/ppc.rs

@@ -0,0 +1,110 @@
+use std::collections::BTreeMap;
+
+use anyhow::Result;
+use ppc750cl::{disasm_iter, Argument, SimplifiedIns};
+
+use crate::{
+    diff::ProcessCodeResult,
+    obj::{ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc, ObjRelocKind},
+};
+
+// Relative relocation, can be Simm or BranchOffset
+fn is_relative_arg(arg: &ObjInsArg) -> bool {
+    matches!(arg, ObjInsArg::Arg(ObjInsArgValue::Signed(_)) | ObjInsArg::BranchOffset(_))
+}
+
+// Relative or absolute relocation, can be Uimm, Simm or Offset
+fn is_rel_abs_arg(arg: &ObjInsArg) -> bool {
+    matches!(
+        arg,
+        ObjInsArg::Arg(ObjInsArgValue::Signed(_) | ObjInsArgValue::Unsigned(_))
+            | ObjInsArg::ArgWithBase(ObjInsArgValue::Signed(_))
+    )
+}
+
+fn is_offset_arg(arg: &ObjInsArg) -> bool {
+    matches!(arg, ObjInsArg::ArgWithBase(ObjInsArgValue::Signed(_)))
+}
+
+pub fn process_code(
+    data: &[u8],
+    address: u64,
+    relocs: &[ObjReloc],
+    line_info: &Option<BTreeMap<u64, u64>>,
+) -> Result<ProcessCodeResult> {
+    let ins_count = data.len() / 4;
+    let mut ops = Vec::<u8>::with_capacity(ins_count);
+    let mut insts = Vec::<ObjIns>::with_capacity(ins_count);
+    for mut ins in disasm_iter(data, address as u32) {
+        let reloc = relocs.iter().find(|r| (r.address as u32 & !3) == ins.addr);
+        if let Some(reloc) = reloc {
+            // Zero out relocations
+            ins.code = match reloc.kind {
+                ObjRelocKind::PpcEmbSda21 => ins.code & !0x1FFFFF,
+                ObjRelocKind::PpcRel24 => ins.code & !0x3FFFFFC,
+                ObjRelocKind::PpcRel14 => ins.code & !0xFFFC,
+                ObjRelocKind::PpcAddr16Hi
+                | ObjRelocKind::PpcAddr16Ha
+                | ObjRelocKind::PpcAddr16Lo => ins.code & !0xFFFF,
+                _ => ins.code,
+            };
+        }
+        let simplified = ins.clone().simplified();
+        let mut args: Vec<ObjInsArg> = simplified
+            .args
+            .iter()
+            .map(|a| match a {
+                Argument::Simm(simm) => ObjInsArg::Arg(ObjInsArgValue::Signed(simm.0)),
+                Argument::Uimm(uimm) => ObjInsArg::Arg(ObjInsArgValue::Unsigned(uimm.0)),
+                Argument::Offset(offset) => {
+                    ObjInsArg::ArgWithBase(ObjInsArgValue::Signed(offset.0))
+                }
+                Argument::BranchDest(dest) => ObjInsArg::BranchOffset(dest.0),
+                _ => ObjInsArg::Arg(ObjInsArgValue::Opaque(a.to_string())),
+            })
+            .collect();
+        if let Some(reloc) = reloc {
+            match reloc.kind {
+                ObjRelocKind::PpcEmbSda21 => {
+                    args = vec![args[0].clone(), ObjInsArg::Reloc];
+                }
+                ObjRelocKind::PpcRel24 | ObjRelocKind::PpcRel14 => {
+                    let arg = args
+                        .iter_mut()
+                        .rfind(|a| is_relative_arg(a))
+                        .ok_or_else(|| anyhow::Error::msg("Failed to locate rel arg for reloc"))?;
+                    *arg = ObjInsArg::Reloc;
+                }
+                ObjRelocKind::PpcAddr16Hi
+                | ObjRelocKind::PpcAddr16Ha
+                | ObjRelocKind::PpcAddr16Lo => {
+                    let arg = args.iter_mut().rfind(|a| is_rel_abs_arg(a)).ok_or_else(|| {
+                        anyhow::Error::msg("Failed to locate rel/abs arg for reloc")
+                    })?;
+                    *arg = if is_offset_arg(arg) {
+                        ObjInsArg::RelocWithBase
+                    } else {
+                        ObjInsArg::Reloc
+                    };
+                }
+                _ => {}
+            }
+        }
+        ops.push(simplified.ins.op as u8);
+        let line = line_info
+            .as_ref()
+            .and_then(|map| map.range(..=simplified.ins.addr as u64).last().map(|(_, &b)| b));
+        insts.push(ObjIns {
+            address: simplified.ins.addr,
+            code: simplified.ins.code,
+            mnemonic: format!("{}{}", simplified.mnemonic, simplified.suffix),
+            args,
+            reloc: reloc.cloned(),
+            op: ins.op as u8,
+            branch_dest: None,
+            line,
+            orig: Some(format!("{}", SimplifiedIns::basic_form(ins))),
+        });
+    }
+    Ok(ProcessCodeResult { ops, insts })
+}

objdiff-core/src/util.rs

@@ -0,0 +1,24 @@
+use std::fmt::{LowerHex, UpperHex};
+
+use num_traits::PrimInt;
+
+// https://stackoverflow.com/questions/44711012/how-do-i-format-a-signed-integer-to-a-sign-aware-hexadecimal-representation
+pub(crate) struct ReallySigned<N: PrimInt>(pub(crate) N);
+
+impl<N: PrimInt> LowerHex for ReallySigned<N> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let num = self.0.to_i32().unwrap();
+        let prefix = if f.alternate() { "0x" } else { "" };
+        let bare_hex = format!("{:x}", num.abs());
+        f.pad_integral(num >= 0, prefix, &bare_hex)
+    }
+}
+
+impl<N: PrimInt> UpperHex for ReallySigned<N> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let num = self.0.to_i32().unwrap();
+        let prefix = if f.alternate() { "0x" } else { "" };
+        let bare_hex = format!("{:X}", num.abs());
+        f.pad_integral(num >= 0, prefix, &bare_hex)
+    }
+}