PPC: Reimplement pooled data reference calculation

objdiff-core/config-schema.json

@@ -194,6 +194,13 @@
       "name": "Register '$' prefix",
       "description": "Display MIPS register names with a '$' prefix."
     },
+    {
+      "id": "ppc.calculatePoolRelocations",
+      "type": "boolean",
+      "default": true,
+      "name": "Calculate pooled data references",
+      "description": "Display pooled data references in functions as fake relocations."
+    },
     {
       "id": "x86.formatter",
       "type": "choice",
@@ -253,6 +260,13 @@
         "mips.registerPrefix"
       ]
     },
+    {
+      "id": "ppc",
+      "name": "PPC",
+      "properties": [
+        "ppc.calculatePoolRelocations"
+      ]
+    },
     {
       "id": "x86",
       "name": "x86",

objdiff-core/src/arch/mod.rs

@@ -10,8 +10,8 @@ use crate::{
         DiffObjConfig,
     },
     obj::{
-        InstructionArg, Object, ParsedInstruction, RelocationFlags, ResolvedInstructionRef,
-        ScannedInstruction, SymbolFlagSet, SymbolKind,
+        InstructionArg, Object, ParsedInstruction, Relocation, RelocationFlags,
+        ResolvedInstructionRef, ScannedInstruction, Symbol, SymbolFlagSet, SymbolKind,
     },
     util::ReallySigned,
 };
@@ -212,6 +212,17 @@ pub trait Arch: Send + Sync + Debug {
         cb: &mut dyn FnMut(InstructionPart) -> Result<()>,
     ) -> Result<()>;
 
+    /// Generate a list of fake relocations from the given code that represent pooled data accesses.
+    fn generate_pooled_relocations(
+        &self,
+        _address: u64,
+        _code: &[u8],
+        _relocations: &[Relocation],
+        _symbols: &[Symbol],
+    ) -> Vec<Relocation> {
+        Vec::new()
+    }
+
     fn implcit_addend(
         &self,
         file: &object::File<'_>,

objdiff-core/src/diff/code.rs

@@ -502,17 +502,3 @@ fn diff_instruction(
 
     Ok(InstructionDiffResult::new(InstructionDiffKind::None))
 }
-
-// TODO
-// fn find_symbol_matching_fake_symbol_in_sections(
-//     fake_symbol: &ObjSymbol,
-//     sections: &[ObjSection],
-// ) -> Option<ObjSymbol> {
-//     let orig_section_index = fake_symbol.orig_section_index?;
-//     let section = sections.iter().find(|s| s.orig_index == orig_section_index)?;
-//     let real_symbol = section
-//         .symbols
-//         .iter()
-//         .find(|s| s.size > 0 && (s.address..s.address + s.size).contains(&fake_symbol.address))?;
-//     Some(real_symbol.clone())
-// }

objdiff-core/src/diff/data.rs

@@ -8,7 +8,7 @@ use super::{
     code::{address_eq, section_name_eq},
     DataDiff, DataDiffKind, DataRelocationDiff, ObjectDiff, SectionDiff, SymbolDiff,
 };
-use crate::obj::{Object, Relocation, ResolvedRelocation, SymbolFlag, SymbolKind};
+use crate::obj::{Object, Relocation, ResolvedRelocation, Symbol, SymbolFlag, SymbolKind};
 
 pub fn diff_bss_symbol(
     left_obj: &Object,
@@ -64,10 +64,10 @@ fn reloc_eq(
 
 #[inline]
 pub fn resolve_relocation<'obj>(
-    obj: &'obj Object,
+    symbols: &'obj [Symbol],
     reloc: &'obj Relocation,
 ) -> ResolvedRelocation<'obj> {
-    let symbol = &obj.symbols[reloc.target_symbol];
+    let symbol = &symbols[reloc.target_symbol];
     ResolvedRelocation { relocation: reloc, symbol }
 }
 
@@ -88,7 +88,7 @@ fn diff_data_relocs_for_range<'left, 'right>(
             continue;
         }
         let left_offset = left_reloc.address as usize - left_range.start;
-        let left_reloc = resolve_relocation(left_obj, left_reloc);
+        let left_reloc = resolve_relocation(&left_obj.symbols, left_reloc);
         let Some(right_reloc) = right_section.relocations.iter().find(|r| {
             if !right_range.contains(&(r.address as usize)) {
                 return false;
@@ -99,7 +99,7 @@ fn diff_data_relocs_for_range<'left, 'right>(
             diffs.push((DataDiffKind::Delete, Some(left_reloc), None));
             continue;
         };
-        let right_reloc = resolve_relocation(right_obj, right_reloc);
+        let right_reloc = resolve_relocation(&right_obj.symbols, right_reloc);
         if reloc_eq(left_obj, right_obj, left_reloc, right_reloc) {
             diffs.push((DataDiffKind::None, Some(left_reloc), Some(right_reloc)));
         } else {
@@ -111,7 +111,7 @@ fn diff_data_relocs_for_range<'left, 'right>(
             continue;
         }
         let right_offset = right_reloc.address as usize - right_range.start;
-        let right_reloc = resolve_relocation(right_obj, right_reloc);
+        let right_reloc = resolve_relocation(&right_obj.symbols, right_reloc);
         let Some(_) = left_section.relocations.iter().find(|r| {
             if !left_range.contains(&(r.address as usize)) {
                 return false;

objdiff-core/src/obj/read.rs

@@ -6,7 +6,7 @@ use alloc::{
 };
 use core::cmp::Ordering;
 
-use anyhow::{bail, ensure, Context, Result};
+use anyhow::{anyhow, bail, ensure, Context, Result};
 use object::{Object as _, ObjectSection as _, ObjectSymbol as _};
 
 use crate::{
@@ -421,6 +421,44 @@ fn map_relocations(
     Ok(())
 }
 
+fn calculate_pooled_relocations(
+    arch: &dyn Arch,
+    sections: &mut [Section],
+    symbols: &[Symbol],
+) -> Result<()> {
+    for (section_index, section) in sections.iter_mut().enumerate() {
+        if section.kind != SectionKind::Code {
+            continue;
+        }
+        let mut fake_pool_relocs = Vec::new();
+        for symbol in symbols {
+            if symbol.section != Some(section_index) {
+                continue;
+            }
+            if symbol.kind != SymbolKind::Function {
+                continue;
+            }
+            let code =
+                section.data_range(symbol.address, symbol.size as usize).ok_or_else(|| {
+                    anyhow!(
+                        "Symbol data out of bounds: {:#x}..{:#x}",
+                        symbol.address,
+                        symbol.address + symbol.size
+                    )
+                })?;
+            fake_pool_relocs.append(&mut arch.generate_pooled_relocations(
+                symbol.address,
+                code,
+                &section.relocations,
+                symbols,
+            ));
+        }
+        section.relocations.append(&mut fake_pool_relocs);
+        section.relocations.sort_by_key(|r| r.address);
+    }
+    Ok(())
+}
+
 fn parse_line_info(
     obj_file: &object::File,
     sections: &mut [Section],
@@ -812,6 +850,9 @@ pub fn parse(data: &[u8], config: &DiffObjConfig) -> Result<Object> {
     let (mut symbols, symbol_indices) =
         map_symbols(arch.as_ref(), &obj_file, &sections, &section_indices, split_meta.as_ref())?;
     map_relocations(arch.as_ref(), &obj_file, &mut sections, &section_indices, &symbol_indices)?;
+    if config.ppc_calculate_pool_relocations {
+        calculate_pooled_relocations(arch.as_ref(), &mut sections, &symbols)?;
+    }
     parse_line_info(&obj_file, &mut sections, &section_indices, data)?;
     if config.combine_data_sections || config.combine_text_sections {
         combine_sections(&mut sections, &mut symbols, config)?;

objdiff-core/tests/snapshots/arch_ppc__diff_ppc.snap

@@ -1,5 +1,6 @@
 ---
 source: objdiff-core/tests/arch_ppc.rs
+assertion_line: 70
 expression: sections_display
 ---
 [
@@ -46,7 +47,7 @@ expression: sections_display
         name: ".text",
         size: 3060,
         match_percent: Some(
-            59.02353,
+            58.662746,
         ),
         symbols: [
             SectionDisplaySymbol {