Add alt shortcut support to many elements

DiffViewState::post_update is where the flag gets set, so clearing it right before that at the start of the function seems to make the most sense, instead of doing it in App::update.

Cargo.toml

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

objdiff-cli/Cargo.toml

@@ -14,7 +14,7 @@ publish = false
 
 [dependencies]
 anyhow = "1.0"
-argp = "0.4"
+argp = "0.3"
 crossterm = "0.28"
 enable-ansi-support = "0.2"
 memmap2 = "0.9"

objdiff-cli/src/cmd/report.rs

@@ -169,26 +169,22 @@ fn report_object(
         }
         _ => {}
     }
-    let diff_config = diff::DiffObjConfig { relax_reloc_diffs: true, ..Default::default() };
-    let mapping_config = diff::MappingConfig::default();
+    let config = diff::DiffObjConfig { relax_reloc_diffs: true, ..Default::default() };
     let target = object
         .target_path
         .as_ref()
         .map(|p| {
-            obj::read::read(p, &diff_config)
-                .with_context(|| format!("Failed to open {}", p.display()))
+            obj::read::read(p, &config).with_context(|| format!("Failed to open {}", p.display()))
         })
         .transpose()?;
     let base = object
         .base_path
         .as_ref()
         .map(|p| {
-            obj::read::read(p, &diff_config)
-                .with_context(|| format!("Failed to open {}", p.display()))
+            obj::read::read(p, &config).with_context(|| format!("Failed to open {}", p.display()))
         })
         .transpose()?;
-    let result =
-        diff::diff_objs(&diff_config, &mapping_config, target.as_ref(), base.as_ref(), None)?;
+    let result = diff::diff_objs(&config, target.as_ref(), base.as_ref(), None)?;
 
     let metadata = ReportUnitMetadata {
         complete: object.complete(),

objdiff-cli/src/main.rs

@@ -1,7 +1,6 @@
 mod argp_version;
 mod cmd;
 mod util;
-mod views;
 
 // musl's allocator is very slow, so use mimalloc when targeting musl.
 // Otherwise, use the system allocator to avoid extra code size.

objdiff-cli/src/views/mod.rs

@@ -1,25 +0,0 @@
-use anyhow::Result;
-use crossterm::event::Event;
-use ratatui::Frame;
-
-use crate::cmd::diff::AppState;
-
-pub mod function_diff;
-
-#[derive(Default)]
-pub struct EventResult {
-    pub redraw: bool,
-    pub click_xy: Option<(u16, u16)>,
-}
-
-pub enum EventControlFlow {
-    Break,
-    Continue(EventResult),
-    Reload,
-}
-
-pub trait UiView {
-    fn draw(&mut self, state: &AppState, f: &mut Frame, result: &mut EventResult);
-    fn handle_event(&mut self, state: &mut AppState, event: Event) -> EventControlFlow;
-    fn reload(&mut self, state: &AppState) -> Result<()>;
-}

objdiff-core/Cargo.toml

@@ -16,104 +16,17 @@ documentation = "https://docs.rs/objdiff-core"
 crate-type = ["cdylib", "rlib"]
 
 [features]
-all = [
-    # Features
-    "bindings",
-    "build",
-    "config",
-    "dwarf",
-    # Architectures
-    "mips",
-    "ppc",
-    "x86",
-    "arm",
-    "arm64",
-]
-# Implicit, used to check if any arch is enabled
-any-arch = [
-    "config",
-    "dep:bimap",
-    "dep:byteorder",
-    "dep:flagset",
-    "dep:heck",
-    "dep:log",
-    "dep:memmap2",
-    "dep:num-traits",
-    "dep:prettyplease",
-    "dep:proc-macro2",
-    "dep:quote",
-    "dep:serde",
-    "dep:serde_json",
-    "dep:similar",
-    "dep:strum",
-    "dep:syn",
-]
-bindings = [
-    "dep:pbjson",
-    "dep:pbjson-build",
-    "dep:prost",
-    "dep:prost-build",
-    "dep:serde",
-    "dep:serde_json",
-]
-build = [
-    "dep:notify",
-    "dep:notify-debouncer-full",
-    "dep:path-slash",
-    "dep:reqwest",
-    "dep:self_update",
-    "dep:shell-escape",
-    "dep:tempfile",
-    "dep:time",
-    "dep:winapi",
-]
-config = [
-    "dep:bimap",
-    "dep:filetime",
-    "dep:globset",
-    "dep:semver",
-    "dep:serde",
-    "dep:serde_json",
-    "dep:serde_yaml",
-]
+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"]
-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:arm-attr",
-    "dep:cpp_demangle",
-    "dep:unarm",
-]
-arm64 = [
-    "any-arch",
-    "dep:cpp_demangle",
-    "dep:yaxpeax-arch",
-    "dep:yaxpeax-arm",
-]
-wasm = [
-    "any-arch",
-    "bindings",
-    "dep:console_error_panic_hook",
-    "dep:console_log",
-    "dep:log",
-    "dep:tsify-next",
-    "dep:wasm-bindgen",
-]
+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"]
 
 [package.metadata.docs.rs]
 features = ["all"]
@@ -168,34 +81,6 @@ arm-attr = { version = "0.1", optional = true }
 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
-notify = { git = "https://github.com/notify-rs/notify", rev = "128bf6230c03d39dbb7f301ff7b20e594e34c3a2", version = "6.1.1", optional = true }
-notify-debouncer-full = { git = "https://github.com/notify-rs/notify", rev = "128bf6230c03d39dbb7f301ff7b20e594e34c3a2", version = "0.4.0", optional = true }
-shell-escape = { version = "0.1", optional = true }
-tempfile = { version = "3.14", optional = true }
-time = { version = "0.3", optional = true }
-
-[target.'cfg(windows)'.dependencies]
-path-slash = { version = "0.2", optional = true }
-winapi = { version = "0.3", optional = true }
-
-# For Linux static binaries, use rustls
-[target.'cfg(target_os = "linux")'.dependencies]
-reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "multipart", "rustls-tls"], optional = true }
-self_update = { version = "0.42", default-features = false, features = ["rustls"], optional = true }
-
-# For all other platforms, use native TLS
-[target.'cfg(not(target_os = "linux"))'.dependencies]
-reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "multipart", "default-tls"], optional = true }
-self_update = { version = "0.42", optional = true }
-
 [build-dependencies]
-heck = { version = "0.5", optional = true }
-pbjson-build = { version = "0.7", optional = true }
-prettyplease = { version = "0.2", optional = true }
-proc-macro2 = { version = "1.0", optional = true }
 prost-build = { version = "0.13", optional = true }
-quote = { version = "1.0", optional = true }
-serde = { version = "1.0", features = ["derive"], optional = true }
-serde_json = { version = "1.0", optional = true }
-syn = { version = "2.0", optional = true }
+pbjson-build = { version = "0.7", optional = true }

objdiff-core/build.rs

@@ -1,11 +1,6 @@
-#[cfg(feature = "any-arch")]
-mod config_gen;
-
 fn main() {
     #[cfg(feature = "bindings")]
     compile_protos();
-    #[cfg(feature = "any-arch")]
-    config_gen::generate_diff_config();
 }
 
 #[cfg(feature = "bindings")]

objdiff-core/config-schema.json

@@ -1,230 +0,0 @@
-{
-  "properties": [
-    {
-      "id": "relaxRelocDiffs",
-      "type": "boolean",
-      "default": false,
-      "name": "Relax relocation diffs",
-      "description": "Ignores differences in relocation targets. (Address, name, etc)"
-    },
-    {
-      "id": "spaceBetweenArgs",
-      "type": "boolean",
-      "default": true,
-      "name": "Space between args",
-      "description": "Adds a space between arguments in the diff output."
-    },
-    {
-      "id": "combineDataSections",
-      "type": "boolean",
-      "default": false,
-      "name": "Combine data sections",
-      "description": "Combines data sections with equal names."
-    },
-    {
-      "id": "arm.archVersion",
-      "type": "choice",
-      "default": "auto",
-      "name": "Architecture version",
-      "description": "ARM architecture version to use for disassembly.",
-      "items": [
-        {
-          "value": "auto",
-          "name": "Auto"
-        },
-        {
-          "value": "v4t",
-          "name": "ARMv4T (GBA)"
-        },
-        {
-          "value": "v5te",
-          "name": "ARMv5TE (DS)"
-        },
-        {
-          "value": "v6k",
-          "name": "ARMv6K (3DS)"
-        }
-      ]
-    },
-    {
-      "id": "arm.unifiedSyntax",
-      "type": "boolean",
-      "default": false,
-      "name": "Unified syntax",
-      "description": "Disassemble as unified assembly language (UAL)."
-    },
-    {
-      "id": "arm.avRegisters",
-      "type": "boolean",
-      "default": false,
-      "name": "Use A/V registers",
-      "description": "Display R0-R3 as A1-A4 and R4-R11 as V1-V8."
-    },
-    {
-      "id": "arm.r9Usage",
-      "type": "choice",
-      "default": "generalPurpose",
-      "name": "Display R9 as",
-      "items": [
-        {
-          "value": "generalPurpose",
-          "name": "R9 or V6",
-          "description": "Use R9 as a general-purpose register."
-        },
-        {
-          "value": "sb",
-          "name": "SB (static base)",
-          "description": "Used for position-independent data (PID)."
-        },
-        {
-          "value": "tr",
-          "name": "TR (TLS register)",
-          "description": "Used for thread-local storage."
-        }
-      ]
-    },
-    {
-      "id": "arm.slUsage",
-      "type": "boolean",
-      "default": false,
-      "name": "Display R10 as SL",
-      "description": "Used for explicit stack limits."
-    },
-    {
-      "id": "arm.fpUsage",
-      "type": "boolean",
-      "default": false,
-      "name": "Display R11 as FP",
-      "description": "Used for frame pointers."
-    },
-    {
-      "id": "arm.ipUsage",
-      "type": "boolean",
-      "default": false,
-      "name": "Display R12 as IP",
-      "description": "Used for interworking and long branches."
-    },
-    {
-      "id": "mips.abi",
-      "type": "choice",
-      "default": "auto",
-      "name": "ABI",
-      "description": "MIPS ABI to use for disassembly.",
-      "items": [
-        {
-          "value": "auto",
-          "name": "Auto"
-        },
-        {
-          "value": "o32",
-          "name": "O32"
-        },
-        {
-          "value": "n32",
-          "name": "N32"
-        },
-        {
-          "value": "n64",
-          "name": "N64"
-        }
-      ]
-    },
-    {
-      "id": "mips.instrCategory",
-      "type": "choice",
-      "default": "auto",
-      "name": "Instruction category",
-      "description": "MIPS instruction category to use for disassembly.",
-      "items": [
-        {
-          "value": "auto",
-          "name": "Auto"
-        },
-        {
-          "value": "cpu",
-          "name": "CPU"
-        },
-        {
-          "value": "rsp",
-          "name": "RSP (N64)"
-        },
-        {
-          "value": "r3000gte",
-          "name": "R3000 GTE (PS1)"
-        },
-        {
-          "value": "r4000allegrex",
-          "name": "R4000 ALLEGREX (PSP)"
-        },
-        {
-          "value": "r5900",
-          "name": "R5900 EE (PS2)"
-        }
-      ]
-    },
-    {
-      "id": "x86.formatter",
-      "type": "choice",
-      "default": "intel",
-      "name": "Format",
-      "description": "x86 disassembly syntax.",
-      "items": [
-        {
-          "value": "intel",
-          "name": "Intel"
-        },
-        {
-          "value": "gas",
-          "name": "AT&T"
-        },
-        {
-          "value": "nasm",
-          "name": "NASM"
-        },
-        {
-          "value": "masm",
-          "name": "MASM"
-        }
-      ]
-    }
-  ],
-  "groups": [
-    {
-      "id": "general",
-      "name": "General",
-      "properties": [
-        "relaxRelocDiffs",
-        "spaceBetweenArgs",
-        "combineDataSections"
-      ]
-    },
-    {
-      "id": "arm",
-      "name": "ARM",
-      "properties": [
-        "arm.archVersion",
-        "arm.unifiedSyntax",
-        "arm.avRegisters",
-        "arm.r9Usage",
-        "arm.slUsage",
-        "arm.fpUsage",
-        "arm.ipUsage"
-      ]
-    },
-    {
-      "id": "mips",
-      "name": "MIPS",
-      "properties": [
-        "mips.abi",
-        "mips.instrCategory"
-      ]
-    },
-    {
-      "id": "x86",
-      "name": "x86",
-      "properties": [
-        "x86.formatter"
-      ]
-    }
-  ]
-}

objdiff-core/config_gen.rs

@@ -1,491 +0,0 @@
-use std::{
-    fs::File,
-    path::{Path, PathBuf},
-};
-
-use heck::{ToShoutySnakeCase, ToSnakeCase, ToUpperCamelCase};
-use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
-
-#[derive(Debug, serde::Deserialize)]
-pub struct ConfigSchema {
-    pub properties: Vec<ConfigProperty>,
-    pub groups: Vec<ConfigGroup>,
-}
-
-#[derive(Debug, serde::Deserialize)]
-#[serde(tag = "type")]
-pub enum ConfigProperty {
-    #[serde(rename = "boolean")]
-    Boolean(ConfigPropertyBoolean),
-    #[serde(rename = "choice")]
-    Choice(ConfigPropertyChoice),
-}
-
-#[derive(Debug, serde::Deserialize)]
-pub struct ConfigPropertyBase {
-    pub id: String,
-    pub name: String,
-    pub description: Option<String>,
-}
-
-#[derive(Debug, serde::Deserialize)]
-pub struct ConfigPropertyBoolean {
-    #[serde(flatten)]
-    pub base: ConfigPropertyBase,
-    pub default: bool,
-}
-
-#[derive(Debug, serde::Deserialize)]
-pub struct ConfigPropertyChoice {
-    #[serde(flatten)]
-    pub base: ConfigPropertyBase,
-    pub default: String,
-    pub items: Vec<ConfigPropertyChoiceItem>,
-}
-
-#[derive(Debug, serde::Deserialize)]
-pub struct ConfigPropertyChoiceItem {
-    pub value: String,
-    pub name: String,
-    pub description: Option<String>,
-}
-
-#[derive(Debug, serde::Deserialize)]
-pub struct ConfigGroup {
-    pub id: String,
-    pub name: String,
-    pub description: Option<String>,
-    pub properties: Vec<String>,
-}
-
-fn build_doc(name: &str, description: Option<&str>) -> TokenStream {
-    let mut doc = format!(" {}", name);
-    let mut out = quote! { #[doc = #doc] };
-    if let Some(description) = description {
-        doc = format!(" {}", description);
-        out.extend(quote! { #[doc = ""] });
-        out.extend(quote! { #[doc = #doc] });
-    }
-    out
-}
-
-pub fn generate_diff_config() {
-    let schema_path = Path::new(env!("CARGO_MANIFEST_DIR")).join("config-schema.json");
-    println!("cargo:rerun-if-changed={}", schema_path.display());
-    let schema_file = File::open(schema_path).expect("Failed to open config schema file");
-    let schema: ConfigSchema =
-        serde_json::from_reader(schema_file).expect("Failed to parse config schema");
-
-    let mut enums = TokenStream::new();
-    for property in &schema.properties {
-        let ConfigProperty::Choice(choice) = property else {
-            continue;
-        };
-        let enum_ident = format_ident!("{}", choice.base.id.to_upper_camel_case());
-        let mut variants = TokenStream::new();
-        let mut full_variants = TokenStream::new();
-        let mut variant_info = TokenStream::new();
-        let mut variant_to_str = TokenStream::new();
-        let mut variant_to_name = TokenStream::new();
-        let mut variant_to_description = TokenStream::new();
-        let mut variant_from_str = TokenStream::new();
-        for item in &choice.items {
-            let variant_name = item.value.to_upper_camel_case();
-            let variant_ident = format_ident!("{}", variant_name);
-            let is_default = item.value == choice.default;
-            variants.extend(build_doc(&item.name, item.description.as_deref()));
-            if is_default {
-                variants.extend(quote! { #[default] });
-            }
-            let value = &item.value;
-            variants.extend(quote! {
-                #[serde(rename = #value, alias = #variant_name)]
-                #variant_ident,
-            });
-            full_variants.extend(quote! { #enum_ident::#variant_ident, });
-            variant_to_str.extend(quote! { #enum_ident::#variant_ident => #value, });
-            let name = &item.name;
-            variant_to_name.extend(quote! { #enum_ident::#variant_ident => #name, });
-            if let Some(description) = &item.description {
-                variant_to_description.extend(quote! {
-                    #enum_ident::#variant_ident => Some(#description),
-                });
-            } else {
-                variant_to_description.extend(quote! {
-                    #enum_ident::#variant_ident => None,
-                });
-            }
-            let description = if let Some(description) = &item.description {
-                quote! { Some(#description) }
-            } else {
-                quote! { None }
-            };
-            variant_info.extend(quote! {
-                ConfigEnumVariantInfo {
-                    value: #value,
-                    name: #name,
-                    description: #description,
-                    is_default: #is_default,
-                },
-            });
-            variant_from_str.extend(quote! {
-                if s.eq_ignore_ascii_case(#value) { return Ok(#enum_ident::#variant_ident); }
-            });
-        }
-        enums.extend(quote! {
-            #[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Hash, serde::Deserialize, serde::Serialize)]
-            #[cfg_attr(feature = "wasm", derive(tsify_next::Tsify), tsify(from_wasm_abi))]
-            pub enum #enum_ident {
-                #variants
-            }
-            impl ConfigEnum for #enum_ident {
-                #[inline]
-                fn variants() -> &'static [Self] {
-                    static VARIANTS: &[#enum_ident] = &[#full_variants];
-                    VARIANTS
-                }
-                #[inline]
-                fn variant_info() -> &'static [ConfigEnumVariantInfo] {
-                    static VARIANT_INFO: &[ConfigEnumVariantInfo] = &[
-                        #variant_info
-                    ];
-                    VARIANT_INFO
-                }
-                fn as_str(&self) -> &'static str {
-                    match self {
-                        #variant_to_str
-                    }
-                }
-                fn name(&self) -> &'static str {
-                    match self {
-                        #variant_to_name
-                    }
-                }
-                fn description(&self) -> Option<&'static str> {
-                    match self {
-                        #variant_to_description
-                    }
-                }
-            }
-            impl std::str::FromStr for #enum_ident {
-                type Err = ();
-                fn from_str(s: &str) -> Result<Self, Self::Err> {
-                    #variant_from_str
-                    Err(())
-                }
-            }
-        });
-    }
-
-    let mut groups = TokenStream::new();
-    let mut group_idents = Vec::new();
-    for group in &schema.groups {
-        let ident = format_ident!("CONFIG_GROUP_{}", group.id.to_shouty_snake_case());
-        let id = &group.id;
-        let name = &group.name;
-        let description = if let Some(description) = &group.description {
-            quote! { Some(#description) }
-        } else {
-            quote! { None }
-        };
-        let properties =
-            group.properties.iter().map(|p| format_ident!("{}", p.to_upper_camel_case()));
-        groups.extend(quote! {
-            ConfigPropertyGroup {
-                id: #id,
-                name: #name,
-                description: #description,
-                properties: &[#(ConfigPropertyId::#properties,)*],
-            },
-        });
-        group_idents.push(ident);
-    }
-
-    let mut property_idents = Vec::new();
-    let mut property_variants = TokenStream::new();
-    let mut variant_info = TokenStream::new();
-    let mut config_property_id_to_str = TokenStream::new();
-    let mut config_property_id_to_name = TokenStream::new();
-    let mut config_property_id_to_description = TokenStream::new();
-    let mut config_property_id_to_kind = TokenStream::new();
-    let mut property_fields = TokenStream::new();
-    let mut default_fields = TokenStream::new();
-    let mut get_property_value_variants = TokenStream::new();
-    let mut set_property_value_variants = TokenStream::new();
-    let mut set_property_value_str_variants = TokenStream::new();
-    let mut config_property_id_from_str = TokenStream::new();
-    for property in &schema.properties {
-        let base = match property {
-            ConfigProperty::Boolean(b) => &b.base,
-            ConfigProperty::Choice(c) => &c.base,
-        };
-        let id = &base.id;
-        let enum_ident = format_ident!("{}", id.to_upper_camel_case());
-        property_idents.push(enum_ident.clone());
-        config_property_id_to_str.extend(quote! { Self::#enum_ident => #id, });
-        let name = &base.name;
-        config_property_id_to_name.extend(quote! { Self::#enum_ident => #name, });
-        if let Some(description) = &base.description {
-            config_property_id_to_description.extend(quote! {
-                Self::#enum_ident => Some(#description),
-            });
-        } else {
-            config_property_id_to_description.extend(quote! {
-                Self::#enum_ident => None,
-            });
-        }
-        let doc = build_doc(name, base.description.as_deref());
-        property_variants.extend(quote! { #doc #enum_ident, });
-        property_fields.extend(doc);
-        let field_ident = format_ident!("{}", id.to_snake_case());
-        match property {
-            ConfigProperty::Boolean(b) => {
-                let default = b.default;
-                if default {
-                    property_fields.extend(quote! {
-                        #[serde(default = "default_true")]
-                    });
-                }
-                property_fields.extend(quote! {
-                    pub #field_ident: bool,
-                });
-                default_fields.extend(quote! {
-                    #field_ident: #default,
-                });
-            }
-            ConfigProperty::Choice(_) => {
-                property_fields.extend(quote! {
-                    pub #field_ident: #enum_ident,
-                });
-                default_fields.extend(quote! {
-                    #field_ident: #enum_ident::default(),
-                });
-            }
-        }
-        let property_value = match property {
-            ConfigProperty::Boolean(_) => {
-                quote! { ConfigPropertyValue::Boolean(self.#field_ident) }
-            }
-            ConfigProperty::Choice(_) => {
-                quote! { ConfigPropertyValue::Choice(self.#field_ident.as_str()) }
-            }
-        };
-        get_property_value_variants.extend(quote! {
-            ConfigPropertyId::#enum_ident => #property_value,
-        });
-        match property {
-            ConfigProperty::Boolean(_) => {
-                set_property_value_variants.extend(quote! {
-                    ConfigPropertyId::#enum_ident => {
-                        if let ConfigPropertyValue::Boolean(value) = value {
-                            self.#field_ident = value;
-                            Ok(())
-                        } else {
-                            Err(())
-                        }
-                    },
-                });
-                set_property_value_str_variants.extend(quote! {
-                    ConfigPropertyId::#enum_ident => {
-                        if let Ok(value) = value.parse() {
-                            self.#field_ident = value;
-                            Ok(())
-                        } else {
-                            Err(())
-                        }
-                    },
-                });
-            }
-            ConfigProperty::Choice(_) => {
-                set_property_value_variants.extend(quote! {
-                    ConfigPropertyId::#enum_ident => {
-                        if let ConfigPropertyValue::Choice(value) = value {
-                            if let Ok(value) = value.parse() {
-                                self.#field_ident = value;
-                                Ok(())
-                            } else {
-                                Err(())
-                            }
-                        } else {
-                            Err(())
-                        }
-                    },
-                });
-                set_property_value_str_variants.extend(quote! {
-                    ConfigPropertyId::#enum_ident => {
-                        if let Ok(value) = value.parse() {
-                            self.#field_ident = value;
-                            Ok(())
-                        } else {
-                            Err(())
-                        }
-                    },
-                });
-            }
-        }
-        let description = if let Some(description) = &base.description {
-            quote! { Some(#description) }
-        } else {
-            quote! { None }
-        };
-        variant_info.extend(quote! {
-            ConfigEnumVariantInfo {
-                value: #id,
-                name: #name,
-                description: #description,
-                is_default: false,
-            },
-        });
-        match property {
-            ConfigProperty::Boolean(_) => {
-                config_property_id_to_kind.extend(quote! {
-                    Self::#enum_ident => ConfigPropertyKind::Boolean,
-                });
-            }
-            ConfigProperty::Choice(_) => {
-                config_property_id_to_kind.extend(quote! {
-                    Self::#enum_ident => ConfigPropertyKind::Choice(#enum_ident::variant_info()),
-                });
-            }
-        }
-        let snake_id = id.to_snake_case();
-        config_property_id_from_str.extend(quote! {
-            if s.eq_ignore_ascii_case(#id) || s.eq_ignore_ascii_case(#snake_id) {
-                return Ok(Self::#enum_ident);
-            }
-        });
-    }
-
-    let tokens = quote! {
-        pub trait ConfigEnum: Sized {
-            fn variants() -> &'static [Self];
-            fn variant_info() -> &'static [ConfigEnumVariantInfo];
-            fn as_str(&self) -> &'static str;
-            fn name(&self) -> &'static str;
-            fn description(&self) -> Option<&'static str>;
-        }
-        #[derive(Clone, Debug)]
-        pub struct ConfigEnumVariantInfo {
-            pub value: &'static str,
-            pub name: &'static str,
-            pub description: Option<&'static str>,
-            pub is_default: bool,
-        }
-        #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-        pub enum ConfigPropertyId {
-            #property_variants
-        }
-        impl ConfigEnum for ConfigPropertyId {
-            #[inline]
-            fn variants() -> &'static [Self] {
-                static VARIANTS: &[ConfigPropertyId] = &[#(ConfigPropertyId::#property_idents,)*];
-                VARIANTS
-            }
-            #[inline]
-            fn variant_info() -> &'static [ConfigEnumVariantInfo] {
-                static VARIANT_INFO: &[ConfigEnumVariantInfo] = &[
-                    #variant_info
-                ];
-                VARIANT_INFO
-            }
-            fn as_str(&self) -> &'static str {
-                match self {
-                    #config_property_id_to_str
-                }
-            }
-            fn name(&self) -> &'static str {
-                match self {
-                    #config_property_id_to_name
-                }
-            }
-            fn description(&self) -> Option<&'static str> {
-                match self {
-                    #config_property_id_to_description
-                }
-            }
-        }
-        impl ConfigPropertyId {
-            pub fn kind(&self) -> ConfigPropertyKind {
-                match self {
-                    #config_property_id_to_kind
-                }
-            }
-        }
-        impl std::str::FromStr for ConfigPropertyId {
-            type Err = ();
-            fn from_str(s: &str) -> Result<Self, Self::Err> {
-                #config_property_id_from_str
-                Err(())
-            }
-        }
-        #[derive(Clone, Debug)]
-        pub struct ConfigPropertyGroup {
-            pub id: &'static str,
-            pub name: &'static str,
-            pub description: Option<&'static str>,
-            pub properties: &'static [ConfigPropertyId],
-        }
-        pub static CONFIG_GROUPS: &[ConfigPropertyGroup] = &[#groups];
-        #[derive(Clone, Debug, Eq, PartialEq, Hash)]
-        pub enum ConfigPropertyValue {
-            Boolean(bool),
-            Choice(&'static str),
-        }
-        impl ConfigPropertyValue {
-            pub fn to_json(&self) -> serde_json::Value {
-                match self {
-                    ConfigPropertyValue::Boolean(value) => serde_json::Value::Bool(*value),
-                    ConfigPropertyValue::Choice(value) => serde_json::Value::String(value.to_string()),
-                }
-            }
-        }
-        #[derive(Clone, Debug)]
-        pub enum ConfigPropertyKind {
-            Boolean,
-            Choice(&'static [ConfigEnumVariantInfo]),
-        }
-        #enums
-        #[inline(always)]
-        fn default_true() -> bool { true }
-        #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
-        #[cfg_attr(feature = "wasm", derive(tsify_next::Tsify), tsify(from_wasm_abi))]
-        #[serde(default)]
-        pub struct DiffObjConfig {
-            #property_fields
-        }
-        impl Default for DiffObjConfig {
-            fn default() -> Self {
-                Self {
-                    #default_fields
-                }
-            }
-        }
-        impl DiffObjConfig {
-            pub fn get_property_value(&self, id: ConfigPropertyId) -> ConfigPropertyValue {
-                match id {
-                    #get_property_value_variants
-                }
-            }
-            #[allow(clippy::result_unit_err)]
-            pub fn set_property_value(&mut self, id: ConfigPropertyId, value: ConfigPropertyValue) -> Result<(), ()> {
-                match id {
-                    #set_property_value_variants
-                }
-            }
-            #[allow(clippy::result_unit_err)]
-            pub fn set_property_value_str(&mut self, id: ConfigPropertyId, value: &str) -> Result<(), ()> {
-                match id {
-                    #set_property_value_str_variants
-                }
-            }
-        }
-    };
-    let file = syn::parse2(tokens).unwrap();
-    let formatted = prettyplease::unparse(&file);
-    std::fs::write(
-        PathBuf::from(std::env::var_os("OUT_DIR").unwrap()).join("config.gen.rs"),
-        formatted,
-    )
-    .unwrap();
-}

objdiff-core/protos/diff.proto

@@ -21,9 +21,9 @@ enum SymbolFlag {
   SYMBOL_NONE = 0;
   SYMBOL_GLOBAL = 1;
   SYMBOL_LOCAL = 2;
-  SYMBOL_WEAK = 4;
-  SYMBOL_COMMON = 8;
-  SYMBOL_HIDDEN = 16;
+  SYMBOL_WEAK = 3;
+  SYMBOL_COMMON = 4;
+  SYMBOL_HIDDEN = 5;
 }
 
 // A single parsed instruction
@@ -122,17 +122,10 @@ message InstructionBranchTo {
   uint32 branch_index = 2;
 }
 
-message SymbolRef {
-  optional uint32 section_index = 1;
-  uint32 symbol_index = 2;
-}
-
-message SymbolDiff {
+message FunctionDiff {
   Symbol symbol = 1;
   repeated InstructionDiff instructions = 2;
   optional float match_percent = 3;
-  // The symbol ref in the _other_ object that this symbol was diffed against
-  optional SymbolRef target = 5;
 }
 
 message DataDiff {
@@ -147,7 +140,7 @@ message SectionDiff {
   SectionKind kind = 2;
   uint64 size = 3;
   uint64 address = 4;
-  repeated SymbolDiff symbols = 5;
+  repeated FunctionDiff functions = 5;
   repeated DataDiff data = 6;
   optional float match_percent = 7;
 }

objdiff-core/src/arch/arm.rs

@@ -139,9 +139,9 @@ impl ObjArch for ObjArchArm {
 
         let version = match config.arm_arch_version {
             ArmArchVersion::Auto => self.detected_version.unwrap_or(ArmVersion::V5Te),
-            ArmArchVersion::V4t => ArmVersion::V4T,
-            ArmArchVersion::V5te => ArmVersion::V5Te,
-            ArmArchVersion::V6k => ArmVersion::V6K,
+            ArmArchVersion::V4T => ArmVersion::V4T,
+            ArmArchVersion::V5TE => ArmVersion::V5Te,
+            ArmArchVersion::V6K => ArmVersion::V6K,
         };
         let endian = match self.endianness {
             object::Endianness::Little => unarm::Endian::Little,

objdiff-core/src/arch/mips.rs

@@ -99,8 +99,8 @@ impl ObjArch for ObjArchMips {
             MipsInstrCategory::Auto => self.instr_category,
             MipsInstrCategory::Cpu => InstrCategory::CPU,
             MipsInstrCategory::Rsp => InstrCategory::RSP,
-            MipsInstrCategory::R3000gte => InstrCategory::R3000GTE,
-            MipsInstrCategory::R4000allegrex => InstrCategory::R4000ALLEGREX,
+            MipsInstrCategory::R3000Gte => InstrCategory::R3000GTE,
+            MipsInstrCategory::R4000Allegrex => InstrCategory::R4000ALLEGREX,
             MipsInstrCategory::R5900 => InstrCategory::R5900,
         };
 

objdiff-core/src/arch/mod.rs

@@ -36,22 +36,13 @@ pub enum DataType {
 
 impl DataType {
     pub fn display_bytes<Endian: ByteOrder>(&self, bytes: &[u8]) -> Option<String> {
-        if self.required_len().is_some_and(|l| bytes.len() < l) {
-            log::warn!("Failed to display a symbol value for a symbol whose size is too small for instruction referencing it.");
+        // TODO: Attempt to interpret large symbols as arrays of a smaller type,
+        // fallback to intrepreting it as bytes.
+        // https://github.com/encounter/objdiff/issues/124
+        if self.required_len().is_some_and(|l| bytes.len() != l) {
+            log::warn!("Failed to display a symbol value for a symbol whose size doesn't match the instruction referencing it.");
             return None;
         }
-        let mut bytes = bytes;
-        if self.required_len().is_some_and(|l| bytes.len() > l) {
-            // If the symbol's size is larger a single instance of this data type, we take just the
-            // bytes necessary for one of them in order to display the first element of the array.
-            bytes = &bytes[0..self.required_len().unwrap()];
-            // TODO: Attempt to interpret large symbols as arrays of a smaller type and show all
-            // elements of the array instead. https://github.com/encounter/objdiff/issues/124
-            // However, note that the stride of an array can not always be determined just by the
-            // data type guessed by the single instruction accessing it. There can also be arrays of
-            // structs that contain multiple elements of different types, so if other elements after
-            // the first one were to be displayed in this manner, they may be inaccurate.
-        }
 
         match self {
             DataType::Int8 => {
@@ -95,10 +86,10 @@ impl DataType {
                 }
             }
             DataType::Float => {
-                format!("Float: {:?}f", Endian::read_f32(bytes))
+                format!("Float: {}", Endian::read_f32(bytes))
             }
             DataType::Double => {
-                format!("Double: {:?}", Endian::read_f64(bytes))
+                format!("Double: {}", Endian::read_f64(bytes))
             }
             DataType::Bytes => {
                 format!("Bytes: {:#?}", bytes)

objdiff-core/src/arch/ppc.rs

@@ -1,7 +1,4 @@
-use std::{
-    borrow::Cow,
-    collections::{BTreeMap, HashMap},
-};
+use std::{borrow::Cow, collections::BTreeMap};
 
 use anyhow::{bail, ensure, Result};
 use byteorder::BigEndian;
@@ -10,7 +7,7 @@ use object::{
     elf, File, Object, ObjectSection, ObjectSymbol, Relocation, RelocationFlags, RelocationTarget,
     Symbol, SymbolKind,
 };
-use ppc750cl::{Argument, InsIter, Opcode, ParsedIns, GPR};
+use ppc750cl::{Argument, InsIter, Opcode, GPR};
 
 use crate::{
     arch::{DataType, ObjArch, ProcessCodeResult},
@@ -52,8 +49,6 @@ impl ObjArch for ObjArchPpc {
         let ins_count = code.len() / 4;
         let mut ops = Vec::<u16>::with_capacity(ins_count);
         let mut insts = Vec::<ObjIns>::with_capacity(ins_count);
-        let fake_pool_reloc_for_addr =
-            generate_fake_pool_reloc_for_addr_mapping(address, code, relocations);
         for (cur_addr, mut ins) in InsIter::new(code, address as u32) {
             let reloc = relocations.iter().find(|r| (r.address as u32 & !3) == cur_addr);
             if let Some(reloc) = reloc {
@@ -150,7 +145,7 @@ impl ObjArch for ObjArchPpc {
                 size: 4,
                 mnemonic: Cow::Borrowed(simplified.mnemonic),
                 args,
-                reloc: reloc.or(fake_pool_reloc_for_addr.get(&cur_addr)).cloned(),
+                reloc: reloc.cloned(),
                 op: ins.op as u16,
                 branch_dest,
                 line,
@@ -178,7 +173,6 @@ impl ObjArch for ObjArchPpc {
     fn display_reloc(&self, flags: RelocationFlags) -> Cow<'static, str> {
         match flags {
             RelocationFlags::Elf { r_type } => match r_type {
-                elf::R_PPC_NONE => Cow::Borrowed("R_PPC_NONE"), // We use this for fake pool relocs
                 elf::R_PPC_ADDR16_LO => Cow::Borrowed("R_PPC_ADDR16_LO"),
                 elf::R_PPC_ADDR16_HI => Cow::Borrowed("R_PPC_ADDR16_HI"),
                 elf::R_PPC_ADDR16_HA => Cow::Borrowed("R_PPC_ADDR16_HA"),
@@ -194,22 +188,26 @@ impl ObjArch for ObjArchPpc {
     }
 
     fn guess_data_type(&self, instruction: &ObjIns) -> Option<super::DataType> {
+        // Always shows the first string of the table. Not ideal, but it's really hard to find
+        // the actual string being referenced.
         if instruction.reloc.as_ref().is_some_and(|r| r.target.name.starts_with("@stringBase")) {
             return Some(DataType::String);
         }
 
-        let op = Opcode::from(instruction.op as u8);
-        if let Some(ty) = guess_data_type_from_load_store_inst_op(op) {
-            Some(ty)
-        } else if op == Opcode::Addi {
-            // Assume that any addi instruction that references a local symbol is loading a string.
-            // This hack is not ideal and results in tons of false positives where it will show
-            // garbage strings (e.g. misinterpreting arrays, float literals, etc).
-            // But not all strings are in the @stringBase pool, so the condition above that checks
-            // the target symbol name would miss some.
-            Some(DataType::String)
-        } else {
-            None
+        match Opcode::from(instruction.op as u8) {
+            Opcode::Lbz | Opcode::Lbzu | Opcode::Lbzux | Opcode::Lbzx => Some(DataType::Int8),
+            Opcode::Lhz | Opcode::Lhzu | Opcode::Lhzux | Opcode::Lhzx => Some(DataType::Int16),
+            Opcode::Lha | Opcode::Lhau | Opcode::Lhaux | Opcode::Lhax => Some(DataType::Int16),
+            Opcode::Lwz | Opcode::Lwzu | Opcode::Lwzux | Opcode::Lwzx => Some(DataType::Int32),
+            Opcode::Lfs | Opcode::Lfsu | Opcode::Lfsux | Opcode::Lfsx => Some(DataType::Float),
+            Opcode::Lfd | Opcode::Lfdu | Opcode::Lfdux | Opcode::Lfdx => Some(DataType::Double),
+
+            Opcode::Stb | Opcode::Stbu | Opcode::Stbux | Opcode::Stbx => Some(DataType::Int8),
+            Opcode::Sth | Opcode::Sthu | Opcode::Sthux | Opcode::Sthx => Some(DataType::Int16),
+            Opcode::Stw | Opcode::Stwu | Opcode::Stwux | Opcode::Stwx => Some(DataType::Int32),
+            Opcode::Stfs | Opcode::Stfsu | Opcode::Stfsux | Opcode::Stfsx => Some(DataType::Float),
+            Opcode::Stfd | Opcode::Stfdu | Opcode::Stfdux | Opcode::Stfdx => Some(DataType::Double),
+            _ => None,
         }
     }
 
@@ -383,196 +381,3 @@ fn make_symbol_ref(symbol: &Symbol) -> Result<ExtabSymbolRef> {
     let demangled_name = cwdemangle::demangle(&name, &cwdemangle::DemangleOptions::default());
     Ok(ExtabSymbolRef { original_index: symbol.index().0, name, demangled_name })
 }
-
-fn guess_data_type_from_load_store_inst_op(inst_op: Opcode) -> Option<DataType> {
-    match inst_op {
-        Opcode::Lbz | Opcode::Lbzu | Opcode::Lbzux | Opcode::Lbzx => Some(DataType::Int8),
-        Opcode::Lhz | Opcode::Lhzu | Opcode::Lhzux | Opcode::Lhzx => Some(DataType::Int16),
-        Opcode::Lha | Opcode::Lhau | Opcode::Lhaux | Opcode::Lhax => Some(DataType::Int16),
-        Opcode::Lwz | Opcode::Lwzu | Opcode::Lwzux | Opcode::Lwzx => Some(DataType::Int32),
-        Opcode::Lfs | Opcode::Lfsu | Opcode::Lfsux | Opcode::Lfsx => Some(DataType::Float),
-        Opcode::Lfd | Opcode::Lfdu | Opcode::Lfdux | Opcode::Lfdx => Some(DataType::Double),
-
-        Opcode::Stb | Opcode::Stbu | Opcode::Stbux | Opcode::Stbx => Some(DataType::Int8),
-        Opcode::Sth | Opcode::Sthu | Opcode::Sthux | Opcode::Sthx => Some(DataType::Int16),
-        Opcode::Stw | Opcode::Stwu | Opcode::Stwux | Opcode::Stwx => Some(DataType::Int32),
-        Opcode::Stfs | Opcode::Stfsu | Opcode::Stfsux | Opcode::Stfsx => Some(DataType::Float),
-        Opcode::Stfd | Opcode::Stfdu | Opcode::Stfdux | Opcode::Stfdx => Some(DataType::Double),
-        _ => None,
-    }
-}
-
-// Given an instruction, determine if it could accessing data at the address in a register.
-// If so, return the offset added to the register's address, the register containing that address,
-// and (optionally) which destination register the address is being copied into.
-fn get_offset_and_addr_gpr_for_possible_pool_reference(
-    opcode: Opcode,
-    simplified: &ParsedIns,
-) -> Option<(i16, GPR, Option<GPR>)> {
-    let args = &simplified.args;
-    if guess_data_type_from_load_store_inst_op(opcode).is_some() {
-        match (args[1], args[2]) {
-            (Argument::Offset(offset), Argument::GPR(addr_src_gpr)) => {
-                // e.g. lwz. Immediate offset.
-                Some((offset.0, addr_src_gpr, None))
-            }
-            (Argument::GPR(addr_src_gpr), Argument::GPR(_offset_gpr)) => {
-                // e.g. lwzx. The offset is in a register and was likely calculated from an index.
-                // Treat the offset as being 0 in this case to show the first element of the array.
-                // It may be possible to show all elements by figuring out the stride of the array
-                // from the calculations performed on the index before it's put into offset_gpr, but
-                // this would be much more complicated, so it's not currently done.
-                Some((0, addr_src_gpr, None))
-            }
-            _ => None,
-        }
-    } else {
-        // If it's not a load/store instruction, there's two more possibilities we need to handle.
-        // 1. It could be loading a pointer to a string.
-        // 2. It could be moving the relocation address plus an offset into a different register to
-        //    load from later.
-        // If either of these match, we also want to return the destination register that the
-        // address is being copied into so that we can detect any future references to that new
-        // register as well.
-        match (opcode, args[0], args[1], args[2]) {
-            (
-                Opcode::Addi,
-                Argument::GPR(addr_dst_gpr),
-                Argument::GPR(addr_src_gpr),
-                Argument::Simm(simm),
-            ) => Some((simm.0, addr_src_gpr, Some(addr_dst_gpr))),
-            (
-                Opcode::Or,
-                Argument::GPR(addr_dst_gpr),
-                Argument::GPR(addr_src_gpr),
-                Argument::None,
-            ) => Some((0, addr_src_gpr, Some(addr_dst_gpr))), // `mr` or `mr.`
-            _ => None,
-        }
-    }
-}
-
-// We create a fake relocation for an instruction, vaguely simulating what the actual relocation
-// might have looked like if it wasn't pooled. This is so minimal changes are needed to display
-// pooled accesses vs non-pooled accesses. We set the relocation type to R_PPC_NONE to indicate that
-// there isn't really a relocation here, as copying the pool relocation's type wouldn't make sense.
-// Also, if this instruction is accessing the middle of a symbol instead of the start, we add an
-// addend to indicate that.
-fn make_fake_pool_reloc(offset: i16, cur_addr: u32, pool_reloc: &ObjReloc) -> Option<ObjReloc> {
-    let offset_from_pool = pool_reloc.addend + offset as i64;
-    let target_address = pool_reloc.target.address.checked_add_signed(offset_from_pool)?;
-    let orig_section_index = pool_reloc.target.orig_section_index?;
-    // We also need to create a fake target symbol to go inside our fake relocation.
-    // This is because we don't have access to list of all symbols in this section, so we can't find
-    // the real symbol yet. Instead we make a placeholder that has the correct `orig_section_index`
-    // and `address` fields, and then later on when this information is displayed to the user, we
-    // can find the real symbol by searching through the object's section's symbols for one that
-    // contains this address.
-    let fake_target_symbol = ObjSymbol {
-        name: "".to_string(),
-        demangled_name: None,
-        address: target_address,
-        section_address: 0,
-        size: 0,
-        size_known: false,
-        kind: Default::default(),
-        flags: Default::default(),
-        orig_section_index: Some(orig_section_index),
-        virtual_address: None,
-        original_index: None,
-        bytes: vec![],
-    };
-    // The addend is also fake because we don't know yet if the `target_address` here is the exact
-    // start of the symbol or if it's in the middle of it.
-    let fake_addend = 0;
-    Some(ObjReloc {
-        flags: RelocationFlags::Elf { r_type: elf::R_PPC_NONE },
-        address: cur_addr as u64,
-        target: fake_target_symbol,
-        addend: fake_addend,
-    })
-}
-
-// Searches through all instructions in a function, determining which registers have the addresses
-// of pooled data relocations in them, finding which instructions load data from those addresses,
-// and constructing a mapping of the address of that instruction to a "fake pool relocation" that
-// simulates what that instruction's relocation would look like if data hadn't been pooled.
-// Limitations: This method currently only goes through the instructions in a function in linear
-// order, from start to finish. It does *not* follow any branches. This means that it could have
-// false positives or false negatives in determining which relocation is currently loaded in which
-// register at any given point in the function, as control flow is not respected.
-// There are currently no known examples of this method producing inaccurate results in reality, but
-// if examples are found, it may be possible to update this method to also follow all branches so
-// that it produces more accurate results.
-fn generate_fake_pool_reloc_for_addr_mapping(
-    address: u64,
-    code: &[u8],
-    relocations: &[ObjReloc],
-) -> HashMap<u32, ObjReloc> {
-    let mut active_pool_relocs = HashMap::new();
-    let mut pool_reloc_for_addr = HashMap::new();
-    for (cur_addr, ins) in InsIter::new(code, address as u32) {
-        let simplified = ins.simplified();
-        let reloc = relocations.iter().find(|r| (r.address as u32 & !3) == cur_addr);
-
-        if let Some(reloc) = reloc {
-            // This instruction has a real relocation, so it may be a pool load we want to keep
-            // track of.
-            let args = &simplified.args;
-            match (ins.op, args[0], args[1], args[2]) {
-                (
-                    Opcode::Addi,
-                    Argument::GPR(addr_dst_gpr),
-                    Argument::GPR(_addr_src_gpr),
-                    Argument::Simm(_simm),
-                ) => {
-                    active_pool_relocs.insert(addr_dst_gpr.0, reloc.clone()); // `lis` + `addi`
-                }
-                (
-                    Opcode::Ori,
-                    Argument::GPR(addr_dst_gpr),
-                    Argument::GPR(_addr_src_gpr),
-                    Argument::Uimm(_uimm),
-                ) => {
-                    active_pool_relocs.insert(addr_dst_gpr.0, reloc.clone()); // `lis` + `ori`
-                }
-                (Opcode::B, _, _, _) => {
-                    if simplified.mnemonic == "bl" {
-                        // When encountering a function call, clear any active pool relocations from
-                        // the volatile registers (r0, r3-r12), but not the nonvolatile registers.
-                        active_pool_relocs.remove(&0);
-                        for gpr in 3..12 {
-                            active_pool_relocs.remove(&gpr);
-                        }
-                    }
-                }
-                _ => {}
-            }
-        } else if let Some((offset, addr_src_gpr, addr_dst_gpr)) =
-            get_offset_and_addr_gpr_for_possible_pool_reference(ins.op, &simplified)
-        {
-            // This instruction doesn't have a real relocation, so it may be a reference to one of
-            // the already-loaded pools.
-            if let Some(pool_reloc) = active_pool_relocs.get(&addr_src_gpr.0) {
-                if let Some(fake_pool_reloc) = make_fake_pool_reloc(offset, cur_addr, pool_reloc) {
-                    pool_reloc_for_addr.insert(cur_addr, fake_pool_reloc);
-                }
-                if let Some(addr_dst_gpr) = addr_dst_gpr {
-                    // If the address of the pool relocation got copied into another register, we
-                    // need to keep track of it in that register too as future instructions may
-                    // reference the symbol indirectly via this new register, instead of the
-                    // register the symbol's address was originally loaded into.
-                    // For example, the start of the function might `lis` + `addi` the start of the
-                    // ...data pool into r25, and then later the start of a loop will `addi` r25
-                    // with the offset within the .data section of an array variable into r21.
-                    // Then the body of the loop will `lwzx` one of the array elements from r21.
-                    let mut new_reloc = pool_reloc.clone();
-                    new_reloc.addend += offset as i64;
-                    active_pool_relocs.insert(addr_dst_gpr.0, new_reloc);
-                }
-            }
-        }
-    }
-
-    pool_reloc_for_addr
-}

objdiff-core/src/bindings/diff.rs

@@ -4,7 +4,6 @@ use crate::{
         ObjDataDiff, ObjDataDiffKind, ObjDiff, ObjInsArgDiff, ObjInsBranchFrom, ObjInsBranchTo,
         ObjInsDiff, ObjInsDiffKind, ObjSectionDiff, ObjSymbolDiff,
     },
-    obj,
     obj::{
         ObjInfo, ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc, ObjSectionKind, ObjSymbol,
         ObjSymbolFlagSet, ObjSymbolFlags,
@@ -40,14 +39,14 @@ impl ObjectDiff {
 impl SectionDiff {
     pub fn new(obj: &ObjInfo, section_index: usize, section_diff: &ObjSectionDiff) -> Self {
         let section = &obj.sections[section_index];
-        let symbols = section_diff.symbols.iter().map(|d| SymbolDiff::new(obj, d)).collect();
+        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,
-            symbols,
+            functions,
             data,
             match_percent: section_diff.match_percent,
         }
@@ -65,22 +64,13 @@ impl From<ObjSectionKind> for SectionKind {
     }
 }
 
-impl From<obj::SymbolRef> for SymbolRef {
-    fn from(value: obj::SymbolRef) -> Self {
-        Self {
-            section_index: if value.section_idx == obj::SECTION_COMMON {
-                None
-            } else {
-                Some(value.section_idx as u32)
-            },
-            symbol_index: value.symbol_idx as u32,
-        }
-    }
-}
-
-impl SymbolDiff {
+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()
@@ -88,9 +78,9 @@ impl SymbolDiff {
             .collect();
         Self {
             symbol: Some(Symbol::new(symbol)),
+            // diff_symbol,
             instructions,
             match_percent: symbol_diff.match_percent,
-            target: symbol_diff.target_symbol.map(SymbolRef::from),
         }
     }
 }
@@ -120,7 +110,7 @@ impl Symbol {
 fn symbol_flags(value: ObjSymbolFlagSet) -> u32 {
     let mut flags = 0u32;
     if value.0.contains(ObjSymbolFlags::Global) {
-        flags |= SymbolFlag::SymbolGlobal as u32;
+        flags |= SymbolFlag::SymbolNone as u32;
     }
     if value.0.contains(ObjSymbolFlags::Local) {
         flags |= SymbolFlag::SymbolLocal as u32;

objdiff-core/src/bindings/wasm.rs

@@ -13,22 +13,20 @@ fn parse_object(
 fn parse_and_run_diff(
     left: Option<Box<[u8]>>,
     right: Option<Box<[u8]>>,
-    diff_config: diff::DiffObjConfig,
-    mapping_config: diff::MappingConfig,
+    config: diff::DiffObjConfig,
 ) -> Result<DiffResult, JsError> {
-    let target = parse_object(left, &diff_config)?;
-    let base = parse_object(right, &diff_config)?;
-    run_diff(target.as_ref(), base.as_ref(), diff_config, mapping_config)
+    let target = parse_object(left, &config)?;
+    let base = parse_object(right, &config)?;
+    run_diff(target.as_ref(), base.as_ref(), config)
 }
 
 fn run_diff(
     left: Option<&obj::ObjInfo>,
     right: Option<&obj::ObjInfo>,
-    diff_config: diff::DiffObjConfig,
-    mapping_config: diff::MappingConfig,
+    config: diff::DiffObjConfig,
 ) -> Result<DiffResult, JsError> {
-    log::debug!("Running diff with config: {:?}", diff_config);
-    let result = diff::diff_objs(&diff_config, &mapping_config, left, right, None).to_js()?;
+    log::debug!("Running diff with config: {:?}", config);
+    let result = diff::diff_objs(&config, left, right, None).to_js()?;
     let left = left.and_then(|o| result.left.as_ref().map(|d| (o, d)));
     let right = right.and_then(|o| result.right.as_ref().map(|d| (o, d)));
     Ok(DiffResult::new(left, right))
@@ -48,10 +46,9 @@ fn run_diff(
 pub fn run_diff_proto(
     left: Option<Box<[u8]>>,
     right: Option<Box<[u8]>>,
-    diff_config: diff::DiffObjConfig,
-    mapping_config: diff::MappingConfig,
+    config: diff::DiffObjConfig,
 ) -> Result<Box<[u8]>, JsError> {
-    let out = parse_and_run_diff(left, right, diff_config, mapping_config)?;
+    let out = parse_and_run_diff(left, right, config)?;
     Ok(out.encode_to_vec().into_boxed_slice())
 }