[WIP] OMF object support

Cargo.lock

@@ -3484,7 +3484,7 @@ dependencies = [
 
 [[package]]
 name = "objdiff-cli"
-version = "3.3.1"
+version = "3.3.0"
 dependencies = [
  "anyhow",
  "argp",
@@ -3507,7 +3507,7 @@ dependencies = [
 
 [[package]]
 name = "objdiff-core"
-version = "3.3.1"
+version = "3.3.0"
 dependencies = [
  "anyhow",
  "arm-attr",
@@ -3563,7 +3563,7 @@ dependencies = [
 
 [[package]]
 name = "objdiff-gui"
-version = "3.3.1"
+version = "3.3.0"
 dependencies = [
  "anyhow",
  "argp",
@@ -3601,7 +3601,7 @@ dependencies = [
 
 [[package]]
 name = "objdiff-wasm"
-version = "3.3.1"
+version = "3.3.0"
 dependencies = [
  "log",
  "objdiff-core",
@@ -3624,8 +3624,7 @@ dependencies = [
 [[package]]
 name = "object"
 version = "0.37.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
+source = "git+https://github.com/encounter/object?branch=omf#f8023933c931335a1ea55384bfef538457c412a5"
 dependencies = [
  "memchr",
 ]

Cargo.toml

@@ -14,7 +14,7 @@ default-members = [
 resolver = "3"
 
 [workspace.package]
-version = "3.3.1"
+version = "3.3.0"
 authors = ["Luke Street <luke@street.dev>"]
 edition = "2024"
 license = "MIT OR Apache-2.0"

objdiff-core/Cargo.toml

@@ -132,7 +132,7 @@ itertools = { version = "0.14", default-features = false, features = ["use_alloc
 log = { version = "0.4", default-features = false, optional = true }
 memmap2 = { version = "0.9", optional = true }
 num-traits = { version = "0.2", default-features = false, optional = true }
-object = { version = "0.37", default-features = false, features = ["read_core", "elf", "coff"] }
+object = { git = "https://github.com/encounter/object", branch = "omf", default-features = false, features = ["read_core", "elf", "coff", "omf"] }
 pbjson = { version = "0.8", default-features = false, optional = true }
 prost = { version = "0.14", default-features = false, features = ["derive"], optional = true }
 regex = { version = "1.11", default-features = false, features = [], optional = true }

objdiff-core/config-schema.json

@@ -82,27 +82,6 @@
       "name": "Space between args",
       "description": "Adds a space between arguments in the diff output."
     },
-    {
-      "id": "showSymbolSizes",
-      "type": "choice",
-      "default": "off",
-      "name": "Show symbol sizes",
-      "description": "Shows symbol sizes in the symbol view.",
-      "items": [
-        {
-          "value": "off",
-          "name": "Off"
-        },
-        {
-          "value": "hex",
-          "name": "Hex"
-        },
-        {
-          "value": "decimal",
-          "name": "Decimal"
-        }
-      ]
-    },
     {
       "id": "combineDataSections",
       "type": "boolean",
@@ -317,7 +296,6 @@
       "properties": [
         "functionRelocDiffs",
         "demangler",
-        "showSymbolSizes",
         "spaceBetweenArgs",
         "combineDataSections",
         "combineTextSections"

objdiff-core/src/arch/mips.rs

@@ -293,7 +293,6 @@ impl Arch for ArchMips {
                         }
                         elf::R_MIPS_PC16 => 0, // PC-relative relocation
                         R_MIPS15_S3 => ((code & 0x001FFFC0) >> 3) as i64,
-                        elf::R_MIPS_GPREL32 => (code as i32 as i64) + self.ri_gp_value as i64,
                         flags => bail!("Unsupported MIPS implicit relocation {flags:?}"),
                     };
                     Ok(Some(RelocationOverride { target: RelocationOverrideTarget::Keep, addend }))
@@ -319,7 +318,6 @@ impl Arch for ArchMips {
                 elf::R_MIPS_GOT16 => Some("R_MIPS_GOT16"),
                 elf::R_MIPS_PC16 => Some("R_MIPS_PC16"),
                 elf::R_MIPS_CALL16 => Some("R_MIPS_CALL16"),
-                elf::R_MIPS_GPREL32 => Some("R_MIPS_GPREL32"),
                 R_MIPS15_S3 => Some("R_MIPS15_S3"),
                 _ => None,
             },

objdiff-core/src/arch/ppc/mod.rs

@@ -332,6 +332,7 @@ impl Arch for ArchPpc {
                 pe::IMAGE_REL_PPC_PAIR => Some("IMAGE_REL_PPC_PAIR"),
                 _ => None,
             },
+            _ => None,
         }
     }
 

objdiff-core/src/arch/x86.rs

@@ -72,6 +72,7 @@ impl ArchX86 {
                     elf::R_386_16 => Some(2),
                     _ => None,
                 },
+                RelocationFlags::Omf() => Some(4), // TODO
             },
             Architecture::X86_64 => match flags {
                 RelocationFlags::Coff(typ) => match typ {
@@ -84,6 +85,7 @@ impl ArchX86 {
                     elf::R_X86_64_64 => Some(8),
                     _ => None,
                 },
+                RelocationFlags::Omf() => None, // TODO
             },
         }
     }

objdiff-core/src/obj/mdebug.rs

@@ -1,401 +0,0 @@
-use alloc::vec::Vec;
-
-use anyhow::{Context, Result, bail, ensure};
-use object::{Endianness, Object, ObjectSection};
-
-use super::{Section, SectionKind};
-
-const HDRR_SIZE: usize = 0x60;
-const FDR_SIZE: usize = 0x48;
-const PDR_SIZE: usize = 0x34;
-const SYMR_SIZE: usize = 0x0c;
-
-const ST_PROC: u8 = 6;
-const ST_STATICPROC: u8 = 14;
-const ST_END: u8 = 8;
-
-pub(super) fn parse_line_info_mdebug(
-    obj_file: &object::File,
-    sections: &mut [Section],
-) -> Result<()> {
-    let Some(section) = obj_file.section_by_name(".mdebug") else {
-        return Ok(());
-    };
-
-    let data = section.data().context("failed to read .mdebug contents")?;
-    if data.len() < HDRR_SIZE {
-        return Ok(());
-    }
-
-    let section_file_offset = section.file_range().map(|(offset, _)| offset as usize);
-
-    let endianness = obj_file.endianness();
-    let header = Header::parse(data, endianness)?;
-
-    let symbols_data = slice_at(
-        data,
-        header.cb_sym_offset,
-        header.isym_max.checked_mul(SYMR_SIZE as u32).context("symbol table size overflow")?,
-        section_file_offset,
-    )?;
-    let symbols = parse_symbols(symbols_data, endianness)?;
-
-    let fdr_data = slice_at(
-        data,
-        header.cb_fd_offset,
-        header
-            .ifd_max
-            .checked_mul(FDR_SIZE as u32)
-            .context("file descriptor table size overflow")?,
-        section_file_offset,
-    )?;
-
-    for fdr_index in 0..header.ifd_max as usize {
-        let fdr_offset = fdr_index * FDR_SIZE;
-        let fdr = FileDescriptor::parse(&fdr_data[fdr_offset..fdr_offset + FDR_SIZE], endianness)?;
-        if fdr.cpd == 0 || fdr.csym == 0 {
-            continue;
-        }
-
-        let sym_base = fdr.isym_base as usize;
-        let sym_end = sym_base + fdr.csym as usize;
-        if sym_end > symbols.len() {
-            continue;
-        }
-
-        let Some(line_file_offset) = header.cb_line_offset.checked_add(fdr.cb_line_offset) else {
-            continue;
-        };
-        let Some(line_file_base) =
-            resolve_offset(line_file_offset, data.len(), section_file_offset)
-        else {
-            continue;
-        };
-        let Some(line_file_end) = line_file_base.checked_add(fdr.cb_line as usize) else {
-            continue;
-        };
-        if line_file_end > data.len() {
-            continue;
-        }
-
-        for local_proc_index in 0..fdr.cpd as usize {
-            let pdr_index = fdr.ipd_first as usize + local_proc_index;
-            let pdr_offset = header
-                .cb_pd_offset
-                .checked_add((pdr_index as u32) * PDR_SIZE as u32)
-                .context("procedure descriptor offset overflow")?;
-            let pdr_data = match slice_at(data, pdr_offset, PDR_SIZE as u32, section_file_offset) {
-                Ok(data) => data,
-                Err(_) => continue,
-            };
-            let pdr = ProcDescriptor::parse(pdr_data, endianness)?;
-            if pdr.isym as usize >= fdr.csym as usize {
-                continue;
-            }
-            let global_sym_index = sym_base + pdr.isym as usize;
-            let Some(start_symbol) = symbols.get(global_sym_index) else {
-                continue;
-            };
-            if start_symbol.st != ST_PROC && start_symbol.st != ST_STATICPROC {
-                continue;
-            }
-
-            let local_index = pdr.isym as u32;
-            let mut end_address = None;
-            for sym in &symbols[global_sym_index..sym_end] {
-                if sym.st == ST_END && sym.index == local_index {
-                    end_address = Some(sym.value);
-                    break;
-                }
-            }
-            let Some(end_address) = end_address else {
-                continue;
-            };
-            let Some(size) = end_address.checked_sub(start_symbol.value) else {
-                continue;
-            };
-            if size == 0 || size % 4 != 0 {
-                continue;
-            }
-            let word_count = (size / 4) as usize;
-            if word_count == 0 {
-                continue;
-            }
-
-            let Some(mut cursor) = line_file_base.checked_add(pdr.cb_line_offset as usize) else {
-                continue;
-            };
-            if cursor >= line_file_end {
-                continue;
-            }
-
-            let mut line_number = pdr.ln_low as i32;
-            let mut lines = Vec::with_capacity(word_count);
-            while lines.len() < word_count && cursor < line_file_end {
-                let b0 = data[cursor];
-                cursor += 1;
-                let count = (b0 & 0x0f) as usize + 1;
-                let delta = decode_delta(endianness, b0 >> 4, data, &mut cursor, line_file_end)?;
-                line_number = line_number.wrapping_add(delta as i32);
-                for _ in 0..count {
-                    if lines.len() == word_count {
-                        break;
-                    }
-                    lines.push(line_number);
-                }
-            }
-
-            if lines.len() != word_count {
-                continue;
-            }
-
-            assign_lines(sections, fdr.adr as u64 + pdr.addr as u64, &lines);
-        }
-    }
-
-    Ok(())
-}
-
-fn assign_lines(sections: &mut [Section], base_address: u64, lines: &[i32]) {
-    let mut address = base_address;
-    for &line in lines {
-        if line >= 0
-            && let Some(section) = find_code_section(sections, address)
-        {
-            section.line_info.insert(address, line as u32);
-        }
-        address = address.wrapping_add(4);
-    }
-}
-
-fn find_code_section(sections: &mut [Section], address: u64) -> Option<&mut Section> {
-    sections.iter_mut().find(|section| {
-        section.kind == SectionKind::Code
-            && address >= section.address
-            && address < section.address + section.size
-    })
-}
-
-fn decode_delta(
-    endianness: Endianness,
-    nibble: u8,
-    data: &[u8],
-    cursor: &mut usize,
-    end: usize,
-) -> Result<i32> {
-    if nibble == 8 {
-        ensure!(*cursor + 2 <= end, "extended delta out of range");
-        let bytes: [u8; 2] = data[*cursor..*cursor + 2].try_into().unwrap();
-        *cursor += 2;
-        Ok(match endianness {
-            Endianness::Big => i16::from_be_bytes(bytes) as i32,
-            Endianness::Little => i16::from_le_bytes(bytes) as i32,
-        })
-    } else {
-        let mut value = (nibble & 0x0f) as i32;
-        if value & 0x8 != 0 {
-            value -= 0x10;
-        }
-        Ok(value)
-    }
-}
-
-fn slice_at(
-    data: &[u8],
-    offset: u32,
-    size: u32,
-    section_file_offset: Option<usize>,
-) -> Result<&[u8]> {
-    let size = size as usize;
-    if size == 0 {
-        ensure!(
-            resolve_offset(offset, data.len(), section_file_offset).is_some(),
-            "offset outside of .mdebug section"
-        );
-        return Ok(&data[0..0]);
-    }
-    let Some(offset) = resolve_offset(offset, data.len(), section_file_offset) else {
-        bail!("offset outside of .mdebug section");
-    };
-    let end = offset.checked_add(size).context("range overflow")?;
-    ensure!(end <= data.len(), "range exceeds .mdebug size");
-    Ok(&data[offset..end])
-}
-
-fn resolve_offset(
-    offset: u32,
-    data_len: usize,
-    section_file_offset: Option<usize>,
-) -> Option<usize> {
-    let offset = offset as usize;
-    if offset <= data_len {
-        Some(offset)
-    } else if let Some(file_offset) = section_file_offset {
-        offset.checked_sub(file_offset).filter(|rel| *rel <= data_len)
-    } else {
-        None
-    }
-}
-
-#[derive(Clone, Copy)]
-struct Header {
-    cb_line_offset: u32,
-    cb_pd_offset: u32,
-    cb_sym_offset: u32,
-    cb_fd_offset: u32,
-    isym_max: u32,
-    ifd_max: u32,
-}
-
-impl Header {
-    fn parse(data: &[u8], endianness: Endianness) -> Result<Self> {
-        ensure!(HDRR_SIZE <= data.len(), ".mdebug header truncated");
-        let mut cursor = 0;
-        let magic = read_u16(data, &mut cursor, endianness)?;
-        let _vstamp = read_u16(data, &mut cursor, endianness)?;
-        ensure!(magic == 0x7009, "unexpected .mdebug magic: {magic:#x}");
-        let _iline_max = read_u32(data, &mut cursor, endianness)?;
-        let _cb_line = read_u32(data, &mut cursor, endianness)?;
-        let cb_line_offset = read_u32(data, &mut cursor, endianness)?;
-        let _idn_max = read_u32(data, &mut cursor, endianness)?;
-        let _cb_dn_offset = read_u32(data, &mut cursor, endianness)?;
-        let _ipd_max = read_u32(data, &mut cursor, endianness)?;
-        let cb_pd_offset = read_u32(data, &mut cursor, endianness)?;
-        let isym_max = read_u32(data, &mut cursor, endianness)?;
-        let cb_sym_offset = read_u32(data, &mut cursor, endianness)?;
-        let _iopt_max = read_u32(data, &mut cursor, endianness)?;
-        let _cb_opt_offset = read_u32(data, &mut cursor, endianness)?;
-        let _iaux_max = read_u32(data, &mut cursor, endianness)?;
-        let _cb_aux_offset = read_u32(data, &mut cursor, endianness)?;
-        let _iss_max = read_u32(data, &mut cursor, endianness)?;
-        let _cb_ss_offset = read_u32(data, &mut cursor, endianness)?;
-        let _iss_ext_max = read_u32(data, &mut cursor, endianness)?;
-        let _cb_ss_ext_offset = read_u32(data, &mut cursor, endianness)?;
-        let ifd_max = read_u32(data, &mut cursor, endianness)?;
-        let cb_fd_offset = read_u32(data, &mut cursor, endianness)?;
-        let _crfd = read_u32(data, &mut cursor, endianness)?;
-        let _cb_rfd_offset = read_u32(data, &mut cursor, endianness)?;
-        let _iext_max = read_u32(data, &mut cursor, endianness)?;
-        let _cb_ext_offset = read_u32(data, &mut cursor, endianness)?;
-
-        Ok(Header { cb_line_offset, cb_pd_offset, cb_sym_offset, cb_fd_offset, isym_max, ifd_max })
-    }
-}
-
-#[derive(Clone, Copy)]
-struct FileDescriptor {
-    adr: u32,
-    isym_base: u32,
-    csym: u32,
-    ipd_first: u16,
-    cpd: u16,
-    cb_line_offset: u32,
-    cb_line: u32,
-}
-
-impl FileDescriptor {
-    fn parse(data: &[u8], endianness: Endianness) -> Result<Self> {
-        ensure!(data.len() >= FDR_SIZE, "FDR truncated");
-        let mut cursor = 0;
-        let adr = read_u32(data, &mut cursor, endianness)?;
-        let _rss = read_u32(data, &mut cursor, endianness)?;
-        let _iss_base = read_u32(data, &mut cursor, endianness)?;
-        let _cb_ss = read_u32(data, &mut cursor, endianness)?;
-        let isym_base = read_u32(data, &mut cursor, endianness)?;
-        let csym = read_u32(data, &mut cursor, endianness)?;
-        let _iline_base = read_u32(data, &mut cursor, endianness)?;
-        let _cline = read_u32(data, &mut cursor, endianness)?;
-        let _iopt_base = read_u32(data, &mut cursor, endianness)?;
-        let _copt = read_u32(data, &mut cursor, endianness)?;
-        let ipd_first = read_u16(data, &mut cursor, endianness)?;
-        let cpd = read_u16(data, &mut cursor, endianness)?;
-        let _iaux_base = read_u32(data, &mut cursor, endianness)?;
-        let _caux = read_u32(data, &mut cursor, endianness)?;
-        let _rfd_base = read_u32(data, &mut cursor, endianness)?;
-        let _crfd = read_u32(data, &mut cursor, endianness)?;
-        let _bits = read_u32(data, &mut cursor, endianness)?;
-        let cb_line_offset = read_u32(data, &mut cursor, endianness)?;
-        let cb_line = read_u32(data, &mut cursor, endianness)?;
-
-        Ok(FileDescriptor { adr, isym_base, csym, ipd_first, cpd, cb_line_offset, cb_line })
-    }
-}
-
-#[derive(Clone, Copy)]
-struct ProcDescriptor {
-    addr: u32,
-    isym: u32,
-    ln_low: i32,
-    cb_line_offset: u32,
-}
-
-impl ProcDescriptor {
-    fn parse(data: &[u8], endianness: Endianness) -> Result<Self> {
-        ensure!(data.len() >= PDR_SIZE, "PDR truncated");
-        let mut cursor = 0;
-        let addr = read_u32(data, &mut cursor, endianness)?;
-        let isym = read_u32(data, &mut cursor, endianness)?;
-        let _iline = read_u32(data, &mut cursor, endianness)?;
-        let _regmask = read_u32(data, &mut cursor, endianness)?;
-        let _regoffset = read_u32(data, &mut cursor, endianness)?;
-        let _iopt = read_u32(data, &mut cursor, endianness)?;
-        let _fregmask = read_u32(data, &mut cursor, endianness)?;
-        let _fregoffset = read_u32(data, &mut cursor, endianness)?;
-        let _frameoffset = read_u32(data, &mut cursor, endianness)?;
-        let _framereg = read_u16(data, &mut cursor, endianness)?;
-        let _pcreg = read_u16(data, &mut cursor, endianness)?;
-        let ln_low = read_i32(data, &mut cursor, endianness)?;
-        let _ln_high = read_i32(data, &mut cursor, endianness)?;
-        let cb_line_offset = read_u32(data, &mut cursor, endianness)?;
-
-        Ok(ProcDescriptor { addr, isym, ln_low, cb_line_offset })
-    }
-}
-
-#[derive(Clone, Copy)]
-struct SymbolEntry {
-    value: u32,
-    st: u8,
-    index: u32,
-}
-
-fn parse_symbols(data: &[u8], endianness: Endianness) -> Result<Vec<SymbolEntry>> {
-    ensure!(data.len().is_multiple_of(SYMR_SIZE), "symbol table misaligned");
-    let mut symbols = Vec::with_capacity(data.len() / SYMR_SIZE);
-    let mut cursor = 0;
-    while cursor + SYMR_SIZE <= data.len() {
-        let _iss = read_u32(data, &mut cursor, endianness)?;
-        let value = read_u32(data, &mut cursor, endianness)?;
-        let bits = read_u32(data, &mut cursor, endianness)?;
-        let (st, index) = match endianness {
-            Endianness::Big => (((bits >> 26) & 0x3f) as u8, bits & 0x000f_ffff),
-            Endianness::Little => (((bits & 0x3f) as u8), (bits >> 12) & 0x000f_ffff),
-        };
-        symbols.push(SymbolEntry { value, st, index });
-    }
-    Ok(symbols)
-}
-
-fn read_u16(data: &[u8], cursor: &mut usize, endianness: Endianness) -> Result<u16> {
-    ensure!(*cursor + 2 <= data.len(), "unexpected EOF while reading u16");
-    let bytes: [u8; 2] = data[*cursor..*cursor + 2].try_into().unwrap();
-    *cursor += 2;
-    Ok(match endianness {
-        Endianness::Big => u16::from_be_bytes(bytes),
-        Endianness::Little => u16::from_le_bytes(bytes),
-    })
-}
-
-fn read_u32(data: &[u8], cursor: &mut usize, endianness: Endianness) -> Result<u32> {
-    ensure!(*cursor + 4 <= data.len(), "unexpected EOF while reading u32");
-    let bytes: [u8; 4] = data[*cursor..*cursor + 4].try_into().unwrap();
-    *cursor += 4;
-    Ok(match endianness {
-        Endianness::Big => u32::from_be_bytes(bytes),
-        Endianness::Little => u32::from_le_bytes(bytes),
-    })
-}
-
-fn read_i32(data: &[u8], cursor: &mut usize, endianness: Endianness) -> Result<i32> {
-    Ok(read_u32(data, cursor, endianness)? as i32)
-}

objdiff-core/src/obj/mod.rs

@@ -1,6 +1,5 @@
 #[cfg(feature = "dwarf")]
 mod dwarf2;
-mod mdebug;
 pub mod read;
 pub mod split_meta;
 
@@ -371,6 +370,7 @@ pub struct Relocation {
 pub enum RelocationFlags {
     Elf(u32),
     Coff(u16),
+    Omf(/* TODO */),
 }
 
 #[derive(Debug, Copy, Clone)]

objdiff-core/src/obj/read.rs

@@ -510,6 +510,7 @@ fn map_section_relocations(
         let flags = match reloc.flags() {
             object::RelocationFlags::Elf { r_type } => RelocationFlags::Elf(r_type),
             object::RelocationFlags::Coff { typ } => RelocationFlags::Coff(typ),
+            object::RelocationFlags::Omf { .. } => RelocationFlags::Omf(/* TODO */),
             flags => bail!("Unhandled relocation flags: {:?}", flags),
         };
         let target_symbol = match symbol_indices.get(symbol_index.0).copied() {
@@ -654,10 +655,6 @@ fn parse_line_info(
         log::warn!("Failed to parse COFF line info: {e}");
     }
 
-    if let Err(e) = super::mdebug::parse_line_info_mdebug(obj_file, sections) {
-        log::warn!("Failed to parse MIPS mdebug line info: {e}");
-    }
-
     Ok(())
 }
 

objdiff-core/tests/arch_mips.rs

@@ -62,21 +62,3 @@ fn filter_non_matching() {
     .unwrap();
     insta::assert_debug_snapshot!(obj.symbols);
 }
-
-#[test]
-#[cfg(feature = "mips")]
-fn ido_mdebug_line_numbers() {
-    let diff_config = diff::DiffObjConfig::default();
-    let obj = obj::read::parse(
-        include_object!("data/mips/ido_lines_example.o"),
-        &diff_config,
-        diff::DiffSide::Base,
-    )
-    .unwrap();
-
-    let text_section = obj.sections.iter().find(|s| s.name == ".text").unwrap();
-    assert_eq!(text_section.line_info.get(&0), Some(&6));
-    assert_eq!(text_section.line_info.get(&12), Some(&7));
-    assert_eq!(text_section.line_info.get(&56), Some(&9));
-    assert_eq!(text_section.line_info.len(), 66);
-}

objdiff-gui/src/app_config.rs

@@ -6,7 +6,7 @@ use objdiff_core::{
     config::ScratchConfig,
     diff::{
         ArmArchVersion, ArmR9Usage, DiffObjConfig, FunctionRelocDiffs, MipsAbi, MipsInstrCategory,
-        ShowSymbolSizes, X86Formatter,
+        X86Formatter,
     },
 };
 use typed_path::{Utf8PlatformPathBuf, Utf8UnixPathBuf};
@@ -227,7 +227,6 @@ pub struct DiffObjConfigV1 {
     pub relax_reloc_diffs: bool,
     #[serde(default = "bool_true")]
     pub space_between_args: bool,
-    pub show_symbol_sizes: ShowSymbolSizes,
     pub combine_data_sections: bool,
     // x86
     pub x86_formatter: X86Formatter,
@@ -249,7 +248,6 @@ impl Default for DiffObjConfigV1 {
         Self {
             relax_reloc_diffs: false,
             space_between_args: true,
-            show_symbol_sizes: Default::default(),
             combine_data_sections: false,
             x86_formatter: Default::default(),
             mips_abi: Default::default(),
@@ -274,7 +272,6 @@ impl DiffObjConfigV1 {
                 FunctionRelocDiffs::default()
             },
             space_between_args: self.space_between_args,
-            show_symbol_sizes: self.show_symbol_sizes,
             combine_data_sections: self.combine_data_sections,
             x86_formatter: self.x86_formatter,
             mips_abi: self.mips_abi,

objdiff-gui/src/views/diff.rs

@@ -665,7 +665,6 @@ fn diff_col_ui(
                 appearance,
                 column,
                 open_sections,
-                diff_config,
             ) {
                 match (column, action) {
                     (
@@ -704,7 +703,6 @@ fn diff_col_ui(
                 appearance,
                 column,
                 open_sections,
-                diff_config,
             ) {
                 ret = Some(result);
             }

objdiff-gui/src/views/symbol_diff.rs

@@ -6,7 +6,7 @@ use egui::{
 };
 use objdiff_core::{
     diff::{
-        DiffObjConfig, ObjectDiff, ShowSymbolSizes, SymbolDiff,
+        ObjectDiff, SymbolDiff,
         display::{
             HighlightKind, SectionDisplay, SymbolFilter, SymbolNavigationKind, display_sections,
             symbol_context, symbol_hover,
@@ -525,7 +525,6 @@ fn symbol_ui(
     state: &SymbolViewState,
     appearance: &Appearance,
     column: usize,
-    diff_config: &DiffObjConfig,
 ) -> Option<DiffViewAction> {
     let mut ret = None;
     let mut job = LayoutJob::default();
@@ -573,21 +572,6 @@ fn symbol_ui(
         write_text(") ", appearance.text_color, &mut job, appearance.code_font.clone());
     }
     write_text(name, appearance.highlight_color, &mut job, appearance.code_font.clone());
-    if diff_config.show_symbol_sizes == ShowSymbolSizes::Decimal {
-        write_text(
-            &format!(" (size={})", symbol.size),
-            appearance.deemphasized_text_color,
-            &mut job,
-            appearance.code_font.clone(),
-        );
-    } else if diff_config.show_symbol_sizes == ShowSymbolSizes::Hex {
-        write_text(
-            &format!(" (size={:x})", symbol.size),
-            appearance.deemphasized_text_color,
-            &mut job,
-            appearance.code_font.clone(),
-        );
-    }
     let response = egui::Button::selectable(selected, job)
         .ui(ui)
         .on_hover_ui_at_pointer(|ui| symbol_hover_ui(ui, ctx, symbol_idx, appearance));
@@ -662,7 +646,6 @@ pub fn symbol_list_ui(
     appearance: &Appearance,
     column: usize,
     open_sections: Option<bool>,
-    diff_config: &DiffObjConfig,
 ) -> Option<DiffViewAction> {
     let mut ret = None;
     ScrollArea::both().auto_shrink([false, false]).show(ui, |ui| {
@@ -787,7 +770,6 @@ pub fn symbol_list_ui(
                                 state,
                                 appearance,
                                 column,
-                                diff_config,
                             ) {
                                 ret = Some(result);
                             }

objdiff-wasm/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "objdiff-wasm",
-  "version": "3.3.1",
+  "version": "3.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "objdiff-wasm",
-      "version": "3.3.1",
+      "version": "3.3.0",
       "license": "MIT OR Apache-2.0",
       "devDependencies": {
         "@biomejs/biome": "^1.9.3",
@@ -852,7 +852,6 @@
       "integrity": "sha512-Y3b4Y7lGIvNPywspP38deHkp/EEkTXrJEHeX1K5yz8U/94PkWvPlDebjjiSvmI6TT+9iVzsq22qDlBEdDuJZhA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@rspack/core": "1.2.3",
         "@rspack/lite-tapable": "~1.0.1",
@@ -1084,7 +1083,6 @@
       "integrity": "sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "dependencies": {
         "tslib": "^2.8.0"
       }
@@ -2141,7 +2139,6 @@
       "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -2169,7 +2166,6 @@
       "integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"

objdiff-wasm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objdiff-wasm",
-  "version": "3.3.1",
+  "version": "3.3.0",
   "description": "A local diffing tool for decompilation projects.",
   "author": {
     "name": "Luke Street",