fixup: move to runner-shared

Author: not-matthias

crates/runner-shared/src/debug_info.rs

@@ -0,0 +1,28 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Hash, PartialEq, Eq, Clone, Serialize, Deserialize)]
+pub struct DebugInfo {
+    pub addr: u64,
+    pub size: u64,
+    pub name: String,
+    pub file: String,
+    pub line: Option<u32>,
+}
+
+impl std::fmt::Debug for DebugInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let location = format!("{}:{}", self.file, self.line.unwrap_or(0));
+        let name = &self.name;
+        write!(
+            f,
+            "DebugInfo {{ addr: {:x}, size: {:x}, name: {}, location: {} }}",
+            self.addr, self.size, name, location
+        )
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ModuleDebugInfo {
+    pub load_bias: u64,
+    pub debug_infos: Vec<DebugInfo>,
+}

crates/runner-shared/src/lib.rs

@@ -1,3 +1,4 @@
+pub mod debug_info;
 pub mod fifo;
 pub mod metadata;
 pub mod unwind_data;

src/run/runner/wall_time/perf/debug_info.rs

@@ -2,46 +2,43 @@ use crate::prelude::*;
 use crate::run::runner::wall_time::perf::perf_map::ModuleSymbols;
 use libc::pid_t;
 use object::{Object, ObjectSection};
-use serde::{Deserialize, Serialize};
-use std::{fmt::Debug, path::Path};
-
-#[derive(Hash, PartialEq, Eq, Clone, Serialize, Deserialize)]
-pub struct DebugInfo {
-    pub addr: u64,
-    pub size: u64,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub file: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub line: Option<u32>,
-}
+use runner_shared::debug_info::{DebugInfo, ModuleDebugInfo};
+use std::path::Path;
+
+pub trait ModuleDebugInfoExt {
+    fn from_symbols<P: AsRef<Path>>(path: P, symbols: &ModuleSymbols) -> anyhow::Result<Self>
+    where
+        Self: Sized;
 
-impl Debug for DebugInfo {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let location = match (&self.file, self.line) {
-            (Some(file), Some(line)) => format!("{file}:{line}"),
-            (Some(file), None) => file.clone(),
-            _ => String::from("<unknown>"),
+    fn create_dwarf_context(
+        object: &object::File,
+    ) -> anyhow::Result<addr2line::Context<gimli::EndianRcSlice<gimli::RunTimeEndian>>> {
+        let endian = if object.is_little_endian() {
+            gimli::RunTimeEndian::Little
+        } else {
+            gimli::RunTimeEndian::Big
+        };
+
+        type EndianRcSlice = gimli::EndianRcSlice<gimli::RunTimeEndian>;
+        let load_section = |id: gimli::SectionId| -> Result<EndianRcSlice, gimli::Error> {
+            let data = object
+                .section_by_name(id.name())
+                .and_then(|s| s.uncompressed_data().ok())
+                .unwrap_or(std::borrow::Cow::Borrowed(&[]));
+            Ok(gimli::EndianRcSlice::new(
+                std::rc::Rc::from(data.as_ref()),
+                endian,
+            ))
         };
-        let name = self.name.as_deref().unwrap_or("<no symbol>");
-        write!(
-            f,
-            "DebugInfo {{ addr: {:x}, size: {:x}, name: {}, location: {} }}",
-            self.addr, self.size, name, location
-        )
-    }
-}
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ModuleDebugInfo {
-    load_bias: u64,
-    debug_infos: Vec<DebugInfo>,
+        let dwarf = gimli::Dwarf::load(load_section)?;
+        addr2line::Context::from_dwarf(dwarf).map_err(Into::into)
+    }
 }
 
-impl ModuleDebugInfo {
+impl ModuleDebugInfoExt for ModuleDebugInfo {
     /// Create debug info from existing symbols by looking up file/line in DWARF
-    pub fn from_symbols<P: AsRef<Path>>(path: P, symbols: &ModuleSymbols) -> anyhow::Result<Self> {
+    fn from_symbols<P: AsRef<Path>>(path: P, symbols: &ModuleSymbols) -> anyhow::Result<Self> {
         let content = std::fs::read(path.as_ref())?;
         let object = object::File::parse(&*content)?;
 
@@ -62,43 +59,18 @@ impl ModuleDebugInfo {
                 Some(DebugInfo {
                     addr: symbol.addr,
                     size: symbol.size,
-                    name: Some(symbol.name.clone()),
-                    file: Some(file),
+                    name: symbol.name.clone(),
+                    file,
                     line,
                 })
             })
             .collect();
 
-        Ok(Self {
+        Ok(ModuleDebugInfo {
             load_bias,
             debug_infos,
         })
     }
-
-    fn create_dwarf_context(
-        object: &object::File,
-    ) -> anyhow::Result<addr2line::Context<gimli::EndianRcSlice<gimli::RunTimeEndian>>> {
-        let endian = if object.is_little_endian() {
-            gimli::RunTimeEndian::Little
-        } else {
-            gimli::RunTimeEndian::Big
-        };
-
-        type EndianRcSlice = gimli::EndianRcSlice<gimli::RunTimeEndian>;
-        let load_section = |id: gimli::SectionId| -> Result<EndianRcSlice, gimli::Error> {
-            let data = object
-                .section_by_name(id.name())
-                .and_then(|s| s.uncompressed_data().ok())
-                .unwrap_or(std::borrow::Cow::Borrowed(&[]));
-            Ok(gimli::EndianRcSlice::new(
-                std::rc::Rc::from(data.as_ref()),
-                endian,
-            ))
-        };
-
-        let dwarf = gimli::Dwarf::load(load_section)?;
-        addr2line::Context::from_dwarf(dwarf).map_err(Into::into)
-    }
 }
 
 /// Represents all the modules inside a process and their debug info.