Merge pull request #5 from swananan/fix_gimli_unsafe_use

refactor: eliminate unsafe lifetime transmutes in DWARF parser

Author: swananan

ghostscope-dwarf/src/data/block_index.rs

@@ -6,7 +6,7 @@
 //! - Provides fast lookup of in-scope variables at a given PC
 
 use crate::parser::RangeExtractor;
-use gimli::{EndianSlice, LittleEndian};
+use gimli::{EndianArcSlice, LittleEndian, Reader};
 use std::collections::BTreeMap;
 
 /// Reference to a variable DIE within a unit
@@ -190,11 +190,11 @@ impl BlockIndex {
 
 /// Builder for block index using DWARF data
 pub struct BlockIndexBuilder<'a> {
-    dwarf: &'a gimli::Dwarf<EndianSlice<'static, LittleEndian>>,
+    dwarf: &'a gimli::Dwarf<EndianArcSlice<LittleEndian>>,
 }
 
 impl<'a> BlockIndexBuilder<'a> {
-    pub fn new(dwarf: &'a gimli::Dwarf<EndianSlice<'static, LittleEndian>>) -> Self {
+    pub fn new(dwarf: &'a gimli::Dwarf<EndianArcSlice<LittleEndian>>) -> Self {
         Self { dwarf }
     }
 
@@ -213,7 +213,7 @@ impl<'a> BlockIndexBuilder<'a> {
                     .ok()
                     .and_then(|a| a)
                     .and_then(|a| self.dwarf.attr_string(&unit, a.value()).ok())
-                    .map(|s| s.to_string_lossy().into_owned());
+                    .and_then(|s| s.to_string_lossy().ok().map(|cow| cow.into_owned()));
                 let mut fb = FunctionBlocks::new(name, cu_offset, entry.offset());
                 if let Ok(ranges) = RangeExtractor::extract_all_ranges(entry, &unit, self.dwarf) {
                     fb.ranges = ranges;
@@ -250,7 +250,7 @@ impl<'a> BlockIndexBuilder<'a> {
             .ok()
             .and_then(|a| a)
             .and_then(|a| self.dwarf.attr_string(&unit, a.value()).ok())
-            .map(|s| s.to_string_lossy().into_owned());
+            .and_then(|s| s.to_string_lossy().ok().map(|cow| cow.into_owned()));
         let mut fb = FunctionBlocks::new(name, cu_offset, die_offset);
         if let Ok(ranges) = RangeExtractor::extract_all_ranges(&entry, &unit, self.dwarf) {
             fb.ranges = ranges;
@@ -269,8 +269,8 @@ impl<'a> BlockIndexBuilder<'a> {
 
     fn build_blocks_for_function(
         &self,
-        unit: &gimli::Unit<EndianSlice<'static, LittleEndian>>,
-        func_entry: &gimli::DebuggingInformationEntry<EndianSlice<'static, LittleEndian>>,
+        unit: &gimli::Unit<EndianArcSlice<LittleEndian>>,
+        func_entry: &gimli::DebuggingInformationEntry<EndianArcSlice<LittleEndian>>,
         fb: &mut FunctionBlocks,
     ) {
         // DFS but only within this function's subtree
@@ -283,8 +283,8 @@ impl<'a> BlockIndexBuilder<'a> {
 
     fn walk_children(
         &self,
-        unit: &gimli::Unit<EndianSlice<'static, LittleEndian>>,
-        node: gimli::EntriesTreeNode<EndianSlice<'static, LittleEndian>>,
+        unit: &gimli::Unit<EndianArcSlice<LittleEndian>>,
+        node: gimli::EntriesTreeNode<EndianArcSlice<LittleEndian>>,
         parent_idx: usize,
         fb: &mut FunctionBlocks,
     ) {

ghostscope-dwarf/src/data/cfi_index.rs

@@ -6,18 +6,27 @@
 use crate::core::{CfaResult, ComputeStep, Result};
 use anyhow::{anyhow, Context};
 use gimli::{
-    BaseAddresses, CfaRule, CieOrFde, EhFrame, EhFrameHdr, EndianSlice, FrameDescriptionEntry,
-    LittleEndian, ParsedEhFrameHdr, UnwindContext, UnwindSection,
+    BaseAddresses, CfaRule, CieOrFde, EhFrame, EhFrameHdr, FrameDescriptionEntry, LittleEndian,
+    ParsedEhFrameHdr, UnwindContext, UnwindSection,
 };
 use object::{Object, ObjectSection};
+use std::sync::Arc;
 use tracing::{debug, info, warn};
 
+use gimli::{EndianSlice, LittleEndian as LE};
+
 /// CFI index for fast CFA rule lookup
 pub struct CfiIndex {
-    /// Parsed eh_frame section
-    eh_frame: EhFrame<EndianSlice<'static, LittleEndian>>,
+    /// Keep file data alive
+    _file_data: Arc<[u8]>,
+    /// Keep eh_frame section data alive
+    _eh_frame_data: Arc<[u8]>,
+    /// Keep eh_frame_hdr section data alive (if present)
+    _eh_frame_hdr_data: Option<Arc<[u8]>>,
+    /// Parsed eh_frame section (using 'static via Box::leak)
+    eh_frame: EhFrame<EndianSlice<'static, LE>>,
     /// Parsed eh_frame_hdr for fast lookup (if available)
-    eh_frame_hdr: Option<ParsedEhFrameHdr<EndianSlice<'static, LittleEndian>>>,
+    eh_frame_hdr: Option<ParsedEhFrameHdr<EndianSlice<'static, LE>>>,
     /// Base addresses for DWARF sections
     bases: BaseAddresses,
     /// Whether we have eh_frame_hdr for fast lookup
@@ -34,48 +43,63 @@ impl std::fmt::Debug for CfiIndex {
 }
 
 impl CfiIndex {
-    /// Create a new CFI index from an object file
-    pub fn from_static_data(file_data: &'static [u8]) -> Result<Self> {
-        let object = object::File::parse(file_data).context("Failed to parse object file")?;
+    /// Create a new CFI index from an object file data
+    pub fn from_arc_data(file_data: Arc<[u8]>) -> Result<Self> {
+        let object = object::File::parse(&file_data[..]).context("Failed to parse object file")?;
 
         // Load eh_frame section (required)
-        let eh_frame_data = object
+        let eh_frame_section = object
             .section_by_name(".eh_frame")
-            .ok_or_else(|| anyhow!(".eh_frame section not found"))?
-            .data()
-            .context("Failed to read .eh_frame section data")?;
-
-        let eh_frame = EhFrame::new(eh_frame_data, LittleEndian);
+            .ok_or_else(|| anyhow!(".eh_frame section not found"))?;
+
+        // Get section data range
+        let (eh_frame_start, eh_frame_size) = eh_frame_section
+            .file_range()
+            .ok_or_else(|| anyhow!(".eh_frame section has no file range"))?;
+        let eh_frame_start = eh_frame_start as usize;
+        let eh_frame_end = eh_frame_start + eh_frame_size as usize;
+
+        // Create Arc slice for eh_frame and leak to 'static
+        // Note: We must copy once for Box::leak (gimli's EhFrame requires 'static lifetime)
+        let eh_frame_data = file_data[eh_frame_start..eh_frame_end].to_vec();
+        let eh_frame_static: &'static [u8] = Box::leak(eh_frame_data.into_boxed_slice());
+        let eh_frame_arc: Arc<[u8]> = Arc::from(eh_frame_static); // Zero-copy: reference leaked data
+        let eh_frame = EhFrame::new(eh_frame_static, LittleEndian);
 
         // Try to load eh_frame_hdr for fast lookup (optional)
+        let mut hdr_arc_opt: Option<Arc<[u8]>> = None;
         let (eh_frame_hdr, has_fast_lookup) = match object.section_by_name(".eh_frame_hdr") {
-            Some(section) => {
-                match section.data() {
-                    Ok(data) => {
-                        let hdr_section = EhFrameHdr::new(data, LittleEndian);
-
-                        // Parse with proper address_size
-                        let address_size = if object.is_64() { 8 } else { 4 };
-                        let mut bases = BaseAddresses::default();
-
-                        // Set eh_frame_hdr section base
-                        if let Some(hdr_section_obj) = object.section_by_name(".eh_frame_hdr") {
-                            bases = bases.set_eh_frame_hdr(hdr_section_obj.address());
-                        }
-
-                        match hdr_section.parse(&bases, address_size) {
-                            Ok(parsed) => {
-                                info!("Successfully parsed .eh_frame_hdr for fast FDE lookup");
-                                (Some(parsed), true)
-                            }
-                            Err(e) => {
-                                warn!("Failed to parse .eh_frame_hdr: {:?}, falling back to linear search", e);
-                                (None, false)
-                            }
-                        }
+            Some(hdr_section_obj) => {
+                let (hdr_start, hdr_size) = hdr_section_obj
+                    .file_range()
+                    .ok_or_else(|| anyhow!(".eh_frame_hdr section has no file range"))?;
+                let hdr_start = hdr_start as usize;
+                let hdr_end = hdr_start + hdr_size as usize;
+
+                // Create Arc slice for eh_frame_hdr and leak to 'static
+                let hdr_data = file_data[hdr_start..hdr_end].to_vec();
+                let hdr_static: &'static [u8] = Box::leak(hdr_data.into_boxed_slice());
+                let hdr_arc: Arc<[u8]> = Arc::from(hdr_static); // Zero-copy: reference leaked data
+                hdr_arc_opt = Some(hdr_arc);
+                let hdr_section = EhFrameHdr::new(hdr_static, LittleEndian);
+
+                // Parse with proper address_size
+                let address_size = if object.is_64() { 8 } else { 4 };
+                let mut bases = BaseAddresses::default();
+
+                // Set eh_frame_hdr section base
+                bases = bases.set_eh_frame_hdr(hdr_section_obj.address());
+
+                match hdr_section.parse(&bases, address_size) {
+                    Ok(parsed) => {
+                        info!("Successfully parsed .eh_frame_hdr for fast FDE lookup");
+                        (Some(parsed), true)
                     }
                     Err(e) => {
-                        warn!("Failed to read .eh_frame_hdr data: {:?}", e);
+                        warn!(
+                            "Failed to parse .eh_frame_hdr: {:?}, falling back to linear search",
+                            e
+                        );
                         (None, false)
                     }
                 }
@@ -105,6 +129,9 @@ impl CfiIndex {
         }
 
         Ok(Self {
+            _file_data: file_data.clone(),
+            _eh_frame_data: eh_frame_arc,
+            _eh_frame_hdr_data: hdr_arc_opt,
             eh_frame,
             eh_frame_hdr,
             bases,
@@ -142,7 +169,11 @@ impl CfiIndex {
                 // Get the expression bytes from the section
                 let expression = expr.get(&self.eh_frame)?;
                 // Parse DWARF expression to compute steps
-                let steps = self.parse_dwarf_expression(expression.0.slice())?;
+                // expression.0 is EndianSlice, get the underlying bytes
+                use gimli::Reader;
+                let temp = expression.0.to_slice().ok();
+                let expr_bytes = temp.as_deref().unwrap_or(&[]);
+                let steps = self.parse_dwarf_expression(expr_bytes)?;
                 CfaResult::Expression { steps }
             }
         };
@@ -156,7 +187,7 @@ impl CfiIndex {
     fn find_fde_for_address(
         &self,
         address: u64,
-    ) -> Result<FrameDescriptionEntry<EndianSlice<'static, LittleEndian>, usize>> {
+    ) -> Result<FrameDescriptionEntry<EndianSlice<'static, LE>, usize>> {
         if let Some(hdr) = &self.eh_frame_hdr {
             // Fast path: O(log n) binary search using eh_frame_hdr
             debug!(

ghostscope-dwarf/src/data/on_demand_resolver.rs

@@ -4,7 +4,7 @@
 use crate::{
     core::Result, data::TypeNameIndex, parser::DetailedParser, parser::VariableWithEvaluation,
 };
-use gimli::{EndianSlice, LittleEndian};
+use gimli::{EndianArcSlice, LittleEndian};
 // Use upper-case aliases to satisfy non_upper_case_globals lint on pattern constants
 // No direct constant tag imports needed here
 // tracing::warn no longer used after removing legacy traversal
@@ -18,7 +18,7 @@ pub struct ChainSpec<'a> {
 /// Real on-demand DWARF resolver
 #[derive(Debug)]
 pub struct OnDemandResolver {
-    dwarf: gimli::Dwarf<EndianSlice<'static, LittleEndian>>,
+    dwarf: gimli::Dwarf<EndianArcSlice<LittleEndian>>,
     detailed_parser: DetailedParser,
     /// Optional cross-CU type name index (built from lightweight index)
     type_name_index: Option<std::sync::Arc<TypeNameIndex>>,
@@ -29,7 +29,7 @@ pub struct OnDemandResolver {
 impl OnDemandResolver {
     /// Create resolver with a type name index for faster cross-CU completion
     pub fn new_with_type_index(
-        dwarf: gimli::Dwarf<EndianSlice<'static, LittleEndian>>,
+        dwarf: gimli::Dwarf<EndianArcSlice<LittleEndian>>,
         type_index: std::sync::Arc<TypeNameIndex>,
     ) -> Self {
         let mut detailed_parser = DetailedParser::new();
@@ -43,7 +43,7 @@ impl OnDemandResolver {
     }
 
     /// Borrow DWARF reference for building auxiliary indexes lazily
-    pub fn dwarf_ref(&self) -> &gimli::Dwarf<EndianSlice<'static, LittleEndian>> {
+    pub fn dwarf_ref(&self) -> &gimli::Dwarf<EndianArcSlice<LittleEndian>> {
         &self.dwarf
     }