test

Author: emesare

Cargo.lock

@@ -9,6 +9,7 @@ members = [
     "arch/riscv",
     "arch/msp430",
     "rust/plugin_examples/data_renderer",
+    "rust/plugin_examples/source_line_renderer",
     "view/minidump",
     "plugins/dwarf/dwarf_import",
     "plugins/dwarf/dwarf_import/demo",

Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "source_line_renderer"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+binaryninjacore-sys = { path = "../../binaryninjacore-sys" }
+binaryninja = { path = "../.." }
+gimli = "0.33.0"
+tracing = "0.1"

rust/plugin_examples/source_line_renderer/Cargo.toml

@@ -0,0 +1,25 @@
+fn main() {
+    let link_path = std::env::var_os("DEP_BINARYNINJACORE_PATH")
+        .expect("DEP_BINARYNINJACORE_PATH not specified");
+
+    println!("cargo::rustc-link-lib=dylib=binaryninjacore");
+    println!("cargo::rustc-link-search={}", link_path.to_str().unwrap());
+
+    #[cfg(target_os = "linux")]
+    {
+        println!(
+            "cargo::rustc-link-arg=-Wl,-rpath,{0},-L{0}",
+            link_path.to_string_lossy()
+        );
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        let crate_name = std::env::var("CARGO_PKG_NAME").expect("CARGO_PKG_NAME not set");
+        let lib_name = crate_name.replace('-', "_");
+        println!(
+            "cargo::rustc-link-arg=-Wl,-install_name,@rpath/lib{}.dylib",
+            lib_name
+        );
+    }
+}

rust/plugin_examples/source_line_renderer/build.rs

@@ -0,0 +1,108 @@
+use binaryninja::binary_view::BinaryView;
+use binaryninja::disassembly::{InstructionTextToken, InstructionTextTokenKind};
+use binaryninja::file_metadata::SessionId;
+use binaryninja::linear_view::{LinearDisassemblyLine, LinearViewObject};
+use binaryninja::object_destructor::ObjectDestructor;
+use binaryninja::render_layer::{register_render_layer, RenderLayer, RenderLayerDefaultState};
+use std::collections::HashMap;
+use std::sync::RwLock;
+
+pub mod state;
+
+#[derive(Default)]
+struct DebugLineRenderLayer {
+    data: RwLock<HashMap<SessionId, state::DebugLineState>>,
+}
+
+impl DebugLineRenderLayer {
+    pub fn map_line_info(
+        &self,
+        view: &BinaryView,
+        mut line: LinearDisassemblyLine,
+    ) -> LinearDisassemblyLine {
+        let addr = line.contents.address;
+        if let Some(info) = self.line_info(view, addr) {
+            // We only want to add the line number for lines that display an address.
+            if line.contents.tokens.first().is_some_and(|t| {
+                t.kind == InstructionTextTokenKind::AddressDisplay { address: addr }
+            }) {
+                line.contents.tokens.insert(
+                    0,
+                    InstructionTextToken::new(" ", InstructionTextTokenKind::AddressSeparator),
+                );
+                line.contents.tokens.insert(
+                    0,
+                    InstructionTextToken::new(
+                        info.to_string(),
+                        InstructionTextTokenKind::AddressDisplay { address: addr },
+                    ),
+                );
+            }
+        }
+        line
+    }
+
+    pub fn line_info(&self, view: &BinaryView, address: u64) -> Option<state::DebugLineInfo> {
+        let lock = self.data.read().ok()?;
+        let state = lock.get(&view.file().session_id())?;
+        state.line_info(address)
+    }
+
+    // TODO: This is manual probing rn, would prefer to not do like this.
+    fn probe_state(&self, view: &BinaryView) {
+        let session_id = view.file().session_id();
+        let mut lock = self.data.write().unwrap();
+        if !lock.contains_key(&session_id) {
+            if let Ok(state) = state::DebugLineState::new(view) {
+                lock.insert(session_id, state);
+            }
+        }
+    }
+}
+
+impl RenderLayer for DebugLineRenderLayer {
+    fn apply_to_linear_object(
+        &self,
+        _object: &mut LinearViewObject,
+        _prev_object: Option<&mut LinearViewObject>,
+        _next_object: Option<&mut LinearViewObject>,
+        lines: Vec<LinearDisassemblyLine>,
+    ) -> Vec<LinearDisassemblyLine> {
+        let view = match lines.first() {
+            Some(first_line) => first_line.function.as_ref().map(|f| f.view()),
+            None => return lines,
+        };
+
+        if let Some(view) = view {
+            self.probe_state(&view);
+            let lines = lines
+                .into_iter()
+                .map(|line| self.map_line_info(&view, line))
+                .collect();
+            lines
+        } else {
+            lines
+        }
+    }
+}
+
+impl ObjectDestructor for DebugLineRenderLayer {
+    fn destruct_view(&self, view: &BinaryView) {
+        let mut lock = self.data.write().unwrap();
+        lock.remove(&view.file().session_id());
+    }
+}
+
+#[allow(non_snake_case)]
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn CorePluginInit() -> bool {
+    binaryninja::tracing_init!();
+
+    register_render_layer(
+        "Debug Lines",
+        DebugLineRenderLayer::default(),
+        RenderLayerDefaultState::Disabled,
+    );
+
+    true
+}

rust/plugin_examples/source_line_renderer/src/lib.rs

@@ -0,0 +1,122 @@
+use binaryninja::binary_view::{BinaryView, BinaryViewBase};
+use binaryninja::Endianness;
+use gimli::{DebugInfoOffset, RunTimeEndian, UnitSectionOffset};
+use std::borrow::Cow;
+use std::collections::BTreeMap;
+
+pub struct DebugLineInfo {
+    pub file: String,
+    pub line_number: u64,
+}
+
+impl std::fmt::Display for DebugLineInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}:{}", self.file, self.line_number)
+    }
+}
+
+pub struct DebugLineState {
+    sections: gimli::DwarfSections<Cow<'static, [u8]>>,
+    endian: RunTimeEndian,
+    address_mapping: BTreeMap<u64, UnitSectionOffset>,
+}
+
+impl DebugLineState {
+    // TODO: Support supplementary files and networked files.
+    pub fn new(view: &BinaryView) -> Result<Self, Box<dyn std::error::Error>> {
+        let section_reader =
+            |name: &str| -> Result<Cow<'static, [u8]>, Box<dyn std::error::Error>> {
+                let mut section = view.section_by_name(name);
+                if section.is_none() {
+                    // Looks like macho uses underscores instead of dots for section names.
+                    let alt_name = name.replace(".", "__");
+                    section = view.section_by_name(alt_name);
+                }
+
+                match section {
+                    Some(section) => Ok(Cow::Owned(view.read_vec(section.start(), section.len()))),
+                    // TODO: Instead of failing, we return empty section so we can continue.
+                    None => Ok(Cow::Owned(Vec::new())),
+                }
+            };
+
+        let loader = |section: gimli::SectionId| section_reader(section.name());
+        let dwarf_sections = gimli::DwarfSections::load(loader)?;
+
+        let endian = match view.default_endianness() {
+            Endianness::LittleEndian => RunTimeEndian::Little,
+            Endianness::BigEndian => RunTimeEndian::Big,
+        };
+
+        let borrow_section = |section| gimli::EndianSlice::new(Cow::as_ref(section), endian);
+        let dwarf = dwarf_sections.borrow(borrow_section);
+
+        // TODO: The row.address() will not be adjusted for the view image base.
+        // let base_address = view.image_base();
+        let mut address_mapping = BTreeMap::new();
+        let mut units = dwarf.units();
+        while let Ok(Some(unit_header)) = units.next() {
+            let Ok(unit) = dwarf.unit(unit_header) else {
+                continue;
+            };
+            let Some(line_program) = unit.line_program.as_ref() else {
+                continue;
+            };
+
+            let mut program_rows = line_program.clone().rows();
+            while let Ok(Some((_, row))) = program_rows.next_row() {
+                if row.end_sequence() {
+                    continue;
+                }
+                address_mapping.insert(row.address(), unit_header.offset());
+            }
+        }
+
+        Ok(Self {
+            sections: dwarf_sections,
+            endian,
+            address_mapping,
+        })
+    }
+
+    pub fn line_info(&self, address: u64) -> Option<DebugLineInfo> {
+        // TODO: This can approximte the lie number, and should be more refined before shipping, most of
+        // TODO: it to do with the address mapping being a tree and we selecting for the closest.
+        let (_, unit_offset) = self.address_mapping.range(..=address).next_back()?;
+        let borrow_section = |section| gimli::EndianSlice::new(Cow::as_ref(section), self.endian);
+        let dwarf = self.sections.borrow(borrow_section);
+        let unit_offset = DebugInfoOffset(unit_offset.0);
+        let unit_header = dwarf.debug_info.header_from_offset(unit_offset).ok()?;
+        let unit = dwarf.unit(unit_header).ok()?;
+
+        let line_program = unit.line_program.as_ref()?;
+        let mut rows = line_program.clone().rows();
+
+        let mut current_file_index = 0;
+        let mut current_line = None;
+        while let Ok(Some((_, row))) = rows.next_row() {
+            if row.address() > address {
+                break;
+            }
+            if row.end_sequence() {
+                continue;
+            }
+            current_file_index = row.file_index();
+            if let Some(line) = row.line() {
+                current_line = Some(line.get());
+            }
+        }
+
+        let header = line_program.header();
+        let file = header.file(current_file_index)?;
+        let mut file_name = "<unknown file>".to_string();
+        if let Ok(attr_str) = dwarf.attr_string(&unit, file.path_name()) {
+            file_name = attr_str.to_string_lossy().into_owned();
+        }
+
+        Some(DebugLineInfo {
+            file: file_name,
+            line_number: current_line?,
+        })
+    }
+}