Add graphics backend configuration

Hopefully #74, #73, #56

README.md

@@ -14,9 +14,10 @@ Features:
 - Click to highlight all instances of values and registers.
 
 Supports:
-- PowerPC 750CL (GameCube & Wii)
+- PowerPC 750CL (GameCube, Wii)
-- MIPS (Nintendo 64 & PS2)
+- MIPS (N64, PS1, PS2, PSP)
 - x86 (COFF only at the moment)
+- ARMv5 (DS)
 
 See [Usage](#usage) for more information.
 

objdiff-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "objdiff-cli"
-version = "2.0.0-alpha.1"
+version = "2.0.0-alpha.4"
 edition = "2021"
 rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]

objdiff-cli/src/cmd/diff.rs

@@ -823,6 +823,8 @@ impl FunctionDiffUi {
             relax_reloc_diffs: self.relax_reloc_diffs,
             space_between_args: true,                // TODO
             x86_formatter: Default::default(),       // TODO
+            mips_abi: Default::default(),            // TODO
+            mips_instr_category: Default::default(), // TODO
         };
         let result = diff::diff_objs(&config, target.as_ref(), base.as_ref(), prev.as_ref())?;
 

objdiff-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "objdiff-core"
-version = "2.0.0-alpha.1"
+version = "2.0.0-alpha.4"
 edition = "2021"
 rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]
@@ -12,13 +12,14 @@ A local diffing tool for decompilation projects.
 """
 
 [features]
-all = ["config", "dwarf", "mips", "ppc", "x86"]
+all = ["config", "dwarf", "mips", "ppc", "x86", "arm"]
 any-arch = [] # Implicit, used to check if any arch is enabled
 config = ["globset", "semver", "serde_json", "serde_yaml"]
 dwarf = ["gimli"]
 mips = ["any-arch", "rabbitizer"]
 ppc = ["any-arch", "cwdemangle", "ppc750cl"]
 x86 = ["any-arch", "cpp_demangle", "iced-x86", "msvc-demangler"]
+arm = ["any-arch", "cpp_demangle", "unarm"]
 
 [dependencies]
 anyhow = "1.0.82"
@@ -31,6 +32,7 @@ num-traits = "0.2.18"
 object = { version = "0.35.0", features = ["read_core", "std", "elf", "pe"], default-features = false }
 serde = { version = "1", features = ["derive"] }
 similar = { version = "2.5.0", default-features = false }
+strum = { version = "0.26.2", features = ["derive"] }
 
 # config
 globset = { version = "0.4.14", features = ["serde1"], optional = true }
@@ -46,9 +48,12 @@ cwdemangle = { version = "1.0.0", optional = true }
 ppc750cl = { git = "https://github.com/encounter/ppc750cl", rev = "6cbd7d888c7082c2c860f66cbb9848d633f753ed", optional = true }
 
 # mips
-rabbitizer = { version = "1.10.0", optional = true }
+rabbitizer = { version = "1.11.0", optional = true }
 
 # x86
 cpp_demangle = { version = "0.4.3", optional = true }
 iced-x86 = { version = "1.21.0", default-features = false, features = ["std", "decoder", "intel", "gas", "masm", "nasm", "exhaustive_enums"], optional = true }
 msvc-demangler = { version = "0.10.0", optional = true }
+
+# arm
+unarm = { version = "1.0.0", optional = true }

objdiff-core/src/arch/arm.rs

@@ -0,0 +1,296 @@
+use std::{
+    borrow::Cow,
+    collections::{BTreeMap, HashMap},
+};
+
+use anyhow::{bail, Result};
+use object::{
+    elf, File, Object, ObjectSection, ObjectSymbol, Relocation, RelocationFlags, SectionIndex,
+    SectionKind, Symbol,
+};
+use unarm::{
+    args::{Argument, OffsetImm, OffsetReg, Register},
+    parse::{ArmVersion, ParseMode, Parser},
+    ParsedIns,
+};
+
+use crate::{
+    arch::{ObjArch, ProcessCodeResult},
+    diff::DiffObjConfig,
+    obj::{ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc, ObjSection},
+};
+
+pub struct ObjArchArm {
+    /// Maps section index, to list of disasm modes (arm, thumb or data) sorted by address
+    disasm_modes: HashMap<SectionIndex, Vec<DisasmMode>>,
+}
+
+impl ObjArchArm {
+    pub fn new(file: &File) -> Result<Self> {
+        match file {
+            File::Elf32(_) => {
+                let disasm_modes: HashMap<_, _> = file
+                    .sections()
+                    .filter(|s| s.kind() == SectionKind::Text)
+                    .map(|s| {
+                        let index = s.index();
+                        let mut mapping_symbols: Vec<_> = file
+                            .symbols()
+                            .filter(|s| s.section_index().map(|i| i == index).unwrap_or(false))
+                            .filter_map(|s| DisasmMode::from_symbol(&s))
+                            .collect();
+                        mapping_symbols.sort_unstable_by_key(|x| x.address);
+                        (s.index(), mapping_symbols)
+                    })
+                    .collect();
+                Ok(Self { disasm_modes })
+            }
+            _ => bail!("Unsupported file format {:?}", file.format()),
+        }
+    }
+}
+
+impl ObjArch for ObjArchArm {
+    fn process_code(
+        &self,
+        address: u64,
+        code: &[u8],
+        section_index: usize,
+        relocations: &[ObjReloc],
+        line_info: &BTreeMap<u64, u64>,
+        config: &DiffObjConfig,
+    ) -> Result<ProcessCodeResult> {
+        let start_addr = address as u32;
+        let end_addr = start_addr + code.len() as u32;
+
+        // Mapping symbols decide what kind of data comes after it. $a for ARM code, $t for Thumb code and $d for data.
+        let fallback_mappings = [DisasmMode { address: start_addr, mapping: ParseMode::Arm }];
+        let mapping_symbols = self
+            .disasm_modes
+            .get(&SectionIndex(section_index))
+            .map(|x| x.as_slice())
+            .unwrap_or(&fallback_mappings);
+        let first_mapping_idx =
+            match mapping_symbols.binary_search_by_key(&start_addr, |x| x.address) {
+                Ok(idx) => idx,
+                Err(idx) => idx - 1,
+            };
+        let first_mapping = mapping_symbols[first_mapping_idx].mapping;
+
+        let mut mappings_iter =
+            mapping_symbols.iter().skip(first_mapping_idx + 1).take_while(|x| x.address < end_addr);
+        let mut next_mapping = mappings_iter.next();
+
+        let ins_count = code.len() / first_mapping.instruction_size();
+        let mut ops = Vec::<u16>::with_capacity(ins_count);
+        let mut insts = Vec::<ObjIns>::with_capacity(ins_count);
+        let mut parser = Parser::new(ArmVersion::V5Te, first_mapping, start_addr, code);
+
+        while let Some((address, op, ins)) = parser.next() {
+            if let Some(next) = next_mapping {
+                let next_address = parser.address;
+                if next_address >= next.address {
+                    // Change mapping
+                    parser.mode = next.mapping;
+                    next_mapping = mappings_iter.next();
+                }
+            }
+
+            let line = line_info.range(..=address as u64).last().map(|(_, &b)| b);
+
+            let reloc = relocations.iter().find(|r| (r.address as u32 & !1) == address).cloned();
+
+            let mut reloc_arg = None;
+            if let Some(reloc) = &reloc {
+                match reloc.flags {
+                    RelocationFlags::Elf { r_type: elf::R_ARM_THM_XPC22 }
+                    | RelocationFlags::Elf { r_type: elf::R_ARM_PC24 } => {
+                        reloc_arg =
+                            ins.args.iter().rposition(|a| matches!(a, Argument::BranchDest(_)));
+                    }
+                    _ => (),
+                }
+            };
+
+            let (args, branch_dest) = if reloc.is_some() && parser.mode == ParseMode::Data {
+                (vec![ObjInsArg::Reloc], None)
+            } else {
+                push_args(&ins, config, reloc_arg, address)?
+            };
+
+            ops.push(op.id());
+            insts.push(ObjIns {
+                address: address as u64,
+                size: (parser.address - address) as u8,
+                op: op.id(),
+                mnemonic: ins.mnemonic.to_string(),
+                args,
+                reloc,
+                branch_dest,
+                line,
+                formatted: ins.to_string(),
+                orig: None,
+            });
+        }
+
+        Ok(ProcessCodeResult { ops, insts })
+    }
+
+    fn implcit_addend(
+        &self,
+        _section: &ObjSection,
+        address: u64,
+        reloc: &Relocation,
+    ) -> anyhow::Result<i64> {
+        bail!("Unsupported ARM implicit relocation {:#x}{:?}", address, reloc.flags())
+    }
+
+    fn demangle(&self, name: &str) -> Option<String> {
+        cpp_demangle::Symbol::new(name)
+            .ok()
+            .and_then(|s| s.demangle(&cpp_demangle::DemangleOptions::default()).ok())
+    }
+
+    fn display_reloc(&self, flags: RelocationFlags) -> Cow<'static, str> {
+        Cow::Owned(format!("<{flags:?}>"))
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct DisasmMode {
+    address: u32,
+    mapping: ParseMode,
+}
+
+impl DisasmMode {
+    fn from_symbol<'a>(sym: &Symbol<'a, '_, &'a [u8]>) -> Option<Self> {
+        if let Ok(name) = sym.name() {
+            ParseMode::from_mapping_symbol(name)
+                .map(|mapping| DisasmMode { address: sym.address() as u32, mapping })
+        } else {
+            None
+        }
+    }
+}
+
+fn push_args(
+    parsed_ins: &ParsedIns,
+    config: &DiffObjConfig,
+    reloc_arg: Option<usize>,
+    cur_addr: u32,
+) -> Result<(Vec<ObjInsArg>, Option<u64>)> {
+    let mut args = vec![];
+    let mut branch_dest = None;
+    let mut writeback = false;
+    let mut deref = false;
+    for (i, arg) in parsed_ins.args_iter().enumerate() {
+        // Emit punctuation before separator
+        if deref {
+            match arg {
+                Argument::OffsetImm(OffsetImm { post_indexed: true, value: _ })
+                | Argument::OffsetReg(OffsetReg { add: _, post_indexed: true, reg: _ })
+                | Argument::CoOption(_) => {
+                    deref = false;
+                    args.push(ObjInsArg::PlainText("]".into()));
+                    if writeback {
+                        writeback = false;
+                        args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque("!".into())));
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        if i > 0 {
+            args.push(ObjInsArg::PlainText(config.separator().into()));
+        }
+
+        if reloc_arg == Some(i) {
+            args.push(ObjInsArg::Reloc);
+        } else {
+            match arg {
+                Argument::Reg(reg) => {
+                    if reg.deref {
+                        deref = true;
+                        args.push(ObjInsArg::PlainText("[".into()));
+                    }
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(reg.reg.to_string().into())));
+                    if reg.writeback {
+                        if reg.deref {
+                            writeback = true;
+                        } else {
+                            args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque("!".into())));
+                        }
+                    }
+                }
+                Argument::RegList(reg_list) => {
+                    args.push(ObjInsArg::PlainText("{".into()));
+                    let mut first = true;
+                    for i in 0..16 {
+                        if (reg_list.regs & (1 << i)) != 0 {
+                            if !first {
+                                args.push(ObjInsArg::PlainText(config.separator().into()));
+                            }
+                            args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
+                                Register::parse(i).to_string().into(),
+                            )));
+                            first = false;
+                        }
+                    }
+                    args.push(ObjInsArg::PlainText("}".into()));
+                    if reg_list.user_mode {
+                        args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque("^".to_string().into())));
+                    }
+                }
+                Argument::UImm(value) | Argument::CoOpcode(value) => {
+                    args.push(ObjInsArg::PlainText("#".into()));
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Unsigned(*value as u64)));
+                }
+                Argument::SImm(value)
+                | Argument::OffsetImm(OffsetImm { post_indexed: _, value }) => {
+                    args.push(ObjInsArg::PlainText("#".into()));
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Signed(*value as i64)));
+                }
+                Argument::BranchDest(value) => {
+                    let dest = cur_addr.wrapping_add_signed(*value) as u64;
+                    args.push(ObjInsArg::BranchDest(dest));
+                    branch_dest = Some(dest);
+                }
+                Argument::CoOption(value) => {
+                    args.push(ObjInsArg::PlainText("{".into()));
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Unsigned(*value as u64)));
+                    args.push(ObjInsArg::PlainText("}".into()));
+                }
+                Argument::CoprocNum(value) => {
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(format!("p{}", value).into())));
+                }
+                Argument::ShiftImm(shift) => {
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(shift.op.to_string().into())));
+                    args.push(ObjInsArg::PlainText(" #".into()));
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Unsigned(shift.imm as u64)));
+                }
+                Argument::ShiftReg(shift) => {
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(shift.op.to_string().into())));
+                    args.push(ObjInsArg::PlainText(" ".into()));
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(shift.reg.to_string().into())));
+                }
+                Argument::OffsetReg(offset) => {
+                    if !offset.add {
+                        args.push(ObjInsArg::PlainText("-".into()));
+                    }
+                    args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
+                        offset.reg.to_string().into(),
+                    )));
+                }
+                _ => args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(arg.to_string().into()))),
+            }
+        }
+    }
+    if deref {
+        args.push(ObjInsArg::PlainText("]".into()));
+        if writeback {
+            args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque("!".into())));
+        }
+    }
+    Ok((args, branch_dest))
+}

objdiff-core/src/arch/mips.rs

@@ -1,54 +1,95 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, collections::BTreeMap, sync::Mutex};
 
 use anyhow::{anyhow, bail, Result};
-use object::{elf, Endian, Endianness, File, Object, Relocation, RelocationFlags};
+use object::{elf, Endian, Endianness, File, FileFlags, Object, Relocation, RelocationFlags};
 use rabbitizer::{config, Abi, InstrCategory, Instruction, OperandType};
 
 use crate::{
     arch::{ObjArch, ProcessCodeResult},
-    diff::DiffObjConfig,
+    diff::{DiffObjConfig, MipsAbi, MipsInstrCategory},
-    obj::{ObjInfo, ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc, ObjSection, SymbolRef},
+    obj::{ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc, ObjSection},
 };
 
-fn configure_rabbitizer() {
+static RABBITIZER_MUTEX: Mutex<()> = Mutex::new(());
+
+fn configure_rabbitizer(abi: Abi) {
     unsafe {
-        config::RabbitizerConfig_Cfg.reg_names.fpr_abi_names = Abi::O32;
+        config::RabbitizerConfig_Cfg.reg_names.fpr_abi_names = abi;
     }
 }
 
 pub struct ObjArchMips {
     pub endianness: Endianness,
+    pub abi: Abi,
+    pub instr_category: InstrCategory,
 }
 
+const EF_MIPS_ABI: u32 = 0x0000F000;
+const EF_MIPS_MACH: u32 = 0x00FF0000;
+
+const E_MIPS_MACH_ALLEGREX: u32 = 0x00840000;
+const E_MIPS_MACH_5900: u32 = 0x00920000;
+
 impl ObjArchMips {
     pub fn new(object: &File) -> Result<Self> {
-        configure_rabbitizer();
+        let mut abi = Abi::NUMERIC;
-        Ok(Self { endianness: object.endianness() })
+        let mut instr_category = InstrCategory::CPU;
+        match object.flags() {
+            FileFlags::None => {}
+            FileFlags::Elf { e_flags, .. } => {
+                abi = match e_flags & EF_MIPS_ABI {
+                    elf::EF_MIPS_ABI_O32 => Abi::O32,
+                    elf::EF_MIPS_ABI_EABI32 | elf::EF_MIPS_ABI_EABI64 => Abi::N32,
+                    _ => Abi::NUMERIC,
+                };
+                instr_category = match e_flags & EF_MIPS_MACH {
+                    E_MIPS_MACH_ALLEGREX => InstrCategory::R4000ALLEGREX,
+                    E_MIPS_MACH_5900 => InstrCategory::R5900,
+                    _ => InstrCategory::CPU,
+                };
+            }
+            _ => bail!("Unsupported MIPS file flags"),
+        }
+        Ok(Self { endianness: object.endianness(), abi, instr_category })
     }
 }
 
 impl ObjArch for ObjArchMips {
     fn process_code(
         &self,
-        obj: &ObjInfo,
+        address: u64,
-        symbol_ref: SymbolRef,
+        code: &[u8],
+        _section_index: usize,
+        relocations: &[ObjReloc],
+        line_info: &BTreeMap<u64, u64>,
         config: &DiffObjConfig,
     ) -> Result<ProcessCodeResult> {
-        let (section, symbol) = obj.section_symbol(symbol_ref);
+        let _guard = RABBITIZER_MUTEX.lock().map_err(|e| anyhow!("Failed to lock mutex: {e}"))?;
-        let section = section.ok_or_else(|| anyhow!("Code symbol section not found"))?;
+        configure_rabbitizer(match config.mips_abi {
-        let code = &section.data
+            MipsAbi::Auto => self.abi,
-            [symbol.section_address as usize..(symbol.section_address + symbol.size) as usize];
+            MipsAbi::O32 => Abi::O32,
+            MipsAbi::N32 => Abi::N32,
+            MipsAbi::N64 => Abi::N64,
+        });
+        let instr_category = match config.mips_instr_category {
+            MipsInstrCategory::Auto => self.instr_category,
+            MipsInstrCategory::Cpu => InstrCategory::CPU,
+            MipsInstrCategory::Rsp => InstrCategory::RSP,
+            MipsInstrCategory::R3000Gte => InstrCategory::R3000GTE,
+            MipsInstrCategory::R4000Allegrex => InstrCategory::R4000ALLEGREX,
+            MipsInstrCategory::R5900 => InstrCategory::R5900,
+        };
 
-        let start_address = symbol.address;
+        let start_address = address;
-        let end_address = symbol.address + symbol.size;
+        let end_address = address + code.len() as u64;
         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 mut cur_addr = start_address as u32;
         for chunk in code.chunks_exact(4) {
-            let reloc = section.relocations.iter().find(|r| (r.address as u32 & !3) == cur_addr);
+            let reloc = relocations.iter().find(|r| (r.address as u32 & !3) == cur_addr);
             let code = self.endianness.read_u32_bytes(chunk.try_into()?);
-            let instruction = Instruction::new(code, cur_addr, InstrCategory::CPU);
+            let instruction = Instruction::new(code, cur_addr, instr_category);
 
             let formatted = instruction.disassemble(None, 0);
             let op = instruction.unique_id as u16;
@@ -112,7 +153,7 @@ impl ObjArch for ObjArchMips {
                     }
                 }
             }
-            let line = section.line_info.range(..=cur_addr as u64).last().map(|(_, &b)| b);
+            let line = line_info.range(..=cur_addr as u64).last().map(|(_, &b)| b);
             insts.push(ObjIns {
                 address: cur_addr as u64,
                 size: 4,

objdiff-core/src/arch/mod.rs

@@ -1,25 +1,30 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, collections::BTreeMap};
 
 use anyhow::{bail, Result};
 use object::{Architecture, Object, Relocation, RelocationFlags};
 
 use crate::{
     diff::DiffObjConfig,
-    obj::{ObjInfo, ObjIns, ObjSection, SymbolRef},
+    obj::{ObjIns, ObjReloc, ObjSection},
 };
 
+#[cfg(feature = "arm")]
+mod arm;
 #[cfg(feature = "mips")]
-mod mips;
+pub mod mips;
 #[cfg(feature = "ppc")]
-mod ppc;
+pub mod ppc;
 #[cfg(feature = "x86")]
-mod x86;
+pub mod x86;
 
 pub trait ObjArch: Send + Sync {
     fn process_code(
         &self,
-        obj: &ObjInfo,
+        address: u64,
-        symbol_ref: SymbolRef,
+        code: &[u8],
+        section_index: usize,
+        relocations: &[ObjReloc],
+        line_info: &BTreeMap<u64, u64>,
         config: &DiffObjConfig,
     ) -> Result<ProcessCodeResult>;
 
@@ -44,6 +49,8 @@ pub fn new_arch(object: &object::File) -> Result<Box<dyn ObjArch>> {
         Architecture::Mips => Box::new(mips::ObjArchMips::new(object)?),
         #[cfg(feature = "x86")]
         Architecture::I386 | Architecture::X86_64 => Box::new(x86::ObjArchX86::new(object)?),
+        #[cfg(feature = "arm")]
+        Architecture::Arm => Box::new(arm::ObjArchArm::new(object)?),
         arch => bail!("Unsupported architecture: {arch:?}"),
     })
 }

objdiff-core/src/arch/ppc.rs

@@ -1,13 +1,13 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, collections::BTreeMap};
 
-use anyhow::{anyhow, bail, Result};
+use anyhow::{bail, Result};
 use object::{elf, File, Relocation, RelocationFlags};
 use ppc750cl::{Argument, InsIter, GPR};
 
 use crate::{
     arch::{ObjArch, ProcessCodeResult},
     diff::DiffObjConfig,
-    obj::{ObjInfo, ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc, ObjSection, SymbolRef},
+    obj::{ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc, ObjSection},
 };
 
 // Relative relocation, can be Simm, Offset or BranchDest
@@ -31,20 +31,18 @@ impl ObjArchPpc {
 impl ObjArch for ObjArchPpc {
     fn process_code(
         &self,
-        obj: &ObjInfo,
+        address: u64,
-        symbol_ref: SymbolRef,
+        code: &[u8],
+        _section_index: usize,
+        relocations: &[ObjReloc],
+        line_info: &BTreeMap<u64, u64>,
         config: &DiffObjConfig,
     ) -> Result<ProcessCodeResult> {
-        let (section, symbol) = obj.section_symbol(symbol_ref);
-        let section = section.ok_or_else(|| anyhow!("Code symbol section not found"))?;
-        let code = &section.data
-            [symbol.section_address as usize..(symbol.section_address + symbol.size) as usize];
-
         let ins_count = code.len() / 4;
         let mut ops = Vec::<u16>::with_capacity(ins_count);
         let mut insts = Vec::<ObjIns>::with_capacity(ins_count);
-        for (cur_addr, mut ins) in InsIter::new(code, symbol.address as u32) {
+        for (cur_addr, mut ins) in InsIter::new(code, address as u32) {
-            let reloc = section.relocations.iter().find(|r| (r.address as u32 & !3) == cur_addr);
+            let reloc = relocations.iter().find(|r| (r.address as u32 & !3) == cur_addr);
             if let Some(reloc) = reloc {
                 // Zero out relocations
                 ins.code = match reloc.flags {
@@ -133,7 +131,7 @@ impl ObjArch for ObjArchPpc {
             }
 
             ops.push(ins.op as u16);
-            let line = section.line_info.range(..=cur_addr as u64).last().map(|(_, &b)| b);
+            let line = line_info.range(..=cur_addr as u64).last().map(|(_, &b)| b);
             insts.push(ObjIns {
                 address: cur_addr as u64,
                 size: 4,

objdiff-core/src/arch/x86.rs

@@ -1,4 +1,4 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, collections::BTreeMap};
 
 use anyhow::{anyhow, bail, ensure, Result};
 use iced_x86::{
@@ -11,7 +11,7 @@ use object::{pe, Endian, Endianness, File, Object, Relocation, RelocationFlags};
 use crate::{
     arch::{ObjArch, ProcessCodeResult},
     diff::{DiffObjConfig, X86Formatter},
-    obj::{ObjInfo, ObjIns, ObjInsArg, ObjInsArgValue, ObjSection, SymbolRef},
+    obj::{ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc, ObjSection},
 };
 
 pub struct ObjArchX86 {
@@ -28,17 +28,15 @@ impl ObjArchX86 {
 impl ObjArch for ObjArchX86 {
     fn process_code(
         &self,
-        obj: &ObjInfo,
+        address: u64,
-        symbol_ref: SymbolRef,
+        code: &[u8],
+        _section_index: usize,
+        relocations: &[ObjReloc],
+        line_info: &BTreeMap<u64, u64>,
         config: &DiffObjConfig,
     ) -> Result<ProcessCodeResult> {
-        let (section, symbol) = obj.section_symbol(symbol_ref);
-        let section = section.ok_or_else(|| anyhow!("Code symbol section not found"))?;
-        let code = &section.data
-            [symbol.section_address as usize..(symbol.section_address + symbol.size) as usize];
-
         let mut result = ProcessCodeResult { ops: Vec::new(), insts: Vec::new() };
-        let mut decoder = Decoder::with_ip(self.bits, code, symbol.address, DecoderOptions::NONE);
+        let mut decoder = Decoder::with_ip(self.bits, code, address, DecoderOptions::NONE);
         let mut formatter: Box<dyn Formatter> = match config.x86_formatter {
             X86Formatter::Intel => Box::new(IntelFormatter::new()),
             X86Formatter::Gas => Box::new(GasFormatter::new()),
@@ -70,11 +68,10 @@ impl ObjArch for ObjArchX86 {
 
             let address = instruction.ip();
             let op = instruction.mnemonic() as u16;
-            let reloc = section
+            let reloc = relocations
-                .relocations
                 .iter()
                 .find(|r| r.address >= address && r.address < address + instruction.len() as u64);
-            let line = section.line_info.range(..=address).last().map(|(_, &b)| b);
+            let line = line_info.range(..=address).last().map(|(_, &b)| b);
             output.ins = ObjIns {
                 address,
                 size: instruction.len() as u8,

objdiff-core/src/diff/code.rs

@@ -4,7 +4,7 @@ use std::{
     time::{Duration, Instant},
 };
 
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use similar::{capture_diff_slices_deadline, Algorithm};
 
 use crate::{
@@ -16,34 +16,48 @@ use crate::{
     obj::{ObjInfo, ObjInsArg, ObjReloc, ObjSymbol, ObjSymbolFlags, SymbolRef},
 };
 
-pub fn no_diff_code(
+pub fn process_code_symbol(
     obj: &ObjInfo,
     symbol_ref: SymbolRef,
     config: &DiffObjConfig,
-) -> Result<ObjSymbolDiff> {
+) -> Result<ProcessCodeResult> {
-    let out = obj.arch.process_code(obj, symbol_ref, config)?;
+    let (section, symbol) = obj.section_symbol(symbol_ref);
+    let section = section.ok_or_else(|| anyhow!("Code symbol section not found"))?;
+    let code = &section.data
+        [symbol.section_address as usize..(symbol.section_address + symbol.size) as usize];
+    obj.arch.process_code(
+        symbol.address,
+        code,
+        section.orig_index,
+        &section.relocations,
+        &section.line_info,
+        config,
+    )
+}
 
+pub fn no_diff_code(out: &ProcessCodeResult, symbol_ref: SymbolRef) -> Result<ObjSymbolDiff> {
     let mut diff = Vec::<ObjInsDiff>::new();
-    for i in out.insts {
+    for i in &out.insts {
-        diff.push(ObjInsDiff { ins: Some(i), kind: ObjInsDiffKind::None, ..Default::default() });
+        diff.push(ObjInsDiff {
+            ins: Some(i.clone()),
+            kind: ObjInsDiffKind::None,
+            ..Default::default()
+        });
     }
     resolve_branches(&mut diff);
     Ok(ObjSymbolDiff { symbol_ref, diff_symbol: None, instructions: diff, match_percent: None })
 }
 
 pub fn diff_code(
-    left_obj: &ObjInfo,
+    left_out: &ProcessCodeResult,
-    right_obj: &ObjInfo,
+    right_out: &ProcessCodeResult,
     left_symbol_ref: SymbolRef,
     right_symbol_ref: SymbolRef,
     config: &DiffObjConfig,
 ) -> Result<(ObjSymbolDiff, ObjSymbolDiff)> {
-    let left_out = left_obj.arch.process_code(left_obj, left_symbol_ref, config)?;
-    let right_out = right_obj.arch.process_code(right_obj, right_symbol_ref, config)?;
-
     let mut left_diff = Vec::<ObjInsDiff>::new();
     let mut right_diff = Vec::<ObjInsDiff>::new();
-    diff_instructions(&mut left_diff, &mut right_diff, &left_out, &right_out)?;
+    diff_instructions(&mut left_diff, &mut right_diff, left_out, right_out)?;
 
     resolve_branches(&mut left_diff);
     resolve_branches(&mut right_diff);

objdiff-core/src/diff/mod.rs

@@ -4,7 +4,7 @@ use anyhow::Result;
 
 use crate::{
     diff::{
-        code::{diff_code, no_diff_code},
+        code::{diff_code, no_diff_code, process_code_symbol},
         data::{
             diff_bss_section, diff_bss_symbol, diff_data_section, diff_data_symbol,
             diff_text_section, no_diff_symbol,
@@ -13,29 +13,112 @@ use crate::{
     obj::{ObjInfo, ObjIns, ObjSection, ObjSectionKind, ObjSymbol, SymbolRef},
 };
 
-mod code;
+pub mod code;
-mod data;
+pub mod data;
 pub mod display;
 
-#[derive(Debug, Copy, Clone, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[derive(
+    Debug,
+    Copy,
+    Clone,
+    Default,
+    Eq,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::VariantArray,
+    strum::EnumMessage,
+)]
 pub enum X86Formatter {
     #[default]
+    #[strum(message = "Intel (default)")]
     Intel,
+    #[strum(message = "AT&T")]
     Gas,
+    #[strum(message = "NASM")]
     Nasm,
+    #[strum(message = "MASM")]
     Masm,
 }
 
+#[derive(
+    Debug,
+    Copy,
+    Clone,
+    Default,
+    Eq,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::VariantArray,
+    strum::EnumMessage,
+)]
+pub enum MipsAbi {
+    #[default]
+    #[strum(message = "Auto (default)")]
+    Auto,
+    #[strum(message = "O32")]
+    O32,
+    #[strum(message = "N32")]
+    N32,
+    #[strum(message = "N64")]
+    N64,
+}
+
+#[derive(
+    Debug,
+    Copy,
+    Clone,
+    Default,
+    Eq,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::VariantArray,
+    strum::EnumMessage,
+)]
+pub enum MipsInstrCategory {
+    #[default]
+    #[strum(message = "Auto (default)")]
+    Auto,
+    #[strum(message = "CPU")]
+    Cpu,
+    #[strum(message = "RSP (N64)")]
+    Rsp,
+    #[strum(message = "R3000 GTE (PS1)")]
+    R3000Gte,
+    #[strum(message = "R4000 ALLEGREX (PSP)")]
+    R4000Allegrex,
+    #[strum(message = "R5900 EE (PS2)")]
+    R5900,
+}
+
 #[inline]
 const fn default_true() -> bool { true }
 
-#[derive(Debug, Clone, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
 #[serde(default)]
 pub struct DiffObjConfig {
     pub relax_reloc_diffs: bool,
     #[serde(default = "default_true")]
     pub space_between_args: bool,
+    // x86
     pub x86_formatter: X86Formatter,
+    // MIPS
+    pub mips_abi: MipsAbi,
+    pub mips_instr_category: MipsInstrCategory,
+}
+
+impl Default for DiffObjConfig {
+    fn default() -> Self {
+        Self {
+            relax_reloc_diffs: false,
+            space_between_args: true,
+            x86_formatter: Default::default(),
+            mips_abi: Default::default(),
+            mips_instr_category: Default::default(),
+        }
+    }
 }
 
 impl DiffObjConfig {
@@ -238,9 +321,11 @@ pub fn diff_objs(
                 let (right_obj, right_out) = right.as_mut().unwrap();
                 match section_kind {
                     ObjSectionKind::Code => {
+                        let left_code = process_code_symbol(left_obj, left_symbol_ref, config)?;
+                        let right_code = process_code_symbol(right_obj, right_symbol_ref, config)?;
                         let (left_diff, right_diff) = diff_code(
-                            left_obj,
+                            &left_code,
-                            right_obj,
+                            &right_code,
                             left_symbol_ref,
                             right_symbol_ref,
                             config,
@@ -250,9 +335,10 @@ pub fn diff_objs(
 
                         if let Some(prev_symbol_ref) = prev_symbol_ref {
                             let (prev_obj, prev_out) = prev.as_mut().unwrap();
+                            let prev_code = process_code_symbol(prev_obj, prev_symbol_ref, config)?;
                             let (_, prev_diff) = diff_code(
-                                right_obj,
+                                &right_code,
-                                prev_obj,
+                                &prev_code,
                                 right_symbol_ref,
                                 prev_symbol_ref,
                                 config,
@@ -286,8 +372,9 @@ pub fn diff_objs(
                 let (left_obj, left_out) = left.as_mut().unwrap();
                 match section_kind {
                     ObjSectionKind::Code => {
+                        let code = process_code_symbol(left_obj, left_symbol_ref, config)?;
                         *left_out.symbol_diff_mut(left_symbol_ref) =
-                            no_diff_code(left_obj, left_symbol_ref, config)?;
+                            no_diff_code(&code, left_symbol_ref)?;
                     }
                     ObjSectionKind::Data | ObjSectionKind::Bss => {
                         *left_out.symbol_diff_mut(left_symbol_ref) =
@@ -299,8 +386,9 @@ pub fn diff_objs(
                 let (right_obj, right_out) = right.as_mut().unwrap();
                 match section_kind {
                     ObjSectionKind::Code => {
+                        let code = process_code_symbol(right_obj, right_symbol_ref, config)?;
                         *right_out.symbol_diff_mut(right_symbol_ref) =
-                            no_diff_code(right_obj, right_symbol_ref, config)?;
+                            no_diff_code(&code, right_symbol_ref)?;
                     }
                     ObjSectionKind::Data | ObjSectionKind::Bss => {
                         *right_out.symbol_diff_mut(right_symbol_ref) =

objdiff-core/src/obj/read.rs

@@ -328,15 +328,10 @@ fn line_info(obj_file: &File<'_>, sections: &mut [ObjSection]) -> Result<()> {
             if let Some(program) = unit.line_program.clone() {
                 let mut text_sections =
                     obj_file.sections().filter(|s| s.kind() == SectionKind::Text);
-                let section_index = text_sections
+                let section_index = text_sections.next().map(|s| s.index().0);
-                    .next()
+                let mut lines = section_index.map(|index| {
-                    .ok_or_else(|| anyhow!("Next text section not found for line info"))?
+                    &mut sections.iter_mut().find(|s| s.orig_index == index).unwrap().line_info
-                    .index()
+                });
-                    .0;
-                let mut lines = sections
-                    .iter_mut()
-                    .find(|s| s.orig_index == section_index)
-                    .map(|s| &mut s.line_info);
 
                 let mut rows = program.rows();
                 while let Some((_header, row)) = rows.next_row()? {

objdiff-gui/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "objdiff-gui"
-version = "2.0.0-alpha.1"
+version = "2.0.0-alpha.4"
 edition = "2021"
 rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]
@@ -19,7 +19,8 @@ path = "src/main.rs"
 
 [features]
 default = ["wgpu", "wsl"]
-wgpu = ["eframe/wgpu"]
+glow = ["eframe/glow"]
+wgpu = ["eframe/wgpu", "dep:wgpu"]
 wsl = []
 
 [dependencies]
@@ -29,7 +30,6 @@ cfg-if = "1.0.0"
 const_format = "0.2.32"
 cwdemangle = "1.0.0"
 dirs = "5.0.1"
-eframe = { version = "0.27.2", features = ["persistence"] }
 egui = "0.27.2"
 egui_extras = "0.27.2"
 filetime = "0.2.23"
@@ -37,7 +37,7 @@ float-ord = "0.3.2"
 font-kit = "0.13.0"
 globset = { version = "0.4.14", features = ["serde1"] }
 log = "0.4.21"
-notify = "6.1.1"
+notify = { git = "https://github.com/encounter/notify", rev = "4c1783e8e041b5f69d4cf1750b9f07e335a0771e" }
 objdiff-core = { path = "../objdiff-core", features = ["all"] }
 png = "0.17.13"
 pollster = "0.3.0"
@@ -46,9 +46,32 @@ ron = "0.8.1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1.0.116"
 shell-escape = "0.1.5"
+strum = { version = "0.26.2", features = ["derive"] }
 tempfile = "3.10.1"
 time = { version = "0.3.36", features = ["formatting", "local-offset"] }
 
+# Keep version in sync with egui
+[dependencies.eframe]
+version = "0.27.2"
+features = [
+    "default_fonts",
+    "persistence",
+    "wayland",
+    "x11",
+]
+default-features = false
+
+# Keep version in sync with eframe
+[dependencies.wgpu]
+version = "0.19.1"
+features = [
+    "dx12",
+    "metal",
+    "webgpu",
+]
+optional = true
+default-features = false
+
 # For Linux static binaries, use rustls
 [target.'cfg(target_os = "linux")'.dependencies]
 reqwest = { version = "0.12.4", default-features = false, features = ["blocking", "json", "multipart", "rustls-tls"] }

objdiff-gui/src/app.rs

@@ -30,13 +30,14 @@ use crate::{
     views::{
         appearance::{appearance_window, Appearance},
         config::{
-            config_ui, diff_config_window, project_window, ConfigViewState, CONFIG_DISABLED_TEXT,
+            arch_config_window, config_ui, project_window, ConfigViewState, CONFIG_DISABLED_TEXT,
         },
         data_diff::data_diff_ui,
         debug::debug_window,
         demangle::{demangle_window, DemangleViewState},
         frame_history::FrameHistory,
         function_diff::function_diff_ui,
+        graphics::{graphics_window, GraphicsConfig, GraphicsViewState},
         jobs::jobs_ui,
         symbol_diff::{symbol_diff_ui, DiffViewState, View},
     },
@@ -48,12 +49,14 @@ pub struct ViewState {
     pub config_state: ConfigViewState,
     pub demangle_state: DemangleViewState,
     pub diff_state: DiffViewState,
+    pub graphics_state: GraphicsViewState,
     pub frame_history: FrameHistory,
     pub show_appearance_config: bool,
     pub show_demangle: bool,
     pub show_project_config: bool,
-    pub show_diff_config: bool,
+    pub show_arch_config: bool,
     pub show_debug: bool,
+    pub show_graphics: bool,
 }
 
 /// The configuration for a single object file.
@@ -209,6 +212,7 @@ pub struct App {
     config: AppConfigRef,
     modified: Arc<AtomicBool>,
     watcher: Option<notify::RecommendedWatcher>,
+    app_path: Option<PathBuf>,
     relaunch_path: Rc<Mutex<Option<PathBuf>>>,
     should_relaunch: bool,
 }
@@ -222,6 +226,9 @@ impl App {
         cc: &eframe::CreationContext<'_>,
         utc_offset: UtcOffset,
         relaunch_path: Rc<Mutex<Option<PathBuf>>>,
+        app_path: Option<PathBuf>,
+        graphics_config: GraphicsConfig,
+        graphics_config_path: Option<PathBuf>,
     ) -> Self {
         // Load previous app state (if any).
         // Note that you must enable the `persistence` feature for this to work.
@@ -244,7 +251,32 @@ impl App {
         }
         app.appearance.init_fonts(&cc.egui_ctx);
         app.appearance.utc_offset = utc_offset;
+        app.app_path = app_path;
         app.relaunch_path = relaunch_path;
+        #[cfg(feature = "wgpu")]
+        if let Some(wgpu_render_state) = &cc.wgpu_render_state {
+            use eframe::egui_wgpu::wgpu::Backend;
+            let info = wgpu_render_state.adapter.get_info();
+            app.view_state.graphics_state.active_backend = match info.backend {
+                Backend::Empty => "Unknown",
+                Backend::Vulkan => "Vulkan",
+                Backend::Metal => "Metal",
+                Backend::Dx12 => "DirectX 12",
+                Backend::Gl => "OpenGL",
+                Backend::BrowserWebGpu => "WebGPU",
+            }
+            .to_string();
+            app.view_state.graphics_state.active_device.clone_from(&info.name);
+        }
+        #[cfg(feature = "glow")]
+        if let Some(gl) = &cc.gl {
+            use eframe::glow::HasContext;
+            app.view_state.graphics_state.active_backend = "OpenGL".to_string();
+            app.view_state.graphics_state.active_device =
+                unsafe { gl.get_parameter_string(0x1F01) }; // GL_RENDERER
+        }
+        app.view_state.graphics_state.graphics_config = graphics_config;
+        app.view_state.graphics_state.graphics_config_path = graphics_config_path;
         app
     }
 
@@ -267,9 +299,9 @@ impl App {
                         JobResult::Update(state) => {
                             if let Ok(mut guard) = self.relaunch_path.lock() {
                                 *guard = Some(state.exe_path);
-                            }
                                 self.should_relaunch = true;
                             }
+                        }
                         _ => results.push(result),
                     }
                 }
@@ -308,7 +340,7 @@ impl App {
     fn post_update(&mut self, ctx: &egui::Context) {
         self.appearance.post_update(ctx);
 
-        let ViewState { jobs, diff_state, config_state, .. } = &mut self.view_state;
+        let ViewState { jobs, diff_state, config_state, graphics_state, .. } = &mut self.view_state;
         config_state.post_update(ctx, jobs, &self.config);
         diff_state.post_update(ctx, jobs, &self.config);
 
@@ -390,6 +422,15 @@ impl App {
             jobs.push(start_build(ctx, diff_config));
             config.queue_reload = false;
         }
+
+        if graphics_state.should_relaunch {
+            if let Some(app_path) = &self.app_path {
+                if let Ok(mut guard) = self.relaunch_path.lock() {
+                    *guard = Some(app_path.clone());
+                    self.should_relaunch = true;
+                }
+            }
+        }
     }
 }
 
@@ -410,12 +451,14 @@ impl eframe::App for App {
             config_state,
             demangle_state,
             diff_state,
+            graphics_state,
             frame_history,
             show_appearance_config,
             show_demangle,
             show_project_config,
-            show_diff_config,
+            show_arch_config,
             show_debug,
+            show_graphics,
         } = view_state;
 
         frame_history.on_new_frame(ctx.input(|i| i.time), frame.info().cpu_usage);
@@ -457,6 +500,10 @@ impl eframe::App for App {
                         *show_appearance_config = !*show_appearance_config;
                         ui.close_menu();
                     }
+                    if ui.button("Graphics…").clicked() {
+                        *show_graphics = !*show_graphics;
+                        ui.close_menu();
+                    }
                     if ui.button("Quit").clicked() {
                         ctx.send_viewport_cmd(egui::ViewportCommand::Close);
                     }
@@ -468,8 +515,8 @@ impl eframe::App for App {
                     }
                 });
                 ui.menu_button("Diff Options", |ui| {
-                    if ui.button("More…").clicked() {
+                    if ui.button("Arch Settings…").clicked() {
-                        *show_diff_config = !*show_diff_config;
+                        *show_arch_config = !*show_arch_config;
                         ui.close_menu();
                     }
                     let mut config = config.write().unwrap();
@@ -541,8 +588,9 @@ impl eframe::App for App {
         project_window(ctx, config, show_project_config, config_state, appearance);
         appearance_window(ctx, show_appearance_config, appearance);
         demangle_window(ctx, show_demangle, demangle_state, appearance);
-        diff_config_window(ctx, config, show_diff_config, appearance);
+        arch_config_window(ctx, config, show_arch_config, appearance);
         debug_window(ctx, show_debug, frame_history, appearance);
+        graphics_window(ctx, show_graphics, frame_history, graphics_state, appearance);
 
         self.post_update(ctx);
     }

objdiff-gui/src/jobs/objdiff.rs

@@ -143,7 +143,7 @@ fn run_make_cmd(config: &BuildConfig, cwd: &Path, arg: &Path) -> Result<BuildSta
         cmdline.push(' ');
         cmdline.push_str(shell_escape::escape(arg.to_string_lossy()).as_ref());
     }
-    let output = command.output().context("Failed to execute build")?;
+    let output = command.output().map_err(|e| anyhow!("Failed to execute build: {e}"))?;
     let stdout = from_utf8(&output.stdout).context("Failed to process stdout")?;
     let stderr = from_utf8(&output.stderr).context("Failed to process stderr")?;
     Ok(BuildStatus {

objdiff-gui/src/main.rs

@@ -19,6 +19,8 @@ use anyhow::{ensure, Result};
 use cfg_if::cfg_if;
 use time::UtcOffset;
 
+use crate::views::graphics::{load_graphics_config, GraphicsBackend, GraphicsConfig};
+
 fn load_icon() -> Result<egui::IconData> {
     use bytes::Buf;
     let decoder = png::Decoder::new(include_bytes!("../assets/icon_64.png").reader());
@@ -31,6 +33,8 @@ fn load_icon() -> Result<egui::IconData> {
     Ok(egui::IconData { rgba: buf, width: info.width, height: info.height })
 }
 
+const APP_NAME: &str = "objdiff";
+
 // When compiling natively:
 #[cfg(not(target_arch = "wasm32"))]
 fn main() {
@@ -42,6 +46,7 @@ fn main() {
     // https://github.com/time-rs/time/issues/293
     let utc_offset = UtcOffset::current_local_offset().unwrap_or(UtcOffset::UTC);
 
+    let app_path = std::env::current_exe().ok();
     let exec_path: Rc<Mutex<Option<PathBuf>>> = Rc::new(Mutex::new(None));
     let exec_path_clone = exec_path.clone();
     let mut native_options =
@@ -54,14 +59,47 @@ fn main() {
             log::warn!("Failed to load application icon: {}", e);
         }
     }
+    let mut graphics_config = GraphicsConfig::default();
+    let mut graphics_config_path = None;
+    if let Some(storage_dir) = eframe::storage_dir(APP_NAME) {
+        let config_path = storage_dir.join("graphics.ron");
+        match load_graphics_config(&config_path) {
+            Ok(Some(config)) => {
+                graphics_config = config;
+            }
+            Ok(None) => {}
+            Err(e) => {
+                log::error!("Failed to load native config: {:?}", e);
+            }
+        }
+        graphics_config_path = Some(config_path);
+    }
     #[cfg(feature = "wgpu")]
     {
-        native_options.renderer = eframe::Renderer::Wgpu;
+        use eframe::egui_wgpu::wgpu::Backends;
+        if graphics_config.desired_backend.is_supported() {
+            native_options.wgpu_options.supported_backends = match graphics_config.desired_backend {
+                GraphicsBackend::Auto => native_options.wgpu_options.supported_backends,
+                GraphicsBackend::Dx12 => Backends::DX12,
+                GraphicsBackend::Metal => Backends::METAL,
+                GraphicsBackend::Vulkan => Backends::VULKAN,
+                GraphicsBackend::OpenGL => Backends::GL,
+            };
+        }
     }
     eframe::run_native(
-        "objdiff",
+        APP_NAME,
         native_options,
-        Box::new(move |cc| Box::new(app::App::new(cc, utc_offset, exec_path_clone))),
+        Box::new(move |cc| {
+            Box::new(app::App::new(
+                cc,
+                utc_offset,
+                exec_path_clone,
+                app_path,
+                graphics_config,
+                graphics_config_path,
+            ))
+        }),
     )
     .expect("Failed to run eframe application");
 
@@ -77,9 +115,7 @@ fn main() {
                 } else {
                     let result = std::process::Command::new(path)
                         .args(std::env::args())
-                        .spawn()
+                        .spawn();
-                        .unwrap()
-                        .wait();
                     if let Err(e) = result {
                         log::error!("Failed to relaunch: {:?}", e);
                     }

objdiff-gui/src/views/appearance.rs

@@ -119,6 +119,8 @@ impl Appearance {
                 self.delete_color = Color32::from_rgb(200, 40, 41);
             }
         }
+        style.spacing.scroll = egui::style::ScrollStyle::solid();
+        style.spacing.scroll.bar_width = 10.0;
         ctx.set_style(style);
     }
 

objdiff-gui/src/views/config.rs

@@ -16,9 +16,10 @@ use egui::{
 use globset::Glob;
 use objdiff_core::{
     config::{ProjectObject, DEFAULT_WATCH_PATTERNS},
-    diff::X86Formatter,
+    diff::{MipsAbi, MipsInstrCategory, X86Formatter},
 };
 use self_update::cargo_crate_version;
+use strum::{EnumMessage, VariantArray};
 
 use crate::{
     app::{AppConfig, AppConfigRef, ObjectConfig},
@@ -241,7 +242,7 @@ pub fn config_ui(
                     || {
                         Box::pin(
                             rfd::AsyncFileDialog::new()
-                                .set_directory(&target_dir)
+                                .set_directory(target_dir)
                                 .add_filter("Object file", &["o", "elf", "obj"])
                                 .pick_file(),
                         )
@@ -842,29 +843,28 @@ fn split_obj_config_ui(
     });
 }
 
-pub fn diff_config_window(
+pub fn arch_config_window(
     ctx: &egui::Context,
     config: &AppConfigRef,
     show: &mut bool,
     appearance: &Appearance,
 ) {
     let mut config_guard = config.write().unwrap();
-    egui::Window::new("Diff Config").open(show).show(ctx, |ui| {
+    egui::Window::new("Arch Settings").open(show).show(ctx, |ui| {
-        diff_config_ui(ui, &mut config_guard, appearance);
+        arch_config_ui(ui, &mut config_guard, appearance);
     });
 }
 
-fn diff_config_ui(ui: &mut egui::Ui, config: &mut AppConfig, _appearance: &Appearance) {
+fn arch_config_ui(ui: &mut egui::Ui, config: &mut AppConfig, _appearance: &Appearance) {
-    egui::ComboBox::new("x86_formatter", "X86 Format")
+    ui.heading("x86");
-        .selected_text(format!("{:?}", config.diff_obj_config.x86_formatter))
+    egui::ComboBox::new("x86_formatter", "Format")
+        .selected_text(config.diff_obj_config.x86_formatter.get_message().unwrap())
         .show_ui(ui, |ui| {
-            for &formatter in
+            for &formatter in X86Formatter::VARIANTS {
-                &[X86Formatter::Intel, X86Formatter::Gas, X86Formatter::Nasm, X86Formatter::Masm]
-            {
                 if ui
                     .selectable_label(
                         config.diff_obj_config.x86_formatter == formatter,
-                        format!("{:?}", formatter),
+                        formatter.get_message().unwrap(),
                     )
                     .clicked()
                 {
@@ -873,4 +873,38 @@ fn diff_config_ui(ui: &mut egui::Ui, config: &mut AppConfig, _appearance: &Appea
                 }
             }
         });
+    ui.separator();
+    ui.heading("MIPS");
+    egui::ComboBox::new("mips_abi", "ABI")
+        .selected_text(config.diff_obj_config.mips_abi.get_message().unwrap())
+        .show_ui(ui, |ui| {
+            for &abi in MipsAbi::VARIANTS {
+                if ui
+                    .selectable_label(
+                        config.diff_obj_config.mips_abi == abi,
+                        abi.get_message().unwrap(),
+                    )
+                    .clicked()
+                {
+                    config.diff_obj_config.mips_abi = abi;
+                    config.queue_reload = true;
+                }
+            }
+        });
+    egui::ComboBox::new("mips_instr_category", "Instruction Category")
+        .selected_text(config.diff_obj_config.mips_instr_category.get_message().unwrap())
+        .show_ui(ui, |ui| {
+            for &category in MipsInstrCategory::VARIANTS {
+                if ui
+                    .selectable_label(
+                        config.diff_obj_config.mips_instr_category == category,
+                        category.get_message().unwrap(),
+                    )
+                    .clicked()
+                {
+                    config.diff_obj_config.mips_instr_category = category;
+                    config.queue_reload = true;
+                }
+            }
+        });
 }

objdiff-gui/src/views/debug.rs

@@ -12,6 +12,9 @@ pub fn debug_window(
 }
 
 fn debug_ui(ui: &mut egui::Ui, frame_history: &mut FrameHistory, _appearance: &Appearance) {
+    if ui.button("Clear memory").clicked() {
+        ui.memory_mut(|m| *m = Default::default());
+    }
     ui.label(format!("Repainting the UI each frame. FPS: {:.1}", frame_history.fps()));
     frame_history.ui(ui);
 }

objdiff-gui/src/views/graphics.rs

@@ -0,0 +1,158 @@
+use std::{
+    fs::File,
+    path::{Path, PathBuf},
+};
+
+use anyhow::Result;
+use egui::{text::LayoutJob, Context, FontId, RichText, TextFormat, TextStyle, Window};
+use serde::{Deserialize, Serialize};
+use strum::{EnumIter, EnumMessage, IntoEnumIterator};
+
+use crate::views::{appearance::Appearance, frame_history::FrameHistory};
+
+#[derive(Default)]
+pub struct GraphicsViewState {
+    pub active_backend: String,
+    pub active_device: String,
+    pub graphics_config: GraphicsConfig,
+    pub graphics_config_path: Option<PathBuf>,
+    pub should_relaunch: bool,
+}
+
+#[derive(
+    Copy, Clone, Debug, Default, PartialEq, Eq, EnumIter, EnumMessage, Serialize, Deserialize,
+)]
+pub enum GraphicsBackend {
+    #[default]
+    #[strum(message = "Auto")]
+    Auto,
+    #[strum(message = "Vulkan")]
+    Vulkan,
+    #[strum(message = "Metal")]
+    Metal,
+    #[strum(message = "DirectX 12")]
+    Dx12,
+    #[strum(message = "OpenGL")]
+    OpenGL,
+}
+
+#[derive(Debug, Default, serde::Deserialize, serde::Serialize)]
+pub struct GraphicsConfig {
+    #[serde(default)]
+    pub desired_backend: GraphicsBackend,
+}
+
+pub fn load_graphics_config(path: &Path) -> Result<Option<GraphicsConfig>> {
+    if !path.exists() {
+        return Ok(None);
+    }
+    let file = File::open(path)?;
+    let config: GraphicsConfig = ron::de::from_reader(file)?;
+    Ok(Some(config))
+}
+
+pub fn save_graphics_config(path: &Path, config: &GraphicsConfig) -> Result<()> {
+    let file = File::create(path)?;
+    ron::ser::to_writer(file, config)?;
+    Ok(())
+}
+
+impl GraphicsBackend {
+    pub fn is_supported(&self) -> bool {
+        match self {
+            GraphicsBackend::Auto => true,
+            GraphicsBackend::Vulkan => {
+                cfg!(all(feature = "wgpu", any(target_os = "windows", target_os = "linux")))
+            }
+            GraphicsBackend::Metal => cfg!(all(feature = "wgpu", target_os = "macos")),
+            GraphicsBackend::Dx12 => cfg!(all(feature = "wgpu", target_os = "windows")),
+            GraphicsBackend::OpenGL => true,
+        }
+    }
+}
+
+pub fn graphics_window(
+    ctx: &Context,
+    show: &mut bool,
+    frame_history: &mut FrameHistory,
+    state: &mut GraphicsViewState,
+    appearance: &Appearance,
+) {
+    Window::new("Graphics").open(show).show(ctx, |ui| {
+        ui.label("Graphics backend:");
+        ui.label(
+            RichText::new(&state.active_backend)
+                .color(appearance.emphasized_text_color)
+                .text_style(TextStyle::Monospace),
+        );
+        ui.label("Graphics device:");
+        ui.label(
+            RichText::new(&state.active_device)
+                .color(appearance.emphasized_text_color)
+                .text_style(TextStyle::Monospace),
+        );
+        ui.label(format!("FPS: {:.1}", frame_history.fps()));
+
+        ui.separator();
+        let mut job = LayoutJob::default();
+        job.append(
+            "WARNING: ",
+            0.0,
+            TextFormat::simple(appearance.ui_font.clone(), appearance.delete_color),
+        );
+        job.append(
+            "Changing the graphics backend may cause the application\nto no longer start or display correctly. Use with caution!",
+            0.0,
+            TextFormat::simple(appearance.ui_font.clone(), appearance.emphasized_text_color),
+        );
+        if let Some(config_path) = &state.graphics_config_path {
+            job.append(
+                "\n\nDelete the following file to reset:\n",
+                0.0,
+                TextFormat::simple(appearance.ui_font.clone(), appearance.emphasized_text_color),
+            );
+            job.append(
+                config_path.to_string_lossy().as_ref(),
+                0.0,
+                TextFormat::simple(
+                    FontId {
+                        family: appearance.code_font.family.clone(),
+                        size: appearance.ui_font.size,
+                    },
+                    appearance.emphasized_text_color,
+                ),
+            );
+        }
+        job.append(
+            "\n\nChanging the graphics backend will restart the application.",
+            0.0,
+            TextFormat::simple(appearance.ui_font.clone(), appearance.replace_color),
+        );
+        ui.label(job);
+
+        ui.add_enabled_ui(state.graphics_config_path.is_some(), |ui| {
+            ui.horizontal(|ui| {
+                ui.label("Desired backend:");
+                for backend in GraphicsBackend::iter().filter(GraphicsBackend::is_supported) {
+                    let selected = state.graphics_config.desired_backend == backend;
+                    if ui.selectable_label(selected, backend.get_message().unwrap()).clicked() {
+                        let prev_backend = state.graphics_config.desired_backend;
+                        state.graphics_config.desired_backend = backend;
+                        match save_graphics_config(
+                            state.graphics_config_path.as_ref().unwrap(),
+                            &state.graphics_config,
+                        ) {
+                            Ok(()) => {
+                                state.should_relaunch = true;
+                            }
+                            Err(e) => {
+                                log::error!("Failed to save graphics config: {:?}", e);
+                                state.graphics_config.desired_backend = prev_backend;
+                            }
+                        }
+                    }
+                }
+            });
+        });
+    });
+}

objdiff-gui/src/views/mod.rs

@@ -8,6 +8,7 @@ pub(crate) mod demangle;
 pub(crate) mod file;
 pub(crate) mod frame_history;
 pub(crate) mod function_diff;
+pub(crate) mod graphics;
 pub(crate) mod jobs;
 pub(crate) mod symbol_diff;