Fix filtering out symbols from the target side that have a symbol with the same name and a .NON_MATCHING suffix.

- Target side: Show all the symbols except the `.NON_MATCHING` ones.
- Base side: Ignore all the `.NON_MATCHING` symbols and also ignore the ones with the same name without the suffix

Author: AngheloAlf

objdiff-cli/src/cmd/report.rs

@@ -4,12 +4,10 @@ use anyhow::{Context, Result, bail};
 use argp::FromArgs;
 use objdiff_core::{
     bindings::report::{
-        ChangeItem, ChangeItemInfo, ChangeUnit, Changes, ChangesInput, Measures, REPORT_VERSION,
-        Report, ReportCategory, ReportItem, ReportItemMetadata, ReportUnit, ReportUnitMetadata,
+        ChangeItem, ChangeItemInfo, ChangeUnit, Changes, ChangesInput, Measures, Report, ReportCategory, ReportItem, ReportItemMetadata, ReportUnit, ReportUnitMetadata, REPORT_VERSION
     },
     config::path::platform_path,
-    diff, obj,
-    obj::{SectionKind, SymbolFlag},
+    diff, obj::{self, DiffSide, SectionKind, SymbolFlag},
 };
 use prost::Message;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
@@ -177,14 +175,14 @@ fn report_object(
         .target_path
         .as_ref()
         .map(|p| {
-            obj::read::read(p.as_ref(), diff_config).with_context(|| format!("Failed to open {p}"))
+            obj::read::read(p.as_ref(), diff_config, DiffSide::Target).with_context(|| format!("Failed to open {p}"))
         })
         .transpose()?;
     let base = object
         .base_path
         .as_ref()
         .map(|p| {
-            obj::read::read(p.as_ref(), diff_config).with_context(|| format!("Failed to open {p}"))
+            obj::read::read(p.as_ref(), diff_config, DiffSide::Base).with_context(|| format!("Failed to open {p}"))
         })
         .transpose()?;
     let result =

objdiff-core/src/arch/mips.rs

@@ -12,10 +12,9 @@ use rabbitizer::{
 
 use crate::{
     arch::{Arch, RelocationOverride, RelocationOverrideTarget},
-    diff::{DiffObjConfig, MipsAbi, MipsInstrCategory, display::InstructionPart},
+    diff::{display::InstructionPart, DiffObjConfig, MipsAbi, MipsInstrCategory},
     obj::{
-        InstructionArg, InstructionArgValue, InstructionRef, Relocation, RelocationFlags,
-        ResolvedInstructionRef, ResolvedRelocation, Section, Symbol, SymbolFlag, SymbolFlagSet,
+        DiffSide, InstructionArg, InstructionArgValue, InstructionRef, Relocation, RelocationFlags, ResolvedInstructionRef, ResolvedRelocation, Section, Symbol, SymbolFlag, SymbolFlagSet
     },
 };
 
@@ -27,6 +26,7 @@ pub struct ArchMips {
     pub ri_gp_value: i32,
     pub paired_relocations: Vec<BTreeMap<u64, i64>>,
     pub ignored_symbols: BTreeSet<usize>,
+    pub diff_side: DiffSide,
 }
 
 const EF_MIPS_ABI: u32 = 0x0000F000;
@@ -38,7 +38,7 @@ const EF_MIPS_MACH_5900: u32 = 0x00920000;
 const R_MIPS15_S3: u32 = 119;
 
 impl ArchMips {
-    pub fn new(object: &object::File) -> Result<Self> {
+    pub fn new(object: &object::File, diff_side: DiffSide) -> Result<Self> {
         let mut abi = Abi::O32;
         let mut isa_extension = None;
         match object.flags() {
@@ -124,7 +124,7 @@ impl ArchMips {
             let Ok(name) = obj_symbol.name() else { continue };
             if let Some(prefix) = name.strip_suffix(".NON_MATCHING") {
                 ignored_symbols.insert(obj_symbol.index().0);
-                if let Some(target_symbol) = object.symbol_by_name(prefix) {
+                if diff_side == DiffSide::Base && let Some(target_symbol) = object.symbol_by_name(prefix) {
                     ignored_symbols.insert(target_symbol.index().0);
                 }
             }
@@ -137,6 +137,7 @@ impl ArchMips {
             ri_gp_value,
             paired_relocations,
             ignored_symbols,
+            diff_side,
         })
     }
 

objdiff-core/src/arch/mod.rs

@@ -17,13 +17,10 @@ use object::Endian as _;
 
 use crate::{
     diff::{
-        DiffObjConfig,
-        display::{ContextItem, HoverItem, InstructionPart},
+        display::{ContextItem, HoverItem, InstructionPart}, DiffObjConfig
     },
     obj::{
-        FlowAnalysisResult, InstructionArg, InstructionRef, Object, ParsedInstruction, Relocation,
-        RelocationFlags, ResolvedInstructionRef, ResolvedSymbol, Section, Symbol, SymbolFlagSet,
-        SymbolKind,
+        DiffSide, FlowAnalysisResult, InstructionArg, InstructionRef, Object, ParsedInstruction, Relocation, RelocationFlags, ResolvedInstructionRef, ResolvedSymbol, Section, Symbol, SymbolFlagSet, SymbolKind
     },
     util::ReallySigned,
 };
@@ -418,15 +415,18 @@ pub trait Arch: Any + Debug + Send + Sync {
     }
 }
 
-pub fn new_arch(object: &object::File) -> Result<Box<dyn Arch>> {
+pub fn new_arch(object: &object::File, diff_side: DiffSide) -> Result<Box<dyn Arch>> {
     use object::Object as _;
+    // Avoid unused warnings on non-mips builds
+    let _ = diff_side;
+
     Ok(match object.architecture() {
         #[cfg(feature = "ppc")]
         object::Architecture::PowerPc | object::Architecture::PowerPc64 => {
             Box::new(ppc::ArchPpc::new(object)?)
         }
         #[cfg(feature = "mips")]
-        object::Architecture::Mips => Box::new(mips::ArchMips::new(object)?),
+        object::Architecture::Mips => Box::new(mips::ArchMips::new(object, diff_side)?),
         #[cfg(feature = "x86")]
         object::Architecture::I386 | object::Architecture::X86_64 => {
             Box::new(x86::ArchX86::new(object)?)

objdiff-core/src/jobs/objdiff.rs

@@ -5,10 +5,10 @@ use time::OffsetDateTime;
 use typed_path::Utf8PlatformPathBuf;
 
 use crate::{
-    build::{BuildConfig, BuildStatus, run_make},
-    diff::{DiffObjConfig, MappingConfig, ObjectDiff, diff_objs},
-    jobs::{Job, JobContext, JobResult, JobState, start_job, update_status},
-    obj::{Object, read},
+    build::{run_make, BuildConfig, BuildStatus},
+    diff::{diff_objs, DiffObjConfig, MappingConfig, ObjectDiff},
+    jobs::{start_job, update_status, Job, JobContext, JobResult, JobState},
+    obj::{read, DiffSide, Object},
 };
 
 pub struct ObjDiffConfig {
@@ -117,7 +117,7 @@ fn run_build(
                 &cancel,
             )?;
             step_idx += 1;
-            match read::read(target_path.as_ref(), &config.diff_obj_config) {
+            match read::read(target_path.as_ref(), &config.diff_obj_config, DiffSide::Target) {
                 Ok(obj) => Some(obj),
                 Err(e) => {
                     first_status = BuildStatus {
@@ -141,7 +141,7 @@ fn run_build(
         Some(base_path) if second_status.success => {
             update_status(context, format!("Loading base {base_path}"), step_idx, total, &cancel)?;
             step_idx += 1;
-            match read::read(base_path.as_ref(), &config.diff_obj_config) {
+            match read::read(base_path.as_ref(), &config.diff_obj_config, DiffSide::Base) {
                 Ok(obj) => Some(obj),
                 Err(e) => {
                     second_status = BuildStatus {

objdiff-core/src/obj/mod.rs

@@ -437,3 +437,11 @@ impl Default for ResolvedInstructionRef<'_> {
         }
     }
 }
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum DiffSide {
+    /// The target/expected side of the diff.
+    Target,
+    /// The base side of the diff.
+    Base,
+}

objdiff-core/src/obj/read.rs

@@ -11,12 +11,10 @@ use anyhow::{Context, Result, anyhow, bail, ensure};
 use object::{Object as _, ObjectSection as _, ObjectSymbol as _};
 
 use crate::{
-    arch::{Arch, RelocationOverride, RelocationOverrideTarget, new_arch},
+    arch::{new_arch, Arch, RelocationOverride, RelocationOverrideTarget},
     diff::DiffObjConfig,
     obj::{
-        FlowAnalysisResult, Object, Relocation, RelocationFlags, Section, SectionData, SectionFlag,
-        SectionKind, Symbol, SymbolFlag, SymbolKind,
-        split_meta::{SPLITMETA_SECTION, SplitMeta},
+        split_meta::{SplitMeta, SPLITMETA_SECTION}, DiffSide, FlowAnalysisResult, Object, Relocation, RelocationFlags, Section, SectionData, SectionFlag, SectionKind, Symbol, SymbolFlag, SymbolKind
     },
     util::{align_data_slice_to, align_u64_to, read_u16, read_u32},
 };
@@ -925,21 +923,21 @@ fn do_combine_sections(
 }
 
 #[cfg(feature = "std")]
-pub fn read(obj_path: &std::path::Path, config: &DiffObjConfig) -> Result<Object> {
+pub fn read(obj_path: &std::path::Path, config: &DiffObjConfig, diff_side: DiffSide) -> Result<Object> {
     let (data, timestamp) = {
         let file = std::fs::File::open(obj_path)?;
         let timestamp = filetime::FileTime::from_last_modification_time(&file.metadata()?);
         (unsafe { memmap2::Mmap::map(&file) }?, timestamp)
     };
-    let mut obj = parse(&data, config)?;
+    let mut obj = parse(&data, config, diff_side)?;
     obj.path = Some(obj_path.to_path_buf());
     obj.timestamp = Some(timestamp);
     Ok(obj)
 }
 
-pub fn parse(data: &[u8], config: &DiffObjConfig) -> Result<Object> {
+pub fn parse(data: &[u8], config: &DiffObjConfig, diff_side: DiffSide) -> Result<Object> {
     let obj_file = object::File::parse(data)?;
-    let mut arch = new_arch(&obj_file)?;
+    let mut arch = new_arch(&obj_file, diff_side)?;
     let split_meta = parse_split_meta(&obj_file)?;
     let (mut sections, section_indices) =
         map_sections(arch.as_ref(), &obj_file, split_meta.as_ref())?;