Merge 6f05b6b964 into 7aa878b48e

Co-authored-by: Luke Street <luke@street.dev>

.gitignore

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

Cargo.toml

@@ -13,7 +13,7 @@ strip = "debuginfo"
 codegen-units = 1
 
 [workspace.package]
-version = "2.3.4"
+version = "2.4.0"
 authors = ["Luke Street <luke@street.dev>"]
 edition = "2021"
 license = "MIT OR Apache-2.0"

README.md

@@ -20,6 +20,7 @@ Supports:
 - MIPS (N64, PS1, PS2, PSP)
 - x86 (COFF only at the moment)
 - ARM (GBA, DS, 3DS)
+- ARM64 (Switch, experimental)
 
 See [Usage](#usage) for more information.
 

deny.toml

@@ -73,6 +73,7 @@ ignore = [
     #{ id = "RUSTSEC-0000-0000", reason = "you can specify a reason the advisory is ignored" },
     #"a-crate-that-is-yanked@0.1.1", # you can also ignore yanked crate versions if you wish
     #{ crate = "a-crate-that-is-yanked@0.1.1", reason = "you can specify why you are ignoring the yanked crate" },
+    { id = "RUSTSEC-2024-0384", reason = "Unmaintained indirect dependency" },
 ]
 # If this is true, then cargo deny will use the git executable to fetch advisory database.
 # If this is false, then it uses a built-in git library.
@@ -97,7 +98,7 @@ allow = [
     "BSL-1.0",
     "CC0-1.0",
     "MPL-2.0",
-    "Unicode-DFS-2016",
+    "Unicode-3.0",
     "Zlib",
     "0BSD",
     "OFL-1.1",

objdiff-cli/Cargo.toml

@@ -20,7 +20,7 @@ enable-ansi-support = "0.2"
 memmap2 = "0.9"
 objdiff-core = { path = "../objdiff-core", features = ["all"] }
 prost = "0.13"
-ratatui = "0.28"
+ratatui = "0.29"
 rayon = "1.10"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

objdiff-cli/src/cmd/diff.rs

@@ -844,11 +844,15 @@ impl FunctionDiffUi {
                             base_color = COLOR_ROTATION[diff.idx % COLOR_ROTATION.len()]
                         }
                     }
-                    DiffText::Symbol(sym) => {
+                    DiffText::Symbol(sym, diff) => {
                         let name = sym.demangled_name.as_ref().unwrap_or(&sym.name);
                         label_text = name.clone();
+                        if let Some(diff) = diff {
+                            base_color = COLOR_ROTATION[diff.idx % COLOR_ROTATION.len()]
+                        } else {
                             base_color = Color::White;
                         }
+                    }
                     DiffText::Spacing(n) => {
                         line.spans.push(Span::raw(" ".repeat(n)));
                         sx += n as u16;

objdiff-core/Cargo.toml

@@ -16,7 +16,7 @@ documentation = "https://docs.rs/objdiff-core"
 crate-type = ["cdylib", "rlib"]
 
 [features]
-all = ["config", "dwarf", "mips", "ppc", "x86", "arm", "bindings"]
+all = ["config", "dwarf", "mips", "ppc", "x86", "arm", "arm64", "bindings"]
 any-arch = ["config", "dep:bimap", "dep:strum", "dep:similar", "dep:flagset", "dep:log", "dep:memmap2", "dep:byteorder", "dep:num-traits"] # Implicit, used to check if any arch is enabled
 config = ["dep:bimap", "dep:globset", "dep:semver", "dep:serde_json", "dep:serde_yaml", "dep:serde", "dep:filetime"]
 dwarf = ["dep:gimli"]
@@ -24,6 +24,7 @@ mips = ["any-arch", "dep:rabbitizer"]
 ppc = ["any-arch", "dep:cwdemangle", "dep:cwextab", "dep:ppc750cl"]
 x86 = ["any-arch", "dep:cpp_demangle", "dep:iced-x86", "dep:msvc-demangler"]
 arm = ["any-arch", "dep:cpp_demangle", "dep:unarm", "dep:arm-attr"]
+arm64 = ["any-arch", "dep:cpp_demangle", "dep:yaxpeax-arch", "dep:yaxpeax-arm"]
 bindings = ["dep:serde_json", "dep:prost", "dep:pbjson", "dep:serde", "dep:prost-build", "dep:pbjson-build"]
 wasm = ["bindings", "any-arch", "dep:console_error_panic_hook", "dep:console_log", "dep:wasm-bindgen", "dep:tsify-next", "dep:log"]
 
@@ -76,6 +77,10 @@ msvc-demangler = { version = "0.10", optional = true }
 unarm = { version = "1.6", optional = true }
 arm-attr = { version = "0.1", optional = true }
 
+# arm64
+yaxpeax-arch = { version = "0.3", default-features = false, features = ["std"], optional = true }
+yaxpeax-arm = { version = "0.3", default-features = false, features = ["std"], optional = true }
+
 [build-dependencies]
 prost-build = { version = "0.13", optional = true }
 pbjson-build = { version = "0.7", optional = true }

objdiff-core/README.md

@@ -11,4 +11,5 @@ objdiff-core contains the core functionality of [objdiff](https://github.com/enc
 - **`ppc`**: Enables the PowerPC backend powered by [ppc750cl](https://github.com/encounter/ppc750cl).
 - **`x86`**: Enables the x86 backend powered by [iced-x86](https://crates.io/crates/iced-x86).
 - **`arm`**: Enables the ARM backend powered by [unarm](https://github.com/AetiasHax/unarm).
+- **`arm64`**: Enables the ARM64 backend powered by [yaxpeax-arm](https://github.com/iximeow/yaxpeax-arm).
 - **`bindings`**: Enables serialization and deserialization of objdiff data structures.

objdiff-core/src/arch/arm.rs

@@ -124,11 +124,9 @@ impl ObjArch for ObjArchArm {
             .get(&SectionIndex(section_index))
             .map(|x| x.as_slice())
             .unwrap_or(&fallback_mappings);
-        let first_mapping_idx =
-            match mapping_symbols.binary_search_by_key(&start_addr, |x| x.address) {
-                Ok(idx) => idx,
-                Err(idx) => idx - 1,
-            };
+        let first_mapping_idx = mapping_symbols
+            .binary_search_by_key(&start_addr, |x| x.address)
+            .unwrap_or_else(|idx| idx - 1);
         let first_mapping = mapping_symbols[first_mapping_idx].mapping;
 
         let mut mappings_iter =
@@ -215,7 +213,7 @@ impl ObjArch for ObjArchArm {
                 address: address as u64,
                 size: (parser.address - address) as u8,
                 op: ins.opcode_id(),
-                mnemonic: parsed_ins.mnemonic.to_string(),
+                mnemonic: Cow::Borrowed(parsed_ins.mnemonic),
                 args,
                 reloc,
                 branch_dest,
@@ -234,7 +232,7 @@ impl ObjArch for ObjArchArm {
         section: &ObjSection,
         address: u64,
         reloc: &Relocation,
-    ) -> anyhow::Result<i64> {
+    ) -> Result<i64> {
         let address = address as usize;
         Ok(match reloc.flags() {
             // ARM calls

objdiff-core/src/arch/mips.rs

@@ -119,7 +119,7 @@ impl ObjArch for ObjArchMips {
             let op = instruction.unique_id as u16;
             ops.push(op);
 
-            let mnemonic = instruction.opcode_name().to_string();
+            let mnemonic = instruction.opcode_name();
             let is_branch = instruction.is_branch();
             let branch_offset = instruction.branch_offset();
             let mut branch_dest = if is_branch {
@@ -202,7 +202,7 @@ impl ObjArch for ObjArchMips {
                 address: cur_addr as u64,
                 size: 4,
                 op,
-                mnemonic,
+                mnemonic: Cow::Borrowed(mnemonic),
                 args,
                 reloc: reloc.cloned(),
                 branch_dest,

objdiff-core/src/arch/mod.rs

@@ -12,6 +12,8 @@ use crate::{
 
 #[cfg(feature = "arm")]
 mod arm;
+#[cfg(feature = "arm64")]
+mod arm64;
 #[cfg(feature = "mips")]
 pub mod mips;
 #[cfg(feature = "ppc")]
@@ -165,6 +167,8 @@ pub fn new_arch(object: &File) -> Result<Box<dyn ObjArch>> {
         Architecture::I386 | Architecture::X86_64 => Box::new(x86::ObjArchX86::new(object)?),
         #[cfg(feature = "arm")]
         Architecture::Arm => Box::new(arm::ObjArchArm::new(object)?),
+        #[cfg(feature = "arm64")]
+        Architecture::Aarch64 => Box::new(arm64::ObjArchArm64::new(object)?),
         arch => bail!("Unsupported architecture: {arch:?}"),
     })
 }

objdiff-core/src/arch/ppc.rs

@@ -143,7 +143,7 @@ impl ObjArch for ObjArchPpc {
             insts.push(ObjIns {
                 address: cur_addr as u64,
                 size: 4,
-                mnemonic: simplified.mnemonic.to_string(),
+                mnemonic: Cow::Borrowed(simplified.mnemonic),
                 args,
                 reloc: reloc.cloned(),
                 op: ins.op as u16,

objdiff-core/src/arch/x86.rs

@@ -51,7 +51,7 @@ impl ObjArch for ObjArchX86 {
                 address: 0,
                 size: 0,
                 op: 0,
-                mnemonic: String::new(),
+                mnemonic: Cow::Borrowed("<invalid>"),
                 args: vec![],
                 reloc: None,
                 branch_dest: None,
@@ -76,7 +76,7 @@ impl ObjArch for ObjArchX86 {
                 address,
                 size: instruction.len() as u8,
                 op,
-                mnemonic: String::new(),
+                mnemonic: Cow::Borrowed("<invalid>"),
                 args: vec![],
                 reloc: reloc.cloned(),
                 branch_dest: None,
@@ -242,7 +242,8 @@ impl FormatterOutput for InstructionFormatterOutput {
 
     fn write_mnemonic(&mut self, _instruction: &Instruction, text: &str) {
         self.formatted.push_str(text);
-        self.ins.mnemonic = text.to_string();
+        // TODO: can iced-x86 guarantee 'static here?
+        self.ins.mnemonic = Cow::Owned(text.to_string());
     }
 
     fn write_number(

objdiff-core/src/bindings/diff.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::needless_lifetimes)] // Generated serde code
 use crate::{
     diff::{
         ObjDataDiff, ObjDataDiffKind, ObjDiff, ObjInsArgDiff, ObjInsBranchFrom, ObjInsBranchTo,
@@ -132,7 +133,7 @@ impl Instruction {
             address: instruction.address,
             size: instruction.size as u32,
             opcode: instruction.op as u32,
-            mnemonic: instruction.mnemonic.clone(),
+            mnemonic: instruction.mnemonic.to_string(),
             formatted: instruction.formatted.clone(),
             arguments: instruction.args.iter().map(Argument::new).collect(),
             relocation: instruction.reloc.as_ref().map(|reloc| Relocation::new(object, reloc)),

objdiff-core/src/bindings/report.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::needless_lifetimes)] // Generated serde code
 use std::ops::AddAssign;
 
 use anyhow::{bail, Result};
@@ -173,8 +174,7 @@ impl Report {
                 continue;
             }
             fn is_sub_category(id: &str, parent: &str, sep: char) -> bool {
-                id.starts_with(parent)
-                    && id.get(parent.len()..).map_or(false, |s| s.starts_with(sep))
+                id.starts_with(parent) && id.get(parent.len()..).is_some_and(|s| s.starts_with(sep))
             }
             let mut sub_categories = self
                 .categories

objdiff-core/src/config/mod.rs

@@ -165,6 +165,8 @@ pub struct ScratchConfig {
     pub ctx_path: Option<PathBuf>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub build_ctx: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub preset_id: Option<u32>,
 }
 
 pub const CONFIG_FILENAMES: [&str; 3] = ["objdiff.json", "objdiff.yml", "objdiff.yaml"];

objdiff-core/src/diff/code.rs

@@ -259,11 +259,17 @@ fn arg_eq(
                     right_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
                 )
         }
-        ObjInsArg::BranchDest(_) => {
+        ObjInsArg::BranchDest(_) => match right {
             // Compare dest instruction idx after diffing
+            ObjInsArg::BranchDest(_) => {
                 left_diff.branch_to.as_ref().map(|b| b.ins_idx)
                     == right_diff.branch_to.as_ref().map(|b| b.ins_idx)
             }
+            // If relocations are relaxed, match if left is a constant and right is a reloc
+            // Useful for instances where the target object is created without relocations
+            ObjInsArg::Reloc => config.relax_reloc_diffs,
+            _ => false,
+        },
     }
 }
 
@@ -293,15 +299,10 @@ fn compare_ins(
 ) -> Result<InsDiffResult> {
     let mut result = InsDiffResult::default();
     if let (Some(left_ins), Some(right_ins)) = (&left.ins, &right.ins) {
-        if left_ins.args.len() != right_ins.args.len()
-            || left_ins.op != right_ins.op
-            // Check if any PlainText segments differ (punctuation and spacing)
-            // This indicates a more significant difference than a simple arg mismatch
-            || !left_ins.args.iter().zip(&right_ins.args).all(|(a, b)| match (a, b) {
-                (ObjInsArg::PlainText(l), ObjInsArg::PlainText(r)) => l == r,
-                _ => true,
-            })
-        {
+        // Count only non-PlainText args
+        let left_args_count = left_ins.iter_args().count();
+        let right_args_count = right_ins.iter_args().count();
+        if left_args_count != right_args_count || left_ins.op != right_ins.op {
             // Totally different op
             result.kind = ObjInsDiffKind::Replace;
             state.diff_count += 1;
@@ -312,7 +313,7 @@ fn compare_ins(
             result.kind = ObjInsDiffKind::OpMismatch;
             state.diff_count += 1;
         }
-        for (a, b) in left_ins.args.iter().zip(&right_ins.args) {
+        for (a, b) in left_ins.iter_args().zip(right_ins.iter_args()) {
             if arg_eq(config, left_obj, right_obj, a, b, left, right) {
                 result.left_args_diff.push(None);
                 result.right_args_diff.push(None);
@@ -324,8 +325,11 @@ fn compare_ins(
                 let a_str = match a {
                     ObjInsArg::PlainText(arg) => arg.to_string(),
                     ObjInsArg::Arg(arg) => arg.to_string(),
-                    ObjInsArg::Reloc => String::new(),
-                    ObjInsArg::BranchDest(arg) => format!("{arg}"),
+                    ObjInsArg::Reloc => left_ins
+                        .reloc
+                        .as_ref()
+                        .map_or_else(|| "<unknown>".to_string(), |r| r.target.name.clone()),
+                    ObjInsArg::BranchDest(arg) => arg.to_string(),
                 };
                 let a_diff = if let Some(idx) = state.left_args_idx.get(&a_str) {
                     ObjInsArgDiff { idx: *idx }
@@ -338,8 +342,11 @@ fn compare_ins(
                 let b_str = match b {
                     ObjInsArg::PlainText(arg) => arg.to_string(),
                     ObjInsArg::Arg(arg) => arg.to_string(),
-                    ObjInsArg::Reloc => String::new(),
-                    ObjInsArg::BranchDest(arg) => format!("{arg}"),
+                    ObjInsArg::Reloc => right_ins
+                        .reloc
+                        .as_ref()
+                        .map_or_else(|| "<unknown>".to_string(), |r| r.target.name.clone()),
+                    ObjInsArg::BranchDest(arg) => arg.to_string(),
                 };
                 let b_diff = if let Some(idx) = state.right_args_idx.get(&b_str) {
                     ObjInsArgDiff { idx: *idx }

objdiff-core/src/diff/display.rs

@@ -22,7 +22,7 @@ pub enum DiffText<'a> {
     /// Branch destination
     BranchDest(u64, Option<&'a ObjInsArgDiff>),
     /// Symbol name
-    Symbol(&'a ObjSymbol),
+    Symbol(&'a ObjSymbol, Option<&'a ObjInsArgDiff>),
     /// Number of spaces
     Spacing(usize),
     /// End of line
@@ -58,20 +58,23 @@ pub fn display_diff<E>(
         cb(DiffText::Spacing(4))?;
     }
     cb(DiffText::Opcode(&ins.mnemonic, ins.op))?;
+    let mut arg_diff_idx = 0; // non-PlainText index
     for (i, arg) in ins.args.iter().enumerate() {
         if i == 0 {
             cb(DiffText::Spacing(1))?;
         }
-        let diff = ins_diff.arg_diff.get(i).and_then(|o| o.as_ref());
+        let diff = ins_diff.arg_diff.get(arg_diff_idx).and_then(|o| o.as_ref());
         match arg {
             ObjInsArg::PlainText(s) => {
                 cb(DiffText::Basic(s))?;
             }
             ObjInsArg::Arg(v) => {
                 cb(DiffText::Argument(v, diff))?;
+                arg_diff_idx += 1;
             }
             ObjInsArg::Reloc => {
-                display_reloc_name(ins.reloc.as_ref().unwrap(), &mut cb)?;
+                display_reloc_name(ins.reloc.as_ref().unwrap(), &mut cb, diff)?;
+                arg_diff_idx += 1;
             }
             ObjInsArg::BranchDest(dest) => {
                 if let Some(dest) = dest.checked_sub(base_addr) {
@@ -79,6 +82,7 @@ pub fn display_diff<E>(
                 } else {
                     cb(DiffText::Basic("<unknown>"))?;
                 }
+                arg_diff_idx += 1;
             }
         }
     }
@@ -92,8 +96,9 @@ pub fn display_diff<E>(
 fn display_reloc_name<E>(
     reloc: &ObjReloc,
     mut cb: impl FnMut(DiffText) -> Result<(), E>,
+    diff: Option<&ObjInsArgDiff>,
 ) -> Result<(), E> {
-    cb(DiffText::Symbol(&reloc.target))?;
+    cb(DiffText::Symbol(&reloc.target, diff))?;
     match reloc.addend.cmp(&0i64) {
         Ordering::Greater => cb(DiffText::Basic(&format!("+{:#x}", reloc.addend))),
         Ordering::Less => cb(DiffText::Basic(&format!("-{:#x}", -reloc.addend))),
@@ -106,7 +111,7 @@ impl PartialEq<DiffText<'_>> for HighlightKind {
         match (self, other) {
             (HighlightKind::Opcode(a), DiffText::Opcode(_, b)) => a == b,
             (HighlightKind::Arg(a), DiffText::Argument(b, _)) => a.loose_eq(b),
-            (HighlightKind::Symbol(a), DiffText::Symbol(b)) => a == &b.name,
+            (HighlightKind::Symbol(a), DiffText::Symbol(b, _)) => a == &b.name,
             (HighlightKind::Address(a), DiffText::Address(b) | DiffText::BranchDest(b, _)) => {
                 a == b
             }
@@ -124,7 +129,7 @@ impl From<DiffText<'_>> for HighlightKind {
         match value {
             DiffText::Opcode(_, op) => HighlightKind::Opcode(op),
             DiffText::Argument(arg, _) => HighlightKind::Arg(arg.clone()),
-            DiffText::Symbol(sym) => HighlightKind::Symbol(sym.name.to_string()),
+            DiffText::Symbol(sym, _) => HighlightKind::Symbol(sym.name.to_string()),
             DiffText::Address(addr) | DiffText::BranchDest(addr, _) => HighlightKind::Address(addr),
             _ => HighlightKind::None,
         }

objdiff-core/src/diff/mod.rs

@@ -245,7 +245,7 @@ pub struct ObjInsDiff {
     pub branch_from: Option<ObjInsBranchFrom>,
     /// Branches to instruction
     pub branch_to: Option<ObjInsBranchTo>,
-    /// Arg diffs
+    /// Arg diffs (only contains non-PlainText args)
     pub arg_diff: Vec<Option<ObjInsArgDiff>>,
 }
 
@@ -577,7 +577,7 @@ fn generate_mapping_symbols(
     let Some(base_symbol_ref) = symbol_ref_by_name(base_obj, base_name) else {
         return Ok(());
     };
-    let (base_section, base_symbol) = base_obj.section_symbol(base_symbol_ref);
+    let (base_section, _base_symbol) = base_obj.section_symbol(base_symbol_ref);
     let Some(base_section) = base_section else {
         return Ok(());
     };
@@ -588,9 +588,7 @@ fn generate_mapping_symbols(
     for (target_section_index, target_section) in
         target_obj.sections.iter().enumerate().filter(|(_, s)| s.kind == base_section.kind)
     {
-        for (target_symbol_index, _target_symbol) in
-            target_section.symbols.iter().enumerate().filter(|(_, s)| s.kind == base_symbol.kind)
-        {
+        for (target_symbol_index, _target_symbol) in target_section.symbols.iter().enumerate() {
             let target_symbol_ref =
                 SymbolRef { section_idx: target_section_index, symbol_idx: target_symbol_index };
             match base_section.kind {

objdiff-core/src/obj/mod.rs

@@ -85,6 +85,9 @@ pub enum ObjInsArg {
 }
 
 impl ObjInsArg {
+    #[inline]
+    pub fn is_plain_text(&self) -> bool { matches!(self, ObjInsArg::PlainText(_)) }
+
     pub fn loose_eq(&self, other: &ObjInsArg) -> bool {
         match (self, other) {
             (ObjInsArg::Arg(a), ObjInsArg::Arg(b)) => a.loose_eq(b),
@@ -100,7 +103,7 @@ pub struct ObjIns {
     pub address: u64,
     pub size: u8,
     pub op: u16,
-    pub mnemonic: String,
+    pub mnemonic: Cow<'static, str>,
     pub args: Vec<ObjInsArg>,
     pub reloc: Option<ObjReloc>,
     pub branch_dest: Option<u64>,
@@ -112,6 +115,14 @@ pub struct ObjIns {
     pub orig: Option<String>,
 }
 
+impl ObjIns {
+    /// Iterate over non-PlainText arguments.
+    #[inline]
+    pub fn iter_args(&self) -> impl DoubleEndedIterator<Item = &ObjInsArg> {
+        self.args.iter().filter(|a| !a.is_plain_text())
+    }
+}
+
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
 pub enum ObjSymbolKind {
     #[default]

objdiff-core/src/obj/read.rs

@@ -65,10 +65,7 @@ fn to_obj_symbol(
         flags = ObjSymbolFlagSet(flags.0 | ObjSymbolFlags::Hidden);
     }
     #[cfg(feature = "ppc")]
-    if arch
-        .ppc()
-        .and_then(|a| a.extab.as_ref())
-        .map_or(false, |e| e.contains_key(&symbol.index().0))
+    if arch.ppc().and_then(|a| a.extab.as_ref()).is_some_and(|e| e.contains_key(&symbol.index().0))
     {
         flags = ObjSymbolFlagSet(flags.0 | ObjSymbolFlags::HasExtra);
     }
@@ -335,6 +332,10 @@ fn relocations_by_section(
                 };
                 symbol
             }
+            RelocationTarget::Absolute => {
+                log::warn!("Ignoring absolute relocation @ {}:{:#x}", section.name, address);
+                continue;
+            }
             _ => bail!("Unhandled relocation target: {:?}", reloc.target()),
         };
         let flags = reloc.flags(); // TODO validate reloc here?

objdiff-gui/Cargo.toml

@@ -25,7 +25,7 @@ wsl = []
 
 [dependencies]
 anyhow = "1.0"
-bytes = "1.7"
+bytes = "1.9"
 cfg-if = "1.0"
 const_format = "0.2"
 cwdemangle = "1.0"
@@ -42,7 +42,7 @@ notify = { git = "https://github.com/notify-rs/notify", rev = "128bf6230c03d39db
 objdiff-core = { path = "../objdiff-core", features = ["all"] }
 open = "5.3"
 png = "0.17"
-pollster = "0.3"
+pollster = "0.4"
 regex = "1.11"
 rfd = { version = "0.15" } #, default-features = false, features = ['xdg-portal']
 rlwinmdec = "1.0"
@@ -51,7 +51,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 shell-escape = "0.1"
 strum = { version = "0.26", features = ["derive"] }
-tempfile = "3.13"
+tempfile = "3.14"
 time = { version = "0.3", features = ["formatting", "local-offset"] }
 
 # Keep version in sync with egui
@@ -95,7 +95,7 @@ exec = "0.3"
 
 # native:
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-tracing-subscriber = "0.3"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
 # web:
 [target.'cfg(target_arch = "wasm32")'.dependencies]

objdiff-gui/src/app_config.rs

@@ -71,6 +71,7 @@ impl ScratchConfigV1 {
             c_flags: self.c_flags,
             ctx_path: self.ctx_path,
             build_ctx: self.build_ctx.then_some(true),
+            preset_id: None,
         }
     }
 }

objdiff-gui/src/config.rs

@@ -12,6 +12,21 @@ pub enum ProjectObjectNode {
     Dir(String, Vec<ProjectObjectNode>),
 }
 
+fn join_single_dir_entries(nodes: &mut Vec<ProjectObjectNode>) {
+    for node in nodes {
+        if let ProjectObjectNode::Dir(my_name, my_nodes) = node {
+            join_single_dir_entries(my_nodes);
+            // If this directory consists of a single sub-directory...
+            if let [ProjectObjectNode::Dir(sub_name, sub_nodes)] = &mut my_nodes[..] {
+                // ... join the two names with a path separator and eliminate the layer
+                *my_name += "/";
+                *my_name += sub_name;
+                *my_nodes = std::mem::take(sub_nodes);
+            }
+        }
+    }
+}
+
 fn find_dir<'a>(
     name: &str,
     nodes: &'a mut Vec<ProjectObjectNode>,
@@ -60,6 +75,14 @@ fn build_nodes(
         let filename = path.file_name().unwrap().to_str().unwrap().to_string();
         out_nodes.push(ProjectObjectNode::Unit(filename, idx));
     }
+    // Within the top-level module directories, join paths. Leave the
+    // top-level name intact though since it's the module name.
+    for node in &mut nodes {
+        if let ProjectObjectNode::Dir(_, sub_nodes) = node {
+            join_single_dir_entries(sub_nodes);
+        }
+    }
+
     nodes
 }
 

objdiff-gui/src/jobs/create_scratch.rs

@@ -23,6 +23,7 @@ pub struct CreateScratchConfig {
     pub compiler_flags: String,
     pub function_name: String,
     pub target_obj: PathBuf,
+    pub preset_id: Option<u32>,
 }
 
 impl CreateScratchConfig {
@@ -45,6 +46,7 @@ impl CreateScratchConfig {
             compiler_flags: scratch_config.c_flags.clone().unwrap_or_default(),
             function_name,
             target_obj: target_path.to_path_buf(),
+            preset_id: scratch_config.preset_id,
         })
     }
 
@@ -101,15 +103,18 @@ fn run_create_scratch(
     let obj_path = project_dir.join(&config.target_obj);
     let file = reqwest::blocking::multipart::Part::file(&obj_path)
         .with_context(|| format!("Failed to open {}", obj_path.display()))?;
-    let form = reqwest::blocking::multipart::Form::new()
+    let mut form = reqwest::blocking::multipart::Form::new()
         .text("compiler", config.compiler.clone())
         .text("platform", config.platform.clone())
         .text("compiler_flags", config.compiler_flags.clone())
         .text("diff_label", config.function_name.clone())
         .text("diff_flags", diff_flags)
         .text("context", context.unwrap_or_default())
-        .text("source_code", "// Move related code from Context tab to here")
-        .part("target_obj", file);
+        .text("source_code", "// Move related code from Context tab to here");
+    if let Some(preset) = config.preset_id {
+        form = form.text("preset", preset.to_string());
+    }
+    form = form.part("target_obj", file);
     let client = reqwest::blocking::Client::new();
     let response = client
         .post(formatcp!("{API_HOST}/api/scratch"))

objdiff-gui/src/jobs/mod.rs

@@ -152,8 +152,7 @@ fn start_job(
     let context = JobContext { status: status.clone(), egui: ctx.clone() };
     let context_inner = JobContext { status: status.clone(), egui: ctx.clone() };
     let (tx, rx) = std::sync::mpsc::channel();
-    let handle = std::thread::spawn(move || {
-        return match run(context_inner, rx) {
+    let handle = std::thread::spawn(move || match run(context_inner, rx) {
         Ok(state) => state,
         Err(e) => {
             if let Ok(mut w) = status.write() {
@@ -161,7 +160,6 @@ fn start_job(
             }
             JobResult::None
         }
-        };
     });
     let id = JOB_ID.fetch_add(1, Ordering::Relaxed);
     log::info!("Started job {}", id);

objdiff-gui/src/views/data_diff.rs

@@ -213,8 +213,8 @@ pub fn data_diff_ui(
     let right_ctx = SectionDiffContext::new(result.second_obj.as_ref(), section_name);
 
     // If both sides are missing a symbol, switch to symbol diff view
-    if !right_ctx.map_or(false, |ctx| ctx.has_section())
-        && !left_ctx.map_or(false, |ctx| ctx.has_section())
+    if !right_ctx.is_some_and(|ctx| ctx.has_section())
+        && !left_ctx.is_some_and(|ctx| ctx.has_section())
     {
         return Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
     }

objdiff-gui/src/views/extab_diff.rs

@@ -101,7 +101,7 @@ pub fn extab_diff_ui(
     let right_diff_symbol = right_ctx.and_then(|ctx| {
         ctx.symbol_ref.and_then(|symbol_ref| ctx.diff.symbol_diff(symbol_ref).target_symbol)
     });
-    if left_diff_symbol.is_some() && right_ctx.map_or(false, |ctx| !ctx.has_symbol()) {
+    if left_diff_symbol.is_some() && right_ctx.is_some_and(|ctx| !ctx.has_symbol()) {
         let (right_section, right_symbol) =
             right_ctx.unwrap().obj.section_symbol(left_diff_symbol.unwrap());
         let symbol_ref = SymbolRefByName::new(right_symbol, right_section);
@@ -111,7 +111,7 @@ pub fn extab_diff_ui(
             left_symbol: state.symbol_state.left_symbol.clone(),
             right_symbol: Some(symbol_ref),
         }));
-    } else if right_diff_symbol.is_some() && left_ctx.map_or(false, |ctx| !ctx.has_symbol()) {
+    } else if right_diff_symbol.is_some() && left_ctx.is_some_and(|ctx| !ctx.has_symbol()) {
         let (left_section, left_symbol) =
             left_ctx.unwrap().obj.section_symbol(right_diff_symbol.unwrap());
         let symbol_ref = SymbolRefByName::new(left_symbol, left_section);
@@ -124,8 +124,8 @@ pub fn extab_diff_ui(
     }
 
     // If both sides are missing a symbol, switch to symbol diff view
-    if right_ctx.map_or(false, |ctx| !ctx.has_symbol())
-        && left_ctx.map_or(false, |ctx| !ctx.has_symbol())
+    if right_ctx.is_some_and(|ctx| !ctx.has_symbol())
+        && left_ctx.is_some_and(|ctx| !ctx.has_symbol())
     {
         return Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
     }
@@ -144,7 +144,7 @@ pub fn extab_diff_ui(
                     .add_enabled(
                         !state.scratch_running
                             && state.scratch_available
-                            && left_ctx.map_or(false, |ctx| ctx.has_symbol()),
+                            && left_ctx.is_some_and(|ctx| ctx.has_symbol()),
                         egui::Button::new("📲 decomp.me"),
                     )
                     .on_hover_text_at_pointer("Create a new scratch on decomp.me (beta)")

objdiff-gui/src/views/function_diff.rs

@@ -149,6 +149,10 @@ fn ins_hover_ui(
                 ui.colored_label(appearance.highlight_color, "Extern".to_string());
             }
         }
+
+        if let Some(decoded) = rlwinmdec::decode(&ins.formatted) {
+            ui.colored_label(appearance.highlight_color, decoded.trim());
+        }
     });
 }
 
@@ -292,11 +296,15 @@ fn diff_text_ui(
                 base_color = appearance.diff_colors[diff.idx % appearance.diff_colors.len()]
             }
         }
-        DiffText::Symbol(sym) => {
+        DiffText::Symbol(sym, diff) => {
             let name = sym.demangled_name.as_ref().unwrap_or(&sym.name);
             label_text = name.clone();
+            if let Some(diff) = diff {
+                base_color = appearance.diff_colors[diff.idx % appearance.diff_colors.len()]
+            } else {
                 base_color = appearance.emphasized_text_color;
             }
+        }
         DiffText::Spacing(n) => {
             ui.add_space(n as f32 * space_width);
             return ret;
@@ -636,7 +644,7 @@ pub fn function_diff_ui(
     let right_diff_symbol = right_ctx.and_then(|ctx| {
         ctx.symbol_ref.and_then(|symbol_ref| ctx.diff.symbol_diff(symbol_ref).target_symbol)
     });
-    if left_diff_symbol.is_some() && right_ctx.map_or(false, |ctx| !ctx.has_symbol()) {
+    if left_diff_symbol.is_some() && right_ctx.is_some_and(|ctx| !ctx.has_symbol()) {
         let (right_section, right_symbol) =
             right_ctx.unwrap().obj.section_symbol(left_diff_symbol.unwrap());
         let symbol_ref = SymbolRefByName::new(right_symbol, right_section);
@@ -646,7 +654,7 @@ pub fn function_diff_ui(
             left_symbol: state.symbol_state.left_symbol.clone(),
             right_symbol: Some(symbol_ref),
         }));
-    } else if right_diff_symbol.is_some() && left_ctx.map_or(false, |ctx| !ctx.has_symbol()) {
+    } else if right_diff_symbol.is_some() && left_ctx.is_some_and(|ctx| !ctx.has_symbol()) {
         let (left_section, left_symbol) =
             left_ctx.unwrap().obj.section_symbol(right_diff_symbol.unwrap());
         let symbol_ref = SymbolRefByName::new(left_symbol, left_section);
@@ -659,8 +667,8 @@ pub fn function_diff_ui(
     }
 
     // If both sides are missing a symbol, switch to symbol diff view
-    if right_ctx.map_or(false, |ctx| !ctx.has_symbol())
-        && left_ctx.map_or(false, |ctx| !ctx.has_symbol())
+    if right_ctx.is_some_and(|ctx| !ctx.has_symbol())
+        && left_ctx.is_some_and(|ctx| !ctx.has_symbol())
     {
         return Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
     }
@@ -679,7 +687,7 @@ pub fn function_diff_ui(
                     .add_enabled(
                         !state.scratch_running
                             && state.scratch_available
-                            && left_ctx.map_or(false, |ctx| ctx.has_symbol()),
+                            && left_ctx.is_some_and(|ctx| ctx.has_symbol()),
                         egui::Button::new("📲 decomp.me"),
                     )
                     .on_hover_text_at_pointer("Create a new scratch on decomp.me (beta)")
@@ -703,7 +711,7 @@ pub fn function_diff_ui(
                         .font(appearance.code_font.clone())
                         .color(appearance.highlight_color),
                 );
-                if right_ctx.map_or(false, |m| m.has_symbol())
+                if right_ctx.is_some_and(|m| m.has_symbol())
                     && ui
                         .button("Change target")
                         .on_hover_text_at_pointer("Choose a different symbol to use as the target")
@@ -773,7 +781,7 @@ pub fn function_diff_ui(
                                 .color(match_color_for_symbol(match_percent, appearance)),
                         );
                     }
-                    if left_ctx.map_or(false, |m| m.has_symbol()) {
+                    if left_ctx.is_some_and(|m| m.has_symbol()) {
                         ui.separator();
                         if ui
                             .button("Change base")

objdiff-gui/src/views/rlwinm.rs

@@ -16,13 +16,13 @@ pub fn rlwinm_decode_window(
     egui::Window::new("Rlwinm Decoder").open(show).show(ctx, |ui| {
         ui.text_edit_singleline(&mut state.text);
         ui.add_space(10.0);
-        if let Some(demangled) = rlwinmdec::decode(&state.text) {
+        if let Some(decoded) = rlwinmdec::decode(&state.text) {
             ui.scope(|ui| {
                 ui.style_mut().override_text_style = Some(TextStyle::Monospace);
-                ui.colored_label(appearance.replace_color, &demangled);
+                ui.colored_label(appearance.replace_color, decoded.trim());
             });
             if ui.button("Copy").clicked() {
-                ui.output_mut(|output| output.copied_text = demangled);
+                ui.output_mut(|output| output.copied_text = decoded);
             }
         } else {
             ui.scope(|ui| {