#![allow(clippy::useless_borrows_in_formatting)]
use alloc::{
string::{String, ToString},
vec,
vec::Vec,
};
use core::fmt::Write;
use anyhow::Result;
use crate::{
diff::{self, DiffObjConfig, display::InstructionPart},
obj::{self, Object, SymbolFlag},
};
include!(concat!(env!("OUT_DIR"), "/objdiff.diff.rs"));
#[cfg(feature = "serde")]
include!(concat!(env!("OUT_DIR"), "/objdiff.diff.serde.rs"));
impl DiffResult {
pub fn new(
left: Option<(&Object, &diff::ObjectDiff)>,
right: Option<(&Object, &diff::ObjectDiff)>,
diff_config: &DiffObjConfig,
) -> Result<Self> {
Ok(Self {
left: left.map(|(obj, diff)| DiffObject::new(obj, diff, diff_config)).transpose()?,
right: right.map(|(obj, diff)| DiffObject::new(obj, diff, diff_config)).transpose()?,
})
}
}
impl DiffObject {
pub fn new(obj: &Object, diff: &diff::ObjectDiff, diff_config: &DiffObjConfig) -> Result<Self> {
let mut sections = Vec::with_capacity(obj.sections.len());
for (section_idx, section) in obj.sections.iter().enumerate() {
let section_diff = &diff.sections[section_idx];
sections.push(DiffSection::new(obj, section, section_diff));
}
let mut symbols = Vec::with_capacity(obj.symbols.len());
for (symbol_idx, symbol) in obj.symbols.iter().enumerate() {
let symbol_diff = &diff.symbols[symbol_idx];
symbols.push(DiffSymbol::new(obj, symbol_idx, symbol, symbol_diff, diff_config)?);
}
Ok(Self { sections, symbols })
}
}
impl DiffSection {
pub fn new(obj: &Object, section: &obj::Section, section_diff: &diff::SectionDiff) -> Self {
Self {
name: section.name.clone(),
kind: DiffSectionKind::from(section.kind) as i32,
size: section.size,
address: section.address,
match_percent: section_diff.match_percent,
data_diff: section_diff.data_diff.iter().map(DiffDataSegment::from).collect(),
reloc_diff: section_diff
.reloc_diff
.iter()
.map(|r| DiffDataRelocation::new(obj, r))
.collect(),
}
}
}
impl From<obj::SectionKind> for DiffSectionKind {
fn from(value: obj::SectionKind) -> Self {
match value {
obj::SectionKind::Unknown => DiffSectionKind::SectionUnknown,
obj::SectionKind::Code => DiffSectionKind::SectionCode,
obj::SectionKind::Data => DiffSectionKind::SectionData,
obj::SectionKind::Bss => DiffSectionKind::SectionBss,
obj::SectionKind::Common => DiffSectionKind::SectionCommon,
}
}
}
impl DiffSymbol {
pub fn new(
obj: &Object,
symbol_idx: usize,
symbol: &obj::Symbol,
symbol_diff: &diff::SymbolDiff,
diff_config: &DiffObjConfig,
) -> Result<Self> {
let instructions = symbol_diff
.instruction_rows
.iter()
.map(|row| DiffInstructionRow::new(obj, symbol_idx, row, diff_config))
.collect::<Result<Vec<_>>>()?;
let data_diff: Vec<DiffDataSegment> = symbol_diff
.data_rows
.iter()
.flat_map(|row| row.segments.iter().map(DiffDataSegment::from))
.collect();
Ok(Self {
name: symbol.name.clone(),
demangled_name: symbol.demangled_name.clone(),
address: symbol.address,
size: symbol.size,
flags: symbol_flags(&symbol.flags),
kind: DiffSymbolKind::from(symbol.kind) as i32,
target_symbol: symbol_diff.target_symbol.map(|i| i as u32),
match_percent: symbol_diff.match_percent,
instructions,
data_diff,
})
}
}
impl From<obj::SymbolKind> for DiffSymbolKind {
fn from(value: obj::SymbolKind) -> Self {
match value {
obj::SymbolKind::Unknown => DiffSymbolKind::SymbolUnknown,
obj::SymbolKind::Function => DiffSymbolKind::SymbolFunction,
obj::SymbolKind::Object => DiffSymbolKind::SymbolObject,
obj::SymbolKind::Section => DiffSymbolKind::SymbolSection,
}
}
}
fn symbol_flags(flags: &obj::SymbolFlagSet) -> Option<DiffSymbolFlags> {
Some(DiffSymbolFlags {
global: flags.contains(SymbolFlag::Global),
local: flags.contains(SymbolFlag::Local),
weak: flags.contains(SymbolFlag::Weak),
common: flags.contains(SymbolFlag::Common),
hidden: flags.contains(SymbolFlag::Hidden),
ignored: flags.contains(SymbolFlag::Ignored),
size_inferred: flags.contains(SymbolFlag::SizeInferred),
})
}
impl DiffInstructionRow {
pub fn new(
obj: &Object,
symbol_idx: usize,
row: &diff::InstructionDiffRow,
diff_config: &DiffObjConfig,
) -> Result<Self> {
let instruction = if let Some(ins_ref) = row.ins_ref {
let resolved = obj.resolve_instruction_ref(symbol_idx, ins_ref);
resolved.map(|r| DiffInstruction::new(obj, r, diff_config)).transpose()?
} else {
None
};
let arg_diff =
row.arg_diff.iter().map(|d| DiffInstructionArgDiff { diff_index: d.get() }).collect();
Ok(Self { diff_kind: DiffKind::from(row.kind) as i32, instruction, arg_diff })
}
}
impl DiffInstruction {
pub fn new(
obj: &Object,
resolved: obj::ResolvedInstructionRef,
diff_config: &DiffObjConfig,
) -> Result<Self> {
let mut formatted = String::new();
let mut parts = vec![];
let separator = diff_config.separator();
obj.arch.display_instruction(resolved, diff_config, &mut |part| {
write_instruction_part(&mut formatted, &part, separator, resolved.relocation);
parts
.push(DiffInstructionPart { part: Some(diff_instruction_part::Part::from(&part)) });
Ok(())
})?;
let relocation = resolved.relocation.map(|r| DiffRelocation::new(obj, r));
let line_number = resolved
.section
.line_info
.range(..=resolved.ins_ref.address)
.last()
.map(|(_, &line)| line);
Ok(Self {
address: resolved.ins_ref.address,
size: resolved.ins_ref.size as u32,
formatted,
parts,
relocation,
branch_dest: resolved.ins_ref.branch_dest,
line_number,
})
}
}
fn write_instruction_part(
out: &mut String,
part: &InstructionPart,
separator: &str,
reloc: Option<obj::ResolvedRelocation>,
) {
match part {
InstructionPart::Basic(s) => out.push_str(s),
InstructionPart::Opcode(s, _) => {
out.push_str(s);
out.push(' ');
}
InstructionPart::Arg(arg) => match arg {
obj::InstructionArg::Value(v) => {
let _ = write!(out, "{}", v);
}
obj::InstructionArg::Reloc => {
if let Some(resolved) = reloc {
out.push_str(&resolved.symbol.name);
if resolved.relocation.addend != 0 {
if resolved.relocation.addend < 0 {
let _ = write!(out, "-{:#x}", -resolved.relocation.addend);
} else {
let _ = write!(out, "+{:#x}", resolved.relocation.addend);
}
}
}
}
obj::InstructionArg::BranchDest(dest) => {
let _ = write!(out, "{:#x}", dest);
}
},
InstructionPart::Separator => out.push_str(separator),
}
}
impl diff_instruction_part::Part {
fn from(part: &InstructionPart) -> Self {
match part {
InstructionPart::Basic(s) => diff_instruction_part::Part::Basic(s.to_string()),
InstructionPart::Opcode(mnemonic, opcode) => {
diff_instruction_part::Part::Opcode(DiffOpcode {
mnemonic: mnemonic.to_string(),
opcode: *opcode as u32,
})
}
InstructionPart::Arg(arg) => {
diff_instruction_part::Part::Arg(DiffInstructionArg::from(arg))
}
InstructionPart::Separator => diff_instruction_part::Part::Separator(true),
}
}
}
impl From<&obj::InstructionArg<'_>> for DiffInstructionArg {
fn from(arg: &obj::InstructionArg) -> Self {
let arg = match arg {
obj::InstructionArg::Value(v) => match v {
obj::InstructionArgValue::Signed(v) => diff_instruction_arg::Arg::Signed(*v),
obj::InstructionArgValue::Unsigned(v) => diff_instruction_arg::Arg::Unsigned(*v),
obj::InstructionArgValue::Opaque(v) => {
diff_instruction_arg::Arg::Opaque(v.to_string())
}
},
obj::InstructionArg::Reloc => diff_instruction_arg::Arg::Reloc(true),
obj::InstructionArg::BranchDest(dest) => diff_instruction_arg::Arg::BranchDest(*dest),
};
DiffInstructionArg { arg: Some(arg) }
}
}
impl DiffRelocation {
pub fn new(obj: &Object, resolved: obj::ResolvedRelocation) -> Self {
let type_val = relocation_type(resolved.relocation.flags);
let type_name = obj
.arch
.reloc_name(resolved.relocation.flags)
.map(|s| s.to_string())
.unwrap_or_default();
Self {
r#type: type_val,
type_name,
target_symbol: resolved.relocation.target_symbol as u32,
addend: resolved.relocation.addend,
}
}
}
fn relocation_type(flags: obj::RelocationFlags) -> u32 {
match flags {
obj::RelocationFlags::Elf(r_type) => r_type,
obj::RelocationFlags::Coff(typ) => typ as u32,
}
}
impl From<diff::InstructionDiffKind> for DiffKind {
fn from(value: diff::InstructionDiffKind) -> Self {
match value {
diff::InstructionDiffKind::None => DiffKind::DiffNone,
diff::InstructionDiffKind::OpMismatch => DiffKind::DiffOpMismatch,
diff::InstructionDiffKind::ArgMismatch => DiffKind::DiffArgMismatch,
diff::InstructionDiffKind::Replace => DiffKind::DiffReplace,
diff::InstructionDiffKind::Delete => DiffKind::DiffDelete,
diff::InstructionDiffKind::Insert => DiffKind::DiffInsert,
}
}
}
impl From<diff::DataDiffKind> for DiffKind {
fn from(value: diff::DataDiffKind) -> Self {
match value {
diff::DataDiffKind::None => DiffKind::DiffNone,
diff::DataDiffKind::Replace => DiffKind::DiffReplace,
diff::DataDiffKind::Delete => DiffKind::DiffDelete,
diff::DataDiffKind::Insert => DiffKind::DiffInsert,
}
}
}
impl From<&diff::DataDiff> for DiffDataSegment {
fn from(value: &diff::DataDiff) -> Self {
Self {
kind: DiffKind::from(value.kind) as i32,
data: value.data.clone(),
size: value.size as u64,
}
}
}
impl DiffDataRelocation {
pub fn new(obj: &Object, value: &diff::DataRelocationDiff) -> Self {
let type_val = relocation_type(value.reloc.flags);
let type_name =
obj.arch.reloc_name(value.reloc.flags).map(|s| s.to_string()).unwrap_or_default();
Self {
relocation: Some(DiffRelocation {
r#type: type_val,
type_name,
target_symbol: value.reloc.target_symbol as u32,
addend: value.reloc.addend,
}),
kind: DiffKind::from(value.kind) as i32,
start: value.range.start,
end: value.range.end,
}
}
}