Support R_MIPS_LITERAL, R_MIPS15_S3 relocations

Resolves #92 Resolves #95
Fix reading little-endian .line section
2025-12-16 16:37:06 +00:00 · 2024-08-18 22:05:16 -06:00 · 2024-08-18 21:57:53 -06:00 · 2024-08-18 14:01:49 -06:00 · 2024-08-18 13:42:41 -06:00 · 2024-08-18 13:40:49 -06:00
14 changed files with 771 additions and 282 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1475,6 +1475,12 @@ dependencies = [
 "windows-sys 0.52.0",
 ]

+[[package]]
+name = "fixedbitset"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+
 [[package]]
 name = "flagset"
 version = "0.4.5"
@@ -1931,6 +1937,12 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"

+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hermit-abi"
 version = "0.3.9"
@@ -2192,6 +2204,15 @@ dependencies = [
 "either",
 ]

+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.11"
@@ -2479,6 +2500,12 @@ dependencies = [
 "bitflags 2.5.0",
 ]

+[[package]]
+name = "multimap"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03"
+
 [[package]]
 name = "naga"
 version = "0.19.2"
@@ -2798,13 +2825,18 @@ dependencies = [

 [[package]]
 name = "objdiff-cli"
-version = "2.0.0-beta.3"
+version = "2.0.0-beta.4"
 dependencies = [
 "anyhow",
 "argp",
 "crossterm",
 "enable-ansi-support",
+ "memmap2",
 "objdiff-core",
+ "pbjson",
+ "pbjson-build",
+ "prost",
+ "prost-build",
 "ratatui",
 "rayon",
 "serde",
@@ -2817,7 +2849,7 @@ dependencies = [

 [[package]]
 name = "objdiff-core"
-version = "2.0.0-beta.3"
+version = "2.0.0-beta.4"
 dependencies = [
 "anyhow",
 "arm-attr",
@@ -2848,7 +2880,7 @@ dependencies = [

 [[package]]
 name = "objdiff-gui"
-version = "2.0.0-beta.3"
+version = "2.0.0-beta.4"
 dependencies = [
 "anyhow",
 "bytes",
@@ -3060,12 +3092,44 @@ dependencies = [
 "rustc_version",
 ]

+[[package]]
+name = "pbjson"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7e6349fa080353f4a597daffd05cb81572a9c031a6d4fff7e504947496fcc68"
+dependencies = [
+ "base64 0.21.7",
+ "serde",
+]
+
+[[package]]
+name = "pbjson-build"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6eea3058763d6e656105d1403cb04e0a41b7bbac6362d413e7c33be0c32279c9"
+dependencies = [
+ "heck 0.5.0",
+ "itertools 0.13.0",
+ "prost",
+ "prost-types",
+]
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"

+[[package]]
+name = "petgraph"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
+dependencies = [
+ "fixedbitset",
+ "indexmap",
+]
+
 [[package]]
 name = "pin-project"
 version = "1.1.5"
@@ -3178,6 +3242,16 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa"

+[[package]]
+name = "prettyplease"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f12335488a2f3b0a83b14edad48dca9879ce89b2edd10e80237e4e852dd645e"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.60",
+]
+
 [[package]]
 name = "proc-macro-crate"
 version = "1.3.1"
@@ -3212,6 +3286,59 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43d84d1d7a6ac92673717f9f6d1518374ef257669c24ebc5ac25d5033828be58"

+[[package]]
+name = "prost"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13db3d3fde688c61e2446b4d843bc27a7e8af269a69440c0308021dc92333cc"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-build"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bb182580f71dd070f88d01ce3de9f4da5021db7115d2e1c3605a754153b77c1"
+dependencies = [
+ "bytes",
+ "heck 0.5.0",
+ "itertools 0.13.0",
+ "log",
+ "multimap",
+ "once_cell",
+ "petgraph",
+ "prettyplease",
+ "prost",
+ "prost-types",
+ "regex",
+ "syn 2.0.60",
+ "tempfile",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18bec9b0adc4eba778b33684b7ba3e7137789434769ee3ce3930463ef904cfca"
+dependencies = [
+ "anyhow",
+ "itertools 0.13.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cee5168b05f49d4b0ca581206eb14a7b22fafd963efe729ac48eb03266e25cc2"
+dependencies = [
+ "prost",
+]
+
 [[package]]
 name = "pulldown-cmark"
 version = "0.9.6"
@@ -3309,7 +3436,7 @@ dependencies = [
 "compact_str",
 "crossterm",
 "indoc",
- "itertools",
+ "itertools 0.12.1",
 "lru",
 "paste",
 "stability",
@@ -3988,7 +4115,7 @@ version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6cf59daf282c0a494ba14fd21610a0325f9f90ec9d1231dea26bcb1d696c946"
 dependencies = [
- "heck",
+ "heck 0.4.1",
 "proc-macro2",
 "quote",
 "rustversion",
--- a/objdiff-cli/Cargo.toml
+++ b/objdiff-cli/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "objdiff-cli"
-version = "2.0.0-beta.3"
+version = "2.0.0-beta.4"
 edition = "2021"
 rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]
@@ -18,7 +18,10 @@ 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"] }
+pbjson = "0.7.0"
+prost = "0.13.1"
 ratatui = "0.26.2"
 rayon = "1.10.0"
 serde = { version = "1", features = ["derive"] }
@@ -27,3 +30,8 @@ supports-color = "3.0.0"
 time = { version = "0.3.36", features = ["formatting", "local-offset"] }
 tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
+
+[build-dependencies]
+prost-build = "0.13.1"
+pbjson-build = "0.7.0"
+
--- a/objdiff-cli/build.rs
+++ b/objdiff-cli/build.rs
@@ -1,3 +1,5 @@
+use std::path::{Path, PathBuf};
+
 fn main() {
    let output = std::process::Command::new("git")
        .args(["rev-parse", "HEAD"])
@@ -6,4 +8,55 @@ fn main() {
    let rev = String::from_utf8(output.stdout).expect("Failed to parse git output");
    println!("cargo:rustc-env=GIT_COMMIT_SHA={rev}");
    println!("cargo:rustc-rerun-if-changed=.git/HEAD");
+
+    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("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");
 }
--- a/objdiff-cli/protos/proto_descriptor.bin
+++ b/objdiff-cli/protos/proto_descriptor.bin
--- a/objdiff-cli/protos/report.proto
+++ b/objdiff-cli/protos/report.proto
@@ -0,0 +1,135 @@
+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;
+}
+
+// Project progress report
+message Report {
+  // Overall progress info
+  Measures measures = 1;
+  // Units within this report
+  repeated ReportUnit units = 2;
+}
+
+// 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;
+}
+
+// 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;
+}
--- a/objdiff-cli/src/cmd/report.rs
+++ b/objdiff-cli/src/cmd/report.rs
@@ -1,7 +1,8 @@
 use std::{
    collections::HashSet,
    fs::File,
-    io::{BufReader, BufWriter, Write},
+    io::{BufWriter, Read, Write},
+    ops::DerefMut,
    path::{Path, PathBuf},
    time::Instant,
 };
@@ -13,9 +14,15 @@ use objdiff_core::{
    diff, obj,
    obj::{ObjSectionKind, ObjSymbolFlags},
 };
+use prost::Message;
 use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator};
 use tracing::{info, warn};

+use crate::util::report::{
+    ChangeItem, ChangeItemInfo, ChangeUnit, Changes, ChangesInput, Measures, Report, ReportItem,
+    ReportItemMetadata, ReportUnit, ReportUnitMetadata,
+};
+
 #[derive(FromArgs, PartialEq, Debug)]
 /// Commands for processing NVIDIA Shield TV alf files.
 #[argp(subcommand, name = "report")]
@@ -39,11 +46,14 @@ pub struct GenerateArgs {
    /// Project directory
    project: Option<PathBuf>,
    #[argp(option, short = 'o')]
-    /// Output JSON file
+    /// Output file
    output: Option<PathBuf>,
    #[argp(switch, short = 'd')]
    /// Deduplicate global and weak symbols (runs single-threaded)
    deduplicate: bool,
+    #[argp(option, short = 'f')]
+    /// Output format (json or proto, default json)
+    format: Option<String>,
 }

 #[derive(FromArgs, PartialEq, Debug)]
@@ -51,65 +61,17 @@ pub struct GenerateArgs {
 #[argp(subcommand, name = "changes")]
 pub struct ChangesArgs {
    #[argp(positional)]
-    /// Previous report JSON file
+    /// Previous report file
    previous: PathBuf,
    #[argp(positional)]
-    /// Current report JSON file
+    /// Current report file
    current: PathBuf,
    #[argp(option, short = 'o')]
-    /// Output JSON file
+    /// Output file
    output: Option<PathBuf>,
-}
-
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-struct Report {
-    fuzzy_match_percent: f32,
-    total_code: u64,
-    matched_code: u64,
-    matched_code_percent: f32,
-    total_data: u64,
-    matched_data: u64,
-    matched_data_percent: f32,
-    total_functions: u32,
-    matched_functions: u32,
-    matched_functions_percent: f32,
-    units: Vec<ReportUnit>,
-}
-
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-struct ReportUnit {
-    name: String,
-    fuzzy_match_percent: f32,
-    total_code: u64,
-    matched_code: u64,
-    total_data: u64,
-    matched_data: u64,
-    total_functions: u32,
-    matched_functions: u32,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    complete: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    module_name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    module_id: Option<u32>,
-    sections: Vec<ReportItem>,
-    functions: Vec<ReportItem>,
-}
-
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-struct ReportItem {
-    name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    demangled_name: Option<String>,
-    #[serde(
-        default,
-        skip_serializing_if = "Option::is_none",
-        serialize_with = "serialize_hex",
-        deserialize_with = "deserialize_hex"
-    )]
-    address: Option<u64>,
-    size: u64,
-    fuzzy_match_percent: f32,
+    #[argp(option, short = 'f')]
+    /// Output format (json or proto, default json)
+    format: Option<String>,
 }

 pub fn run(args: Args) -> Result<()> {
@@ -119,7 +81,28 @@ pub fn run(args: Args) -> Result<()> {
    }
 }

+enum OutputFormat {
+    Json,
+    Proto,
+}
+
+impl OutputFormat {
+    fn from_str(s: &str) -> Result<Self> {
+        match s {
+            "json" => Ok(Self::Json),
+            "binpb" | "pb" | "proto" | "protobuf" => Ok(Self::Proto),
+            _ => bail!("Invalid output format: {}", s),
+        }
+    }
+}
+
 fn generate(args: GenerateArgs) -> Result<()> {
+    let output_format = if let Some(format) = &args.format {
+        OutputFormat::from_str(format)?
+    } else {
+        OutputFormat::Json
+    };
+
    let project_dir = args.project.as_deref().unwrap_or_else(|| Path::new("."));
    info!("Loading project {}", project_dir.display());

@@ -134,7 +117,7 @@ fn generate(args: GenerateArgs) -> Result<()> {
    );

    let start = Instant::now();
-    let mut report = Report::default();
+    let mut units = vec![];
    let mut existing_functions: HashSet<String> = HashSet::new();
    if args.deduplicate {
        // If deduplicating, we need to run single-threaded
@@ -146,11 +129,11 @@ fn generate(args: GenerateArgs) -> Result<()> {
                project.base_dir.as_deref(),
                Some(&mut existing_functions),
            )? {
-                report.units.push(unit);
+                units.push(unit);
            }
        }
    } else {
-        let units = project
+        let vec = project
            .objects
            .par_iter_mut()
            .map(|object| {
@@ -163,51 +146,52 @@ fn generate(args: GenerateArgs) -> Result<()> {
                )
            })
            .collect::<Result<Vec<Option<ReportUnit>>>>()?;
-        report.units = units.into_iter().flatten().collect();
+        units = vec.into_iter().flatten().collect();
    }
-    for unit in &report.units {
-        report.fuzzy_match_percent += unit.fuzzy_match_percent * unit.total_code as f32;
-        report.total_code += unit.total_code;
-        report.matched_code += unit.matched_code;
-        report.total_data += unit.total_data;
-        report.matched_data += unit.matched_data;
-        report.total_functions += unit.total_functions;
-        report.matched_functions += unit.matched_functions;
-    }
-    if report.total_code == 0 {
-        report.fuzzy_match_percent = 100.0;
-    } else {
-        report.fuzzy_match_percent /= report.total_code as f32;
-    }
-
-    report.matched_code_percent = if report.total_code == 0 {
-        100.0
-    } else {
-        report.matched_code as f32 / report.total_code as f32 * 100.0
-    };
-    report.matched_data_percent = if report.total_data == 0 {
-        100.0
-    } else {
-        report.matched_data as f32 / report.total_data as f32 * 100.0
-    };
-    report.matched_functions_percent = if report.total_functions == 0 {
-        100.0
-    } else {
-        report.matched_functions as f32 / report.total_functions as f32 * 100.0
-    };
+    let measures = units.iter().flat_map(|u| u.measures.into_iter()).collect();
+    let report = Report { measures: Some(measures), units };
    let duration = start.elapsed();
    info!("Report generated in {}.{:03}s", duration.as_secs(), duration.subsec_millis());
-    if let Some(output) = &args.output {
+    write_output(&report, args.output.as_deref(), output_format)?;
+    Ok(())
+}
+
+fn write_output<T>(input: &T, output: Option<&Path>, format: OutputFormat) -> Result<()>
+where T: serde::Serialize + prost::Message {
+    if let Some(output) = output {
        info!("Writing to {}", output.display());
-        let mut output = BufWriter::new(
-            File::create(output)
-                .with_context(|| format!("Failed to create file {}", output.display()))?,
-        );
-        serde_json::to_writer_pretty(&mut output, &report)?;
-        output.flush()?;
+        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_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")?;
+            }
+        }
    } else {
-        serde_json::to_writer_pretty(std::io::stdout(), &report)?;
-    }
+        match format {
+            OutputFormat::Json => {
+                serde_json::to_writer_pretty(std::io::stdout(), input)?;
+            }
+            OutputFormat::Proto => {
+                std::io::stdout().write_all(&input.encode_to_vec())?;
+            }
+        }
+    };
    Ok(())
 }

@@ -246,18 +230,21 @@ fn report_object(
        })
        .transpose()?;
    let result = diff::diff_objs(&config, target.as_ref(), base.as_ref(), None)?;
-    let mut unit = ReportUnit {
-        name: object.name().to_string(),
+
+    let metadata = ReportUnitMetadata {
        complete: object.complete,
        module_name: target
            .as_ref()
            .and_then(|o| o.split_meta.as_ref())
            .and_then(|m| m.module_name.clone()),
        module_id: target.as_ref().and_then(|o| o.split_meta.as_ref()).and_then(|m| m.module_id),
-        ..Default::default()
+        source_path: None, // TODO
    };
-    let obj = target.as_ref().or(base.as_ref()).unwrap();
+    let mut measures = Measures::default();
+    let mut sections = vec![];
+    let mut functions = vec![];

+    let obj = target.as_ref().or(base.as_ref()).unwrap();
    let obj_diff = result.left.as_ref().or(result.right.as_ref()).unwrap();
    for (section, section_diff) in obj.sections.iter().zip(&obj_diff.sections) {
        let section_match_percent = section_diff.match_percent.unwrap_or_else(|| {
@@ -269,19 +256,21 @@ fn report_object(
                0.0
            }
        });
-        unit.sections.push(ReportItem {
+        sections.push(ReportItem {
            name: section.name.clone(),
-            demangled_name: None,
            fuzzy_match_percent: section_match_percent,
            size: section.size,
-            address: section.virtual_address,
+            metadata: Some(ReportItemMetadata {
+                demangled_name: None,
+                virtual_address: section.virtual_address,
+            }),
        });

        match section.kind {
            ObjSectionKind::Data | ObjSectionKind::Bss => {
-                unit.total_data += section.size;
+                measures.total_data += section.size;
                if section_match_percent == 100.0 {
-                    unit.matched_data += section.size;
+                    measures.matched_data += section.size;
                }
                continue;
            }
@@ -309,119 +298,35 @@ fn report_object(
                    0.0
                }
            });
-            unit.fuzzy_match_percent += match_percent * symbol.size as f32;
-            unit.total_code += symbol.size;
+            measures.fuzzy_match_percent += match_percent * symbol.size as f32;
+            measures.total_code += symbol.size;
            if match_percent == 100.0 {
-                unit.matched_code += symbol.size;
+                measures.matched_code += symbol.size;
            }
-            unit.functions.push(ReportItem {
+            functions.push(ReportItem {
                name: symbol.name.clone(),
-                demangled_name: symbol.demangled_name.clone(),
                size: symbol.size,
                fuzzy_match_percent: match_percent,
-                address: symbol.virtual_address,
+                metadata: Some(ReportItemMetadata {
+                    demangled_name: symbol.demangled_name.clone(),
+                    virtual_address: symbol.virtual_address,
+                }),
            });
            if match_percent == 100.0 {
-                unit.matched_functions += 1;
+                measures.matched_functions += 1;
            }
-            unit.total_functions += 1;
+            measures.total_functions += 1;
        }
    }
-    if unit.total_code == 0 {
-        unit.fuzzy_match_percent = 100.0;
-    } else {
-        unit.fuzzy_match_percent /= unit.total_code as f32;
-    }
-    Ok(Some(unit))
-}
-
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-struct Changes {
-    from: ChangeInfo,
-    to: ChangeInfo,
-    units: Vec<ChangeUnit>,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
-struct ChangeInfo {
-    fuzzy_match_percent: f32,
-    total_code: u64,
-    matched_code: u64,
-    matched_code_percent: f32,
-    total_data: u64,
-    matched_data: u64,
-    matched_data_percent: f32,
-    total_functions: u32,
-    matched_functions: u32,
-    matched_functions_percent: f32,
-}
-
-impl From<&Report> for ChangeInfo {
-    fn from(report: &Report) -> Self {
-        Self {
-            fuzzy_match_percent: report.fuzzy_match_percent,
-            total_code: report.total_code,
-            matched_code: report.matched_code,
-            matched_code_percent: report.matched_code_percent,
-            total_data: report.total_data,
-            matched_data: report.matched_data,
-            matched_data_percent: report.matched_data_percent,
-            total_functions: report.total_functions,
-            matched_functions: report.matched_functions,
-            matched_functions_percent: report.matched_functions_percent,
-        }
-    }
-}
-
-impl From<&ReportUnit> for ChangeInfo {
-    fn from(value: &ReportUnit) -> Self {
-        Self {
-            fuzzy_match_percent: value.fuzzy_match_percent,
-            total_code: value.total_code,
-            matched_code: value.matched_code,
-            matched_code_percent: if value.total_code == 0 {
-                100.0
-            } else {
-                value.matched_code as f32 / value.total_code as f32 * 100.0
-            },
-            total_data: value.total_data,
-            matched_data: value.matched_data,
-            matched_data_percent: if value.total_data == 0 {
-                100.0
-            } else {
-                value.matched_data as f32 / value.total_data as f32 * 100.0
-            },
-            total_functions: value.total_functions,
-            matched_functions: value.matched_functions,
-            matched_functions_percent: if value.total_functions == 0 {
-                100.0
-            } else {
-                value.matched_functions as f32 / value.total_functions as f32 * 100.0
-            },
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-struct ChangeUnit {
-    name: String,
-    from: Option<ChangeInfo>,
-    to: Option<ChangeInfo>,
-    sections: Vec<ChangeItem>,
-    functions: Vec<ChangeItem>,
-}
-
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-struct ChangeItem {
-    name: String,
-    from: Option<ChangeItemInfo>,
-    to: Option<ChangeItemInfo>,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
-struct ChangeItemInfo {
-    fuzzy_match_percent: f32,
-    size: u64,
+    measures.calc_fuzzy_match_percent();
+    measures.calc_matched_percent();
+    Ok(Some(ReportUnit {
+        name: object.name().to_string(),
+        measures: Some(measures),
+        sections,
+        functions,
+        metadata: Some(metadata),
+    }))
 }

 impl From<&ReportItem> for ChangeItemInfo {
@@ -431,27 +336,42 @@ impl From<&ReportItem> for ChangeItemInfo {
 }

 fn changes(args: ChangesArgs) -> Result<()> {
-    let previous = read_report(&args.previous)?;
-    let current = read_report(&args.current)?;
-    let mut changes = Changes {
-        from: ChangeInfo::from(&previous),
-        to: ChangeInfo::from(&current),
-        units: vec![],
+    let output_format = if let Some(format) = &args.format {
+        OutputFormat::from_str(format)?
+    } else {
+        OutputFormat::Json
    };
+
+    let (previous, current) = if args.previous == Path::new("-") && args.current == Path::new("-") {
+        // Special case for comparing two reports from stdin
+        let mut data = vec![];
+        std::io::stdin().read_to_end(&mut data)?;
+        let input = ChangesInput::decode(data.as_slice())?;
+        (input.from.unwrap(), input.to.unwrap())
+    } else {
+        let previous = read_report(&args.previous)?;
+        let current = read_report(&args.current)?;
+        (previous, current)
+    };
+    let mut changes = Changes { from: previous.measures, to: current.measures, units: vec![] };
    for prev_unit in &previous.units {
        let curr_unit = current.units.iter().find(|u| u.name == prev_unit.name);
        let sections = process_items(prev_unit, curr_unit, |u| &u.sections);
        let functions = process_items(prev_unit, curr_unit, |u| &u.functions);

-        let prev_unit_info = ChangeInfo::from(prev_unit);
-        let curr_unit_info = curr_unit.map(ChangeInfo::from);
-        if !functions.is_empty() || !matches!(&curr_unit_info, Some(v) if v == &prev_unit_info) {
+        let prev_measures = prev_unit.measures;
+        let curr_measures = curr_unit.and_then(|u| u.measures);
+        if !functions.is_empty() || prev_measures != curr_measures {
            changes.units.push(ChangeUnit {
                name: prev_unit.name.clone(),
-                from: Some(prev_unit_info),
-                to: curr_unit_info,
+                from: prev_measures,
+                to: curr_measures,
                sections,
                functions,
+                metadata: curr_unit
+                    .as_ref()
+                    .and_then(|u| u.metadata.clone())
+                    .or_else(|| prev_unit.metadata.clone()),
            });
        }
    }
@@ -460,23 +380,14 @@ fn changes(args: ChangesArgs) -> Result<()> {
            changes.units.push(ChangeUnit {
                name: curr_unit.name.clone(),
                from: None,
-                to: Some(ChangeInfo::from(curr_unit)),
+                to: curr_unit.measures,
                sections: process_new_items(&curr_unit.sections),
                functions: process_new_items(&curr_unit.functions),
+                metadata: curr_unit.metadata.clone(),
            });
        }
    }
-    if let Some(output) = &args.output {
-        info!("Writing to {}", output.display());
-        let mut output = BufWriter::new(
-            File::create(output)
-                .with_context(|| format!("Failed to create file {}", output.display()))?,
-        );
-        serde_json::to_writer_pretty(&mut output, &changes)?;
-        output.flush()?;
-    } else {
-        serde_json::to_writer_pretty(std::io::stdout(), &changes)?;
-    }
+    write_output(&changes, args.output.as_deref(), output_format)?;
    Ok(())
 }

@@ -499,6 +410,7 @@ fn process_items<F: Fn(&ReportUnit) -> &Vec<ReportItem>>(
                        name: prev_func.name.clone(),
                        from: Some(prev_func_info),
                        to: Some(curr_func_info),
+                        metadata: curr_func.as_ref().unwrap().metadata.clone(),
                    });
                }
            } else {
@@ -506,6 +418,7 @@ fn process_items<F: Fn(&ReportUnit) -> &Vec<ReportItem>>(
                    name: prev_func.name.clone(),
                    from: Some(prev_func_info),
                    to: None,
+                    metadata: prev_func.metadata.clone(),
                });
            }
        }
@@ -515,6 +428,7 @@ fn process_items<F: Fn(&ReportUnit) -> &Vec<ReportItem>>(
                    name: curr_func.name.clone(),
                    from: None,
                    to: Some(ChangeItemInfo::from(curr_func)),
+                    metadata: curr_func.metadata.clone(),
                });
            }
        }
@@ -524,6 +438,7 @@ fn process_items<F: Fn(&ReportUnit) -> &Vec<ReportItem>>(
                name: prev_func.name.clone(),
                from: Some(ChangeItemInfo::from(prev_func)),
                to: None,
+                metadata: prev_func.metadata.clone(),
            });
        }
    }
@@ -533,35 +448,24 @@ fn process_items<F: Fn(&ReportUnit) -> &Vec<ReportItem>>(
 fn process_new_items(items: &[ReportItem]) -> Vec<ChangeItem> {
    items
        .iter()
-        .map(|f| ChangeItem { name: f.name.clone(), from: None, to: Some(ChangeItemInfo::from(f)) })
+        .map(|item| ChangeItem {
+            name: item.name.clone(),
+            from: None,
+            to: Some(ChangeItemInfo::from(item)),
+            metadata: item.metadata.clone(),
+        })
        .collect()
 }

 fn read_report(path: &Path) -> Result<Report> {
-    serde_json::from_reader(BufReader::new(
-        File::open(path).with_context(|| format!("Failed to open {}", path.display()))?,
-    ))
-    .with_context(|| format!("Failed to read report {}", path.display()))
-}
-
-fn serialize_hex<S>(x: &Option<u64>, s: S) -> Result<S::Ok, S::Error>
-where S: serde::Serializer {
-    if let Some(x) = x {
-        s.serialize_str(&format!("{:#x}", x))
-    } else {
-        s.serialize_none()
-    }
-}
-
-fn deserialize_hex<'de, D>(d: D) -> Result<Option<u64>, D::Error>
-where D: serde::Deserializer<'de> {
-    use serde::Deserialize;
-    let s = String::deserialize(d)?;
-    if s.is_empty() {
-        Ok(None)
-    } else if !s.starts_with("0x") {
-        Err(serde::de::Error::custom("expected hex string"))
-    } else {
-        u64::from_str_radix(&s[2..], 16).map(Some).map_err(serde::de::Error::custom)
+    if path == Path::new("-") {
+        let mut data = vec![];
+        std::io::stdin().read_to_end(&mut data)?;
+        return Report::parse(&data).with_context(|| "Failed to load report from stdin");
    }
+    let file = File::open(path).with_context(|| format!("Failed to open {}", path.display()))?;
+    let mmap = unsafe { memmap2::Mmap::map(&file) }
+        .with_context(|| format!("Failed to map {}", path.display()))?;
+    Report::parse(mmap.as_ref())
+        .with_context(|| format!("Failed to load report {}", path.display()))
 }
--- a/objdiff-cli/src/main.rs
+++ b/objdiff-cli/src/main.rs
@@ -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)
    };

--- a/objdiff-cli/src/util/mod.rs
+++ b/objdiff-cli/src/util/mod.rs
@@ -1 +1,2 @@
+pub mod report;
 pub mod term;
--- a/objdiff-cli/src/util/report.rs
+++ b/objdiff-cli/src/util/report.rs
@@ -0,0 +1,226 @@
+use anyhow::{bail, Result};
+use prost::Message;
+use serde_json::error::Category;
+
+// Protobuf report types
+include!(concat!(env!("OUT_DIR"), "/objdiff.report.rs"));
+include!(concat!(env!("OUT_DIR"), "/objdiff.report.serde.rs"));
+
+impl Report {
+    pub fn parse(data: &[u8]) -> Result<Self> {
+        if data.is_empty() {
+            bail!(std::io::Error::from(std::io::ErrorKind::UnexpectedEof));
+        }
+        if data[0] == b'{' {
+            // Load as JSON
+            Self::from_json(data).map_err(anyhow::Error::new)
+        } else {
+            // Load as binary protobuf
+            Self::decode(data).map_err(anyhow::Error::new)
+        }
+    }
+
+    fn from_json(bytes: &[u8]) -> Result<Self, serde_json::Error> {
+        match serde_json::from_slice::<Self>(bytes) {
+            Ok(report) => Ok(report),
+            Err(e) => {
+                match e.classify() {
+                    Category::Io | Category::Eof | Category::Syntax => Err(e),
+                    Category::Data => {
+                        // Try to load as legacy report
+                        match serde_json::from_slice::<LegacyReport>(bytes) {
+                            Ok(legacy_report) => Ok(Report::from(legacy_report)),
+                            Err(_) => Err(e),
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl Measures {
+    /// Average the fuzzy match percentage over total code bytes.
+    pub fn calc_fuzzy_match_percent(&mut self) {
+        if self.total_code == 0 {
+            self.fuzzy_match_percent = 100.0;
+        } else {
+            self.fuzzy_match_percent /= self.total_code as f32;
+        }
+    }
+
+    /// Calculate the percentage of matched code, data, and functions.
+    pub fn calc_matched_percent(&mut self) {
+        self.matched_code_percent = if self.total_code == 0 {
+            100.0
+        } else {
+            self.matched_code as f32 / self.total_code as f32 * 100.0
+        };
+        self.matched_data_percent = if self.total_data == 0 {
+            100.0
+        } else {
+            self.matched_data as f32 / self.total_data as f32 * 100.0
+        };
+        self.matched_functions_percent = if self.total_functions == 0 {
+            100.0
+        } else {
+            self.matched_functions as f32 / self.total_functions as f32 * 100.0
+        };
+    }
+}
+
+/// Allows [collect](Iterator::collect) to be used on an iterator of [Measures].
+impl FromIterator<Measures> for Measures {
+    fn from_iter<T>(iter: T) -> Self
+    where T: IntoIterator<Item = Measures> {
+        let mut measures = Measures::default();
+        for other in iter {
+            measures.fuzzy_match_percent += other.fuzzy_match_percent * other.total_code as f32;
+            measures.total_code += other.total_code;
+            measures.matched_code += other.matched_code;
+            measures.total_data += other.total_data;
+            measures.matched_data += other.matched_data;
+            measures.total_functions += other.total_functions;
+            measures.matched_functions += other.matched_functions;
+        }
+        measures.calc_fuzzy_match_percent();
+        measures.calc_matched_percent();
+        measures
+    }
+}
+
+// Older JSON report types
+#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
+struct LegacyReport {
+    fuzzy_match_percent: f32,
+    total_code: u64,
+    matched_code: u64,
+    matched_code_percent: f32,
+    total_data: u64,
+    matched_data: u64,
+    matched_data_percent: f32,
+    total_functions: u32,
+    matched_functions: u32,
+    matched_functions_percent: f32,
+    units: Vec<LegacyReportUnit>,
+}
+
+impl From<LegacyReport> for Report {
+    fn from(value: LegacyReport) -> Self {
+        Self {
+            measures: Some(Measures {
+                fuzzy_match_percent: value.fuzzy_match_percent,
+                total_code: value.total_code,
+                matched_code: value.matched_code,
+                matched_code_percent: value.matched_code_percent,
+                total_data: value.total_data,
+                matched_data: value.matched_data,
+                matched_data_percent: value.matched_data_percent,
+                total_functions: value.total_functions,
+                matched_functions: value.matched_functions,
+                matched_functions_percent: value.matched_functions_percent,
+            }),
+            units: value.units.into_iter().map(ReportUnit::from).collect(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
+struct LegacyReportUnit {
+    name: String,
+    fuzzy_match_percent: f32,
+    total_code: u64,
+    matched_code: u64,
+    total_data: u64,
+    matched_data: u64,
+    total_functions: u32,
+    matched_functions: u32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    complete: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    module_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    module_id: Option<u32>,
+    sections: Vec<LegacyReportItem>,
+    functions: Vec<LegacyReportItem>,
+}
+
+impl From<LegacyReportUnit> for ReportUnit {
+    fn from(value: LegacyReportUnit) -> Self {
+        let mut measures = Measures {
+            fuzzy_match_percent: value.fuzzy_match_percent,
+            total_code: value.total_code,
+            matched_code: value.matched_code,
+            total_data: value.total_data,
+            matched_data: value.matched_data,
+            total_functions: value.total_functions,
+            matched_functions: value.matched_functions,
+            ..Default::default()
+        };
+        measures.calc_matched_percent();
+        Self {
+            name: value.name.clone(),
+            measures: Some(measures),
+            sections: value.sections.into_iter().map(ReportItem::from).collect(),
+            functions: value.functions.into_iter().map(ReportItem::from).collect(),
+            metadata: Some(ReportUnitMetadata {
+                complete: value.complete,
+                module_name: value.module_name.clone(),
+                module_id: value.module_id,
+                ..Default::default()
+            }),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
+struct LegacyReportItem {
+    name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    demangled_name: Option<String>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        serialize_with = "serialize_hex",
+        deserialize_with = "deserialize_hex"
+    )]
+    address: Option<u64>,
+    size: u64,
+    fuzzy_match_percent: f32,
+}
+
+impl From<LegacyReportItem> for ReportItem {
+    fn from(value: LegacyReportItem) -> Self {
+        Self {
+            name: value.name,
+            size: value.size,
+            fuzzy_match_percent: value.fuzzy_match_percent,
+            metadata: Some(ReportItemMetadata {
+                demangled_name: value.demangled_name,
+                virtual_address: value.address,
+            }),
+        }
+    }
+}
+
+fn serialize_hex<S>(x: &Option<u64>, s: S) -> Result<S::Ok, S::Error>
+where S: serde::Serializer {
+    if let Some(x) = x {
+        s.serialize_str(&format!("{:#x}", x))
+    } else {
+        s.serialize_none()
+    }
+}
+
+fn deserialize_hex<'de, D>(d: D) -> Result<Option<u64>, D::Error>
+where D: serde::Deserializer<'de> {
+    use serde::Deserialize;
+    let s = String::deserialize(d)?;
+    if s.is_empty() {
+        Ok(None)
+    } else if !s.starts_with("0x") {
+        Err(serde::de::Error::custom("expected hex string"))
+    } else {
+        u64::from_str_radix(&s[2..], 16).map(Some).map_err(serde::de::Error::custom)
+    }
+}
--- a/objdiff-core/Cargo.toml
+++ b/objdiff-core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "objdiff-core"
-version = "2.0.0-beta.3"
+version = "2.0.0-beta.4"
 edition = "2021"
 rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]
--- a/objdiff-core/src/arch/mips.rs
+++ b/objdiff-core/src/arch/mips.rs
@@ -34,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;
@@ -169,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(),
@@ -205,13 +219,14 @@ 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,
            } => (addend & 0x0000FFFF) as i16 as i64,
-            RelocationFlags::Elf { r_type: elf::R_MIPS_GPREL16 } => {
+            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");
                };
@@ -225,8 +240,8 @@ impl ObjArch for ObjArchMips {
                    (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_PC16 } => 0, // PC-relative relocation
+            RelocationFlags::Elf { r_type: R_MIPS15_S3 } => ((addend & 0x001FFFC0) >> 3) as i64,
            flags => bail!("Unsupported MIPS implicit relocation {flags:?}"),
        })
    }
@@ -234,14 +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_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"),
-                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"),
+                R_MIPS15_S3 => Cow::Borrowed("R_MIPS15_S3"),
                _ => Cow::Owned(format!("<{flags:?}>")),
            },
            _ => Cow::Owned(format!("<{flags:?}>")),
@@ -277,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_PC16 => {
+            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}"),
--- a/objdiff-core/src/obj/read.rs
+++ b/objdiff-core/src/obj/read.rs
@@ -1,7 +1,6 @@
 use std::{collections::HashSet, fs, io::Cursor, path::Path};

 use anyhow::{anyhow, bail, ensure, Context, Result};
-use byteorder::{BigEndian, ReadBytesExt};
 use cwextab::decode_extab;
 use filetime::FileTime;
 use flagset::Flags;
@@ -18,6 +17,7 @@ use crate::{
        ObjExtab, ObjInfo, ObjReloc, ObjSection, ObjSectionKind, ObjSymbol, ObjSymbolFlagSet,
        ObjSymbolFlags,
    },
+    util::{read_u16, read_u32},
 };

 fn to_obj_section_kind(kind: SectionKind) -> Option<ObjSectionKind> {
@@ -415,8 +415,8 @@ fn line_info(obj_file: &File<'_>, sections: &mut [ObjSection]) -> Result<()> {
                .index()
                .0;
            let start = reader.position();
-            let size = reader.read_u32::<BigEndian>()?;
-            let base_address = reader.read_u32::<BigEndian>()? as u64;
+            let size = read_u32(obj_file, &mut reader)?;
+            let base_address = read_u32(obj_file, &mut reader)? as u64;
            let Some(out_section) =
                sections.iter_mut().find(|s| s.orig_index == text_section_index)
            else {
@@ -426,12 +426,12 @@ fn line_info(obj_file: &File<'_>, sections: &mut [ObjSection]) -> Result<()> {
            };
            let end = start + size as u64;
            while reader.position() < end {
-                let line_number = reader.read_u32::<BigEndian>()? as u64;
-                let statement_pos = reader.read_u16::<BigEndian>()?;
+                let line_number = read_u32(obj_file, &mut reader)? as u64;
+                let statement_pos = read_u16(obj_file, &mut reader)?;
                if statement_pos != 0xFFFF {
                    log::warn!("Unhandled statement pos {}", statement_pos);
                }
-                let address_delta = reader.read_u32::<BigEndian>()? as u64;
+                let address_delta = read_u32(obj_file, &mut reader)? as u64;
                out_section.line_info.insert(base_address + address_delta, line_number);
                log::debug!("Line: {:#x} -> {}", base_address + address_delta, line_number);
            }
--- a/objdiff-core/src/util.rs
+++ b/objdiff-core/src/util.rs
@@ -1,6 +1,12 @@
-use std::fmt::{LowerHex, UpperHex};
+use std::{
+    fmt::{LowerHex, UpperHex},
+    io::Read,
+};

+use anyhow::Result;
+use byteorder::{NativeEndian, ReadBytesExt};
 use num_traits::PrimInt;
+use object::{Endian, Object};

 // https://stackoverflow.com/questions/44711012/how-do-i-format-a-signed-integer-to-a-sign-aware-hexadecimal-representation
 pub(crate) struct ReallySigned<N: PrimInt>(pub(crate) N);
@@ -22,3 +28,11 @@ impl<N: PrimInt> UpperHex for ReallySigned<N> {
        f.pad_integral(num >= 0, prefix, &bare_hex)
    }
 }
+
+pub fn read_u32<R: Read>(obj_file: &object::File, reader: &mut R) -> Result<u32> {
+    Ok(obj_file.endianness().read_u32(reader.read_u32::<NativeEndian>()?))
+}
+
+pub fn read_u16<R: Read>(obj_file: &object::File, reader: &mut R) -> Result<u16> {
+    Ok(obj_file.endianness().read_u16(reader.read_u16::<NativeEndian>()?))
+}
--- a/objdiff-gui/Cargo.toml
+++ b/objdiff-gui/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "objdiff-gui"
-version = "2.0.0-beta.3"
+version = "2.0.0-beta.4"
 edition = "2021"
 rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]
Author	SHA1	Message	Date
Luke Street	8250d26b77	Support R_MIPS_LITERAL, R_MIPS15_S3 relocations Resolves #92 Resolves #95	2024-08-18 22:05:16 -06:00
Luke Street	fd555a6e0f	Fix reading little-endian `.line` section	2024-08-18 21:57:53 -06:00
Luke Street	3710b6a91e	Try even harder to recover from protoc missing	2024-08-18 14:01:49 -06:00
Luke Street	faebddbc5e	More updates to report types	2024-08-18 13:42:41 -06:00
Luke Street	a733a950a3	Avoid requiring protoc unless protos change	2024-08-18 13:40:49 -06:00
Luke Street	cad9b70632	Support protobuf format for reports This migrates to using protobuf to define the "report" and "changes" formats in objdiff-cli. The JSON output now uses the Proto3 "JSON Mapping", which is slightly incompatible with the existing JSON format. Mainly, 64-bit numbers are represented as strings, and addresses are decimal strings instead of hex. However, the older JSON format is still accepted by "report changes" to ease migration.	2024-08-16 00:52:24 -06:00