Hide auto-generated objects in object list

With filter option to display them,
if desired. decomp-toolkit will
start writing auto-generated objects
in objdiff.json for reporting
purposes, so this maintains the
existing behavior.

.gitignore

@@ -22,3 +22,4 @@ android.keystore
 *.frag
 *.vert
 *.metal
+.vscode/launch.json

objdiff-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "objdiff-cli"
-version = "2.0.0-alpha.5"
+version = "2.0.0-beta.5"
 edition = "2021"
 rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]
@@ -18,7 +18,9 @@ anyhow = "1.0.82"
 argp = "0.3.0"
 crossterm = "0.27.0"
 enable-ansi-support = "0.2.1"
+memmap2 = "0.9.4"
 objdiff-core = { path = "../objdiff-core", features = ["all"] }
+prost = "0.13.1"
 ratatui = "0.26.2"
 rayon = "1.10.0"
 serde = { version = "1", features = ["derive"] }

objdiff-cli/src/cmd/diff.rs

@@ -1,4 +1,9 @@
-use std::{fs, io::stdout, path::PathBuf, str::FromStr};
+use std::{
+    fs,
+    io::stdout,
+    path::{Path, PathBuf},
+    str::FromStr,
+};
 
 use anyhow::{bail, Context, Result};
 use argp::FromArgs;
@@ -14,6 +19,7 @@ use crossterm::{
 };
 use event::KeyModifiers;
 use objdiff_core::{
+    bindings::diff::DiffResult,
     config::{ProjectConfig, ProjectObject},
     diff,
     diff::{
@@ -28,10 +34,13 @@ use ratatui::{
     widgets::{Block, Borders, Clear, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState},
 };
 
-use crate::util::term::crossterm_panic_handler;
+use crate::util::{
+    output::{write_output, OutputFormat},
+    term::crossterm_panic_handler,
+};
 
 #[derive(FromArgs, PartialEq, Debug)]
-/// Diff two object files.
+/// Diff two object files. (Interactive or one-shot mode)
 #[argp(subcommand, name = "diff")]
 pub struct Args {
     #[argp(option, short = '1')]
@@ -49,101 +58,152 @@ pub struct Args {
     #[argp(switch, short = 'x')]
     /// Relax relocation diffs
     relax_reloc_diffs: bool,
+    #[argp(option, short = 'o')]
+    /// Output file (one-shot mode) ("-" for stdout)
+    output: Option<PathBuf>,
+    #[argp(option)]
+    /// Output format (json, json-pretty, proto) (default: json)
+    format: Option<String>,
     #[argp(positional)]
     /// Function symbol to diff
-    symbol: String,
+    symbol: Option<String>,
 }
 
 pub fn run(args: Args) -> Result<()> {
-    let (target_path, base_path, project_config) =
-        match (&args.target, &args.base, &args.project, &args.unit) {
-            (Some(t), Some(b), None, None) => (Some(t.clone()), Some(b.clone()), None),
-            (None, None, p, u) => {
-                let project = match p {
-                    Some(project) => project.clone(),
-                    _ => std::env::current_dir().context("Failed to get the current directory")?,
+    let (target_path, base_path, project_config) = match (
+        &args.target,
+        &args.base,
+        &args.project,
+        &args.unit,
+    ) {
+        (Some(t), Some(b), None, None) => (Some(t.clone()), Some(b.clone()), None),
+        (None, None, p, u) => {
+            let project = match p {
+                Some(project) => project.clone(),
+                _ => std::env::current_dir().context("Failed to get the current directory")?,
+            };
+            let Some((project_config, project_config_info)) =
+                objdiff_core::config::try_project_config(&project)
+            else {
+                bail!("Project config not found in {}", &project.display())
+            };
+            let mut project_config = project_config.with_context(|| {
+                format!("Reading project config {}", project_config_info.path.display())
+            })?;
+            let object = {
+                let resolve_paths = |o: &mut ProjectObject| {
+                    o.resolve_paths(
+                        &project,
+                        project_config.target_dir.as_deref(),
+                        project_config.base_dir.as_deref(),
+                    )
                 };
-                let Some((project_config, project_config_info)) =
-                    objdiff_core::config::try_project_config(&project)
-                else {
-                    bail!("Project config not found in {}", &project.display())
-                };
-                let mut project_config = project_config.with_context(|| {
-                    format!("Reading project config {}", project_config_info.path.display())
-                })?;
-                let object = {
-                    let resolve_paths = |o: &mut ProjectObject| {
-                        o.resolve_paths(
-                            &project,
-                            project_config.target_dir.as_deref(),
-                            project_config.base_dir.as_deref(),
-                        )
-                    };
-                    if let Some(u) = u {
-                        let unit_path =
-                            PathBuf::from_str(u).ok().and_then(|p| fs::canonicalize(p).ok());
-
-                        let Some(object) = project_config.objects.iter_mut().find_map(|obj| {
-                            if obj.name.as_deref() == Some(u) {
-                                resolve_paths(obj);
-                                return Some(obj);
-                            }
-
-                            let up = unit_path.as_deref()?;
+                if let Some(u) = u {
+                    let unit_path =
+                        PathBuf::from_str(u).ok().and_then(|p| fs::canonicalize(p).ok());
 
+                    let Some(object) = project_config.objects.iter_mut().find_map(|obj| {
+                        if obj.name.as_deref() == Some(u) {
                             resolve_paths(obj);
-
-                            if [&obj.base_path, &obj.target_path]
-                                .into_iter()
-                                .filter_map(|p| p.as_ref().and_then(|p| p.canonicalize().ok()))
-                                .any(|p| p == up)
-                            {
-                                return Some(obj);
-                            }
-
-                            None
-                        }) else {
-                            bail!("Unit not found: {}", u)
-                        };
-
-                        object
-                    } else {
-                        let mut idx = None;
-                        let mut count = 0usize;
-                        for (i, obj) in project_config.objects.iter_mut().enumerate() {
-                            resolve_paths(obj);
-
-                            if obj
-                                .target_path
-                                .as_deref()
-                                .map(|o| obj::read::has_function(o, &args.symbol))
-                                .transpose()?
-                                .unwrap_or(false)
-                            {
-                                idx = Some(i);
-                                count += 1;
-                                if count > 1 {
-                                    break;
-                                }
-                            }
+                            return Some(obj);
                         }
-                        match (count, idx) {
-                            (0, None) => bail!("Symbol not found: {}", &args.symbol),
-                            (1, Some(i)) => &mut project_config.objects[i],
-                            (2.., Some(_)) => bail!(
-                                "Multiple instances of {} were found, try specifying a unit",
-                                &args.symbol
-                            ),
-                            _ => unreachable!(),
+
+                        let up = unit_path.as_deref()?;
+
+                        resolve_paths(obj);
+
+                        if [&obj.base_path, &obj.target_path]
+                            .into_iter()
+                            .filter_map(|p| p.as_ref().and_then(|p| p.canonicalize().ok()))
+                            .any(|p| p == up)
+                        {
+                            return Some(obj);
+                        }
+
+                        None
+                    }) else {
+                        bail!("Unit not found: {}", u)
+                    };
+
+                    object
+                } else if let Some(symbol_name) = &args.symbol {
+                    let mut idx = None;
+                    let mut count = 0usize;
+                    for (i, obj) in project_config.objects.iter_mut().enumerate() {
+                        resolve_paths(obj);
+
+                        if obj
+                            .target_path
+                            .as_deref()
+                            .map(|o| obj::read::has_function(o, symbol_name))
+                            .transpose()?
+                            .unwrap_or(false)
+                        {
+                            idx = Some(i);
+                            count += 1;
+                            if count > 1 {
+                                break;
+                            }
                         }
                     }
-                };
-                let target_path = object.target_path.clone();
-                let base_path = object.base_path.clone();
-                (target_path, base_path, Some(project_config))
-            }
-            _ => bail!("Either target and base or project and unit must be specified"),
-        };
+                    match (count, idx) {
+                        (0, None) => bail!("Symbol not found: {}", symbol_name),
+                        (1, Some(i)) => &mut project_config.objects[i],
+                        (2.., Some(_)) => bail!(
+                            "Multiple instances of {} were found, try specifying a unit",
+                            symbol_name
+                        ),
+                        _ => unreachable!(),
+                    }
+                } else {
+                    bail!("Must specify one of: symbol, project and unit, target and base objects")
+                }
+            };
+            let target_path = object.target_path.clone();
+            let base_path = object.base_path.clone();
+            (target_path, base_path, Some(project_config))
+        }
+        _ => bail!("Either target and base or project and unit must be specified"),
+    };
+
+    if let Some(output) = &args.output {
+        run_oneshot(&args, output, target_path.as_deref(), base_path.as_deref())
+    } else {
+        run_interactive(args, target_path, base_path, project_config)
+    }
+}
+
+fn run_oneshot(
+    args: &Args,
+    output: &Path,
+    target_path: Option<&Path>,
+    base_path: Option<&Path>,
+) -> Result<()> {
+    let output_format = OutputFormat::from_option(args.format.as_deref())?;
+    let config = diff::DiffObjConfig {
+        relax_reloc_diffs: args.relax_reloc_diffs,
+        ..Default::default() // TODO
+    };
+    let target = target_path
+        .map(|p| obj::read::read(p, &config).with_context(|| format!("Loading {}", p.display())))
+        .transpose()?;
+    let base = base_path
+        .map(|p| obj::read::read(p, &config).with_context(|| format!("Loading {}", p.display())))
+        .transpose()?;
+    let result = diff::diff_objs(&config, target.as_ref(), base.as_ref(), None)?;
+    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)));
+    write_output(&DiffResult::new(left, right), Some(output), output_format)?;
+    Ok(())
+}
+
+fn run_interactive(
+    args: Args,
+    target_path: Option<PathBuf>,
+    base_path: Option<PathBuf>,
+    project_config: Option<ProjectConfig>,
+) -> Result<()> {
+    let Some(symbol_name) = &args.symbol else { bail!("Interactive mode requires a symbol name") };
     let time_format = time::format_description::parse_borrowed::<2>("[hour]:[minute]:[second]")
         .context("Failed to parse time format")?;
     let mut state = Box::new(FunctionDiffUi {
@@ -156,7 +216,7 @@ pub fn run(args: Args) -> Result<()> {
         scroll_state_y: ScrollbarState::default(),
         per_page: 0,
         num_rows: 0,
-        symbol_name: args.symbol.clone(),
+        symbol_name: symbol_name.clone(),
         target_path,
         base_path,
         project_config,
@@ -180,7 +240,7 @@ pub fn run(args: Args) -> Result<()> {
         stdout(),
         EnterAlternateScreen,
         EnableMouseCapture,
-        SetTitle(format!("{} - objdiff", args.symbol)),
+        SetTitle(format!("{} - objdiff", symbol_name)),
     )?;
     let backend = CrosstermBackend::new(stdout());
     let mut terminal = Terminal::new(backend)?;
@@ -750,8 +810,11 @@ impl FunctionDiffUi {
                             base_color = COLOR_ROTATION[diff.idx % COLOR_ROTATION.len()]
                         }
                     }
-                    DiffText::BranchDest(addr) => {
+                    DiffText::BranchDest(addr, diff) => {
                         label_text = format!("{addr:x}");
+                        if let Some(diff) = diff {
+                            base_color = COLOR_ROTATION[diff.idx % COLOR_ROTATION.len()]
+                        }
                     }
                     DiffText::Symbol(sym) => {
                         let name = sym.demangled_name.as_ref().unwrap_or(&sym.name);
@@ -811,12 +874,7 @@ impl FunctionDiffUi {
         let prev = self.right_obj.take();
         let config = diff::DiffObjConfig {
             relax_reloc_diffs: self.relax_reloc_diffs,
-            space_between_args: true,                // TODO
-            combine_data_sections: false,            // TODO
-            x86_formatter: Default::default(),       // TODO
-            mips_abi: Default::default(),            // TODO
-            mips_instr_category: Default::default(), // TODO
-            arm_arch_version: Default::default(),    // TODO
+            ..Default::default() // TODO
         };
         let target = self
             .target_path

objdiff-cli/src/main.rs

@@ -54,7 +54,7 @@ impl FromArgValue for LogLevel {
 }
 
 #[derive(FromArgs, PartialEq, Debug)]
-/// Yet another GameCube/Wii decompilation toolkit.
+/// A local diffing tool for decompilation projects.
 struct TopLevel {
     #[argp(subcommand)]
     command: SubCommand,
@@ -96,7 +96,7 @@ fn main() {
         // Try to enable ANSI support on Windows.
         let _ = enable_ansi_support();
         // Disable isatty check for supports-color. (e.g. when used with ninja)
-        env::set_var("IGNORE_IS_TERMINAL", "1");
+        unsafe { env::set_var("IGNORE_IS_TERMINAL", "1") };
         supports_color::on(Stream::Stdout).is_some_and(|c| c.has_basic)
     };
 

objdiff-cli/src/util/mod.rs

@@ -1 +1,2 @@
+pub mod output;
 pub mod term;

objdiff-cli/src/util/output.rs

@@ -0,0 +1,84 @@
+use std::{
+    fs::File,
+    io::{BufWriter, Write},
+    ops::DerefMut,
+    path::Path,
+};
+
+use anyhow::{bail, Context, Result};
+use tracing::info;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
+pub enum OutputFormat {
+    #[default]
+    Json,
+    JsonPretty,
+    Proto,
+}
+
+impl OutputFormat {
+    pub fn from_str(s: &str) -> Result<Self> {
+        match s.to_ascii_lowercase().as_str() {
+            "json" => Ok(Self::Json),
+            "json-pretty" | "json_pretty" => Ok(Self::JsonPretty),
+            "binpb" | "pb" | "proto" | "protobuf" => Ok(Self::Proto),
+            _ => bail!("Invalid output format: {}", s),
+        }
+    }
+
+    pub fn from_option(s: Option<&str>) -> Result<Self> {
+        match s {
+            Some(s) => Self::from_str(s),
+            None => Ok(Self::default()),
+        }
+    }
+}
+
+pub fn write_output<T>(input: &T, output: Option<&Path>, format: OutputFormat) -> Result<()>
+where T: serde::Serialize + prost::Message {
+    match output {
+        Some(output) if output != Path::new("-") => {
+            info!("Writing to {}", output.display());
+            let file = File::options()
+                .read(true)
+                .write(true)
+                .create(true)
+                .truncate(true)
+                .open(output)
+                .with_context(|| format!("Failed to create file {}", output.display()))?;
+            match format {
+                OutputFormat::Json => {
+                    let mut output = BufWriter::new(file);
+                    serde_json::to_writer(&mut output, input)
+                        .context("Failed to write output file")?;
+                    output.flush().context("Failed to flush output file")?;
+                }
+                OutputFormat::JsonPretty => {
+                    let mut output = BufWriter::new(file);
+                    serde_json::to_writer_pretty(&mut output, input)
+                        .context("Failed to write output file")?;
+                    output.flush().context("Failed to flush output file")?;
+                }
+                OutputFormat::Proto => {
+                    file.set_len(input.encoded_len() as u64)?;
+                    let map = unsafe { memmap2::Mmap::map(&file) }
+                        .context("Failed to map output file")?;
+                    let mut output = map.make_mut().context("Failed to remap output file")?;
+                    input.encode(&mut output.deref_mut()).context("Failed to encode output")?;
+                }
+            }
+        }
+        _ => match format {
+            OutputFormat::Json => {
+                serde_json::to_writer(std::io::stdout(), input)?;
+            }
+            OutputFormat::JsonPretty => {
+                serde_json::to_writer_pretty(std::io::stdout(), input)?;
+            }
+            OutputFormat::Proto => {
+                std::io::stdout().write_all(&input.encode_to_vec())?;
+            }
+        },
+    }
+    Ok(())
+}

objdiff-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "objdiff-core"
-version = "2.0.0-alpha.5"
+version = "2.0.0-beta.5"
 edition = "2021"
 rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]
@@ -11,15 +11,20 @@ description = """
 A local diffing tool for decompilation projects.
 """
 
+[lib]
+crate-type = ["cdylib", "rlib"]
+
 [features]
-all = ["config", "dwarf", "mips", "ppc", "x86", "arm"]
+all = ["config", "dwarf", "mips", "ppc", "x86", "arm", "bindings"]
 any-arch = [] # Implicit, used to check if any arch is enabled
 config = ["globset", "semver", "serde_json", "serde_yaml"]
 dwarf = ["gimli"]
 mips = ["any-arch", "rabbitizer"]
-ppc = ["any-arch", "cwdemangle", "ppc750cl"]
+ppc = ["any-arch", "cwdemangle", "cwextab", "ppc750cl"]
 x86 = ["any-arch", "cpp_demangle", "iced-x86", "msvc-demangler"]
 arm = ["any-arch", "cpp_demangle", "unarm", "arm-attr"]
+bindings = ["serde_json", "prost", "pbjson"]
+wasm = ["bindings", "console_error_panic_hook", "console_log"]
 
 [dependencies]
 anyhow = "1.0.82"
@@ -30,9 +35,15 @@ log = "0.4.21"
 memmap2 = "0.9.4"
 num-traits = "0.2.18"
 object = { version = "0.35.0", features = ["read_core", "std", "elf", "pe"], default-features = false }
+pbjson = { version = "0.7.0", optional = true }
+prost = { version = "0.13.1", optional = true }
 serde = { version = "1", features = ["derive"] }
 similar = { version = "2.5.0", default-features = false }
 strum = { version = "0.26.2", features = ["derive"] }
+wasm-bindgen = "0.2.93"
+tsify-next = { version = "0.5.4", default-features = false, features = ["js"] }
+console_log = { version = "1.0.0", optional = true }
+console_error_panic_hook = { version = "0.1.7", optional = true }
 
 # config
 globset = { version = "0.4.14", features = ["serde1"], optional = true }
@@ -45,6 +56,7 @@ gimli = { version = "0.29.0", default-features = false, features = ["read-all"],
 
 # ppc
 cwdemangle = { version = "1.0.0", optional = true }
+cwextab = { version = "0.2.3", optional = true }
 ppc750cl = { git = "https://github.com/encounter/ppc750cl", rev = "6cbd7d888c7082c2c860f66cbb9848d633f753ed", optional = true }
 
 # mips
@@ -56,5 +68,9 @@ iced-x86 = { version = "1.21.0", default-features = false, features = ["std", "d
 msvc-demangler = { version = "0.10.0", optional = true }
 
 # arm
-unarm = { version = "1.3.0", optional = true }
+unarm = { version = "1.5.0", optional = true }
 arm-attr = { version = "0.1.1", optional = true }
+
+[build-dependencies]
+prost-build = "0.13.1"
+pbjson-build = "0.7.0"

objdiff-core/build.rs

@@ -0,0 +1,54 @@
+use std::path::{Path, PathBuf};
+
+fn main() {
+    let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("protos");
+    let descriptor_path = root.join("proto_descriptor.bin");
+    println!("cargo:rerun-if-changed={}", descriptor_path.display());
+    let descriptor_mtime = std::fs::metadata(&descriptor_path)
+        .map(|m| m.modified().unwrap())
+        .unwrap_or(std::time::SystemTime::UNIX_EPOCH);
+    let mut run_protoc = false;
+    let proto_files = vec![root.join("diff.proto"), root.join("report.proto")];
+    for proto_file in &proto_files {
+        println!("cargo:rerun-if-changed={}", proto_file.display());
+        let mtime = match std::fs::metadata(proto_file) {
+            Ok(m) => m.modified().unwrap(),
+            Err(e) => panic!("Failed to stat proto file {}: {:?}", proto_file.display(), e),
+        };
+        if mtime > descriptor_mtime {
+            run_protoc = true;
+        }
+    }
+
+    fn prost_config(descriptor_path: &Path, run_protoc: bool) -> prost_build::Config {
+        let mut config = prost_build::Config::new();
+        config.file_descriptor_set_path(descriptor_path);
+        // If our cached descriptor is up-to-date, we don't need to run protoc.
+        // This is helpful so that users don't need to have protoc installed
+        // unless they're updating the protos.
+        if !run_protoc {
+            config.skip_protoc_run();
+        }
+        config
+    }
+    if let Err(e) =
+        prost_config(&descriptor_path, run_protoc).compile_protos(&proto_files, &[root.as_path()])
+    {
+        if e.kind() == std::io::ErrorKind::NotFound && e.to_string().contains("protoc") {
+            eprintln!("protoc not found, skipping protobuf compilation");
+            prost_config(&descriptor_path, false)
+                .compile_protos(&proto_files, &[root.as_path()])
+                .expect("Failed to compile protos");
+        } else {
+            panic!("Failed to compile protos: {e:?}");
+        }
+    }
+
+    let descriptor_set = std::fs::read(descriptor_path).expect("Failed to read descriptor set");
+    pbjson_build::Builder::new()
+        .register_descriptors(&descriptor_set)
+        .expect("Failed to register descriptors")
+        .preserve_proto_field_names()
+        .build(&[".objdiff"])
+        .expect("Failed to build pbjson");
+}

objdiff-core/protos/diff.proto

@@ -0,0 +1,163 @@
+syntax = "proto3";
+
+package objdiff.diff;
+
+// A symbol
+message Symbol {
+  // Name of the symbol
+  string name = 1;
+  // Demangled name of the symbol
+  optional string demangled_name = 2;
+  // Symbol address
+  uint64 address = 3;
+  // Symbol size
+  uint64 size = 4;
+  // Bitmask of SymbolFlag
+  uint32 flags = 5;
+}
+
+// Symbol visibility flags
+enum SymbolFlag {
+  SYMBOL_NONE = 0;
+  SYMBOL_GLOBAL = 1;
+  SYMBOL_LOCAL = 2;
+  SYMBOL_WEAK = 3;
+  SYMBOL_COMMON = 4;
+  SYMBOL_HIDDEN = 5;
+}
+
+// A single parsed instruction
+message Instruction {
+  // Instruction address
+  uint64 address = 1;
+  // Instruction size
+  uint32 size = 2;
+  // Instruction opcode
+  uint32 opcode = 3;
+  // Instruction mnemonic
+  string mnemonic = 4;
+  // Instruction formatted string
+  string formatted = 5;
+  // Original (unsimplified) instruction string
+  optional string original = 6;
+  // Instruction arguments
+  repeated Argument arguments = 7;
+  // Instruction relocation
+  optional Relocation relocation = 8;
+  // Instruction branch destination
+  optional uint64 branch_dest = 9;
+  // Instruction line number
+  optional uint32 line_number = 10;
+}
+
+// An instruction argument
+message Argument {
+  oneof value {
+    // Plain text
+    string plain_text = 1;
+    // Value
+    ArgumentValue argument = 2;
+    // Relocation
+    ArgumentRelocation relocation = 3;
+    // Branch destination
+    uint64 branch_dest = 4;
+  }
+}
+
+// An instruction argument value
+message ArgumentValue {
+  oneof value {
+    // Signed integer
+    int64 signed = 1;
+    // Unsigned integer
+    uint64 unsigned = 2;
+    // Opaque value
+    string opaque = 3;
+  }
+}
+
+// Marker type for relocation arguments
+message ArgumentRelocation {
+}
+
+message Relocation {
+  uint32 type = 1;
+  string type_name = 2;
+  RelocationTarget target = 3;
+}
+
+message RelocationTarget {
+  Symbol symbol = 1;
+  int64 addend = 2;
+}
+
+message InstructionDiff {
+  DiffKind diff_kind = 1;
+  optional Instruction instruction = 2;
+  optional InstructionBranchFrom branch_from = 3;
+  optional InstructionBranchTo branch_to = 4;
+  repeated ArgumentDiff arg_diff = 5;
+}
+
+message ArgumentDiff {
+  optional uint32 diff_index = 1;
+}
+
+enum DiffKind {
+  DIFF_NONE = 0;
+  DIFF_REPLACE = 1;
+  DIFF_DELETE = 2;
+  DIFF_INSERT = 3;
+  DIFF_OP_MISMATCH = 4;
+  DIFF_ARG_MISMATCH = 5;
+}
+
+message InstructionBranchFrom {
+  repeated uint32 instruction_index = 1;
+  uint32 branch_index = 2;
+}
+
+message InstructionBranchTo {
+  uint32 instruction_index = 1;
+  uint32 branch_index = 2;
+}
+
+message FunctionDiff {
+  Symbol symbol = 1;
+  repeated InstructionDiff instructions = 2;
+  optional float match_percent = 3;
+}
+
+message DataDiff {
+  DiffKind kind = 1;
+  bytes data = 2;
+  // May be larger than data
+  uint64 size = 3;
+}
+
+message SectionDiff {
+  string name = 1;
+  SectionKind kind = 2;
+  uint64 size = 3;
+  uint64 address = 4;
+  repeated FunctionDiff functions = 5;
+  repeated DataDiff data = 6;
+  optional float match_percent = 7;
+}
+
+enum SectionKind {
+  SECTION_UNKNOWN = 0;
+  SECTION_TEXT = 1;
+  SECTION_DATA = 2;
+  SECTION_BSS = 3;
+  SECTION_COMMON = 4;
+}
+
+message ObjectDiff {
+  repeated SectionDiff sections = 1;
+}
+
+message DiffResult {
+  optional ObjectDiff left = 1;
+  optional ObjectDiff right = 2;
+}

objdiff-core/protos/report.proto

@@ -0,0 +1,160 @@
+syntax = "proto3";
+
+package objdiff.report;
+
+// Progress info for a report or unit
+message Measures {
+  // Overall match percent, including partially matched functions and data
+  float fuzzy_match_percent = 1;
+  // Total size of code in bytes
+  uint64 total_code = 2;
+  // Fully matched code size in bytes
+  uint64 matched_code = 3;
+  // Fully matched code percent
+  float matched_code_percent = 4;
+  // Total size of data in bytes
+  uint64 total_data = 5;
+  // Fully matched data size in bytes
+  uint64 matched_data = 6;
+  // Fully matched data percent
+  float matched_data_percent = 7;
+  // Total number of functions
+  uint32 total_functions = 8;
+  // Fully matched functions
+  uint32 matched_functions = 9;
+  // Fully matched functions percent
+  float matched_functions_percent = 10;
+  // Completed (or "linked") code size in bytes
+  uint64 complete_code = 11;
+  // Completed (or "linked") code percent
+  float complete_code_percent = 12;
+  // Completed (or "linked") data size in bytes
+  uint64 complete_data = 13;
+  // Completed (or "linked") data percent
+  float complete_data_percent = 14;
+}
+
+// Project progress report
+message Report {
+  // Overall progress info
+  Measures measures = 1;
+  // Units within this report
+  repeated ReportUnit units = 2;
+  // Report version
+  uint32 version = 3;
+  // Progress categories
+  repeated ReportCategory categories = 4;
+}
+
+message ReportCategory {
+  // The ID of the category
+  string id = 1;
+  // The name of the category
+  string name = 2;
+  // Progress info for this category
+  Measures measures = 3;
+}
+
+// A unit of the report (usually a translation unit)
+message ReportUnit {
+  // The name of the unit
+  string name = 1;
+  // Progress info for this unit
+  Measures measures = 2;
+  // Sections within this unit
+  repeated ReportItem sections = 3;
+  // Functions within this unit
+  repeated ReportItem functions = 4;
+  // Extra metadata for this unit
+  optional ReportUnitMetadata metadata = 5;
+}
+
+// Extra metadata for a unit
+message ReportUnitMetadata {
+  // Whether this unit is marked as complete (or "linked")
+  optional bool complete = 1;
+  // The name of the module this unit belongs to
+  optional string module_name = 2;
+  // The ID of the module this unit belongs to
+  optional uint32 module_id = 3;
+  // The path to the source file of this unit
+  optional string source_path = 4;
+  // Progress categories for this unit
+  repeated string progress_categories = 5;
+  // Whether this unit is automatically generated (not user-provided)
+  optional bool auto_generated = 6;
+}
+
+// A section or function within a unit
+message ReportItem {
+  // The name of the item
+  string name = 1;
+  // The size of the item in bytes
+  uint64 size = 2;
+  // The overall match percent for this item
+  float fuzzy_match_percent = 3;
+  // Extra metadata for this item
+  optional ReportItemMetadata metadata = 4;
+}
+
+// Extra metadata for an item
+message ReportItemMetadata {
+  // The demangled name of the function
+  optional string demangled_name = 1;
+  // The virtual address of the function or section
+  optional uint64 virtual_address = 2;
+}
+
+// A pair of reports to compare and generate changes
+message ChangesInput {
+  // The previous report
+  Report from = 1;
+  // The current report
+  Report to = 2;
+}
+
+// Changes between two reports
+message Changes {
+  // The progress info for the previous report
+  Measures from = 1;
+  // The progress info for the current report
+  Measures to = 2;
+  // Units that changed
+  repeated ChangeUnit units = 3;
+}
+
+// A changed unit
+message ChangeUnit {
+  // The name of the unit
+  string name = 1;
+  // The previous progress info (omitted if new)
+  optional Measures from = 2;
+  // The current progress info (omitted if removed)
+  optional Measures to = 3;
+  // Sections that changed
+  repeated ChangeItem sections = 4;
+  // Functions that changed
+  repeated ChangeItem functions = 5;
+  // Extra metadata for this unit
+  optional ReportUnitMetadata metadata = 6;
+}
+
+// A changed section or function
+message ChangeItem {
+  // The name of the item
+  string name = 1;
+  // The previous progress info (omitted if new)
+  optional ChangeItemInfo from = 2;
+  // The current progress info (omitted if removed)
+  optional ChangeItemInfo to = 3;
+  // Extra metadata for this item
+  optional ReportItemMetadata metadata = 4;
+}
+
+// Progress info for a section or function
+message ChangeItemInfo {
+  // The overall match percent for this item
+  float fuzzy_match_percent = 1;
+  // The size of the item in bytes
+  uint64 size = 2;
+}

objdiff-core/src/arch/arm.rs

@@ -13,12 +13,12 @@ use object::{
 use unarm::{
     args::{Argument, OffsetImm, OffsetReg, Register},
     parse::{ArmVersion, ParseMode, Parser},
-    ParsedIns,
+    DisplayOptions, ParseFlags, ParsedIns, RegNames,
 };
 
 use crate::{
     arch::{ObjArch, ProcessCodeResult},
-    diff::{ArmArchVersion, DiffObjConfig},
+    diff::{ArmArchVersion, ArmR9Usage, DiffObjConfig},
     obj::{ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc, ObjSection},
 };
 
@@ -111,7 +111,7 @@ impl ObjArch for ObjArchArm {
         code: &[u8],
         section_index: usize,
         relocations: &[ObjReloc],
-        line_info: &BTreeMap<u64, u64>,
+        line_info: &BTreeMap<u64, u32>,
         config: &DiffObjConfig,
     ) -> Result<ProcessCodeResult> {
         let start_addr = address as u32;
@@ -149,9 +149,26 @@ impl ObjArch for ObjArchArm {
             object::Endianness::Little => unarm::Endian::Little,
             object::Endianness::Big => unarm::Endian::Big,
         };
-        let mut parser = Parser::new(version, first_mapping, start_addr, endian, code);
 
-        while let Some((address, op, ins)) = parser.next() {
+        let parse_flags = ParseFlags { ual: config.arm_unified_syntax, version };
+
+        let mut parser = Parser::new(first_mapping, start_addr, endian, parse_flags, code);
+
+        let display_options = DisplayOptions {
+            reg_names: RegNames {
+                av_registers: config.arm_av_registers,
+                r9_use: match config.arm_r9_usage {
+                    ArmR9Usage::GeneralPurpose => unarm::R9Use::GeneralPurpose,
+                    ArmR9Usage::Sb => unarm::R9Use::Pid,
+                    ArmR9Usage::Tr => unarm::R9Use::Tls,
+                },
+                explicit_stack_limit: config.arm_sl_usage,
+                frame_pointer: config.arm_fp_usage,
+                ip: config.arm_ip_usage,
+            },
+        };
+
+        while let Some((address, ins, parsed_ins)) = parser.next() {
             if let Some(next) = next_mapping {
                 let next_address = parser.address;
                 if next_address >= next.address {
@@ -173,12 +190,15 @@ impl ObjArch for ObjArchArm {
                     | RelocationFlags::Elf { r_type: elf::R_ARM_PC24 }
                     | RelocationFlags::Elf { r_type: elf::R_ARM_XPC25 }
                     | RelocationFlags::Elf { r_type: elf::R_ARM_CALL } => {
-                        reloc_arg =
-                            ins.args.iter().rposition(|a| matches!(a, Argument::BranchDest(_)));
+                        reloc_arg = parsed_ins
+                            .args
+                            .iter()
+                            .rposition(|a| matches!(a, Argument::BranchDest(_)));
                     }
                     // Data
                     RelocationFlags::Elf { r_type: elf::R_ARM_ABS32 } => {
-                        reloc_arg = ins.args.iter().rposition(|a| matches!(a, Argument::UImm(_)));
+                        reloc_arg =
+                            parsed_ins.args.iter().rposition(|a| matches!(a, Argument::UImm(_)));
                     }
                     _ => (),
                 }
@@ -187,20 +207,20 @@ impl ObjArch for ObjArchArm {
             let (args, branch_dest) = if reloc.is_some() && parser.mode == ParseMode::Data {
                 (vec![ObjInsArg::Reloc], None)
             } else {
-                push_args(&ins, config, reloc_arg, address)?
+                push_args(&parsed_ins, config, reloc_arg, address, display_options)?
             };
 
-            ops.push(op.id());
+            ops.push(ins.opcode_id());
             insts.push(ObjIns {
                 address: address as u64,
                 size: (parser.address - address) as u8,
-                op: op.id(),
-                mnemonic: ins.mnemonic.to_string(),
+                op: ins.opcode_id(),
+                mnemonic: parsed_ins.mnemonic.to_string(),
                 args,
                 reloc,
                 branch_dest,
                 line,
-                formatted: ins.to_string(),
+                formatted: parsed_ins.display(display_options).to_string(),
                 orig: None,
             });
         }
@@ -210,6 +230,7 @@ impl ObjArch for ObjArchArm {
 
     fn implcit_addend(
         &self,
+        _file: &File<'_>,
         section: &ObjSection,
         address: u64,
         reloc: &Relocation,
@@ -281,6 +302,7 @@ fn push_args(
     config: &DiffObjConfig,
     reloc_arg: Option<usize>,
     cur_addr: u32,
+    display_options: DisplayOptions,
 ) -> Result<(Vec<ObjInsArg>, Option<u64>)> {
     let mut args = vec![];
     let mut branch_dest = None;
@@ -318,7 +340,9 @@ fn push_args(
                         deref = true;
                         args.push(ObjInsArg::PlainText("[".into()));
                     }
-                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(reg.reg.to_string().into())));
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
+                        reg.reg.display(display_options.reg_names).to_string().into(),
+                    )));
                     if reg.writeback {
                         if reg.deref {
                             writeback = true;
@@ -336,7 +360,10 @@ fn push_args(
                                 args.push(ObjInsArg::PlainText(config.separator().into()));
                             }
                             args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
-                                Register::parse(i).to_string().into(),
+                                Register::parse(i)
+                                    .display(display_options.reg_names)
+                                    .to_string()
+                                    .into(),
                             )));
                             first = false;
                         }
@@ -376,14 +403,16 @@ fn push_args(
                 Argument::ShiftReg(shift) => {
                     args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(shift.op.to_string().into())));
                     args.push(ObjInsArg::PlainText(" ".into()));
-                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(shift.reg.to_string().into())));
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
+                        shift.reg.display(display_options.reg_names).to_string().into(),
+                    )));
                 }
                 Argument::OffsetReg(offset) => {
                     if !offset.add {
                         args.push(ObjInsArg::PlainText("-".into()));
                     }
                     args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
-                        offset.reg.to_string().into(),
+                        offset.reg.display(display_options.reg_names).to_string().into(),
                     )));
                 }
                 Argument::CpsrMode(mode) => {
@@ -398,9 +427,9 @@ fn push_args(
                 | Argument::StatusMask(_)
                 | Argument::Shift(_)
                 | Argument::CpsrFlags(_)
-                | Argument::Endian(_) => {
-                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(arg.to_string().into())))
-                }
+                | Argument::Endian(_) => args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
+                    arg.display(display_options, None).to_string().into(),
+                ))),
             }
         }
     }

objdiff-core/src/arch/mips.rs

@@ -1,7 +1,10 @@
 use std::{borrow::Cow, collections::BTreeMap, sync::Mutex};
 
 use anyhow::{anyhow, bail, Result};
-use object::{elf, Endian, Endianness, File, FileFlags, Object, Relocation, RelocationFlags};
+use object::{
+    elf, Endian, Endianness, File, FileFlags, Object, ObjectSection, ObjectSymbol, Relocation,
+    RelocationFlags, RelocationTarget,
+};
 use rabbitizer::{config, Abi, InstrCategory, Instruction, OperandType};
 
 use crate::{
@@ -22,6 +25,7 @@ pub struct ObjArchMips {
     pub endianness: Endianness,
     pub abi: Abi,
     pub instr_category: InstrCategory,
+    pub ri_gp_value: i32,
 }
 
 const EF_MIPS_ABI: u32 = 0x0000F000;
@@ -30,6 +34,8 @@ const EF_MIPS_MACH: u32 = 0x00FF0000;
 const EF_MIPS_MACH_ALLEGREX: u32 = 0x00840000;
 const EF_MIPS_MACH_5900: u32 = 0x00920000;
 
+const R_MIPS15_S3: u32 = 119;
+
 impl ObjArchMips {
     pub fn new(object: &File) -> Result<Self> {
         let mut abi = Abi::NUMERIC;
@@ -56,7 +62,19 @@ impl ObjArchMips {
             }
             _ => bail!("Unsupported MIPS file flags"),
         }
-        Ok(Self { endianness: object.endianness(), abi, instr_category })
+
+        // Parse the ri_gp_value stored in .reginfo to be able to correctly
+        // calculate R_MIPS_GPREL16 relocations later. The value is stored
+        // 0x14 bytes into .reginfo (on 32 bit platforms)
+        let ri_gp_value = object
+            .section_by_name(".reginfo")
+            .and_then(|section| section.data().ok())
+            .and_then(|data| data.get(0x14..0x18))
+            .and_then(|s| s.try_into().ok())
+            .map(|bytes| object.endianness().read_i32_bytes(bytes))
+            .unwrap_or(0);
+
+        Ok(Self { endianness: object.endianness(), abi, instr_category, ri_gp_value })
     }
 }
 
@@ -67,7 +85,7 @@ impl ObjArch for ObjArchMips {
         code: &[u8],
         _section_index: usize,
         relocations: &[ObjReloc],
-        line_info: &BTreeMap<u64, u64>,
+        line_info: &BTreeMap<u64, u32>,
         config: &DiffObjConfig,
     ) -> Result<ProcessCodeResult> {
         let _guard = RABBITIZER_MUTEX.lock().map_err(|e| anyhow!("Failed to lock mutex: {e}"))?;
@@ -104,7 +122,7 @@ impl ObjArch for ObjArchMips {
             let mnemonic = instruction.opcode_name().to_string();
             let is_branch = instruction.is_branch();
             let branch_offset = instruction.branch_offset();
-            let branch_dest = if is_branch {
+            let mut branch_dest = if is_branch {
                 cur_addr.checked_add_signed(branch_offset).map(|a| a as u64)
             } else {
                 None
@@ -121,9 +139,7 @@ impl ObjArch for ObjArchMips {
                     OperandType::cpu_immediate
                     | OperandType::cpu_label
                     | OperandType::cpu_branch_target_label => {
-                        if let Some(branch_dest) = branch_dest {
-                            args.push(ObjInsArg::BranchDest(branch_dest));
-                        } else if let Some(reloc) = reloc {
+                        if let Some(reloc) = reloc {
                             if matches!(&reloc.target_section, Some(s) if s == ".text")
                                 && reloc.target.address > start_address
                                 && reloc.target.address < end_address
@@ -131,7 +147,10 @@ impl ObjArch for ObjArchMips {
                                 args.push(ObjInsArg::BranchDest(reloc.target.address));
                             } else {
                                 push_reloc(&mut args, reloc)?;
+                                branch_dest = None;
                             }
+                        } else if let Some(branch_dest) = branch_dest {
+                            args.push(ObjInsArg::BranchDest(branch_dest));
                         } else {
                             args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
                                 op.disassemble(&instruction, None).into(),
@@ -152,6 +171,18 @@ impl ObjArch for ObjArchMips {
                         )));
                         args.push(ObjInsArg::PlainText(")".into()));
                     }
+                    // OperandType::r5900_immediate15 => match reloc {
+                    //     Some(reloc)
+                    //         if reloc.flags == RelocationFlags::Elf { r_type: R_MIPS15_S3 } =>
+                    //     {
+                    //         push_reloc(&mut args, reloc)?;
+                    //     }
+                    //     _ => {
+                    //         args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
+                    //             op.disassemble(&instruction, None).into(),
+                    //         )));
+                    //     }
+                    // },
                     _ => {
                         args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
                             op.disassemble(&instruction, None).into(),
@@ -179,6 +210,7 @@ impl ObjArch for ObjArchMips {
 
     fn implcit_addend(
         &self,
+        file: &File<'_>,
         section: &ObjSection,
         address: u64,
         reloc: &Relocation,
@@ -187,14 +219,29 @@ impl ObjArch for ObjArchMips {
         let addend = self.endianness.read_u32_bytes(data);
         Ok(match reloc.flags() {
             RelocationFlags::Elf { r_type: elf::R_MIPS_32 } => addend as i64,
+            RelocationFlags::Elf { r_type: elf::R_MIPS_26 } => ((addend & 0x03FFFFFF) << 2) as i64,
             RelocationFlags::Elf { r_type: elf::R_MIPS_HI16 } => {
                 ((addend & 0x0000FFFF) << 16) as i32 as i64
             }
             RelocationFlags::Elf {
-                r_type:
-                    elf::R_MIPS_LO16 | elf::R_MIPS_GOT16 | elf::R_MIPS_CALL16 | elf::R_MIPS_GPREL16,
+                r_type: elf::R_MIPS_LO16 | elf::R_MIPS_GOT16 | elf::R_MIPS_CALL16,
             } => (addend & 0x0000FFFF) as i16 as i64,
-            RelocationFlags::Elf { r_type: elf::R_MIPS_26 } => ((addend & 0x03FFFFFF) << 2) as i64,
+            RelocationFlags::Elf { r_type: elf::R_MIPS_GPREL16 | elf::R_MIPS_LITERAL } => {
+                let RelocationTarget::Symbol(idx) = reloc.target() else {
+                    bail!("Unsupported R_MIPS_GPREL16 relocation against a non-symbol");
+                };
+                let sym = file.symbol_by_index(idx)?;
+
+                // if the symbol we are relocating against is in a local section we need to add
+                // the ri_gp_value from .reginfo to the addend.
+                if sym.section().index().is_some() {
+                    ((addend & 0x0000FFFF) as i16 as i64) + self.ri_gp_value as i64
+                } else {
+                    (addend & 0x0000FFFF) as i16 as i64
+                }
+            }
+            RelocationFlags::Elf { r_type: elf::R_MIPS_PC16 } => 0, // PC-relative relocation
+            RelocationFlags::Elf { r_type: R_MIPS15_S3 } => ((addend & 0x001FFFC0) >> 3) as i64,
             flags => bail!("Unsupported MIPS implicit relocation {flags:?}"),
         })
     }
@@ -202,13 +249,16 @@ impl ObjArch for ObjArchMips {
     fn display_reloc(&self, flags: RelocationFlags) -> Cow<'static, str> {
         match flags {
             RelocationFlags::Elf { r_type } => match r_type {
-                elf::R_MIPS_HI16 => Cow::Borrowed("R_MIPS_HI16"),
-                elf::R_MIPS_LO16 => Cow::Borrowed("R_MIPS_LO16"),
-                elf::R_MIPS_GOT16 => Cow::Borrowed("R_MIPS_GOT16"),
-                elf::R_MIPS_CALL16 => Cow::Borrowed("R_MIPS_CALL16"),
-                elf::R_MIPS_GPREL16 => Cow::Borrowed("R_MIPS_GPREL16"),
                 elf::R_MIPS_32 => Cow::Borrowed("R_MIPS_32"),
                 elf::R_MIPS_26 => Cow::Borrowed("R_MIPS_26"),
+                elf::R_MIPS_HI16 => Cow::Borrowed("R_MIPS_HI16"),
+                elf::R_MIPS_LO16 => Cow::Borrowed("R_MIPS_LO16"),
+                elf::R_MIPS_GPREL16 => Cow::Borrowed("R_MIPS_GPREL16"),
+                elf::R_MIPS_LITERAL => Cow::Borrowed("R_MIPS_LITERAL"),
+                elf::R_MIPS_GOT16 => Cow::Borrowed("R_MIPS_GOT16"),
+                elf::R_MIPS_PC16 => Cow::Borrowed("R_MIPS_PC16"),
+                elf::R_MIPS_CALL16 => Cow::Borrowed("R_MIPS_CALL16"),
+                R_MIPS15_S3 => Cow::Borrowed("R_MIPS15_S3"),
                 _ => Cow::Owned(format!("<{flags:?}>")),
             },
             _ => Cow::Owned(format!("<{flags:?}>")),
@@ -244,7 +294,11 @@ fn push_reloc(args: &mut Vec<ObjInsArg>, reloc: &ObjReloc) -> Result<()> {
                 args.push(ObjInsArg::Reloc);
                 args.push(ObjInsArg::PlainText(")".into()));
             }
-            elf::R_MIPS_32 | elf::R_MIPS_26 => {
+            elf::R_MIPS_32
+            | elf::R_MIPS_26
+            | elf::R_MIPS_LITERAL
+            | elf::R_MIPS_PC16
+            | R_MIPS15_S3 => {
                 args.push(ObjInsArg::Reloc);
             }
             _ => bail!("Unsupported ELF MIPS relocation type {r_type}"),

objdiff-core/src/arch/mod.rs

@@ -1,7 +1,7 @@
 use std::{borrow::Cow, collections::BTreeMap};
 
 use anyhow::{bail, Result};
-use object::{Architecture, Object, ObjectSymbol, Relocation, RelocationFlags, Symbol};
+use object::{Architecture, File, Object, ObjectSymbol, Relocation, RelocationFlags, Symbol};
 
 use crate::{
     diff::DiffObjConfig,
@@ -24,12 +24,17 @@ pub trait ObjArch: Send + Sync {
         code: &[u8],
         section_index: usize,
         relocations: &[ObjReloc],
-        line_info: &BTreeMap<u64, u64>,
+        line_info: &BTreeMap<u64, u32>,
         config: &DiffObjConfig,
     ) -> Result<ProcessCodeResult>;
 
-    fn implcit_addend(&self, section: &ObjSection, address: u64, reloc: &Relocation)
-        -> Result<i64>;
+    fn implcit_addend(
+        &self,
+        file: &File<'_>,
+        section: &ObjSection,
+        address: u64,
+        reloc: &Relocation,
+    ) -> Result<i64>;
 
     fn demangle(&self, _name: &str) -> Option<String> { None }
 

objdiff-core/src/arch/ppc.rs

@@ -35,7 +35,7 @@ impl ObjArch for ObjArchPpc {
         code: &[u8],
         _section_index: usize,
         relocations: &[ObjReloc],
-        line_info: &BTreeMap<u64, u64>,
+        line_info: &BTreeMap<u64, u32>,
         config: &DiffObjConfig,
     ) -> Result<ProcessCodeResult> {
         let ins_count = code.len() / 4;
@@ -150,6 +150,7 @@ impl ObjArch for ObjArchPpc {
 
     fn implcit_addend(
         &self,
+        _file: &File<'_>,
         _section: &ObjSection,
         address: u64,
         reloc: &Relocation,

objdiff-core/src/arch/x86.rs

@@ -32,7 +32,7 @@ impl ObjArch for ObjArchX86 {
         code: &[u8],
         _section_index: usize,
         relocations: &[ObjReloc],
-        line_info: &BTreeMap<u64, u64>,
+        line_info: &BTreeMap<u64, u32>,
         config: &DiffObjConfig,
     ) -> Result<ProcessCodeResult> {
         let mut result = ProcessCodeResult { ops: Vec::new(), insts: Vec::new() };
@@ -128,6 +128,7 @@ impl ObjArch for ObjArchX86 {
 
     fn implcit_addend(
         &self,
+        _file: &File<'_>,
         section: &ObjSection,
         address: u64,
         reloc: &Relocation,

objdiff-core/src/bindings/diff.rs

@@ -0,0 +1,244 @@
+use crate::{
+    diff::{
+        ObjDataDiff, ObjDataDiffKind, ObjDiff, ObjInsArgDiff, ObjInsBranchFrom, ObjInsBranchTo,
+        ObjInsDiff, ObjInsDiffKind, ObjSectionDiff, ObjSymbolDiff,
+    },
+    obj::{
+        ObjInfo, ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc, ObjSectionKind, ObjSymbol,
+        ObjSymbolFlagSet, ObjSymbolFlags,
+    },
+};
+
+// Protobuf diff types
+include!(concat!(env!("OUT_DIR"), "/objdiff.diff.rs"));
+include!(concat!(env!("OUT_DIR"), "/objdiff.diff.serde.rs"));
+
+impl DiffResult {
+    pub fn new(left: Option<(&ObjInfo, &ObjDiff)>, right: Option<(&ObjInfo, &ObjDiff)>) -> Self {
+        Self {
+            left: left.map(|(obj, diff)| ObjectDiff::new(obj, diff)),
+            right: right.map(|(obj, diff)| ObjectDiff::new(obj, diff)),
+        }
+    }
+}
+
+impl ObjectDiff {
+    pub fn new(obj: &ObjInfo, diff: &ObjDiff) -> Self {
+        Self {
+            sections: diff
+                .sections
+                .iter()
+                .enumerate()
+                .map(|(i, d)| SectionDiff::new(obj, i, d))
+                .collect(),
+        }
+    }
+}
+
+impl SectionDiff {
+    pub fn new(obj: &ObjInfo, section_index: usize, section_diff: &ObjSectionDiff) -> Self {
+        let section = &obj.sections[section_index];
+        let functions = section_diff.symbols.iter().map(|d| FunctionDiff::new(obj, d)).collect();
+        let data = section_diff.data_diff.iter().map(|d| DataDiff::new(obj, d)).collect();
+        Self {
+            name: section.name.to_string(),
+            kind: SectionKind::from(section.kind) as i32,
+            size: section.size,
+            address: section.address,
+            functions,
+            data,
+            match_percent: section_diff.match_percent,
+        }
+    }
+}
+
+impl From<ObjSectionKind> for SectionKind {
+    fn from(value: ObjSectionKind) -> Self {
+        match value {
+            ObjSectionKind::Code => SectionKind::SectionText,
+            ObjSectionKind::Data => SectionKind::SectionData,
+            ObjSectionKind::Bss => SectionKind::SectionBss,
+            // TODO common
+        }
+    }
+}
+
+impl FunctionDiff {
+    pub fn new(object: &ObjInfo, symbol_diff: &ObjSymbolDiff) -> Self {
+        let (_section, symbol) = object.section_symbol(symbol_diff.symbol_ref);
+        // let diff_symbol = symbol_diff.diff_symbol.map(|symbol_ref| {
+        //     let (_section, symbol) = object.section_symbol(symbol_ref);
+        //     Symbol::from(symbol)
+        // });
+        let instructions = symbol_diff.instructions.iter().map(InstructionDiff::from).collect();
+        Self {
+            symbol: Some(Symbol::from(symbol)),
+            // diff_symbol,
+            instructions,
+            match_percent: symbol_diff.match_percent,
+        }
+    }
+}
+
+impl DataDiff {
+    pub fn new(_object: &ObjInfo, data_diff: &ObjDataDiff) -> Self {
+        Self {
+            kind: DiffKind::from(data_diff.kind) as i32,
+            data: data_diff.data.clone(),
+            size: data_diff.len as u64,
+        }
+    }
+}
+
+impl<'a> From<&'a ObjSymbol> for Symbol {
+    fn from(value: &'a ObjSymbol) -> Self {
+        Self {
+            name: value.name.to_string(),
+            demangled_name: value.demangled_name.clone(),
+            address: value.address,
+            size: value.size,
+            flags: symbol_flags(value.flags),
+        }
+    }
+}
+
+fn symbol_flags(value: ObjSymbolFlagSet) -> u32 {
+    let mut flags = 0u32;
+    if value.0.contains(ObjSymbolFlags::Global) {
+        flags |= SymbolFlag::SymbolNone as u32;
+    }
+    if value.0.contains(ObjSymbolFlags::Local) {
+        flags |= SymbolFlag::SymbolLocal as u32;
+    }
+    if value.0.contains(ObjSymbolFlags::Weak) {
+        flags |= SymbolFlag::SymbolWeak as u32;
+    }
+    if value.0.contains(ObjSymbolFlags::Common) {
+        flags |= SymbolFlag::SymbolCommon as u32;
+    }
+    if value.0.contains(ObjSymbolFlags::Hidden) {
+        flags |= SymbolFlag::SymbolHidden as u32;
+    }
+    flags
+}
+
+impl<'a> From<&'a ObjIns> for Instruction {
+    fn from(value: &'a ObjIns) -> Self {
+        Self {
+            address: value.address,
+            size: value.size as u32,
+            opcode: value.op as u32,
+            mnemonic: value.mnemonic.clone(),
+            formatted: value.formatted.clone(),
+            arguments: value.args.iter().map(Argument::from).collect(),
+            relocation: value.reloc.as_ref().map(Relocation::from),
+            branch_dest: value.branch_dest,
+            line_number: value.line,
+            original: value.orig.clone(),
+        }
+    }
+}
+
+impl<'a> From<&'a ObjInsArg> for Argument {
+    fn from(value: &'a ObjInsArg) -> Self {
+        Self {
+            value: Some(match value {
+                ObjInsArg::PlainText(s) => argument::Value::PlainText(s.to_string()),
+                ObjInsArg::Arg(v) => argument::Value::Argument(ArgumentValue::from(v)),
+                ObjInsArg::Reloc => argument::Value::Relocation(ArgumentRelocation {}),
+                ObjInsArg::BranchDest(dest) => argument::Value::BranchDest(*dest),
+            }),
+        }
+    }
+}
+
+impl From<&ObjInsArgValue> for ArgumentValue {
+    fn from(value: &ObjInsArgValue) -> Self {
+        Self {
+            value: Some(match value {
+                ObjInsArgValue::Signed(v) => argument_value::Value::Signed(*v),
+                ObjInsArgValue::Unsigned(v) => argument_value::Value::Unsigned(*v),
+                ObjInsArgValue::Opaque(v) => argument_value::Value::Opaque(v.to_string()),
+            }),
+        }
+    }
+}
+
+impl<'a> From<&'a ObjReloc> for Relocation {
+    fn from(value: &ObjReloc) -> Self {
+        Self {
+            r#type: match value.flags {
+                object::RelocationFlags::Elf { r_type } => r_type,
+                object::RelocationFlags::MachO { r_type, .. } => r_type as u32,
+                object::RelocationFlags::Coff { typ } => typ as u32,
+                object::RelocationFlags::Xcoff { r_rtype, .. } => r_rtype as u32,
+                _ => unreachable!(),
+            },
+            type_name: String::new(), // TODO
+            target: Some(RelocationTarget::from(&value.target)),
+        }
+    }
+}
+
+impl<'a> From<&'a ObjSymbol> for RelocationTarget {
+    fn from(value: &'a ObjSymbol) -> Self {
+        Self { symbol: Some(Symbol::from(value)), addend: value.addend }
+    }
+}
+
+impl<'a> From<&'a ObjInsDiff> for InstructionDiff {
+    fn from(value: &'a ObjInsDiff) -> Self {
+        Self {
+            instruction: value.ins.as_ref().map(Instruction::from),
+            diff_kind: DiffKind::from(value.kind) as i32,
+            branch_from: value.branch_from.as_ref().map(InstructionBranchFrom::from),
+            branch_to: value.branch_to.as_ref().map(InstructionBranchTo::from),
+            arg_diff: value.arg_diff.iter().map(ArgumentDiff::from).collect(),
+        }
+    }
+}
+
+impl From<&Option<ObjInsArgDiff>> for ArgumentDiff {
+    fn from(value: &Option<ObjInsArgDiff>) -> Self {
+        Self { diff_index: value.as_ref().map(|v| v.idx as u32) }
+    }
+}
+
+impl From<ObjInsDiffKind> for DiffKind {
+    fn from(value: ObjInsDiffKind) -> Self {
+        match value {
+            ObjInsDiffKind::None => DiffKind::DiffNone,
+            ObjInsDiffKind::OpMismatch => DiffKind::DiffOpMismatch,
+            ObjInsDiffKind::ArgMismatch => DiffKind::DiffArgMismatch,
+            ObjInsDiffKind::Replace => DiffKind::DiffReplace,
+            ObjInsDiffKind::Delete => DiffKind::DiffDelete,
+            ObjInsDiffKind::Insert => DiffKind::DiffInsert,
+        }
+    }
+}
+
+impl From<ObjDataDiffKind> for DiffKind {
+    fn from(value: ObjDataDiffKind) -> Self {
+        match value {
+            ObjDataDiffKind::None => DiffKind::DiffNone,
+            ObjDataDiffKind::Replace => DiffKind::DiffReplace,
+            ObjDataDiffKind::Delete => DiffKind::DiffDelete,
+            ObjDataDiffKind::Insert => DiffKind::DiffInsert,
+        }
+    }
+}
+
+impl<'a> From<&'a ObjInsBranchFrom> for InstructionBranchFrom {
+    fn from(value: &'a ObjInsBranchFrom) -> Self {
+        Self {
+            instruction_index: value.ins_idx.iter().map(|&x| x as u32).collect(),
+            branch_index: value.branch_idx as u32,
+        }
+    }
+}
+
+impl<'a> From<&'a ObjInsBranchTo> for InstructionBranchTo {
+    fn from(value: &'a ObjInsBranchTo) -> Self {
+        Self { instruction_index: value.ins_idx as u32, branch_index: value.branch_idx as u32 }
+    }
+}

objdiff-core/src/bindings/mod.rs

@@ -0,0 +1,5 @@
+#[cfg(feature = "any-arch")]
+pub mod diff;
+pub mod report;
+#[cfg(feature = "wasm")]
+pub mod wasm;