Unify context menu / hover tooltip code + UI improvements

objdiff-core/src/diff/code.rs

@@ -5,7 +5,7 @@ use alloc::{
     vec::Vec,
 };
 
-use anyhow::{anyhow, ensure, Result};
+use anyhow::{anyhow, ensure, Context, Result};
 
 use super::{
     DiffObjConfig, FunctionRelocDiffs, InstructionArgDiffIndex, InstructionBranchFrom,
@@ -196,7 +196,7 @@ fn diff_instructions(
     Ok((left_diff, right_diff))
 }
 
-fn arg_to_string(arg: &InstructionArg, reloc: Option<&ResolvedRelocation>) -> String {
+fn arg_to_string(arg: &InstructionArg, reloc: Option<ResolvedRelocation>) -> String {
     match arg {
         InstructionArg::Value(arg) => arg.to_string(),
         InstructionArg::Reloc => {
@@ -226,7 +226,7 @@ fn resolve_branches(
     for ((i, ins_diff), ins) in
         rows.iter_mut().enumerate().filter(|(_, row)| row.ins_ref.is_some()).zip(ops)
     {
-        let branch_dest = if let Some(resolved) = section.relocation_at(ins.ins_ref, obj) {
+        let branch_dest = if let Some(resolved) = section.relocation_at(obj, ins.ins_ref) {
             if resolved.symbol.section == Some(section_index) {
                 // If the relocation target is in the same section, use it as the branch destination
                 resolved.symbol.address.checked_add_signed(resolved.relocation.addend)
@@ -258,7 +258,7 @@ fn resolve_branches(
     }
 }
 
-pub(crate) fn address_eq(left: &ResolvedRelocation, right: &ResolvedRelocation) -> bool {
+pub(crate) fn address_eq(left: ResolvedRelocation, right: ResolvedRelocation) -> bool {
     if right.symbol.size == 0 && left.symbol.size != 0 {
         // The base relocation is against a pool but the target relocation isn't.
         // This can happen in rare cases where the compiler will generate a pool+addend relocation
@@ -318,7 +318,7 @@ fn reloc_eq(
             section_name_eq(left_obj, right_obj, *sl, *sr)
                 && (diff_config.function_reloc_diffs == FunctionRelocDiffs::DataValue
                     || symbol_name_addend_matches
-                    || address_eq(&left_reloc, &right_reloc))
+                    || address_eq(left_reloc, right_reloc))
                 && (
                     diff_config.function_reloc_diffs == FunctionRelocDiffs::NameAddress
                         || left_reloc.symbol.kind != SymbolKind::Object
@@ -427,54 +427,17 @@ fn diff_instruction(
         return Ok(InstructionDiffResult::new(InstructionDiffKind::Replace));
     }
 
-    let left_symbol = &left_obj.symbols[left_symbol_idx];
-    let right_symbol = &right_obj.symbols[right_symbol_idx];
-    let left_section = left_symbol
-        .section
-        .and_then(|i| left_obj.sections.get(i))
-        .ok_or_else(|| anyhow!("Missing section for symbol"))?;
-    let right_section = right_symbol
-        .section
-        .and_then(|i| right_obj.sections.get(i))
-        .ok_or_else(|| anyhow!("Missing section for symbol"))?;
+    let left_resolved = left_obj
+        .resolve_instruction_ref(left_symbol_idx, l)
+        .context("Failed to resolve left instruction")?;
+    let right_resolved = right_obj
+        .resolve_instruction_ref(right_symbol_idx, r)
+        .context("Failed to resolve right instruction")?;
 
-    // Resolve relocations
-    let left_reloc = left_section.relocation_at(l, left_obj);
-    let right_reloc = right_section.relocation_at(r, right_obj);
-
-    // Compare instruction data
-    let left_data = left_section.data_range(l.address, l.size as usize).ok_or_else(|| {
-        anyhow!(
-            "Instruction data out of bounds: {:#x}..{:#x}",
-            l.address,
-            l.address + l.size as u64
-        )
-    })?;
-    let right_data = right_section.data_range(r.address, r.size as usize).ok_or_else(|| {
-        anyhow!(
-            "Instruction data out of bounds: {:#x}..{:#x}",
-            r.address,
-            r.address + r.size as u64
-        )
-    })?;
-    if left_data != right_data {
+    if left_resolved.code != right_resolved.code {
         // If data doesn't match, process instructions and compare args
-        let left_ins = left_obj.arch.process_instruction(
-            l,
-            left_data,
-            left_reloc,
-            left_symbol.address..left_symbol.address + left_symbol.size,
-            left_symbol.section.unwrap(),
-            diff_config,
-        )?;
-        let right_ins = left_obj.arch.process_instruction(
-            r,
-            right_data,
-            right_reloc,
-            right_symbol.address..right_symbol.address + right_symbol.size,
-            right_symbol.section.unwrap(),
-            diff_config,
-        )?;
+        let left_ins = left_obj.arch.process_instruction(left_resolved, diff_config)?;
+        let right_ins = left_obj.arch.process_instruction(right_resolved, diff_config)?;
         if left_ins.args.len() != right_ins.args.len() {
             state.diff_score += PENALTY_REPLACE;
             return Ok(InstructionDiffResult::new(InstructionDiffKind::Replace));
@@ -492,8 +455,8 @@ fn diff_instruction(
                 right_row,
                 a,
                 b,
-                left_reloc,
-                right_reloc,
+                left_resolved.relocation,
+                right_resolved.relocation,
                 diff_config,
             ) {
                 result.left_args_diff.push(InstructionArgDiffIndex::NONE);
@@ -510,7 +473,7 @@ fn diff_instruction(
                 if result.kind == InstructionDiffKind::None {
                     result.kind = InstructionDiffKind::ArgMismatch;
                 }
-                let a_str = arg_to_string(a, left_reloc.as_ref());
+                let a_str = arg_to_string(a, left_resolved.relocation);
                 let a_diff = match state.left_args_idx.entry(a_str) {
                     btree_map::Entry::Vacant(e) => {
                         let idx = state.left_arg_idx;
@@ -520,7 +483,7 @@ fn diff_instruction(
                     }
                     btree_map::Entry::Occupied(e) => *e.get(),
                 };
-                let b_str = arg_to_string(b, right_reloc.as_ref());
+                let b_str = arg_to_string(b, right_resolved.relocation);
                 let b_diff = match state.right_args_idx.entry(b_str) {
                     btree_map::Entry::Vacant(e) => {
                         let idx = state.right_arg_idx;
@@ -538,8 +501,15 @@ fn diff_instruction(
     }
 
     // Compare relocations
-    if !reloc_eq(left_obj, right_obj, left_reloc, right_reloc, diff_config) {
+    if !reloc_eq(
+        left_obj,
+        right_obj,
+        left_resolved.relocation,
+        right_resolved.relocation,
+        diff_config,
+    ) {
         state.diff_score += PENALTY_REG_DIFF;
+        // TODO add relocation diff to args
         return Ok(InstructionDiffResult::new(InstructionDiffKind::ArgMismatch));
     }
 

objdiff-core/src/diff/data.rs

@@ -38,8 +38,8 @@ pub fn diff_bss_symbol(
 fn reloc_eq(
     left_obj: &Object,
     right_obj: &Object,
-    left: &ResolvedRelocation,
-    right: &ResolvedRelocation,
+    left: ResolvedRelocation,
+    right: ResolvedRelocation,
 ) -> bool {
     if left.relocation.flags != right.relocation.flags {
         return false;
@@ -104,7 +104,7 @@ fn diff_data_relocs_for_range<'left, 'right>(
             continue;
         };
         let right_reloc = resolve_relocation(right_obj, right_reloc);
-        if reloc_eq(left_obj, right_obj, &left_reloc, &right_reloc) {
+        if reloc_eq(left_obj, right_obj, left_reloc, right_reloc) {
             diffs.push((DataDiffKind::None, Some(left_reloc), Some(right_reloc)));
         } else {
             diffs.push((DataDiffKind::Replace, Some(left_reloc), Some(right_reloc)));
@@ -251,13 +251,13 @@ pub fn diff_data_section(
         0..right_max as usize,
     ) {
         if let Some(left_reloc) = left_reloc {
-            let len = left_obj.arch.get_reloc_byte_size(left_reloc.relocation.flags);
+            let len = left_obj.arch.data_reloc_size(left_reloc.relocation.flags);
             let range = left_reloc.relocation.address as usize
                 ..left_reloc.relocation.address as usize + len;
             left_reloc_diffs.push(DataRelocationDiff { kind: diff_kind, range });
         }
         if let Some(right_reloc) = right_reloc {
-            let len = right_obj.arch.get_reloc_byte_size(right_reloc.relocation.flags);
+            let len = right_obj.arch.data_reloc_size(right_reloc.relocation.flags);
             let range = right_reloc.relocation.address as usize
                 ..right_reloc.relocation.address as usize + len;
             right_reloc_diffs.push(DataRelocationDiff { kind: diff_kind, range });
@@ -358,11 +358,9 @@ pub fn diff_data_symbol(
             let reloc_diff_len = match (left_reloc, right_reloc) {
                 (None, None) => unreachable!(),
                 (None, Some(right_reloc)) => {
-                    right_obj.arch.get_reloc_byte_size(right_reloc.relocation.flags)
-                }
-                (Some(left_reloc), _) => {
-                    left_obj.arch.get_reloc_byte_size(left_reloc.relocation.flags)
+                    right_obj.arch.data_reloc_size(right_reloc.relocation.flags)
                 }
+                (Some(left_reloc), _) => left_obj.arch.data_reloc_size(left_reloc.relocation.flags),
             };
             total_reloc_bytes += reloc_diff_len;
             if diff_kind == DataDiffKind::None {

objdiff-core/src/diff/display.rs

@@ -14,8 +14,8 @@ use regex::Regex;
 use crate::{
     diff::{DiffObjConfig, InstructionDiffKind, InstructionDiffRow, ObjectDiff, SymbolDiff},
     obj::{
-        InstructionArg, InstructionArgValue, Object, SectionFlag, SectionKind, Symbol, SymbolFlag,
-        SymbolKind,
+        InstructionArg, InstructionArgValue, Object, ParsedInstruction, ResolvedInstructionRef,
+        SectionFlag, SectionKind, Symbol, SymbolFlag, SymbolKind,
     },
 };
 
@@ -159,24 +159,24 @@ pub fn display_row(
         cb(EOL_SEGMENT)?;
         return Ok(());
     };
-    let symbol = &obj.symbols[symbol_index];
-    let Some(section_index) = symbol.section else {
+    let Some(resolved) = obj.resolve_instruction_ref(symbol_index, ins_ref) else {
         cb(DiffTextSegment::basic("<invalid>", DiffTextColor::Delete))?;
         cb(EOL_SEGMENT)?;
         return Ok(());
     };
-    let section = &obj.sections[section_index];
-    let Some(data) = section.data_range(ins_ref.address, ins_ref.size as usize) else {
-        cb(DiffTextSegment::basic("<invalid>", DiffTextColor::Delete))?;
-        cb(EOL_SEGMENT)?;
-        return Ok(());
+    let base_color = match ins_row.kind {
+        InstructionDiffKind::Replace => DiffTextColor::Replace,
+        InstructionDiffKind::Delete => DiffTextColor::Delete,
+        InstructionDiffKind::Insert => DiffTextColor::Insert,
+        _ => DiffTextColor::Normal,
     };
-    if let Some(line) = section.line_info.range(..=ins_ref.address).last().map(|(_, &b)| b) {
+    if let Some(line) = resolved.section.line_info.range(..=ins_ref.address).last().map(|(_, &b)| b)
+    {
         cb(DiffTextSegment { text: DiffText::Line(line), color: DiffTextColor::Dim, pad_to: 5 })?;
     }
     cb(DiffTextSegment {
-        text: DiffText::Address(ins_ref.address.saturating_sub(symbol.address)),
-        color: DiffTextColor::Normal,
+        text: DiffText::Address(ins_ref.address.saturating_sub(resolved.symbol.address)),
+        color: base_color,
         pad_to: 5,
     })?;
     if let Some(branch) = &ins_row.branch_from {
@@ -185,95 +185,85 @@ pub fn display_row(
         cb(DiffTextSegment::spacing(4))?;
     }
     let mut arg_idx = 0;
-    let relocation = section.relocation_at(ins_ref, obj);
     let mut displayed_relocation = false;
-    obj.arch.display_instruction(
-        ins_ref,
-        data,
-        relocation,
-        symbol.address..symbol.address + symbol.size,
-        section_index,
-        diff_config,
-        &mut |part| match part {
-            InstructionPart::Basic(text) => {
-                if text.chars().all(|c| c == ' ') {
-                    cb(DiffTextSegment::spacing(text.len() as u8))
-                } else {
-                    cb(DiffTextSegment::basic(&text, DiffTextColor::Normal))
-                }
+    obj.arch.display_instruction(resolved, diff_config, &mut |part| match part {
+        InstructionPart::Basic(text) => {
+            if text.chars().all(|c| c == ' ') {
+                cb(DiffTextSegment::spacing(text.len() as u8))
+            } else {
+                cb(DiffTextSegment::basic(&text, base_color))
             }
-            InstructionPart::Opcode(mnemonic, opcode) => cb(DiffTextSegment {
-                text: DiffText::Opcode(mnemonic.as_ref(), opcode),
-                color: if ins_row.kind == InstructionDiffKind::OpMismatch {
-                    DiffTextColor::Replace
-                } else {
-                    DiffTextColor::Normal
-                },
-                pad_to: 10,
-            }),
-            InstructionPart::Arg(arg) => {
-                let diff_index = ins_row.arg_diff.get(arg_idx).copied().unwrap_or_default();
-                arg_idx += 1;
-                match arg {
-                    InstructionArg::Value(value) => cb(DiffTextSegment {
-                        text: DiffText::Argument(value),
-                        color: diff_index
-                            .get()
-                            .map_or(DiffTextColor::Normal, |i| DiffTextColor::Rotating(i as u8)),
+        }
+        InstructionPart::Opcode(mnemonic, opcode) => cb(DiffTextSegment {
+            text: DiffText::Opcode(mnemonic.as_ref(), opcode),
+            color: match ins_row.kind {
+                InstructionDiffKind::OpMismatch => DiffTextColor::Replace,
+                _ => base_color,
+            },
+            pad_to: 10,
+        }),
+        InstructionPart::Arg(arg) => {
+            let diff_index = ins_row.arg_diff.get(arg_idx).copied().unwrap_or_default();
+            arg_idx += 1;
+            match arg {
+                InstructionArg::Value(value) => cb(DiffTextSegment {
+                    text: DiffText::Argument(value),
+                    color: diff_index
+                        .get()
+                        .map_or(base_color, |i| DiffTextColor::Rotating(i as u8)),
+                    pad_to: 0,
+                }),
+                InstructionArg::Reloc => {
+                    displayed_relocation = true;
+                    let resolved = resolved.relocation.unwrap();
+                    let color = diff_index
+                        .get()
+                        .map_or(DiffTextColor::Bright, |i| DiffTextColor::Rotating(i as u8));
+                    cb(DiffTextSegment {
+                        text: DiffText::Symbol(resolved.symbol),
+                        color,
                         pad_to: 0,
-                    }),
-                    InstructionArg::Reloc => {
-                        displayed_relocation = true;
-                        let resolved = relocation.unwrap();
-                        let color = diff_index
-                            .get()
-                            .map_or(DiffTextColor::Bright, |i| DiffTextColor::Rotating(i as u8));
+                    })?;
+                    if resolved.relocation.addend != 0 {
                         cb(DiffTextSegment {
-                            text: DiffText::Symbol(resolved.symbol),
+                            text: DiffText::Addend(resolved.relocation.addend),
                             color,
                             pad_to: 0,
                         })?;
-                        if resolved.relocation.addend != 0 {
-                            cb(DiffTextSegment {
-                                text: DiffText::Addend(resolved.relocation.addend),
-                                color,
-                                pad_to: 0,
-                            })?;
-                        }
-                        Ok(())
                     }
-                    InstructionArg::BranchDest(dest) => {
-                        if let Some(addr) = dest.checked_sub(symbol.address) {
-                            cb(DiffTextSegment {
-                                text: DiffText::BranchDest(addr),
-                                color: diff_index.get().map_or(DiffTextColor::Normal, |i| {
-                                    DiffTextColor::Rotating(i as u8)
-                                }),
-                                pad_to: 0,
-                            })
-                        } else {
-                            cb(DiffTextSegment {
-                                text: DiffText::Argument(InstructionArgValue::Opaque(
-                                    Cow::Borrowed("<invalid>"),
-                                )),
-                                color: diff_index.get().map_or(DiffTextColor::Normal, |i| {
-                                    DiffTextColor::Rotating(i as u8)
-                                }),
-                                pad_to: 0,
-                            })
-                        }
+                    Ok(())
+                }
+                InstructionArg::BranchDest(dest) => {
+                    if let Some(addr) = dest.checked_sub(resolved.symbol.address) {
+                        cb(DiffTextSegment {
+                            text: DiffText::BranchDest(addr),
+                            color: diff_index
+                                .get()
+                                .map_or(base_color, |i| DiffTextColor::Rotating(i as u8)),
+                            pad_to: 0,
+                        })
+                    } else {
+                        cb(DiffTextSegment {
+                            text: DiffText::Argument(InstructionArgValue::Opaque(Cow::Borrowed(
+                                "<invalid>",
+                            ))),
+                            color: diff_index
+                                .get()
+                                .map_or(base_color, |i| DiffTextColor::Rotating(i as u8)),
+                            pad_to: 0,
+                        })
                     }
                 }
             }
-            InstructionPart::Separator => {
-                cb(DiffTextSegment::basic(diff_config.separator(), DiffTextColor::Normal))
-            }
-        },
-    )?;
+        }
+        InstructionPart::Separator => {
+            cb(DiffTextSegment::basic(diff_config.separator(), base_color))
+        }
+    })?;
     // Fallback for relocation that wasn't displayed
-    if relocation.is_some() && !displayed_relocation {
-        cb(DiffTextSegment::basic(" <", DiffTextColor::Normal))?;
-        let resolved = relocation.unwrap();
+    if resolved.relocation.is_some() && !displayed_relocation {
+        cb(DiffTextSegment::basic(" <", base_color))?;
+        let resolved = resolved.relocation.unwrap();
         let diff_index = ins_row.arg_diff.get(arg_idx).copied().unwrap_or_default();
         let color =
             diff_index.get().map_or(DiffTextColor::Bright, |i| DiffTextColor::Rotating(i as u8));
@@ -285,7 +275,7 @@ pub fn display_row(
                 pad_to: 0,
             })?;
         }
-        cb(DiffTextSegment::basic(">", DiffTextColor::Normal))?;
+        cb(DiffTextSegment::basic(">", base_color))?;
     }
     if let Some(branch) = &ins_row.branch_to {
         cb(DiffTextSegment::basic(" ~>", DiffTextColor::Rotating(branch.branch_idx as u8)))?;
@@ -322,9 +312,17 @@ impl From<&DiffText<'_>> for HighlightKind {
     }
 }
 
-pub enum ContextMenuItem {
+pub enum ContextItem {
     Copy { value: String, label: Option<String> },
-    Navigate { label: String },
+    Navigate { label: String, symbol_index: usize, kind: SymbolNavigationKind },
+    Separator,
+}
+
+#[derive(Debug, Clone, Default, Eq, PartialEq)]
+pub enum SymbolNavigationKind {
+    #[default]
+    Normal,
+    Extab,
 }
 
 pub enum HoverItemColor {
@@ -333,66 +331,200 @@ pub enum HoverItemColor {
     Special,    // Blue
 }
 
-pub struct HoverItem {
-    pub text: String,
-    pub color: HoverItemColor,
+pub enum HoverItem {
+    Text { label: String, value: String, color: HoverItemColor },
+    Separator,
 }
 
-pub fn symbol_context(_obj: &Object, symbol: &Symbol) -> Vec<ContextMenuItem> {
+pub fn symbol_context(obj: &Object, symbol_index: usize) -> Vec<ContextItem> {
+    let symbol = &obj.symbols[symbol_index];
     let mut out = Vec::new();
+    out.push(ContextItem::Copy { value: symbol.name.clone(), label: None });
     if let Some(name) = &symbol.demangled_name {
-        out.push(ContextMenuItem::Copy { value: name.clone(), label: None });
+        out.push(ContextItem::Copy { value: name.clone(), label: None });
     }
-    out.push(ContextMenuItem::Copy { value: symbol.name.clone(), label: None });
-    if let Some(address) = symbol.virtual_address {
-        out.push(ContextMenuItem::Copy {
-            value: format!("{:#x}", address),
-            label: Some("virtual address".to_string()),
-        });
+    if symbol.section.is_some() {
+        if let Some(address) = symbol.virtual_address {
+            out.push(ContextItem::Copy {
+                value: format!("{:#x}", address),
+                label: Some("virtual address".to_string()),
+            });
+        }
     }
-    // if let Some(_extab) = obj.arch.ppc().and_then(|ppc| ppc.extab_for_symbol(symbol)) {
-    //     out.push(ContextMenuItem::Navigate { label: "Decode exception table".to_string() });
-    // }
+    out.append(&mut obj.arch.symbol_context(obj, symbol_index));
     out
 }
 
-pub fn symbol_hover(_obj: &Object, symbol: &Symbol) -> Vec<HoverItem> {
+pub fn symbol_hover(obj: &Object, symbol_index: usize, addend: i64) -> Vec<HoverItem> {
+    let symbol = &obj.symbols[symbol_index];
+    let addend_str = match addend.cmp(&0i64) {
+        Ordering::Greater => format!("+{:x}", addend),
+        Ordering::Less => format!("-{:x}", -addend),
+        _ => String::new(),
+    };
     let mut out = Vec::new();
-    out.push(HoverItem {
-        text: format!("Name: {}", symbol.name),
-        color: HoverItemColor::Emphasized,
+    out.push(HoverItem::Text {
+        label: "Name".into(),
+        value: format!("{}{}", symbol.name, addend_str),
+        color: HoverItemColor::Normal,
     });
-    out.push(HoverItem {
-        text: format!("Address: {:x}", symbol.address),
-        color: HoverItemColor::Emphasized,
-    });
-    if symbol.flags.contains(SymbolFlag::SizeInferred) {
-        out.push(HoverItem {
-            text: format!("Size: {:x} (inferred)", symbol.size),
-            color: HoverItemColor::Emphasized,
+    if let Some(demangled_name) = &symbol.demangled_name {
+        out.push(HoverItem::Text {
+            label: "Demangled".into(),
+            value: demangled_name.into(),
+            color: HoverItemColor::Normal,
         });
+    }
+    if let Some(section) = symbol.section {
+        out.push(HoverItem::Text {
+            label: "Section".into(),
+            value: obj.sections[section].name.clone(),
+            color: HoverItemColor::Normal,
+        });
+        out.push(HoverItem::Text {
+            label: "Address".into(),
+            value: format!("{:x}{}", symbol.address, addend_str),
+            color: HoverItemColor::Normal,
+        });
+        if symbol.flags.contains(SymbolFlag::SizeInferred) {
+            out.push(HoverItem::Text {
+                label: "Size".into(),
+                value: format!("{:x} (inferred)", symbol.size),
+                color: HoverItemColor::Normal,
+            });
+        } else {
+            out.push(HoverItem::Text {
+                label: "Size".into(),
+                value: format!("{:x}", symbol.size),
+                color: HoverItemColor::Normal,
+            });
+        }
+        if let Some(align) = symbol.align {
+            out.push(HoverItem::Text {
+                label: "Alignment".into(),
+                value: align.get().to_string(),
+                color: HoverItemColor::Normal,
+            });
+        }
+        if let Some(address) = symbol.virtual_address {
+            out.push(HoverItem::Text {
+                label: "Virtual address".into(),
+                value: format!("{:#x}", address),
+                color: HoverItemColor::Special,
+            });
+        }
     } else {
-        out.push(HoverItem {
-            text: format!("Size: {:x}", symbol.size),
+        out.push(HoverItem::Text {
+            label: Default::default(),
+            value: "Extern".into(),
             color: HoverItemColor::Emphasized,
         });
     }
-    if let Some(address) = symbol.virtual_address {
-        out.push(HoverItem {
-            text: format!("Virtual address: {:#x}", address),
+    out.append(&mut obj.arch.symbol_hover(obj, symbol_index));
+    out
+}
+
+pub fn instruction_context(
+    obj: &Object,
+    resolved: ResolvedInstructionRef,
+    ins: &ParsedInstruction,
+) -> Vec<ContextItem> {
+    let mut out = Vec::new();
+    let mut hex_string = String::new();
+    for byte in resolved.code {
+        hex_string.push_str(&format!("{:02x}", byte));
+    }
+    out.push(ContextItem::Copy { value: hex_string, label: Some("instruction bytes".to_string()) });
+    out.append(&mut obj.arch.instruction_context(obj, resolved));
+    if let Some(virtual_address) = resolved.symbol.virtual_address {
+        let offset = resolved.ins_ref.address - resolved.symbol.address;
+        out.push(ContextItem::Copy {
+            value: format!("{:x}", virtual_address + offset),
+            label: Some("virtual address".to_string()),
+        });
+    }
+    for arg in &ins.args {
+        if let InstructionArg::Value(arg) = arg {
+            out.push(ContextItem::Copy { value: arg.to_string(), label: None });
+            match arg {
+                InstructionArgValue::Signed(v) => {
+                    out.push(ContextItem::Copy { value: v.to_string(), label: None });
+                }
+                InstructionArgValue::Unsigned(v) => {
+                    out.push(ContextItem::Copy { value: v.to_string(), label: None });
+                }
+                _ => {}
+            }
+        }
+    }
+    if let Some(reloc) = resolved.relocation {
+        for literal in display_ins_data_literals(obj, resolved) {
+            out.push(ContextItem::Copy { value: literal, label: None });
+        }
+        out.push(ContextItem::Separator);
+        out.append(&mut symbol_context(obj, reloc.relocation.target_symbol));
+    }
+    out
+}
+
+pub fn instruction_hover(
+    obj: &Object,
+    resolved: ResolvedInstructionRef,
+    ins: &ParsedInstruction,
+) -> Vec<HoverItem> {
+    let mut out = Vec::new();
+    out.push(HoverItem::Text {
+        label: Default::default(),
+        value: format!("{:02x?}", resolved.code),
+        color: HoverItemColor::Normal,
+    });
+    out.append(&mut obj.arch.instruction_hover(obj, resolved));
+    if let Some(virtual_address) = resolved.symbol.virtual_address {
+        let offset = resolved.ins_ref.address - resolved.symbol.address;
+        out.push(HoverItem::Text {
+            label: "Virtual address".into(),
+            value: format!("{:#x}", virtual_address + offset),
             color: HoverItemColor::Special,
         });
     }
-    // if let Some(extab) = obj.arch.ppc().and_then(|ppc| ppc.extab_for_symbol(symbol)) {
-    //     out.push(HoverItem {
-    //         text: format!("extab symbol: {}", extab.etb_symbol.name),
-    //         color: HoverItemColor::Special,
-    //     });
-    //     out.push(HoverItem {
-    //         text: format!("extabindex symbol: {}", extab.eti_symbol.name),
-    //         color: HoverItemColor::Special,
-    //     });
-    // }
+    for arg in &ins.args {
+        if let InstructionArg::Value(arg) = arg {
+            match arg {
+                InstructionArgValue::Signed(v) => {
+                    out.push(HoverItem::Text {
+                        label: Default::default(),
+                        value: format!("{arg} == {v}"),
+                        color: HoverItemColor::Normal,
+                    });
+                }
+                InstructionArgValue::Unsigned(v) => {
+                    out.push(HoverItem::Text {
+                        label: Default::default(),
+                        value: format!("{arg} == {v}"),
+                        color: HoverItemColor::Normal,
+                    });
+                }
+                _ => {}
+            }
+        }
+    }
+    if let Some(reloc) = resolved.relocation {
+        if let Some(name) = obj.arch.reloc_name(reloc.relocation.flags) {
+            out.push(HoverItem::Text {
+                label: "Relocation type".into(),
+                value: name.to_string(),
+                color: HoverItemColor::Normal,
+            });
+        } else {
+            out.push(HoverItem::Text {
+                label: "Relocation type".into(),
+                value: format!("<{:?}>", reloc.relocation.flags),
+                color: HoverItemColor::Normal,
+            });
+        }
+        out.push(HoverItem::Separator);
+        out.append(&mut symbol_hover(obj, reloc.relocation.target_symbol, reloc.relocation.addend));
+    }
     out
 }
 
@@ -556,3 +688,37 @@ fn symbol_sort(a: &Symbol, b: &Symbol) -> Ordering {
 fn symbol_sort_reverse(a: &Symbol, b: &Symbol) -> Ordering {
     section_symbol_sort(a, b).then(b.address.cmp(&a.address)).then(b.size.cmp(&a.size))
 }
+
+pub fn display_ins_data_labels(obj: &Object, resolved: ResolvedInstructionRef) -> Vec<String> {
+    let Some(reloc) = resolved.relocation else {
+        return Vec::new();
+    };
+    if reloc.relocation.addend < 0 || reloc.relocation.addend as u64 >= reloc.symbol.size {
+        return Vec::new();
+    }
+    let Some(data) = obj.symbol_data(reloc.relocation.target_symbol) else {
+        return Vec::new();
+    };
+    let bytes = &data[reloc.relocation.addend as usize..];
+    obj.arch
+        .guess_data_type(resolved)
+        .map(|ty| ty.display_labels(obj.endianness, bytes))
+        .unwrap_or_default()
+}
+
+pub fn display_ins_data_literals(obj: &Object, resolved: ResolvedInstructionRef) -> Vec<String> {
+    let Some(reloc) = resolved.relocation else {
+        return Vec::new();
+    };
+    if reloc.relocation.addend < 0 || reloc.relocation.addend as u64 >= reloc.symbol.size {
+        return Vec::new();
+    }
+    let Some(data) = obj.symbol_data(reloc.relocation.target_symbol) else {
+        return Vec::new();
+    };
+    let bytes = &data[reloc.relocation.addend as usize..];
+    obj.arch
+        .guess_data_type(resolved)
+        .map(|ty| ty.display_literals(obj.endianness, bytes))
+        .unwrap_or_default()
+}