objdiff-core API adjustments

- Allows using process_code without
  constructing an ObjInfo
- Allows creating an arch without
  having to provide an object

Used in decomp-toolkit

objdiff-core/src/diff/code.rs

@@ -4,7 +4,7 @@ use std::{
     time::{Duration, Instant},
 };
 
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use similar::{capture_diff_slices_deadline, Algorithm};
 
 use crate::{
@@ -16,34 +16,41 @@ use crate::{
     obj::{ObjInfo, ObjInsArg, ObjReloc, ObjSymbol, ObjSymbolFlags, SymbolRef},
 };
 
-pub fn no_diff_code(
+pub fn process_code_symbol(
     obj: &ObjInfo,
     symbol_ref: SymbolRef,
     config: &DiffObjConfig,
-) -> Result<ObjSymbolDiff> {
-    let out = obj.arch.process_code(obj, symbol_ref, config)?;
+) -> Result<ProcessCodeResult> {
+    let (section, symbol) = obj.section_symbol(symbol_ref);
+    let section = section.ok_or_else(|| anyhow!("Code symbol section not found"))?;
+    let code = &section.data
+        [symbol.section_address as usize..(symbol.section_address + symbol.size) as usize];
+    obj.arch.process_code(symbol.address, code, &section.relocations, &section.line_info, config)
+}
 
+pub fn no_diff_code(out: &ProcessCodeResult, symbol_ref: SymbolRef) -> Result<ObjSymbolDiff> {
     let mut diff = Vec::<ObjInsDiff>::new();
-    for i in out.insts {
-        diff.push(ObjInsDiff { ins: Some(i), kind: ObjInsDiffKind::None, ..Default::default() });
+    for i in &out.insts {
+        diff.push(ObjInsDiff {
+            ins: Some(i.clone()),
+            kind: ObjInsDiffKind::None,
+            ..Default::default()
+        });
     }
     resolve_branches(&mut diff);
     Ok(ObjSymbolDiff { symbol_ref, diff_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,
     right_symbol_ref: SymbolRef,
     config: &DiffObjConfig,
 ) -> Result<(ObjSymbolDiff, ObjSymbolDiff)> {
-    let left_out = left_obj.arch.process_code(left_obj, left_symbol_ref, config)?;
-    let right_out = right_obj.arch.process_code(right_obj, right_symbol_ref, config)?;
-
     let mut left_diff = Vec::<ObjInsDiff>::new();
     let mut right_diff = Vec::<ObjInsDiff>::new();
-    diff_instructions(&mut left_diff, &mut right_diff, &left_out, &right_out)?;
+    diff_instructions(&mut left_diff, &mut right_diff, left_out, right_out)?;
 
     resolve_branches(&mut left_diff);
     resolve_branches(&mut right_diff);

objdiff-core/src/diff/mod.rs

@@ -4,7 +4,7 @@ use anyhow::Result;
 
 use crate::{
     diff::{
-        code::{diff_code, no_diff_code},
+        code::{diff_code, no_diff_code, process_code_symbol},
         data::{
             diff_bss_section, diff_bss_symbol, diff_data_section, diff_data_symbol,
             diff_text_section, no_diff_symbol,
@@ -13,8 +13,8 @@ use crate::{
     obj::{ObjInfo, ObjIns, ObjSection, ObjSectionKind, ObjSymbol, SymbolRef},
 };
 
-mod code;
-mod data;
+pub mod code;
+pub mod data;
 pub mod display;
 
 #[derive(
@@ -321,9 +321,11 @@ pub fn diff_objs(
                 let (right_obj, right_out) = right.as_mut().unwrap();
                 match section_kind {
                     ObjSectionKind::Code => {
+                        let left_code = process_code_symbol(left_obj, left_symbol_ref, config)?;
+                        let right_code = process_code_symbol(right_obj, right_symbol_ref, config)?;
                         let (left_diff, right_diff) = diff_code(
-                            left_obj,
-                            right_obj,
+                            &left_code,
+                            &right_code,
                             left_symbol_ref,
                             right_symbol_ref,
                             config,
@@ -333,9 +335,10 @@ pub fn diff_objs(
 
                         if let Some(prev_symbol_ref) = prev_symbol_ref {
                             let (prev_obj, prev_out) = prev.as_mut().unwrap();
+                            let prev_code = process_code_symbol(prev_obj, prev_symbol_ref, config)?;
                             let (_, prev_diff) = diff_code(
-                                right_obj,
-                                prev_obj,
+                                &right_code,
+                                &prev_code,
                                 right_symbol_ref,
                                 prev_symbol_ref,
                                 config,
@@ -369,8 +372,9 @@ pub fn diff_objs(
                 let (left_obj, left_out) = left.as_mut().unwrap();
                 match section_kind {
                     ObjSectionKind::Code => {
+                        let code = process_code_symbol(left_obj, left_symbol_ref, config)?;
                         *left_out.symbol_diff_mut(left_symbol_ref) =
-                            no_diff_code(left_obj, left_symbol_ref, config)?;
+                            no_diff_code(&code, left_symbol_ref)?;
                     }
                     ObjSectionKind::Data | ObjSectionKind::Bss => {
                         *left_out.symbol_diff_mut(left_symbol_ref) =
@@ -382,8 +386,9 @@ pub fn diff_objs(
                 let (right_obj, right_out) = right.as_mut().unwrap();
                 match section_kind {
                     ObjSectionKind::Code => {
+                        let code = process_code_symbol(right_obj, right_symbol_ref, config)?;
                         *right_out.symbol_diff_mut(right_symbol_ref) =
-                            no_diff_code(right_obj, right_symbol_ref, config)?;
+                            no_diff_code(&code, right_symbol_ref)?;
                     }
                     ObjSectionKind::Data | ObjSectionKind::Bss => {
                         *right_out.symbol_diff_mut(right_symbol_ref) =