diff --git a/objdiff-cli/src/cmd/diff.rs b/objdiff-cli/src/cmd/diff.rs index 13f64e5f..062e0b89 100644 --- a/objdiff-cli/src/cmd/diff.rs +++ b/objdiff-cli/src/cmd/diff.rs @@ -19,6 +19,7 @@ use crossterm::{ }, }; use objdiff_core::{ + bindings::diff::DiffResult, build::{ BuildConfig, BuildStatus, watcher::{Watcher, create_watcher}, @@ -28,7 +29,7 @@ use objdiff_core::{ build_globset, path::{check_path_buf, platform_path, platform_path_serde_option}, }, - diff::{DiffObjConfig, MappingConfig, ObjectDiff}, + diff::{self, DiffObjConfig, DiffSide, MappingConfig, ObjectDiff}, jobs::{ Job, JobQueue, JobResult, objdiff::{ObjDiffConfig, start_build}, @@ -40,7 +41,10 @@ use typed_path::{Utf8PlatformPath, Utf8PlatformPathBuf}; use crate::{ cmd::apply_config_args, - util::term::crossterm_panic_handler, + util::{ + output::{OutputFormat, write_output}, + term::crossterm_panic_handler, + }, views::{EventControlFlow, EventResult, UiView, function_diff::FunctionDiffUi}, }; @@ -60,6 +64,12 @@ pub struct Args { #[argp(option, short = 'u')] /// Unit name within project unit: Option, + #[argp(option, short = 'o', from_str_fn(platform_path))] + /// Output file (one-shot mode) ("-" for stdout) + output: Option, + #[argp(option)] + /// Output format (json, json-pretty, proto) (default: json) + format: Option, #[argp(positional)] /// Function symbol to diff symbol: Option, @@ -158,7 +168,41 @@ pub fn run(args: Args) -> Result<()> { _ => bail!("Either target and base or project and unit must be specified"), }; - run_interactive(args, target_path, base_path, project_config, unit_options) + if let Some(output) = &args.output { + run_oneshot(&args, output, target_path.as_deref(), base_path.as_deref(), unit_options) + } else { + run_interactive(args, target_path, base_path, project_config, unit_options) + } +} + +fn run_oneshot( + args: &Args, + output: &Utf8PlatformPath, + target_path: Option<&Utf8PlatformPath>, + base_path: Option<&Utf8PlatformPath>, + unit_options: Option, +) -> Result<()> { + let output_format = OutputFormat::from_option(args.format.as_deref())?; + let (diff_config, mapping_config) = build_config_from_args(args, None, unit_options.as_ref())?; + let target = target_path + .map(|p| { + obj::read::read(p.as_ref(), &diff_config, DiffSide::Target) + .with_context(|| format!("Loading {p}")) + }) + .transpose()?; + let base = base_path + .map(|p| { + obj::read::read(p.as_ref(), &diff_config, DiffSide::Base) + .with_context(|| format!("Loading {p}")) + }) + .transpose()?; + let result = + diff::diff_objs(target.as_ref(), base.as_ref(), None, &diff_config, &mapping_config)?; + let left = target.as_ref().and_then(|o| result.left.as_ref().map(|d| (o, d))); + let right = base.as_ref().and_then(|o| result.right.as_ref().map(|d| (o, d))); + let diff_result = DiffResult::new(left, right, &diff_config)?; + write_output(&diff_result, Some(output), output_format)?; + Ok(()) } fn build_config_from_args( diff --git a/objdiff-core/protos/diff.proto b/objdiff-core/protos/diff.proto new file mode 100644 index 00000000..56dfa279 --- /dev/null +++ b/objdiff-core/protos/diff.proto @@ -0,0 +1,162 @@ +syntax = "proto3"; + +package objdiff.diff; + +// Top-level diff result containing left and right object diffs +message DiffResult { + optional DiffObject left = 1; + optional DiffObject right = 2; +} + +// Diff information for a single object file +message DiffObject { + repeated DiffSection sections = 1; + repeated DiffSymbol symbols = 2; +} + +// Diff information for a section +message DiffSection { + string name = 1; + DiffSectionKind kind = 2; + uint64 size = 3; + uint64 address = 4; + optional float match_percent = 5; + repeated DiffDataSegment data_diff = 6; + repeated DiffDataRelocation reloc_diff = 7; +} + +enum DiffSectionKind { + SECTION_UNKNOWN = 0; + SECTION_CODE = 1; + SECTION_DATA = 2; + SECTION_BSS = 3; + SECTION_COMMON = 4; +} + +// Symbol with diff information +message DiffSymbol { + string name = 1; + optional string demangled_name = 2; + uint64 address = 3; + uint64 size = 4; + uint32 flags = 5; + // The symbol index in the _other_ object that this symbol was diffed against + optional uint32 target_symbol = 6; + optional float match_percent = 7; + // Instruction diff rows (for code symbols) + repeated DiffInstructionRow instructions = 8; + // Data diff (for data symbols) + repeated DiffDataSegment data_diff = 9; +} + +// Symbol visibility flags (bitmask) +enum DiffSymbolFlag { + SYMBOL_NONE = 0; + SYMBOL_GLOBAL = 1; + SYMBOL_LOCAL = 2; + SYMBOL_WEAK = 4; + SYMBOL_COMMON = 8; + SYMBOL_HIDDEN = 16; +} + +// A single instruction diff row +message DiffInstructionRow { + DiffKind diff_kind = 1; + optional DiffInstruction instruction = 2; + repeated DiffInstructionArgDiff arg_diff = 3; +} + +// Parsed instruction information +message DiffInstruction { + uint64 address = 1; + uint32 size = 2; + // Formatted instruction string + string formatted = 3; + // Formatted instruction parts + repeated DiffInstructionPart parts = 4; + // Relocation information (if present) + optional DiffRelocation relocation = 5; + // Branch destination address + optional uint64 branch_dest = 6; + // Source line number (if present) + optional uint32 line_number = 7; +} + +// An instruction part +message DiffInstructionPart { + oneof part { + // Basic text (whitespace, punctuation, etc.) + string basic = 1; + // Opcode/mnemonic + DiffOpcode opcode = 2; + // Argument + DiffInstructionArg arg = 3; + // Separator between arguments (comma) + bool separator = 4; + } +} + +message DiffOpcode { + // Mnemonic string + string mnemonic = 1; + // Base opcode ID + uint32 opcode = 2; +} + +// An instruction argument +message DiffInstructionArg { + oneof arg { + // Signed immediate value + sint64 signed = 1; + // Unsigned immediate value + uint64 unsigned = 2; + // Opaque string value (register names, etc.) + string opaque = 3; + // Relocation + bool reloc = 4; + // Branch destination address + uint64 branch_dest = 5; + } +} + +// Relocation information +message DiffRelocation { + uint32 type = 1; + string type_name = 2; + uint32 target_symbol = 3; + int64 addend = 4; +} + +// Argument diff information +message DiffInstructionArgDiff { + // If set, this argument differs from the other side. + // The value is a rotating index for coloring. + optional uint32 diff_index = 1; +} + +// Diff kind for instructions and data +enum DiffKind { + DIFF_NONE = 0; + DIFF_REPLACE = 1; + DIFF_DELETE = 2; + DIFF_INSERT = 3; + DIFF_OP_MISMATCH = 4; + DIFF_ARG_MISMATCH = 5; +} + +// Data diff segment +message DiffDataSegment { + DiffKind kind = 1; + bytes data = 2; + // Size may be larger than data length for BSS + uint64 size = 3; +} + +// Data relocation diff +message DiffDataRelocation { + DiffRelocation relocation = 1; + DiffKind kind = 2; + // Address range this relocation covers + uint64 start = 3; + uint64 end = 4; +} diff --git a/objdiff-core/protos/proto_descriptor.bin b/objdiff-core/protos/proto_descriptor.bin index 8b3ce1e5..ac741718 100644 Binary files a/objdiff-core/protos/proto_descriptor.bin and b/objdiff-core/protos/proto_descriptor.bin differ diff --git a/objdiff-core/src/bindings/diff.rs b/objdiff-core/src/bindings/diff.rs new file mode 100644 index 00000000..9a9c36dc --- /dev/null +++ b/objdiff-core/src/bindings/diff.rs @@ -0,0 +1,350 @@ +#![allow(clippy::needless_lifetimes)] // Generated serde code + +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}, +}; + +// Protobuf diff types +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 { + 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 { + 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]; + if symbol.size == 0 || symbol.flags.contains(SymbolFlag::Ignored) { + continue; + } + 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 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 { + // Convert instruction rows + let instructions = symbol_diff + .instruction_rows + .iter() + .map(|row| DiffInstructionRow::new(obj, symbol_idx, row, diff_config)) + .collect::>>()?; + + // Convert data diff - flatten DataDiffRow segments into a single list + let data_diff: Vec = symbol_diff + .data_rows + .iter() + .flat_map(|row| row.segments.iter().map(DiffDataSegment::from)) + .collect(); + + Ok(Self { + // Symbol metadata + name: symbol.name.clone(), + demangled_name: symbol.demangled_name.clone(), + address: symbol.address, + size: symbol.size, + flags: symbol_flags(&symbol.flags), + // Diff information + target_symbol: symbol_diff.target_symbol.map(|i| i as u32), + match_percent: symbol_diff.match_percent, + instructions, + data_diff, + }) + } +} + +fn symbol_flags(flags: &obj::SymbolFlagSet) -> u32 { + let mut result = 0u32; + if flags.contains(SymbolFlag::Global) { + result |= DiffSymbolFlag::SymbolGlobal as u32; + } + if flags.contains(SymbolFlag::Local) { + result |= DiffSymbolFlag::SymbolLocal as u32; + } + if flags.contains(SymbolFlag::Weak) { + result |= DiffSymbolFlag::SymbolWeak as u32; + } + if flags.contains(SymbolFlag::Common) { + result |= DiffSymbolFlag::SymbolCommon as u32; + } + if flags.contains(SymbolFlag::Hidden) { + result |= DiffSymbolFlag::SymbolHidden as u32; + } + result +} + +impl DiffInstructionRow { + pub fn new( + obj: &Object, + symbol_idx: usize, + row: &diff::InstructionDiffRow, + diff_config: &DiffObjConfig, + ) -> Result { + 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 { + let mut formatted = String::new(); + let mut parts = vec![]; + let separator = diff_config.separator(); + + // Use the arch's display_instruction to get formatted parts + 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, +) { + 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 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 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, + } + } +} diff --git a/objdiff-core/src/bindings/mod.rs b/objdiff-core/src/bindings/mod.rs index 7352eef8..4b67b72a 100644 --- a/objdiff-core/src/bindings/mod.rs +++ b/objdiff-core/src/bindings/mod.rs @@ -1 +1,3 @@ +#[cfg(feature = "any-arch")] +pub mod diff; pub mod report;