encounter/objdiff
1
0
Fork 0
mirror of https://github.com/encounter/objdiff.git synced 2025-06-07 15:13:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

PPC: Reimplement pooled data reference calculation (#167)

Browse Source 
* PPC: Calculate pooled relocations

Reimplements #140

The relocations are now generated when the object is first read in `parse`, right after the real relocations are read.

`resolve_relocation` was changed to take `obj.symbols` instead of `obj` as an argument, because `obj` itself doesn't exist yet at the time the relocations are being read.

* Improve readability of PPC pool relocs code

* Fix regression causing extern pool relocs to be ignored

* Fix showing incorrect diff when diffing weak stripped symbol with an addend

This is a regression that was introduced by #158 diffing addends in addition to symbol names. But it's not really a bug in that PR, rather it seems like I simply never added the offset into the addend when creating a fake pool relocation for an extern symbol. So this commit fixes that root issue instead.

* Add PPC "Calculate pooled data references" option

* Fix objdiff-wasm compilation errors

* Update PPC test snapshots
This commit is contained in:
LagoLunatic 2025-03-04 22:40:34 -05:00 committed by GitHub
parent 1cdfa1e857
commit cf5fc54cfa
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
10 changed files with 429 additions and 295 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
objdiff-core/config-schema.json
View File

@ -194,6 +194,13 @@
"name": "Register '$' prefix", "name": "Register '$' prefix",
"description": "Display MIPS register names with a '$' 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", "id": "x86.formatter",
"type": "choice", "type": "choice",
@ -253,6 +260,13 @@
"mips.registerPrefix" "mips.registerPrefix"
] ]
}, },
{
"id": "ppc",
"name": "PPC",
"properties": [
"ppc.calculatePoolRelocations"
]
},
{ {
"id": "x86", "id": "x86",
"name": "x86", "name": "x86",

15
objdiff-core/src/arch/mod.rs
View File

@ -10,8 +10,8 @@ use crate::{
DiffObjConfig, DiffObjConfig,
}, },
obj::{ obj::{
InstructionArg, Object, ParsedInstruction, RelocationFlags, ResolvedInstructionRef, InstructionArg, Object, ParsedInstruction, Relocation, RelocationFlags,
ScannedInstruction, SymbolFlagSet, SymbolKind, ResolvedInstructionRef, ScannedInstruction, Symbol, SymbolFlagSet, SymbolKind,
}, },
util::ReallySigned, util::ReallySigned,
}; };
@ -212,6 +212,17 @@ pub trait Arch: Send + Sync + Debug {
cb: &mut dyn FnMut(InstructionPart) -> Result<()>, cb: &mut dyn FnMut(InstructionPart) -> Result<()>,
) -> 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( fn implcit_addend(
&self, &self,
file: &object::File<'_>, file: &object::File<'_>,

537
objdiff-core/src/arch/ppc.rs
View File

@ -1,5 +1,5 @@
use alloc::{ use alloc::{
collections::BTreeMap, collections::{BTreeMap, BTreeSet},
string::{String, ToString}, string::{String, ToString},
vec, vec,
vec::Vec, vec::Vec,
@ -13,12 +13,13 @@ use object::{elf, Object as _, ObjectSection as _, ObjectSymbol as _};
use crate::{ use crate::{
arch::{Arch, DataType}, arch::{Arch, DataType},
diff::{ diff::{
data::resolve_relocation,
display::{ContextItem, HoverItem, HoverItemColor, InstructionPart, SymbolNavigationKind}, display::{ContextItem, HoverItem, HoverItemColor, InstructionPart, SymbolNavigationKind},
DiffObjConfig, DiffObjConfig,
}, },
obj::{ obj::{
InstructionRef, Object, Relocation, RelocationFlags, ResolvedInstructionRef, InstructionRef, Object, Relocation, RelocationFlags, ResolvedInstructionRef,
ResolvedRelocation, ScannedInstruction, SymbolFlag, SymbolFlagSet, ResolvedRelocation, ScannedInstruction, Symbol, SymbolFlag, SymbolFlagSet,
}, },
}; };
@ -157,6 +158,16 @@ impl Arch for ArchPpc {
Ok(()) Ok(())
} }
fn generate_pooled_relocations(
&self,
address: u64,
code: &[u8],
relocations: &[Relocation],
symbols: &[Symbol],
) -> Vec<Relocation> {
generate_fake_pool_relocations_for_function(address, code, relocations, symbols)
}
fn implcit_addend( fn implcit_addend(
&self, &self,
_file: &object::File<'_>, _file: &object::File<'_>,
@ -501,21 +512,26 @@ fn guess_data_type_from_load_store_inst_op(inst_op: ppc750cl::Opcode) -> Option<
} }
} }
// Given an instruction, determine if it could accessing data at the address in a register. struct PoolReference {
// If so, return the offset added to the register's address, the register containing that address, addr_src_gpr: ppc750cl::GPR,
// and (optionally) which destination register the address is being copied into. addr_offset: i16,
#[expect(unused)] addr_dst_gpr: Option<ppc750cl::GPR>,
fn get_offset_and_addr_gpr_for_possible_pool_reference( }
// Given an instruction, check if it could be accessing pooled data at the address in a register.
// If so, return information pertaining to where the instruction is getting that address from and
// what it's doing with the address (e.g. copying it into another register, adding an offset, etc).
fn get_pool_reference_for_inst(
opcode: ppc750cl::Opcode, opcode: ppc750cl::Opcode,
simplified: &ppc750cl::ParsedIns, simplified: &ppc750cl::ParsedIns,
) -> Option<(i16, ppc750cl::GPR, Option<ppc750cl::GPR>)> { ) -> Option<PoolReference> {
use ppc750cl::{Argument, Opcode}; use ppc750cl::{Argument, Opcode};
let args = &simplified.args; let args = &simplified.args;
if guess_data_type_from_load_store_inst_op(opcode).is_some() { if guess_data_type_from_load_store_inst_op(opcode).is_some() {
match (args[1], args[2]) { match (args[1], args[2]) {
(Argument::Offset(offset), Argument::GPR(addr_src_gpr)) => { (Argument::Offset(offset), Argument::GPR(addr_src_gpr)) => {
// e.g. lwz. Immediate offset. // e.g. lwz. Immediate offset.
Some((offset.0, addr_src_gpr, None)) Some(PoolReference { addr_src_gpr, addr_offset: offset.0, addr_dst_gpr: None })
} }
(Argument::GPR(addr_src_gpr), Argument::GPR(_offset_gpr)) => { (Argument::GPR(addr_src_gpr), Argument::GPR(_offset_gpr)) => {
// e.g. lwzx. The offset is in a register and was likely calculated from an index. // e.g. lwzx. The offset is in a register and was likely calculated from an index.
@ -523,7 +539,7 @@ fn get_offset_and_addr_gpr_for_possible_pool_reference(
// It may be possible to show all elements by figuring out the stride of the array // It may be possible to show all elements by figuring out the stride of the array
// from the calculations performed on the index before it's put into offset_gpr, but // from the calculations performed on the index before it's put into offset_gpr, but
// this would be much more complicated, so it's not currently done. // this would be much more complicated, so it's not currently done.
Some((0, addr_src_gpr, None)) Some(PoolReference { addr_src_gpr, addr_offset: 0, addr_dst_gpr: None })
} }
_ => None, _ => None,
} }
@ -541,20 +557,32 @@ fn get_offset_and_addr_gpr_for_possible_pool_reference(
Argument::GPR(addr_dst_gpr), Argument::GPR(addr_dst_gpr),
Argument::GPR(addr_src_gpr), Argument::GPR(addr_src_gpr),
Argument::Simm(simm), Argument::Simm(simm),
) => Some((simm.0, addr_src_gpr, Some(addr_dst_gpr))), ) => Some(PoolReference {
addr_src_gpr,
addr_offset: simm.0,
addr_dst_gpr: Some(addr_dst_gpr),
}),
( (
// `mr` or `mr.` // `mr` or `mr.`
Opcode::Or, Opcode::Or,
Argument::GPR(addr_dst_gpr), Argument::GPR(addr_dst_gpr),
Argument::GPR(addr_src_gpr), Argument::GPR(addr_src_gpr),
Argument::None, Argument::None,
) => Some((0, addr_src_gpr, Some(addr_dst_gpr))), ) => Some(PoolReference {
addr_src_gpr,
addr_offset: 0,
addr_dst_gpr: Some(addr_dst_gpr),
}),
( (
Opcode::Add, Opcode::Add,
Argument::GPR(addr_dst_gpr), Argument::GPR(addr_dst_gpr),
Argument::GPR(addr_src_gpr), Argument::GPR(addr_src_gpr),
Argument::GPR(_offset_gpr), Argument::GPR(_offset_gpr),
) => Some((0, addr_src_gpr, Some(addr_dst_gpr))), ) => Some(PoolReference {
addr_src_gpr,
addr_offset: 0,
addr_dst_gpr: Some(addr_dst_gpr),
}),
_ => None, _ => None,
} }
} }
@ -562,7 +590,6 @@ fn get_offset_and_addr_gpr_for_possible_pool_reference(
// Remove the relocation we're keeping track of in a particular register when an instruction reuses // Remove the relocation we're keeping track of in a particular register when an instruction reuses
// that register to hold some other value, unrelated to pool relocation addresses. // that register to hold some other value, unrelated to pool relocation addresses.
#[expect(unused)]
fn clear_overwritten_gprs(ins: ppc750cl::Ins, gpr_pool_relocs: &mut BTreeMap<u8, Relocation>) { fn clear_overwritten_gprs(ins: ppc750cl::Ins, gpr_pool_relocs: &mut BTreeMap<u8, Relocation>) {
use ppc750cl::{Argument, Arguments, Opcode}; use ppc750cl::{Argument, Arguments, Opcode};
let mut def_args = Arguments::default(); let mut def_args = Arguments::default();
@ -582,250 +609,238 @@ fn clear_overwritten_gprs(ins: ppc750cl::Ins, gpr_pool_relocs: &mut BTreeMap<u8,
} }
} }
// TODO // We create a fake relocation for an instruction, vaguely simulating what the actual relocation
// // We create a fake relocation for an instruction, vaguely simulating what the actual relocation // might have looked like if it wasn't pooled. This is so minimal changes are needed to display
// // might have looked like if it wasn't pooled. This is so minimal changes are needed to display // pooled accesses vs non-pooled accesses. We set the relocation type to R_PPC_NONE to indicate that
// // pooled accesses vs non-pooled accesses. We set the relocation type to R_PPC_NONE to indicate that // there isn't really a relocation here, as copying the pool relocation's type wouldn't make sense.
// // there isn't really a relocation here, as copying the pool relocation's type wouldn't make sense. // Also, if this instruction is accessing the middle of a symbol instead of the start, we add an
// // Also, if this instruction is accessing the middle of a symbol instead of the start, we add an // addend to indicate that.
// // addend to indicate that. fn make_fake_pool_reloc(
// fn make_fake_pool_reloc(offset: i16, cur_addr: u32, pool_reloc: &Relocation) -> Option<Relocation> { offset: i16,
// let offset_from_pool = pool_reloc.addend + offset as i64; cur_addr: u32,
// let target_address = pool_reloc.sy.address.checked_add_signed(offset_from_pool)?; pool_reloc: &Relocation,
// let target; symbols: &[Symbol],
// let addend; ) -> Option<Relocation> {
// if pool_reloc.target.orig_section_index.is_some() { let pool_reloc = resolve_relocation(symbols, pool_reloc);
// // If the target symbol is within this current object, then we also need to create a fake let offset_from_pool = pool_reloc.relocation.addend + offset as i64;
// // target symbol to go inside our fake relocation. This is because we don't have access to let target_address = pool_reloc.symbol.address.checked_add_signed(offset_from_pool)?;
// // list of all symbols in this section, so we can't find the real symbol within the pool let target_symbol;
// // based on its address yet. Instead we make a placeholder that has the correct let addend;
// // `orig_section_index` and `address` fields, and then later on when this information is if let Some(section_index) = pool_reloc.symbol.section {
// // displayed to the user, we can find the real symbol by searching through the object's // Find the exact data symbol within the pool being accessed here based on the address.
// // section's symbols for one that contains this address. target_symbol = symbols.iter().position(|s| {
// target = ObjSymbol { s.section == Some(section_index)
// name: "".to_string(), && s.size > 0
// demangled_name: None, && (s.address..s.address + s.size).contains(&target_address)
// address: target_address, })?;
// section_address: 0, addend = target_address.checked_sub(symbols[target_symbol].address)? as i64;
// size: 0, } else {
// size_known: false, // If the target symbol is in a different object (extern), we simply copy the pool
// kind: Default::default(), // relocation's target. This is because it's not possible to locate the actual symbol if
// flags: Default::default(), // it's extern. And doing that for external symbols would also be unnecessary, because when
// orig_section_index: pool_reloc.target.orig_section_index, // the compiler generates an instruction that accesses an external "pool" plus some offset,
// virtual_address: None, // that won't be a normal pool that contains other symbols within it that we want to
// original_index: None, // display. It will be something like a vtable for a class with multiple inheritance (for
// bytes: vec![], // example, dCcD_Cyl in The Wind Waker). So just showing that vtable symbol plus an addend
// }; // to represent the offset into it works fine in this case.
// // The addend is also fake because we don't know yet if the `target_address` here is the exact target_symbol = pool_reloc.relocation.target_symbol;
// // start of the symbol or if it's in the middle of it. addend = pool_reloc.relocation.addend + offset_from_pool;
// addend = 0; }
// } else { Some(Relocation {
// // But if the target symbol is in a different object (extern), then we simply copy the pool flags: RelocationFlags::Elf(elf::R_PPC_NONE),
// // relocation's target. This is because it won't be possible to locate the actual symbol address: cur_addr as u64,
// // later on based only off of an offset without knowing the object or section it's in. And target_symbol,
// // doing that for external symbols would also be unnecessary, because when the compiler addend,
// // generates an instruction that accesses an external "pool" plus some offset, that won't be })
// // a normal pool that contains other symbols within it that we want to display. It will be }
// // something like a vtable for a class with multiple inheritance (for example, dCcD_Cyl in
// // The Wind Waker). So just showing that vtable symbol plus an addend to represent the // Searches through all instructions in a function, determining which registers have the addresses
// // offset into it works fine in this case, no fake symbol to hold an address is necessary. // of pooled data relocations in them, finding which instructions load data from those addresses,
// target = pool_reloc.target.clone(); // and returns a Vec of "fake pool relocations" that simulate what a relocation for that instruction
// addend = pool_reloc.addend; // would look like if data hadn't been pooled.
// }; // This method tries to follow the function's proper control flow. It keeps track of a queue of
// Some(ObjReloc { // states it hasn't traversed yet, where each state holds an instruction address and a HashMap of
// flags: RelocationFlags::Elf { r_type: elf::R_PPC_NONE }, // which registers hold which pool relocations at that point.
// address: cur_addr as u64, // When a conditional or unconditional branch is encountered, the destination of the branch is added
// target, // to the queue. Conditional branches will traverse both the path where the branch is taken and the
// addend, // one where it's not. Unconditional branches only follow the branch, ignoring any code immediately
// }) // after the branch instruction.
// } // Limitations: This method does not currently read switch statement jump tables.
// // Instead, we guess that any parts of a function we missed were switch cases, and traverse them as
// // Searches through all instructions in a function, determining which registers have the addresses // if the last `bctr` before that address had branched there. This should be fairly accurate in
// // of pooled data relocations in them, finding which instructions load data from those addresses, // practice - in testing the only instructions it seems to miss are double branches that the
// // and constructing a mapping of the address of that instruction to a "fake pool relocation" that // compiler generates in error which can never be reached during normal execution anyway.
// // simulates what that instruction's relocation would look like if data hadn't been pooled. // It should be possible to implement jump tables properly by reading them out of .data. But this
// // This method tries to follow the function's proper control flow. It keeps track of a queue of // will require keeping track of what value is loaded into each register so we can retrieve the jump
// // states it hasn't traversed yet, where each state holds an instruction address and a HashMap of // table symbol when we encounter a `bctr`.
// // which registers hold which pool relocations at that point. fn generate_fake_pool_relocations_for_function(
// // When a conditional or unconditional branch is encountered, the destination of the branch is added func_address: u64,
// // to the queue. Conditional branches will traverse both the path where the branch is taken and the code: &[u8],
// // one where it's not. Unconditional branches only follow the branch, ignoring any code immediately relocations: &[Relocation],
// // after the branch instruction. symbols: &[Symbol],
// // Limitations: This method cannot read jump tables. This is because the jump tables are located in ) -> Vec<Relocation> {
// // the .data section, but ObjArch.process_code only has access to the .text section. In order to use ppc750cl::{Argument, InsIter, Opcode};
// // work around this limitation and avoid completely missing most code inside switch statements that let mut visited_ins_addrs = BTreeSet::new();
// // use jump tables, we instead guess that any parts of a function we missed were switch cases, and let mut pool_reloc_for_addr = BTreeMap::new();
// // traverse them as if the last `bctr` before that address had branched there. This should be fairly let mut ins_iters_with_gpr_state =
// // accurate in practice - in testing the only instructions it seems to miss are double branches that vec![(InsIter::new(code, func_address as u32), BTreeMap::new())];
// // the compiler generates in error which can never be reached during normal execution anyway. let mut gpr_state_at_bctr = BTreeMap::new();
// fn generate_fake_pool_reloc_for_addr_mapping( while let Some((ins_iter, mut gpr_pool_relocs)) = ins_iters_with_gpr_state.pop() {
// func_address: u64, for (cur_addr, ins) in ins_iter {
// code: &[u8], if visited_ins_addrs.contains(&cur_addr) {
// relocations: &[ObjReloc], // Avoid getting stuck in an infinite loop when following looping branches.
// ) -> BTreeMap<u32, ObjReloc> { break;
// let mut visited_ins_addrs = BTreeSet::new(); }
// let mut pool_reloc_for_addr = BTreeMap::new(); visited_ins_addrs.insert(cur_addr);
// let mut ins_iters_with_gpr_state =
// vec![(InsIter::new(code, func_address as u32), BTreeMap::new())]; let simplified = ins.simplified();
// let mut gpr_state_at_bctr = BTreeMap::new();
// while let Some((ins_iter, mut gpr_pool_relocs)) = ins_iters_with_gpr_state.pop() { // First handle traversing the function's control flow.
// for (cur_addr, ins) in ins_iter { let mut branch_dest = None;
// if visited_ins_addrs.contains(&cur_addr) { for arg in simplified.args_iter() {
// // Avoid getting stuck in an infinite loop when following looping branches. if let Argument::BranchDest(dest) = arg {
// break; let dest = cur_addr.wrapping_add_signed(dest.0);
// } branch_dest = Some(dest);
// visited_ins_addrs.insert(cur_addr); break;
// }
// let simplified = ins.simplified(); }
// if let Some(branch_dest) = branch_dest {
// // First handle traversing the function's control flow. if branch_dest >= func_address as u32
// let mut branch_dest = None; && (branch_dest - func_address as u32) < code.len() as u32
// for arg in simplified.args_iter() { {
// if let Argument::BranchDest(dest) = arg { let dest_offset_into_func = branch_dest - func_address as u32;
// let dest = cur_addr.wrapping_add_signed(dest.0); let dest_code_slice = &code[dest_offset_into_func as usize..];
// branch_dest = Some(dest); match ins.op {
// break; Opcode::Bc => {
// } // Conditional branch.
// } // Add the branch destination to the queue to do later.
// if let Some(branch_dest) = branch_dest { ins_iters_with_gpr_state.push((
// if branch_dest >= func_address as u32 InsIter::new(dest_code_slice, branch_dest),
// && (branch_dest - func_address as u32) < code.len() as u32 gpr_pool_relocs.clone(),
// { ));
// let dest_offset_into_func = branch_dest - func_address as u32; // Then continue on with the current iterator.
// let dest_code_slice = &code[dest_offset_into_func as usize..]; }
// match ins.op { Opcode::B => {
// Opcode::Bc => { if simplified.mnemonic != "bl" {
// // Conditional branch. // Unconditional branch.
// // Add the branch destination to the queue to do later. // Add the branch destination to the queue.
// ins_iters_with_gpr_state.push(( ins_iters_with_gpr_state.push((
// InsIter::new(dest_code_slice, branch_dest), InsIter::new(dest_code_slice, branch_dest),
// gpr_pool_relocs.clone(), gpr_pool_relocs.clone(),
// )); ));
// // Then continue on with the current iterator. // Break out of the current iterator so we can do the newly added one.
// } break;
// Opcode::B => { }
// if simplified.mnemonic != "bl" { }
// // Unconditional branch. _ => unreachable!(),
// // Add the branch destination to the queue. }
// ins_iters_with_gpr_state.push(( }
// InsIter::new(dest_code_slice, branch_dest), }
// gpr_pool_relocs.clone(), if let Opcode::Bcctr = ins.op {
// )); if simplified.mnemonic == "bctr" {
// // Break out of the current iterator so we can do the newly added one. // Unconditional branch to count register.
// break; // Likely a jump table.
// } gpr_state_at_bctr.insert(cur_addr, gpr_pool_relocs.clone());
// } }
// _ => unreachable!(), }
// }
// } // Then handle keeping track of which GPR contains which pool relocation.
// } let reloc = relocations.iter().find(|r| (r.address as u32 & !3) == cur_addr);
// if let Opcode::Bcctr = ins.op { if let Some(reloc) = reloc {
// if simplified.mnemonic == "bctr" { // This instruction has a real relocation, so it may be a pool load we want to keep
// // Unconditional branch to count register. // track of.
// // Likely a jump table. let args = &simplified.args;
// gpr_state_at_bctr.insert(cur_addr, gpr_pool_relocs.clone()); match (ins.op, args[0], args[1], args[2]) {
// } (
// } // `lis` + `addi`
// Opcode::Addi,
// // Then handle keeping track of which GPR contains which pool relocation. Argument::GPR(addr_dst_gpr),
// let reloc = relocations.iter().find(|r| (r.address as u32 & !3) == cur_addr); Argument::GPR(_addr_src_gpr),
// if let Some(reloc) = reloc { Argument::Simm(_simm),
// // This instruction has a real relocation, so it may be a pool load we want to keep ) => {
// // track of. gpr_pool_relocs.insert(addr_dst_gpr.0, reloc.clone());
// let args = &simplified.args; }
// match (ins.op, args[0], args[1], args[2]) { (
// ( // `lis` + `ori`
// // `lis` + `addi` Opcode::Ori,
// Opcode::Addi, Argument::GPR(addr_dst_gpr),
// Argument::GPR(addr_dst_gpr), Argument::GPR(_addr_src_gpr),
// Argument::GPR(_addr_src_gpr), Argument::Uimm(_uimm),
// Argument::Simm(_simm), ) => {
// ) => { gpr_pool_relocs.insert(addr_dst_gpr.0, reloc.clone());
// gpr_pool_relocs.insert(addr_dst_gpr.0, reloc.clone()); }
// } (Opcode::B, _, _, _) => {
// ( if simplified.mnemonic == "bl" {
// // `lis` + `ori` // When encountering a function call, clear any active pool relocations from
// Opcode::Ori, // the volatile registers (r0, r3-r12), but not the nonvolatile registers.
// Argument::GPR(addr_dst_gpr), gpr_pool_relocs.remove(&0);
// Argument::GPR(_addr_src_gpr), for gpr in 3..12 {
// Argument::Uimm(_uimm), gpr_pool_relocs.remove(&gpr);
// ) => { }
// gpr_pool_relocs.insert(addr_dst_gpr.0, reloc.clone()); }
// } }
// (Opcode::B, _, _, _) => { _ => {
// if simplified.mnemonic == "bl" { clear_overwritten_gprs(ins, &mut gpr_pool_relocs);
// // When encountering a function call, clear any active pool relocations from }
// // the volatile registers (r0, r3-r12), but not the nonvolatile registers. }
// gpr_pool_relocs.remove(&0); } else if let Some(pool_ref) = get_pool_reference_for_inst(ins.op, &simplified) {
// for gpr in 3..12 { // This instruction doesn't have a real relocation, so it may be a reference to one of
// gpr_pool_relocs.remove(&gpr); // the already-loaded pools.
// } if let Some(pool_reloc) = gpr_pool_relocs.get(&pool_ref.addr_src_gpr.0) {
// } if let Some(fake_pool_reloc) =
// } make_fake_pool_reloc(pool_ref.addr_offset, cur_addr, pool_reloc, symbols)
// _ => { {
// clear_overwritten_gprs(ins, &mut gpr_pool_relocs); pool_reloc_for_addr.insert(cur_addr, fake_pool_reloc);
// } }
// } if let Some(addr_dst_gpr) = pool_ref.addr_dst_gpr {
// } else if let Some((offset, addr_src_gpr, addr_dst_gpr)) = // If the address of the pool relocation got copied into another register, we
// get_offset_and_addr_gpr_for_possible_pool_reference(ins.op, &simplified) // need to keep track of it in that register too as future instructions may
// { // reference the symbol indirectly via this new register, instead of the
// // This instruction doesn't have a real relocation, so it may be a reference to one of // register the symbol's address was originally loaded into.
// // the already-loaded pools. // For example, the start of the function might `lis` + `addi` the start of the
// if let Some(pool_reloc) = gpr_pool_relocs.get(&addr_src_gpr.0) { // ...data pool into r25, and then later the start of a loop will `addi` r25
// if let Some(fake_pool_reloc) = // with the offset within the .data section of an array variable into r21.
// make_fake_pool_reloc(offset, cur_addr, pool_reloc) // Then the body of the loop will `lwzx` one of the array elements from r21.
// { let mut new_reloc = pool_reloc.clone();
// pool_reloc_for_addr.insert(cur_addr, fake_pool_reloc); new_reloc.addend += pool_ref.addr_offset as i64;
// } gpr_pool_relocs.insert(addr_dst_gpr.0, new_reloc);
// if let Some(addr_dst_gpr) = addr_dst_gpr { } else {
// // If the address of the pool relocation got copied into another register, we clear_overwritten_gprs(ins, &mut gpr_pool_relocs);
// // need to keep track of it in that register too as future instructions may }
// // reference the symbol indirectly via this new register, instead of the } else {
// // register the symbol's address was originally loaded into. clear_overwritten_gprs(ins, &mut gpr_pool_relocs);
// // For example, the start of the function might `lis` + `addi` the start of the }
// // ...data pool into r25, and then later the start of a loop will `addi` r25 } else {
// // with the offset within the .data section of an array variable into r21. clear_overwritten_gprs(ins, &mut gpr_pool_relocs);
// // Then the body of the loop will `lwzx` one of the array elements from r21. }
// let mut new_reloc = pool_reloc.clone(); }
// new_reloc.addend += offset as i64;
// gpr_pool_relocs.insert(addr_dst_gpr.0, new_reloc); // Finally, if we're about to finish the outer loop and don't have any more control flow to
// } else { // follow, we check if there are any instruction addresses in this function that we missed.
// clear_overwritten_gprs(ins, &mut gpr_pool_relocs); // If so, and if there were any `bctr` instructions before those points in this function,
// } // then we try to traverse those missing spots as switch cases.
// } else { if ins_iters_with_gpr_state.is_empty() {
// clear_overwritten_gprs(ins, &mut gpr_pool_relocs); let unseen_addrs = (func_address as u32..func_address as u32 + code.len() as u32)
// } .step_by(4)
// } else { .filter(|addr| !visited_ins_addrs.contains(addr));
// clear_overwritten_gprs(ins, &mut gpr_pool_relocs); for unseen_addr in unseen_addrs {
// } let prev_bctr_gpr_state = gpr_state_at_bctr
// } .iter()
// .filter(|(&addr, _)| addr < unseen_addr)
// // Finally, if we're about to finish the outer loop and don't have any more control flow to .min_by_key(|(&addr, _)| addr)
// // follow, we check if there are any instruction addresses in this function that we missed. .map(|(_, gpr_state)| gpr_state);
// // If so, and if there were any `bctr` instructions before those points in this function, if let Some(gpr_pool_relocs) = prev_bctr_gpr_state {
// // then we try to traverse those missing spots as switch cases. let dest_offset_into_func = unseen_addr - func_address as u32;
// if ins_iters_with_gpr_state.is_empty() { let dest_code_slice = &code[dest_offset_into_func as usize..];
// let unseen_addrs = (func_address as u32..func_address as u32 + code.len() as u32) ins_iters_with_gpr_state.push((
// .step_by(4) InsIter::new(dest_code_slice, unseen_addr),
// .filter(|addr| !visited_ins_addrs.contains(addr)); gpr_pool_relocs.clone(),
// for unseen_addr in unseen_addrs { ));
// let prev_bctr_gpr_state = gpr_state_at_bctr break;
// .iter() }
// .filter(|(&addr, _)| addr < unseen_addr) }
// .min_by_key(|(&addr, _)| addr) }
// .map(|(_, gpr_state)| gpr_state); }
// if let Some(gpr_pool_relocs) = prev_bctr_gpr_state {
// let dest_offset_into_func = unseen_addr - func_address as u32; pool_reloc_for_addr.values().cloned().collect()
// let dest_code_slice = &code[dest_offset_into_func as usize..]; }
// ins_iters_with_gpr_state.push((
// InsIter::new(dest_code_slice, unseen_addr),
// gpr_pool_relocs.clone(),
// ));
// break;
// }
// }
// }
// }
//
// pool_reloc_for_addr
// }

14
objdiff-core/src/diff/code.rs
View File

@ -502,17 +502,3 @@ fn diff_instruction(
Ok(InstructionDiffResult::new(InstructionDiffKind::None)) 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())
// }

12
objdiff-core/src/diff/data.rs
View File

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

43
objdiff-core/src/obj/read.rs
View File

@ -6,7 +6,7 @@ use alloc::{
}; };
use core::cmp::Ordering; 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 object::{Object as _, ObjectSection as _, ObjectSymbol as _};
use crate::{ use crate::{
@ -421,6 +421,44 @@ fn map_relocations(
Ok(()) 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( fn parse_line_info(
obj_file: &object::File, obj_file: &object::File,
sections: &mut [Section], sections: &mut [Section],
@ -812,6 +850,9 @@ pub fn parse(data: &[u8], config: &DiffObjConfig) -> Result<Object> {
let (mut symbols, symbol_indices) = let (mut symbols, symbol_indices) =
map_symbols(arch.as_ref(), &obj_file, &sections, &section_indices, split_meta.as_ref())?; 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)?; 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)?; parse_line_info(&obj_file, &mut sections, &section_indices, data)?;
if config.combine_data_sections || config.combine_text_sections { if config.combine_data_sections || config.combine_text_sections {
combine_sections(&mut sections, &mut symbols, config)?; combine_sections(&mut sections, &mut symbols, config)?;

3
objdiff-core/tests/snapshots/arch_ppc__diff_ppc.snap
View File

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

17
objdiff-core/tests/snapshots/arch_ppc__read_ppc-3.snap
View File

@ -1,5 +1,6 @@
--- ---
source: objdiff-core/tests/arch_ppc.rs source: objdiff-core/tests/arch_ppc.rs
assertion_line: 20
expression: output expression: output
--- ---
[(Address(0), Normal, 5), (Spacing(4), Normal, 0), (Opcode("srwi", 60), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("24")), Normal, 0), (Eol, Normal, 0)] [(Address(0), Normal, 5), (Spacing(4), Normal, 0), (Opcode("srwi", 60), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("24")), Normal, 0), (Eol, Normal, 0)]
@ -9,7 +10,7 @@ expression: output
[(Address(16), Normal, 5), (Spacing(4), Normal, 0), (Opcode("b", 45), Normal, 10), (BranchDest(32), Normal, 0), (Basic(" ~>"), Rotating(1), 0), (Eol, Normal, 0)] [(Address(16), Normal, 5), (Spacing(4), Normal, 0), (Opcode("b", 45), Normal, 10), (BranchDest(32), Normal, 0), (Basic(" ~>"), Rotating(1), 0), (Eol, Normal, 0)]
[(Address(20), Normal, 5), (Basic(" ~> "), Rotating(0), 0), (Opcode("lis", 42), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@ha"), Normal, 0), (Eol, Normal, 0)] [(Address(20), Normal, 5), (Basic(" ~> "), Rotating(0), 0), (Opcode("lis", 42), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@ha"), Normal, 0), (Eol, Normal, 0)]
[(Address(24), Normal, 5), (Spacing(4), Normal, 0), (Opcode("addi", 41), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@l"), Normal, 0), (Eol, Normal, 0)] [(Address(24), Normal, 5), (Spacing(4), Normal, 0), (Opcode("addi", 41), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@l"), Normal, 0), (Eol, Normal, 0)]
[(Address(28), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Eol, Normal, 0)] [(Address(28), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r0")), Normal, 0), (Basic(" <"), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic(">"), Normal, 0), (Eol, Normal, 0)]
[(Address(32), Normal, 5), (Basic(" ~> "), Rotating(1), 0), (Opcode("extrwi", 60), Normal, 10), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("8")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("8")), Normal, 0), (Eol, Normal, 0)] [(Address(32), Normal, 5), (Basic(" ~> "), Rotating(1), 0), (Opcode("extrwi", 60), Normal, 10), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("8")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("8")), Normal, 0), (Eol, Normal, 0)]
[(Address(36), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "text$52", demangled_name: None, address: 8, size: 5, kind: Object, section: Some(2), flags: FlagSet(Local), align: None, virtual_address: Some(2153420056) }), Bright, 0), (Basic("@sda21"), Normal, 0), (Eol, Normal, 0)] [(Address(36), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "text$52", demangled_name: None, address: 8, size: 5, kind: Object, section: Some(2), flags: FlagSet(Local), align: None, virtual_address: Some(2153420056) }), Bright, 0), (Basic("@sda21"), Normal, 0), (Eol, Normal, 0)]
[(Address(40), Normal, 5), (Spacing(4), Normal, 0), (Opcode("cmpwi", 38), Normal, 10), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(-1)), Normal, 0), (Eol, Normal, 0)] [(Address(40), Normal, 5), (Spacing(4), Normal, 0), (Opcode("cmpwi", 38), Normal, 10), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(-1)), Normal, 0), (Eol, Normal, 0)]
@ -18,7 +19,7 @@ expression: output
[(Address(52), Normal, 5), (Spacing(4), Normal, 0), (Opcode("b", 45), Normal, 10), (BranchDest(68), Normal, 0), (Basic(" ~>"), Rotating(3), 0), (Eol, Normal, 0)] [(Address(52), Normal, 5), (Spacing(4), Normal, 0), (Opcode("b", 45), Normal, 10), (BranchDest(68), Normal, 0), (Basic(" ~>"), Rotating(3), 0), (Eol, Normal, 0)]
[(Address(56), Normal, 5), (Basic(" ~> "), Rotating(2), 0), (Opcode("lis", 42), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@ha"), Normal, 0), (Eol, Normal, 0)] [(Address(56), Normal, 5), (Basic(" ~> "), Rotating(2), 0), (Opcode("lis", 42), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@ha"), Normal, 0), (Eol, Normal, 0)]
[(Address(60), Normal, 5), (Spacing(4), Normal, 0), (Opcode("addi", 41), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@l"), Normal, 0), (Eol, Normal, 0)] [(Address(60), Normal, 5), (Spacing(4), Normal, 0), (Opcode("addi", 41), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@l"), Normal, 0), (Eol, Normal, 0)]
[(Address(64), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)] [(Address(64), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(" <"), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic(">"), Normal, 0), (Eol, Normal, 0)]
[(Address(68), Normal, 5), (Basic(" ~> "), Rotating(3), 0), (Opcode("extrwi", 60), Normal, 10), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("8")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("16")), Normal, 0), (Eol, Normal, 0)] [(Address(68), Normal, 5), (Basic(" ~> "), Rotating(3), 0), (Opcode("extrwi", 60), Normal, 10), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("8")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("16")), Normal, 0), (Eol, Normal, 0)]
[(Address(72), Normal, 5), (Spacing(4), Normal, 0), (Opcode("li", 41), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "text$52", demangled_name: None, address: 8, size: 5, kind: Object, section: Some(2), flags: FlagSet(Local), align: None, virtual_address: Some(2153420056) }), Bright, 0), (Basic("@sda21"), Normal, 0), (Eol, Normal, 0)] [(Address(72), Normal, 5), (Spacing(4), Normal, 0), (Opcode("li", 41), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "text$52", demangled_name: None, address: 8, size: 5, kind: Object, section: Some(2), flags: FlagSet(Local), align: None, virtual_address: Some(2153420056) }), Bright, 0), (Basic("@sda21"), Normal, 0), (Eol, Normal, 0)]
[(Address(76), Normal, 5), (Spacing(4), Normal, 0), (Opcode("cmpwi", 38), Normal, 10), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(-1)), Normal, 0), (Eol, Normal, 0)] [(Address(76), Normal, 5), (Spacing(4), Normal, 0), (Opcode("cmpwi", 38), Normal, 10), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(-1)), Normal, 0), (Eol, Normal, 0)]
@ -28,7 +29,7 @@ expression: output
[(Address(92), Normal, 5), (Spacing(4), Normal, 0), (Opcode("b", 45), Normal, 10), (BranchDest(108), Normal, 0), (Basic(" ~>"), Rotating(5), 0), (Eol, Normal, 0)] [(Address(92), Normal, 5), (Spacing(4), Normal, 0), (Opcode("b", 45), Normal, 10), (BranchDest(108), Normal, 0), (Basic(" ~>"), Rotating(5), 0), (Eol, Normal, 0)]
[(Address(96), Normal, 5), (Basic(" ~> "), Rotating(4), 0), (Opcode("lis", 42), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@ha"), Normal, 0), (Eol, Normal, 0)] [(Address(96), Normal, 5), (Basic(" ~> "), Rotating(4), 0), (Opcode("lis", 42), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@ha"), Normal, 0), (Eol, Normal, 0)]
[(Address(100), Normal, 5), (Spacing(4), Normal, 0), (Opcode("addi", 41), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@l"), Normal, 0), (Eol, Normal, 0)] [(Address(100), Normal, 5), (Spacing(4), Normal, 0), (Opcode("addi", 41), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@l"), Normal, 0), (Eol, Normal, 0)]
[(Address(104), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Eol, Normal, 0)] [(Address(104), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(" <"), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic(">"), Normal, 0), (Eol, Normal, 0)]
[(Address(108), Normal, 5), (Basic(" ~> "), Rotating(5), 0), (Opcode("clrlwi", 60), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("24")), Normal, 0), (Eol, Normal, 0)] [(Address(108), Normal, 5), (Basic(" ~> "), Rotating(5), 0), (Opcode("clrlwi", 60), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("24")), Normal, 0), (Eol, Normal, 0)]
[(Address(112), Normal, 5), (Spacing(4), Normal, 0), (Opcode("li", 41), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "text$52", demangled_name: None, address: 8, size: 5, kind: Object, section: Some(2), flags: FlagSet(Local), align: None, virtual_address: Some(2153420056) }), Bright, 0), (Basic("@sda21"), Normal, 0), (Eol, Normal, 0)] [(Address(112), Normal, 5), (Spacing(4), Normal, 0), (Opcode("li", 41), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "text$52", demangled_name: None, address: 8, size: 5, kind: Object, section: Some(2), flags: FlagSet(Local), align: None, virtual_address: Some(2153420056) }), Bright, 0), (Basic("@sda21"), Normal, 0), (Eol, Normal, 0)]
[(Address(116), Normal, 5), (Spacing(4), Normal, 0), (Opcode("cmpwi", 38), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(-1)), Normal, 0), (Eol, Normal, 0)] [(Address(116), Normal, 5), (Spacing(4), Normal, 0), (Opcode("cmpwi", 38), Normal, 10), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(-1)), Normal, 0), (Eol, Normal, 0)]
@ -38,7 +39,7 @@ expression: output
[(Address(132), Normal, 5), (Spacing(4), Normal, 0), (Opcode("b", 45), Normal, 10), (BranchDest(148), Normal, 0), (Basic(" ~>"), Rotating(7), 0), (Eol, Normal, 0)] [(Address(132), Normal, 5), (Spacing(4), Normal, 0), (Opcode("b", 45), Normal, 10), (BranchDest(148), Normal, 0), (Basic(" ~>"), Rotating(7), 0), (Eol, Normal, 0)]
[(Address(136), Normal, 5), (Basic(" ~> "), Rotating(6), 0), (Opcode("lis", 42), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@ha"), Normal, 0), (Eol, Normal, 0)] [(Address(136), Normal, 5), (Basic(" ~> "), Rotating(6), 0), (Opcode("lis", 42), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@ha"), Normal, 0), (Eol, Normal, 0)]
[(Address(140), Normal, 5), (Spacing(4), Normal, 0), (Opcode("addi", 41), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@l"), Normal, 0), (Eol, Normal, 0)] [(Address(140), Normal, 5), (Spacing(4), Normal, 0), (Opcode("addi", 41), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic("@l"), Normal, 0), (Eol, Normal, 0)]
[(Address(144), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Eol, Normal, 0)] [(Address(144), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(" <"), Normal, 0), (Symbol(Symbol { name: "__upper_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic(">"), Normal, 0), (Eol, Normal, 0)]
[(Address(148), Normal, 5), (Basic(" ~> "), Rotating(7), 0), (Opcode("li", 41), Normal, 10), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "text$52", demangled_name: None, address: 8, size: 5, kind: Object, section: Some(2), flags: FlagSet(Local), align: None, virtual_address: Some(2153420056) }), Bright, 0), (Basic("@sda21"), Normal, 0), (Eol, Normal, 0)] [(Address(148), Normal, 5), (Basic(" ~> "), Rotating(7), 0), (Opcode("li", 41), Normal, 10), (Argument(Opaque("r5")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "text$52", demangled_name: None, address: 8, size: 5, kind: Object, section: Some(2), flags: FlagSet(Local), align: None, virtual_address: Some(2153420056) }), Bright, 0), (Basic("@sda21"), Normal, 0), (Eol, Normal, 0)]
[(Address(152), Normal, 5), (Spacing(4), Normal, 0), (Opcode("li", 41), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(0)), Normal, 0), (Eol, Normal, 0)] [(Address(152), Normal, 5), (Spacing(4), Normal, 0), (Opcode("li", 41), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(0)), Normal, 0), (Eol, Normal, 0)]
[(Address(156), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(3)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)] [(Address(156), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(3)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
@ -47,22 +48,22 @@ expression: output
[(Address(168), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(4)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)] [(Address(168), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(4)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
[(Address(172), Normal, 5), (Spacing(4), Normal, 0), (Opcode("li", 41), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(45)), Normal, 0), (Eol, Normal, 0)] [(Address(172), Normal, 5), (Spacing(4), Normal, 0), (Opcode("li", 41), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(45)), Normal, 0), (Eol, Normal, 0)]
[(Address(176), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbz", 162), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "text$52", demangled_name: None, address: 8, size: 5, kind: Object, section: Some(2), flags: FlagSet(Local), align: None, virtual_address: Some(2153420056) }), Bright, 0), (Basic("@sda21"), Normal, 0), (Eol, Normal, 0)] [(Address(176), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbz", 162), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Symbol(Symbol { name: "text$52", demangled_name: None, address: 8, size: 5, kind: Object, section: Some(2), flags: FlagSet(Local), align: None, virtual_address: Some(2153420056) }), Bright, 0), (Basic("@sda21"), Normal, 0), (Eol, Normal, 0)]
[(Address(180), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Eol, Normal, 0)] [(Address(180), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(" <"), Normal, 0), (Symbol(Symbol { name: "__ctype_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic(">"), Normal, 0), (Eol, Normal, 0)]
[(Address(184), Normal, 5), (Spacing(4), Normal, 0), (Opcode("andi.", 66), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Unsigned(220)), Normal, 0), (Eol, Normal, 0)] [(Address(184), Normal, 5), (Spacing(4), Normal, 0), (Opcode("andi.", 66), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Unsigned(220)), Normal, 0), (Eol, Normal, 0)]
[(Address(188), Normal, 5), (Spacing(4), Normal, 0), (Opcode("bne", 43), Normal, 10), (BranchDest(196), Normal, 0), (Basic(" ~>"), Rotating(8), 0), (Eol, Normal, 0)] [(Address(188), Normal, 5), (Spacing(4), Normal, 0), (Opcode("bne", 43), Normal, 10), (BranchDest(196), Normal, 0), (Basic(" ~>"), Rotating(8), 0), (Eol, Normal, 0)]
[(Address(192), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)] [(Address(192), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
[(Address(196), Normal, 5), (Basic(" ~> "), Rotating(8), 0), (Opcode("lbzu", 163), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(1)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)] [(Address(196), Normal, 5), (Basic(" ~> "), Rotating(8), 0), (Opcode("lbzu", 163), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(1)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
[(Address(200), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Eol, Normal, 0)] [(Address(200), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(" <"), Normal, 0), (Symbol(Symbol { name: "__ctype_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic(">"), Normal, 0), (Eol, Normal, 0)]
[(Address(204), Normal, 5), (Spacing(4), Normal, 0), (Opcode("andi.", 66), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Unsigned(220)), Normal, 0), (Eol, Normal, 0)] [(Address(204), Normal, 5), (Spacing(4), Normal, 0), (Opcode("andi.", 66), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Unsigned(220)), Normal, 0), (Eol, Normal, 0)]
[(Address(208), Normal, 5), (Spacing(4), Normal, 0), (Opcode("bne", 43), Normal, 10), (BranchDest(216), Normal, 0), (Basic(" ~>"), Rotating(9), 0), (Eol, Normal, 0)] [(Address(208), Normal, 5), (Spacing(4), Normal, 0), (Opcode("bne", 43), Normal, 10), (BranchDest(216), Normal, 0), (Basic(" ~>"), Rotating(9), 0), (Eol, Normal, 0)]
[(Address(212), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)] [(Address(212), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
[(Address(216), Normal, 5), (Basic(" ~> "), Rotating(9), 0), (Opcode("lbzu", 163), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(1)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)] [(Address(216), Normal, 5), (Basic(" ~> "), Rotating(9), 0), (Opcode("lbzu", 163), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(1)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
[(Address(220), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Eol, Normal, 0)] [(Address(220), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(" <"), Normal, 0), (Symbol(Symbol { name: "__ctype_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic(">"), Normal, 0), (Eol, Normal, 0)]
[(Address(224), Normal, 5), (Spacing(4), Normal, 0), (Opcode("andi.", 66), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Unsigned(220)), Normal, 0), (Eol, Normal, 0)] [(Address(224), Normal, 5), (Spacing(4), Normal, 0), (Opcode("andi.", 66), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Unsigned(220)), Normal, 0), (Eol, Normal, 0)]
[(Address(228), Normal, 5), (Spacing(4), Normal, 0), (Opcode("bne", 43), Normal, 10), (BranchDest(236), Normal, 0), (Basic(" ~>"), Rotating(10), 0), (Eol, Normal, 0)] [(Address(228), Normal, 5), (Spacing(4), Normal, 0), (Opcode("bne", 43), Normal, 10), (BranchDest(236), Normal, 0), (Basic(" ~>"), Rotating(10), 0), (Eol, Normal, 0)]
[(Address(232), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)] [(Address(232), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
[(Address(236), Normal, 5), (Basic(" ~> "), Rotating(10), 0), (Opcode("lbzu", 163), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(1)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)] [(Address(236), Normal, 5), (Basic(" ~> "), Rotating(10), 0), (Opcode("lbzu", 163), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(1)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]
[(Address(240), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Eol, Normal, 0)] [(Address(240), Normal, 5), (Spacing(4), Normal, 0), (Opcode("lbzx", 94), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r4")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(" <"), Normal, 0), (Symbol(Symbol { name: "__ctype_map", demangled_name: None, address: 0, size: 0, kind: Unknown, section: None, flags: FlagSet(Global), align: None, virtual_address: Some(0) }), Bright, 0), (Basic(">"), Normal, 0), (Eol, Normal, 0)]
[(Address(244), Normal, 5), (Spacing(4), Normal, 0), (Opcode("andi.", 66), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Unsigned(220)), Normal, 0), (Eol, Normal, 0)] [(Address(244), Normal, 5), (Spacing(4), Normal, 0), (Opcode("andi.", 66), Normal, 10), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Opaque("r3")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Unsigned(220)), Normal, 0), (Eol, Normal, 0)]
[(Address(248), Normal, 5), (Spacing(4), Normal, 0), (Opcode("bne", 43), Normal, 10), (BranchDest(256), Normal, 0), (Basic(" ~>"), Rotating(11), 0), (Eol, Normal, 0)] [(Address(248), Normal, 5), (Spacing(4), Normal, 0), (Opcode("bne", 43), Normal, 10), (BranchDest(256), Normal, 0), (Basic(" ~>"), Rotating(11), 0), (Eol, Normal, 0)]
[(Address(252), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)] [(Address(252), Normal, 5), (Spacing(4), Normal, 0), (Opcode("stb", 166), Normal, 10), (Argument(Opaque("r0")), Normal, 0), (Basic(", "), Normal, 0), (Argument(Signed(0)), Normal, 0), (Basic("("), Normal, 0), (Argument(Opaque("r5")), Normal, 0), (Basic(")"), Normal, 0), (Eol, Normal, 0)]

65
objdiff-core/tests/snapshots/arch_ppc__read_ppc.snap
View File

@ -1,5 +1,6 @@
--- ---
source: objdiff-core/tests/arch_ppc.rs source: objdiff-core/tests/arch_ppc.rs
assertion_line: 14
expression: obj expression: obj
--- ---
Object { Object {
@ -183,6 +184,14 @@ Object {
target_symbol: 8, target_symbol: 8,
addend: 0, addend: 0,
}, },
Relocation {
flags: Elf(
0,
),
address: 28,
target_symbol: 8,
addend: 0,
},
Relocation { Relocation {
flags: Elf( flags: Elf(
109, 109,
@ -207,6 +216,14 @@ Object {
target_symbol: 8, target_symbol: 8,
addend: 0, addend: 0,
}, },
Relocation {
flags: Elf(
0,
),
address: 64,
target_symbol: 8,
addend: 0,
},
Relocation { Relocation {
flags: Elf( flags: Elf(
109, 109,
@ -231,6 +248,14 @@ Object {
target_symbol: 8, target_symbol: 8,
addend: 0, addend: 0,
}, },
Relocation {
flags: Elf(
0,
),
address: 104,
target_symbol: 8,
addend: 0,
},
Relocation { Relocation {
flags: Elf( flags: Elf(
109, 109,
@ -255,6 +280,14 @@ Object {
target_symbol: 8, target_symbol: 8,
addend: 0, addend: 0,
}, },
Relocation {
flags: Elf(
0,
),
address: 144,
target_symbol: 8,
addend: 0,
},
Relocation { Relocation {
flags: Elf( flags: Elf(
109, 109,
@ -287,6 +320,38 @@ Object {
target_symbol: 5, target_symbol: 5,
addend: 0, addend: 0,
}, },
Relocation {
flags: Elf(
0,
),
address: 180,
target_symbol: 9,
addend: 0,
},
Relocation {
flags: Elf(
0,
),
address: 200,
target_symbol: 9,
addend: 0,
},
Relocation {
flags: Elf(
0,
),
address: 220,
target_symbol: 9,
addend: 0,
},
Relocation {
flags: Elf(
0,
),
address: 240,
target_symbol: 9,
addend: 0,
},
Relocation { Relocation {
flags: Elf( flags: Elf(
109, 109,

4
objdiff-gui/src/views/data_diff.rs
View File

@ -32,7 +32,7 @@ fn data_row_hover(obj: &Object, diffs: &[(DataDiff, Vec<DataRelocationDiff>)]) -
// TODO: Change hover text color depending on Insert/Delete/Replace kind // TODO: Change hover text color depending on Insert/Delete/Replace kind
// let color = get_color_for_diff_kind(reloc_diff.kind, appearance); // let color = get_color_for_diff_kind(reloc_diff.kind, appearance);
let reloc = resolve_relocation(obj, reloc); let reloc = resolve_relocation(&obj.symbols, reloc);
out.append(&mut relocation_hover(obj, reloc)); out.append(&mut relocation_hover(obj, reloc));
} }
out out
@ -55,7 +55,7 @@ fn data_row_context(
} }
prev_reloc = Some(reloc); prev_reloc = Some(reloc);
let reloc = resolve_relocation(obj, reloc); let reloc = resolve_relocation(&obj.symbols, reloc);
out.append(&mut relocation_context(obj, reloc, None)); out.append(&mut relocation_context(obj, reloc, None));
} }
out out