Merge 9051f48731 into 7aa878b48e

objdiff-core/src/arch/arm.rs

@@ -113,6 +113,7 @@ impl ObjArch for ObjArchArm {
         relocations: &[ObjReloc],
         line_info: &BTreeMap<u64, u32>,
         config: &DiffObjConfig,
+        _sections: &[ObjSection],
     ) -> Result<ProcessCodeResult> {
         let start_addr = address as u32;
         let end_addr = start_addr + code.len() as u32;

objdiff-core/src/arch/arm64.rs

@@ -29,6 +29,7 @@ impl ObjArch for ObjArchArm64 {
         relocations: &[ObjReloc],
         line_info: &BTreeMap<u64, u32>,
         config: &DiffObjConfig,
+        _sections: &[ObjSection],
     ) -> Result<ProcessCodeResult> {
         let start_address = address;
         let end_address = address + code.len() as u64;

objdiff-core/src/arch/mips.rs

@@ -87,6 +87,7 @@ impl ObjArch for ObjArchMips {
         relocations: &[ObjReloc],
         line_info: &BTreeMap<u64, u32>,
         config: &DiffObjConfig,
+        _sections: &[ObjSection],
     ) -> Result<ProcessCodeResult> {
         let _guard = RABBITIZER_MUTEX.lock().map_err(|e| anyhow!("Failed to lock mutex: {e}"))?;
         configure_rabbitizer(match config.mips_abi {

objdiff-core/src/arch/mod.rs

@@ -126,6 +126,7 @@ impl DataType {
 }
 
 pub trait ObjArch: Send + Sync {
+    #[expect(clippy::too_many_arguments)]
     fn process_code(
         &self,
         address: u64,
@@ -134,6 +135,7 @@ pub trait ObjArch: Send + Sync {
         relocations: &[ObjReloc],
         line_info: &BTreeMap<u64, u32>,
         config: &DiffObjConfig,
+        sections: &[ObjSection],
     ) -> Result<ProcessCodeResult>;
 
     fn implcit_addend(

objdiff-core/src/arch/ppc.rs

@@ -48,12 +48,13 @@ impl ObjArch for ObjArchPpc {
         relocations: &[ObjReloc],
         line_info: &BTreeMap<u64, u32>,
         config: &DiffObjConfig,
+        sections: &[ObjSection],
     ) -> Result<ProcessCodeResult> {
         let ins_count = code.len() / 4;
         let mut ops = Vec::<u16>::with_capacity(ins_count);
         let mut insts = Vec::<ObjIns>::with_capacity(ins_count);
         let fake_pool_reloc_for_addr =
-            generate_fake_pool_reloc_for_addr_mapping(address, code, relocations);
+            generate_fake_pool_reloc_for_addr_mapping(address, code, relocations, sections);
         for (cur_addr, mut ins) in InsIter::new(code, address as u32) {
             let reloc = relocations.iter().find(|r| (r.address as u32 & !3) == cur_addr);
             if let Some(reloc) = reloc {
@@ -204,21 +205,7 @@ impl ObjArch for ObjArchPpc {
             return Some(DataType::String);
         }
 
-        let op = Opcode::from(instruction.op as u8);
-        if let Some(ty) = guess_data_type_from_load_store_inst_op(op) {
-            Some(ty)
-        } else if op == Opcode::Addi {
-            // Assume that any addi instruction that references a local symbol is loading a string.
-            // This hack is not ideal and results in tons of false positives where it will show
-            // garbage strings (e.g. misinterpreting arrays, float literals, etc).
-            // But there isn't much other choice as not all strings are in the @stringBase pool.
-            // And even those that are would be missed by the target.name.starts_with("@stringBase")
-            // hack above for fake pooled relocations, as they have an empty string placeholder for
-            // the target symbol name.
-            Some(DataType::String)
-        } else {
-            None
-        }
+        guess_data_type_from_load_store_inst_op(Opcode::from(instruction.op as u8))
     }
 
     fn display_data_type(&self, ty: DataType, bytes: &[u8]) -> Option<String> {
@@ -436,7 +423,7 @@ fn get_offset_and_addr_gpr_for_possible_pool_reference(
         }
     } else {
         // If it's not a load/store instruction, there's two more possibilities we need to handle.
-        // 1. It could be loading a pointer to a string.
+        // 1. It could be a reference to @stringBase.
         // 2. It could be moving the relocation address plus an offset into a different register to
         //    load from later.
         // If either of these match, we also want to return the destination register that the
@@ -466,38 +453,26 @@ fn get_offset_and_addr_gpr_for_possible_pool_reference(
 // there isn't really a relocation here, as copying the pool relocation's type wouldn't make sense.
 // Also, if this instruction is accessing the middle of a symbol instead of the start, we add an
 // addend to indicate that.
-fn make_fake_pool_reloc(offset: i16, cur_addr: u32, pool_reloc: &ObjReloc) -> Option<ObjReloc> {
+fn make_fake_pool_reloc(
+    offset: i16,
+    cur_addr: u32,
+    pool_reloc: &ObjReloc,
+    sections: &[ObjSection],
+) -> Option<ObjReloc> {
     let offset_from_pool = pool_reloc.addend + offset as i64;
     let target_address = pool_reloc.target.address.checked_add_signed(offset_from_pool)?;
     let orig_section_index = pool_reloc.target.orig_section_index?;
-    // We also need to create a fake target symbol to go inside our fake relocation.
-    // This is because we don't have access to list of all symbols in this section, so we can't find
-    // the real symbol yet. Instead we make a placeholder that has the correct `orig_section_index`
-    // and `address` fields, and then later on when this information is displayed to the user, we
-    // can find the real symbol by searching through the object's section's symbols for one that
-    // contains this address.
-    let fake_target_symbol = ObjSymbol {
-        name: "".to_string(),
-        demangled_name: None,
-        address: target_address,
-        section_address: 0,
-        size: 0,
-        size_known: false,
-        kind: Default::default(),
-        flags: Default::default(),
-        orig_section_index: Some(orig_section_index),
-        virtual_address: None,
-        original_index: None,
-        bytes: vec![],
-    };
-    // The addend is also fake because we don't know yet if the `target_address` here is the exact
-    // start of the symbol or if it's in the middle of it.
-    let fake_addend = 0;
+    let section = sections.iter().find(|s| s.orig_index == orig_section_index)?;
+    let target_symbol = section
+        .symbols
+        .iter()
+        .find(|s| s.size > 0 && (s.address..s.address + s.size).contains(&target_address))?;
+    let addend = (target_address - target_symbol.address) as i64;
     Some(ObjReloc {
         flags: RelocationFlags::Elf { r_type: elf::R_PPC_NONE },
         address: cur_addr as u64,
-        target: fake_target_symbol,
-        addend: fake_addend,
+        target: target_symbol.clone(),
+        addend,
     })
 }
 
@@ -516,6 +491,7 @@ fn generate_fake_pool_reloc_for_addr_mapping(
     address: u64,
     code: &[u8],
     relocations: &[ObjReloc],
+    sections: &[ObjSection],
 ) -> HashMap<u32, ObjReloc> {
     let mut active_pool_relocs = HashMap::new();
     let mut pool_reloc_for_addr = HashMap::new();
@@ -544,16 +520,6 @@ fn generate_fake_pool_reloc_for_addr_mapping(
                 ) => {
                     active_pool_relocs.insert(addr_dst_gpr.0, reloc.clone()); // `lis` + `ori`
                 }
-                (Opcode::B, _, _, _) => {
-                    if simplified.mnemonic == "bl" {
-                        // When encountering a function call, clear any active pool relocations from
-                        // the volatile registers (r0, r3-r12), but not the nonvolatile registers.
-                        active_pool_relocs.remove(&0);
-                        for gpr in 3..12 {
-                            active_pool_relocs.remove(&gpr);
-                        }
-                    }
-                }
                 _ => {}
             }
         } else if let Some((offset, addr_src_gpr, addr_dst_gpr)) =
@@ -562,7 +528,9 @@ fn generate_fake_pool_reloc_for_addr_mapping(
             // This instruction doesn't have a real relocation, so it may be a reference to one of
             // the already-loaded pools.
             if let Some(pool_reloc) = active_pool_relocs.get(&addr_src_gpr.0) {
-                if let Some(fake_pool_reloc) = make_fake_pool_reloc(offset, cur_addr, pool_reloc) {
+                if let Some(fake_pool_reloc) =
+                    make_fake_pool_reloc(offset, cur_addr, pool_reloc, sections)
+                {
                     pool_reloc_for_addr.insert(cur_addr, fake_pool_reloc);
                 }
                 if let Some(addr_dst_gpr) = addr_dst_gpr {

objdiff-core/src/arch/x86.rs

@@ -34,6 +34,7 @@ impl ObjArch for ObjArchX86 {
         relocations: &[ObjReloc],
         line_info: &BTreeMap<u64, u32>,
         config: &DiffObjConfig,
+        _sections: &[ObjSection],
     ) -> Result<ProcessCodeResult> {
         let mut result = ProcessCodeResult { ops: Vec::new(), insts: Vec::new() };
         let mut decoder = Decoder::with_ip(self.bits, code, address, DecoderOptions::NONE);

objdiff-core/src/diff/code.rs

@@ -28,6 +28,7 @@ pub fn process_code_symbol(
         &section.relocations,
         &section.line_info,
         config,
+        &obj.sections,
     )
 }
 

objdiff-gui/src/hotkeys.rs

@@ -1,108 +0,0 @@
-use egui::{
-    style::ScrollAnimation, vec2, Context, Key, KeyboardShortcut, Modifiers, PointerButton,
-};
-
-fn any_widget_focused(ctx: &Context) -> bool { ctx.memory(|mem| mem.focused().is_some()) }
-
-pub fn enter_pressed(ctx: &Context) -> bool {
-    if any_widget_focused(ctx) {
-        return false;
-    }
-    ctx.input_mut(|i| {
-        i.key_pressed(Key::Enter)
-            || i.key_pressed(Key::Space)
-            || i.pointer.button_pressed(PointerButton::Extra2)
-    })
-}
-
-pub fn back_pressed(ctx: &Context) -> bool {
-    if any_widget_focused(ctx) {
-        return false;
-    }
-    ctx.input_mut(|i| {
-        i.key_pressed(Key::Backspace)
-            || i.key_pressed(Key::Escape)
-            || i.pointer.button_pressed(PointerButton::Extra1)
-    })
-}
-
-pub fn up_pressed(ctx: &Context) -> bool {
-    if any_widget_focused(ctx) {
-        return false;
-    }
-    ctx.input_mut(|i| i.key_pressed(Key::ArrowUp) || i.key_pressed(Key::W))
-}
-
-pub fn down_pressed(ctx: &Context) -> bool {
-    if any_widget_focused(ctx) {
-        return false;
-    }
-    ctx.input_mut(|i| i.key_pressed(Key::ArrowDown) || i.key_pressed(Key::S))
-}
-
-pub fn page_up_pressed(ctx: &Context) -> bool { ctx.input_mut(|i| i.key_pressed(Key::PageUp)) }
-
-pub fn page_down_pressed(ctx: &Context) -> bool { ctx.input_mut(|i| i.key_pressed(Key::PageDown)) }
-
-pub fn home_pressed(ctx: &Context) -> bool { ctx.input_mut(|i| i.key_pressed(Key::Home)) }
-
-pub fn end_pressed(ctx: &Context) -> bool { ctx.input_mut(|i| i.key_pressed(Key::End)) }
-
-pub fn check_scroll_hotkeys(ui: &mut egui::Ui, include_small_increments: bool) {
-    let ui_height = ui.available_rect_before_wrap().height();
-    if up_pressed(ui.ctx()) && include_small_increments {
-        ui.scroll_with_delta_animation(vec2(0.0, ui_height / 10.0), ScrollAnimation::none());
-    } else if down_pressed(ui.ctx()) && include_small_increments {
-        ui.scroll_with_delta_animation(vec2(0.0, -ui_height / 10.0), ScrollAnimation::none());
-    } else if page_up_pressed(ui.ctx()) {
-        ui.scroll_with_delta_animation(vec2(0.0, ui_height), ScrollAnimation::none());
-    } else if page_down_pressed(ui.ctx()) {
-        ui.scroll_with_delta_animation(vec2(0.0, -ui_height), ScrollAnimation::none());
-    } else if home_pressed(ui.ctx()) {
-        ui.scroll_with_delta_animation(vec2(0.0, f32::INFINITY), ScrollAnimation::none());
-    } else if end_pressed(ui.ctx()) {
-        ui.scroll_with_delta_animation(vec2(0.0, -f32::INFINITY), ScrollAnimation::none());
-    }
-}
-
-pub fn consume_up_key(ctx: &Context) -> bool {
-    if any_widget_focused(ctx) {
-        return false;
-    }
-    ctx.input_mut(|i| {
-        i.consume_key(Modifiers::NONE, Key::ArrowUp) || i.consume_key(Modifiers::NONE, Key::W)
-    })
-}
-
-pub fn consume_down_key(ctx: &Context) -> bool {
-    if any_widget_focused(ctx) {
-        return false;
-    }
-    ctx.input_mut(|i| {
-        i.consume_key(Modifiers::NONE, Key::ArrowDown) || i.consume_key(Modifiers::NONE, Key::S)
-    })
-}
-
-const OBJECT_FILTER_SHORTCUT: KeyboardShortcut = KeyboardShortcut::new(Modifiers::CTRL, Key::F);
-
-pub fn consume_object_filter_shortcut(ctx: &Context) -> bool {
-    ctx.input_mut(|i| i.consume_shortcut(&OBJECT_FILTER_SHORTCUT))
-}
-
-const SYMBOL_FILTER_SHORTCUT: KeyboardShortcut = KeyboardShortcut::new(Modifiers::CTRL, Key::S);
-
-pub fn consume_symbol_filter_shortcut(ctx: &Context) -> bool {
-    ctx.input_mut(|i| i.consume_shortcut(&SYMBOL_FILTER_SHORTCUT))
-}
-
-const CHANGE_TARGET_SHORTCUT: KeyboardShortcut = KeyboardShortcut::new(Modifiers::CTRL, Key::T);
-
-pub fn consume_change_target_shortcut(ctx: &Context) -> bool {
-    ctx.input_mut(|i| i.consume_shortcut(&CHANGE_TARGET_SHORTCUT))
-}
-
-const CHANGE_BASE_SHORTCUT: KeyboardShortcut = KeyboardShortcut::new(Modifiers::CTRL, Key::B);
-
-pub fn consume_change_base_shortcut(ctx: &Context) -> bool {
-    ctx.input_mut(|i| i.consume_shortcut(&CHANGE_BASE_SHORTCUT))
-}

objdiff-gui/src/main.rs

@@ -4,7 +4,6 @@ mod app;
 mod app_config;
 mod config;
 mod fonts;
-mod hotkeys;
 mod jobs;
 mod update;
 mod views;

objdiff-gui/src/views/config.rs

@@ -21,7 +21,6 @@ use strum::{EnumMessage, VariantArray};
 use crate::{
     app::{AppConfig, AppState, AppStateRef, ObjectConfig},
     config::ProjectObjectNode,
-    hotkeys,
     jobs::{
         check_update::{start_check_update, CheckUpdateResult},
         update::start_update,
@@ -255,11 +254,7 @@ pub fn config_ui(
         }
     } else {
         let had_search = !config_state.object_search.is_empty();
-        let response =
-            egui::TextEdit::singleline(&mut config_state.object_search).hint_text("Filter").ui(ui);
-        if hotkeys::consume_object_filter_shortcut(ui.ctx()) {
-            response.request_focus();
-        }
+        egui::TextEdit::singleline(&mut config_state.object_search).hint_text("Filter").ui(ui);
 
         let mut root_open = None;
         let mut node_open = NodeOpen::Default;

objdiff-gui/src/views/data_diff.rs

@@ -7,14 +7,11 @@ use objdiff_core::{
 };
 use time::format_description;
 
-use crate::{
-    hotkeys,
-    views::{
-        appearance::Appearance,
-        column_layout::{render_header, render_table},
-        symbol_diff::{DiffViewAction, DiffViewNavigation, DiffViewState},
-        write_text,
-    },
+use crate::views::{
+    appearance::Appearance,
+    column_layout::{render_header, render_table},
+    symbol_diff::{DiffViewAction, DiffViewNavigation, DiffViewState},
+    write_text,
 };
 
 const BYTES_PER_ROW: usize = 16;
@@ -179,8 +176,6 @@ fn data_table_ui(
     let left_diffs = left_section.map(|(_, section)| split_diffs(&section.data_diff));
     let right_diffs = right_section.map(|(_, section)| split_diffs(&section.data_diff));
 
-    hotkeys::check_scroll_hotkeys(ui, true);
-
     render_table(ui, available_width, 2, config.code_font.size, total_rows, |row, column| {
         let i = row.index();
         let address = i * BYTES_PER_ROW;
@@ -229,7 +224,7 @@ pub fn data_diff_ui(
     render_header(ui, available_width, 2, |ui, column| {
         if column == 0 {
             // Left column
-            if ui.button("⏴ Back").clicked() || hotkeys::back_pressed(ui.ctx()) {
+            if ui.button("⏴ Back").clicked() {
                 ret = Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
             }
 

objdiff-gui/src/views/extab_diff.rs

@@ -5,16 +5,13 @@ use objdiff_core::{
 };
 use time::format_description;
 
-use crate::{
-    hotkeys,
-    views::{
-        appearance::Appearance,
-        column_layout::{render_header, render_strips},
-        function_diff::FunctionDiffContext,
-        symbol_diff::{
-            match_color_for_symbol, DiffViewAction, DiffViewNavigation, DiffViewState,
-            SymbolRefByName, View,
-        },
+use crate::views::{
+    appearance::Appearance,
+    column_layout::{render_header, render_strips},
+    function_diff::FunctionDiffContext,
+    symbol_diff::{
+        match_color_for_symbol, DiffViewAction, DiffViewNavigation, DiffViewState, SymbolRefByName,
+        View,
     },
 };
 
@@ -139,7 +136,7 @@ pub fn extab_diff_ui(
         if column == 0 {
             // Left column
             ui.horizontal(|ui| {
-                if ui.button("⏴ Back").clicked() || hotkeys::back_pressed(ui.ctx()) {
+                if ui.button("⏴ Back").clicked() {
                     ret = Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
                 }
                 ui.separator();
@@ -235,8 +232,6 @@ pub fn extab_diff_ui(
         }
     });
 
-    hotkeys::check_scroll_hotkeys(ui, true);
-
     // Table
     render_strips(ui, available_width, 2, |ui, column| {
         if column == 0 {

objdiff-gui/src/views/function_diff.rs

@@ -14,15 +14,12 @@ use objdiff_core::{
 };
 use time::format_description;
 
-use crate::{
-    hotkeys,
-    views::{
-        appearance::Appearance,
-        column_layout::{render_header, render_strips, render_table},
-        symbol_diff::{
-            match_color_for_symbol, symbol_list_ui, DiffViewAction, DiffViewNavigation,
-            DiffViewState, SymbolDiffContext, SymbolFilter, SymbolRefByName, SymbolViewState, View,
-        },
+use crate::views::{
+    appearance::Appearance,
+    column_layout::{render_header, render_strips, render_table},
+    symbol_diff::{
+        match_color_for_symbol, symbol_list_ui, DiffViewAction, DiffViewNavigation, DiffViewState,
+        SymbolDiffContext, SymbolFilter, SymbolRefByName, SymbolViewState, View,
     },
 };
 
@@ -77,19 +74,6 @@ impl FunctionViewState {
     }
 }
 
-fn find_symbol_matching_fake_symbol_in_sections(
-    fake_symbol: &ObjSymbol,
-    sections: &[ObjSection],
-) -> Option<ObjSymbol> {
-    let orig_section_index = fake_symbol.orig_section_index?;
-    let section = sections.iter().find(|s| s.orig_index == orig_section_index)?;
-    let real_symbol = section
-        .symbols
-        .iter()
-        .find(|s| s.size > 0 && (s.address..s.address + s.size).contains(&fake_symbol.address))?;
-    Some(real_symbol.clone())
-}
-
 fn ins_hover_ui(
     ui: &mut egui::Ui,
     obj: &ObjInfo,
@@ -135,29 +119,17 @@ fn ins_hover_ui(
         }
 
         if let Some(reloc) = ins.reloc.as_ref().or(ins.fake_pool_reloc.as_ref()) {
-            let mut target = reloc.target.clone();
-            let mut addend = reloc.addend;
-            if target.size == 0 && target.name.is_empty() {
-                // Fake target symbol we added as a placeholder. We need to find the real one.
-                if let Some(real_target) =
-                    find_symbol_matching_fake_symbol_in_sections(&target, &obj.sections)
-                {
-                    target = real_target;
-                    addend = (reloc.target.address - target.address) as i64;
-                }
-            }
-
             ui.label(format!("Relocation type: {}", obj.arch.display_reloc(reloc.flags)));
-            let addend_str = match addend.cmp(&0i64) {
-                Ordering::Greater => format!("+{:x}", addend),
-                Ordering::Less => format!("-{:x}", -addend),
+            let addend_str = match reloc.addend.cmp(&0i64) {
+                Ordering::Greater => format!("+{:x}", reloc.addend),
+                Ordering::Less => format!("-{:x}", -reloc.addend),
                 _ => "".to_string(),
             };
             ui.colored_label(
                 appearance.highlight_color,
-                format!("Name: {}{}", target.name, addend_str),
+                format!("Name: {}{}", reloc.target.name, addend_str),
             );
-            if let Some(orig_section_index) = target.orig_section_index {
+            if let Some(orig_section_index) = reloc.target.orig_section_index {
                 if let Some(section) =
                     obj.sections.iter().find(|s| s.orig_index == orig_section_index)
                 {
@@ -168,12 +140,15 @@ fn ins_hover_ui(
                 }
                 ui.colored_label(
                     appearance.highlight_color,
-                    format!("Address: {:x}{}", target.address, addend_str),
+                    format!("Address: {:x}{}", reloc.target.address, addend_str),
                 );
-                ui.colored_label(appearance.highlight_color, format!("Size: {:x}", target.size));
-                if addend >= 0 && target.bytes.len() > addend as usize {
+                ui.colored_label(
+                    appearance.highlight_color,
+                    format!("Size: {:x}", reloc.target.size),
+                );
+                if reloc.addend >= 0 && reloc.target.bytes.len() > reloc.addend as usize {
                     if let Some(s) = obj.arch.guess_data_type(ins).and_then(|ty| {
-                        obj.arch.display_data_type(ty, &target.bytes[addend as usize..])
+                        obj.arch.display_data_type(ty, &reloc.target.bytes[reloc.addend as usize..])
                     }) {
                         ui.colored_label(appearance.highlight_color, s);
                     }
@@ -182,10 +157,6 @@ fn ins_hover_ui(
                 ui.colored_label(appearance.highlight_color, "Extern".to_string());
             }
         }
-
-        if let Some(decoded) = rlwinmdec::decode(&ins.formatted) {
-            ui.colored_label(appearance.highlight_color, decoded.trim());
-        }
     });
 }
 
@@ -469,7 +440,6 @@ fn asm_table_ui(
     };
     if left_len.is_some() && right_len.is_some() {
         // Joint view
-        hotkeys::check_scroll_hotkeys(ui, true);
         render_table(
             ui,
             available_width,
@@ -505,7 +475,6 @@ fn asm_table_ui(
             if column == 0 {
                 if let Some(ctx) = left_ctx {
                     if ctx.has_symbol() {
-                        hotkeys::check_scroll_hotkeys(ui, false);
                         render_table(
                             ui,
                             available_width / 2.0,
@@ -551,6 +520,9 @@ fn asm_table_ui(
                                         SymbolRefByName::new(right_symbol, right_section),
                                     ));
                                 }
+                                DiffViewAction::SetSymbolHighlight(_, _) => {
+                                    // Ignore
+                                }
                                 _ => {
                                     ret = Some(action);
                                 }
@@ -563,7 +535,6 @@ fn asm_table_ui(
             } else if column == 1 {
                 if let Some(ctx) = right_ctx {
                     if ctx.has_symbol() {
-                        hotkeys::check_scroll_hotkeys(ui, false);
                         render_table(
                             ui,
                             available_width / 2.0,
@@ -609,6 +580,9 @@ fn asm_table_ui(
                                         right_symbol_ref,
                                     ));
                                 }
+                                DiffViewAction::SetSymbolHighlight(_, _) => {
+                                    // Ignore
+                                }
                                 _ => {
                                     ret = Some(action);
                                 }
@@ -709,7 +683,7 @@ pub fn function_diff_ui(
         if column == 0 {
             // Left column
             ui.horizontal(|ui| {
-                if ui.button("⏴ Back").clicked() || hotkeys::back_pressed(ui.ctx()) {
+                if ui.button("⏴ Back").clicked() {
                     ret = Some(DiffViewAction::Navigate(DiffViewNavigation::symbol_diff()));
                 }
                 ui.separator();
@@ -742,11 +716,10 @@ pub fn function_diff_ui(
                         .color(appearance.highlight_color),
                 );
                 if right_ctx.is_some_and(|m| m.has_symbol())
-                    && (ui
+                    && ui
                         .button("Change target")
                         .on_hover_text_at_pointer("Choose a different symbol to use as the target")
                         .clicked()
-                        || hotkeys::consume_change_target_shortcut(ui.ctx()))
                 {
                     if let Some(symbol_ref) = state.symbol_state.right_symbol.as_ref() {
                         ret = Some(DiffViewAction::SelectingLeft(symbol_ref.clone()));
@@ -820,7 +793,6 @@ pub fn function_diff_ui(
                                 "Choose a different symbol to use as the base",
                             )
                             .clicked()
-                            || hotkeys::consume_change_base_shortcut(ui.ctx())
                         {
                             if let Some(symbol_ref) = state.symbol_state.left_symbol.as_ref() {
                                 ret = Some(DiffViewAction::SelectingRight(symbol_ref.clone()));

objdiff-gui/src/views/rlwinm.rs

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

objdiff-gui/src/views/symbol_diff.rs

@@ -1,8 +1,8 @@
-use std::{collections::BTreeMap, mem::take, ops::Bound};
+use std::{collections::BTreeMap, mem::take};
 
 use egui::{
-    style::ScrollAnimation, text::LayoutJob, CollapsingHeader, Color32, Id, OpenUrl, ScrollArea,
-    SelectableLabel, TextEdit, Ui, Widget,
+    text::LayoutJob, CollapsingHeader, Color32, Id, OpenUrl, ScrollArea, SelectableLabel, TextEdit,
+    Ui, Widget,
 };
 use objdiff_core::{
     arch::ObjArch,
@@ -15,7 +15,6 @@ use regex::{Regex, RegexBuilder};
 
 use crate::{
     app::AppStateRef,
-    hotkeys,
     jobs::{
         create_scratch::{start_create_scratch, CreateScratchConfig, CreateScratchResult},
         objdiff::{BuildStatus, ObjDiffResult},
@@ -57,8 +56,8 @@ pub enum DiffViewAction {
     Build,
     /// Navigate to a new diff view
     Navigate(DiffViewNavigation),
-    /// Set the highlighted symbols in the symbols view, optionally scrolling them into view.
-    SetSymbolHighlight(Option<SymbolRef>, Option<SymbolRef>, bool),
+    /// Set the highlighted symbols in the symbols view
+    SetSymbolHighlight(Option<SymbolRef>, Option<SymbolRef>),
     /// Set the symbols view search filter
     SetSearch(String),
     /// Submit the current function to decomp.me
@@ -136,7 +135,6 @@ pub struct DiffViewState {
 #[derive(Default)]
 pub struct SymbolViewState {
     pub highlighted_symbol: (Option<SymbolRef>, Option<SymbolRef>),
-    pub autoscroll_to_highlighted_symbols: bool,
     pub left_symbol: Option<SymbolRefByName>,
     pub right_symbol: Option<SymbolRefByName>,
     pub reverse_fn_order: bool,
@@ -199,9 +197,6 @@ impl DiffViewState {
             ctx.output_mut(|o| o.open_url = Some(OpenUrl::new_tab(result.scratch_url)));
         }
 
-        // Clear the autoscroll flag so that it doesn't scroll continuously.
-        self.symbol_state.autoscroll_to_highlighted_symbols = false;
-
         let Some(action) = action else {
             return;
         };
@@ -216,6 +211,7 @@ impl DiffViewState {
                     // Ignore action if we're already navigating
                     return;
                 }
+                self.symbol_state.highlighted_symbol = (None, None);
                 let Ok(mut state) = state.write() else {
                     return;
                 };
@@ -251,9 +247,8 @@ impl DiffViewState {
                     self.post_build_nav = Some(nav);
                 }
             }
-            DiffViewAction::SetSymbolHighlight(left, right, autoscroll) => {
+            DiffViewAction::SetSymbolHighlight(left, right) => {
                 self.symbol_state.highlighted_symbol = (left, right);
-                self.symbol_state.autoscroll_to_highlighted_symbols = autoscroll;
             }
             DiffViewAction::SetSearch(search) => {
                 self.search_regex = if search.is_empty() {
@@ -539,15 +534,7 @@ fn symbol_ui(
             ret = Some(DiffViewAction::Navigate(result));
         }
     });
-    if selected && state.autoscroll_to_highlighted_symbols {
-        // Automatically scroll the view to encompass the selected symbol in case the user selected
-        // an offscreen symbol by using a keyboard shortcut.
-        ui.scroll_to_rect_animation(response.rect, None, ScrollAnimation::none());
-        // This autoscroll state flag will be reset in DiffViewState::post_update at the end of
-        // every frame so that we don't continuously scroll the view back when the user is trying to
-        // manually scroll away.
-    }
-    if response.clicked() || (selected && hotkeys::enter_pressed(ui.ctx())) {
+    if response.clicked() {
         if let Some(section) = section {
             match section.kind {
                 ObjSectionKind::Code => {
@@ -574,18 +561,20 @@ fn symbol_ui(
             }
         }
     } else if response.hovered() {
-        ret = Some(if column == 0 {
-            DiffViewAction::SetSymbolHighlight(
-                Some(symbol_diff.symbol_ref),
-                symbol_diff.target_symbol,
-                false,
-            )
+        ret = Some(if let Some(target_symbol) = symbol_diff.target_symbol {
+            if column == 0 {
+                DiffViewAction::SetSymbolHighlight(
+                    Some(symbol_diff.symbol_ref),
+                    Some(target_symbol),
+                )
+            } else {
+                DiffViewAction::SetSymbolHighlight(
+                    Some(target_symbol),
+                    Some(symbol_diff.symbol_ref),
+                )
+            }
         } else {
-            DiffViewAction::SetSymbolHighlight(
-                symbol_diff.target_symbol,
-                Some(symbol_diff.symbol_ref),
-                false,
-            )
+            DiffViewAction::SetSymbolHighlight(None, None)
         });
     }
     ret
@@ -659,58 +648,6 @@ pub fn symbol_list_ui(
             }
         }
 
-        hotkeys::check_scroll_hotkeys(ui, false);
-
-        let mut new_key_value_to_highlight = None;
-        if let Some(sym_ref) =
-            if column == 0 { state.highlighted_symbol.0 } else { state.highlighted_symbol.1 }
-        {
-            let up = if hotkeys::consume_up_key(ui.ctx()) {
-                Some(true)
-            } else if hotkeys::consume_down_key(ui.ctx()) {
-                Some(false)
-            } else {
-                None
-            };
-            if let Some(mut up) = up {
-                if state.reverse_fn_order {
-                    up = !up;
-                }
-                new_key_value_to_highlight = if up {
-                    mapping.range(..sym_ref).next_back()
-                } else {
-                    mapping.range((Bound::Excluded(sym_ref), Bound::Unbounded)).next()
-                };
-            };
-        } else {
-            // No symbol is highlighted in this column. Select the topmost symbol instead.
-            // Note that we intentionally do not consume the up/down key presses in this case, but
-            // we do when a symbol is highlighted. This is so that if only one column has a symbol
-            // highlighted, that one takes precedence over the one with nothing highlighted.
-            if hotkeys::up_pressed(ui.ctx()) || hotkeys::down_pressed(ui.ctx()) {
-                new_key_value_to_highlight = if state.reverse_fn_order {
-                    mapping.last_key_value()
-                } else {
-                    mapping.first_key_value()
-                };
-            }
-        }
-        if let Some((new_sym_ref, new_symbol_diff)) = new_key_value_to_highlight {
-            ret = Some(if column == 0 {
-                DiffViewAction::SetSymbolHighlight(
-                    Some(*new_sym_ref),
-                    new_symbol_diff.target_symbol,
-                    true,
-                )
-            } else {
-                DiffViewAction::SetSymbolHighlight(
-                    new_symbol_diff.target_symbol,
-                    Some(*new_sym_ref),
-                    true,
-                )
-            });
-        }
-
         ui.scope(|ui| {
             ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
             ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Extend);
@@ -901,11 +838,7 @@ pub fn symbol_diff_ui(
             });
 
             let mut search = state.search.clone();
-            let response = TextEdit::singleline(&mut search).hint_text("Filter symbols").ui(ui);
-            if hotkeys::consume_symbol_filter_shortcut(ui.ctx()) {
-                response.request_focus();
-            }
-            if response.changed() {
+            if TextEdit::singleline(&mut search).hint_text("Filter symbols").ui(ui).changed() {
                 ret = Some(DiffViewAction::SetSearch(search));
             }
         } else if column == 1 {