Store Arc<Helper> in SymbolMap.

Author: mstange

samply-api/src/source/mod.rs

@@ -87,10 +87,7 @@ impl<'a, H: FileAndPathHelper> SourceApi<'a, H> {
             }
             FramesLookupResult::Unavailable => return Err(SourceError::NoDebugInfo),
             FramesLookupResult::NeedDwo { svma, .. } => {
-                match symbol_map
-                    .lookup_frames_async(svma, self.symbol_manager.helper())
-                    .await
-                {
+                match symbol_map.lookup_frames_async(svma).await {
                     Some(frames) => frames,
                     None => return Err(SourceError::NoDebugInfo),
                 }

samply-api/src/symbolicate/mod.rs

@@ -132,10 +132,7 @@ impl<'a, H: FileAndPathHelper> SymbolicateApi<'a, H> {
         }
 
         for (address, svma, _) in external_addresses_dwo {
-            if let Some(frames) = symbol_map
-                .lookup_frames_async(svma, self.symbol_manager.helper())
-                .await
-            {
+            if let Some(frames) = symbol_map.lookup_frames_async(svma).await {
                 symbolication_result.add_address_debug_info(address, frames);
             }
         }

samply-symbols/src/breakpad/symbol_map.rs

@@ -9,8 +9,8 @@ use yoke_derive::Yokeable;
 
 use crate::{
     symbol_map::{GetInnerSymbolMap, SymbolMapTrait},
-    AddressInfo, Error, FileContents, FileContentsWrapper, FileLocation, FrameDebugInfo,
-    FramesLookupResult, SourceFilePath, SymbolInfo, SymbolMap,
+    AddressInfo, Error, FileContents, FileContentsWrapper, FrameDebugInfo, FramesLookupResult,
+    SourceFilePath, SymbolInfo,
 };
 
 use super::index::{
@@ -19,20 +19,15 @@ use super::index::{
     BreakpadSymbolType, FileOrInlineOrigin, ItemMap,
 };
 
-pub fn get_symbol_map_for_breakpad_sym<F, FL>(
-    file_contents: FileContentsWrapper<F>,
-    file_location: FL,
-    index_file_contents: Option<FileContentsWrapper<F>>,
-) -> Result<SymbolMap<FL, F>, Error>
-where
-    F: FileContents + 'static,
-    FL: FileLocation,
-{
+pub fn get_symbol_map_for_breakpad_sym<FC: FileContents + 'static>(
+    file_contents: FileContentsWrapper<FC>,
+    index_file_contents: Option<FileContentsWrapper<FC>>,
+) -> Result<BreakpadSymbolMap<FC>, Error> {
     let outer = BreakpadSymbolMapOuter::new(file_contents, index_file_contents)?;
     let symbol_map = BreakpadSymbolMap(Yoke::attach_to_cart(Box::new(outer), |outer| {
         outer.make_symbol_map()
     }));
-    Ok(SymbolMap::new_without(file_location, Box::new(symbol_map)))
+    Ok(symbol_map)
 }
 
 pub struct BreakpadSymbolMap<T: FileContents + 'static>(
@@ -333,51 +328,16 @@ impl<'a, T: FileContents> SymbolMapTrait for BreakpadSymbolMapInner<'a, T> {
 mod test {
     use debugid::DebugId;
 
-    use crate::DwoRef;
-
     use super::*;
 
-    #[derive(Clone)]
-    struct DummyLocation;
-
-    impl FileLocation for DummyLocation {
-        fn location_for_dyld_subcache(&self, _suffix: &str) -> Option<Self> {
-            None
-        }
-
-        fn location_for_external_object_file(&self, _object_file: &str) -> Option<Self> {
-            None
-        }
-
-        fn location_for_pdb_from_binary(&self, _pdb_path: &str) -> Option<Self> {
-            None
-        }
-
-        fn location_for_source_file(&self, _source_file_path: &str) -> Option<Self> {
-            None
-        }
-
-        fn location_for_breakpad_symindex(&self) -> Option<Self> {
-            None
-        }
-
-        fn location_for_dwo(&self, _dwo_ref: &DwoRef) -> Option<Self> {
-            None
-        }
-    }
-    impl std::fmt::Display for DummyLocation {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            "DummyLocation".fmt(f)
-        }
-    }
-
     #[test]
     fn overeager_demangle() {
         let sym = b"MODULE Linux x86_64 BE4E976C325246EE9D6B7847A670B2A90 example-linux\nFILE 0 filename\nFUNC 1160 45 0 f\n1160 c 16 0";
         let fc = FileContentsWrapper::new(&sym[..]);
-        let symbol_map = get_symbol_map_for_breakpad_sym(fc, DummyLocation, None).unwrap();
+        let symbol_map = get_symbol_map_for_breakpad_sym(fc, None).unwrap();
         assert_eq!(
             symbol_map
+                .get_inner_symbol_map()
                 .lookup_relative_address(0x1160)
                 .unwrap()
                 .symbol
@@ -416,15 +376,17 @@ mod test {
         let full_sym_contents = data_slices.concat();
         let sym_fc = FileContentsWrapper::new(full_sym_contents);
         let symindex_fc = FileContentsWrapper::new(index_bytes);
-        let symbol_map =
-            get_symbol_map_for_breakpad_sym(sym_fc, DummyLocation, Some(symindex_fc)).unwrap();
+        let symbol_map = get_symbol_map_for_breakpad_sym(sym_fc, Some(symindex_fc)).unwrap();
 
         assert_eq!(
-            symbol_map.debug_id(),
+            symbol_map.get_inner_symbol_map().debug_id(),
             DebugId::from_breakpad("F1E853FD662672044C4C44205044422E1").unwrap()
         );
 
-        let lookup_result = symbol_map.lookup_relative_address(0x2b7ed).unwrap();
+        let lookup_result = symbol_map
+            .get_inner_symbol_map()
+            .lookup_relative_address(0x2b7ed)
+            .unwrap();
         assert_eq!(
             lookup_result.symbol.name,
             "DloadAcquireSectionWriteAccess()"

samply-symbols/src/compact_symbol_table.rs

@@ -1,4 +1,4 @@
-use crate::{FileContents, FileLocation, SymbolMap};
+use crate::{FileAndPathHelper, SymbolMap};
 
 /// A "compact" representation of a symbol table.
 /// This is a legacy concept used by the Firefox profiler and kept for
@@ -22,7 +22,7 @@ pub struct CompactSymbolTable {
 }
 
 impl CompactSymbolTable {
-    pub fn from_symbol_map<FL: FileLocation, FC: FileContents>(map: &SymbolMap<FL, FC>) -> Self {
+    pub fn from_symbol_map<H: FileAndPathHelper>(map: &SymbolMap<H>) -> Self {
         let total_str_len = map.iter_symbols().map(|(_, s)| s.len()).sum();
         let mut addr = Vec::with_capacity(map.symbol_count());
         let mut index = Vec::with_capacity(map.symbol_count() + 1);

samply-symbols/src/elf.rs

@@ -3,12 +3,13 @@ use elsa::sync::FrozenVec;
 use gimli::{CieOrFde, Dwarf, EhFrame, EndianSlice, RunTimeEndian, UnwindSection};
 use object::{File, FileKind, Object, ObjectSection, ReadRef};
 use std::io::Cursor;
+use std::sync::Arc;
 use yoke::Yoke;
 use yoke_derive::Yokeable;
 
 use crate::dwarf::Addr2lineContextData;
 use crate::error::Error;
-use crate::shared::{FileAndPathHelper, FileContents, FileContentsWrapper, FileLocation};
+use crate::shared::{FileAndPathHelper, FileContents, FileContentsWrapper};
 use crate::symbol_map::SymbolMap;
 use crate::symbol_map_object::{
     AddDwoAndMakeDwarf, ObjectSymbolMap, ObjectSymbolMapInner, ObjectSymbolMapOuter,
@@ -17,28 +18,23 @@ use crate::symbol_map_object::{
 };
 use crate::{debug_id_for_object, ElfBuildId};
 
-pub async fn load_symbol_map_for_elf<T, FL, H>(
-    file_location: FL,
-    file_contents: FileContentsWrapper<T>,
+pub async fn load_symbol_map_for_elf<H: FileAndPathHelper>(
+    file_location: H::FL,
+    file_contents: FileContentsWrapper<H::F>,
     file_kind: FileKind,
-    helper: &H,
-) -> Result<SymbolMap<FL, T>, Error>
-where
-    T: FileContents + 'static,
-    H: FileAndPathHelper<F = T, FL = FL>,
-    FL: FileLocation,
-{
+    helper: Arc<H>,
+) -> Result<SymbolMap<H>, Error> {
     let elf_file =
         File::parse(&file_contents).map_err(|e| Error::ObjectParseError(file_kind, e))?;
 
     if let Some(symbol_map) =
-        try_to_get_symbol_map_from_debug_link(&file_location, &elf_file, file_kind, helper).await
+        try_to_get_symbol_map_from_debug_link(&file_location, &elf_file, file_kind, &*helper).await
     {
         return Ok(symbol_map);
     }
 
     if let Some(supplementary_file) =
-        try_to_load_supplementary_file(&file_location, &elf_file, helper).await
+        try_to_load_supplementary_file(&file_location, &elf_file, &*helper).await
     {
         let owner = ElfSymbolMapDataAndObjects::new(
             file_contents,
@@ -47,7 +43,7 @@ where
             None,
         )?;
         let symbol_map = ObjectSymbolMap::new(owner)?;
-        return Ok(SymbolMap::new_without(file_location, Box::new(symbol_map)));
+        return Ok(SymbolMap::new_plain(file_location, Box::new(symbol_map)));
     }
 
     // If this file has a .gnu_debugdata section, use the uncompressed object from that section instead.
@@ -59,20 +55,22 @@ where
 
     let owner = ElfSymbolMapDataAndObjects::new(file_contents, None, file_kind, None)?;
     let symbol_map = ObjectSymbolMapWithDwoSupport::new(owner)?;
-    Ok(SymbolMap::new_with(file_location, Box::new(symbol_map)))
+    Ok(SymbolMap::new_with(
+        file_location,
+        Box::new(symbol_map),
+        helper,
+    ))
 }
 
-async fn try_to_get_symbol_map_from_debug_link<'data, H, R, FL, FC>(
-    original_file_location: &FL,
+async fn try_to_get_symbol_map_from_debug_link<'data, H, R>(
+    original_file_location: &H::FL,
     elf_file: &File<'data, R>,
     file_kind: FileKind,
     helper: &H,
-) -> Option<SymbolMap<FL, FC>>
+) -> Option<SymbolMap<H>>
 where
-    H: FileAndPathHelper<FL = FL, F = FC>,
     R: ReadRef<'data>,
-    FL: FileLocation,
-    FC: FileContents + 'static,
+    H: FileAndPathHelper,
 {
     let (name, crc) = elf_file.gnu_debuglink().ok().flatten()?;
     let debug_id = debug_id_for_object(elf_file)?;
@@ -99,18 +97,16 @@ where
     None
 }
 
-async fn get_symbol_map_for_debug_link_candidate<H, FL, FC>(
-    original_file_location: &FL,
-    path: &FL,
+async fn get_symbol_map_for_debug_link_candidate<H>(
+    original_file_location: &H::FL,
+    path: &H::FL,
     debug_id: DebugId,
     expected_crc: u32,
     file_kind: FileKind,
     helper: &H,
-) -> Result<SymbolMap<FL, FC>, Error>
+) -> Result<SymbolMap<H>, Error>
 where
-    H: FileAndPathHelper<FL = FL, F = FC>,
-    FL: FileLocation,
-    FC: FileContents + 'static,
+    H: FileAndPathHelper,
 {
     let file_contents = helper
         .load_file(path.clone())
@@ -125,7 +121,7 @@ where
 
     let owner = ElfSymbolMapDataAndObjects::new(file_contents, None, file_kind, Some(debug_id))?;
     let symbol_map = ObjectSymbolMap::new(owner)?;
-    Ok(SymbolMap::new_without(
+    Ok(SymbolMap::new_plain(
         original_file_location.clone(),
         Box::new(symbol_map),
     ))
@@ -268,11 +264,11 @@ where
     None
 }
 
-fn try_get_symbol_map_from_mini_debug_info<'data, R: ReadRef<'data>, FL: FileLocation, FC>(
+fn try_get_symbol_map_from_mini_debug_info<'data, R: ReadRef<'data>, H: FileAndPathHelper>(
     elf_file: &File<'data, R>,
     file_kind: FileKind,
-    debug_file_location: &FL,
-) -> Option<SymbolMap<FL, FC>> {
+    debug_file_location: &H::FL,
+) -> Option<SymbolMap<H>> {
     let debugdata = elf_file.section_by_name(".gnu_debugdata")?;
     let data = debugdata.data().ok()?;
     let mut cursor = Cursor::new(data);
@@ -281,7 +277,7 @@ fn try_get_symbol_map_from_mini_debug_info<'data, R: ReadRef<'data>, FL: FileLoc
     let file_contents = FileContentsWrapper::new(objdata);
     let owner = ElfSymbolMapDataAndObjects::new(file_contents, None, file_kind, None).ok()?;
     let symbol_map = ObjectSymbolMap::new(owner).ok()?;
-    Some(SymbolMap::new_without(
+    Some(SymbolMap::new_plain(
         debug_file_location.clone(),
         Box::new(symbol_map),
     ))

samply-symbols/src/jitdump.rs

@@ -15,10 +15,11 @@ use std::{
 
 use crate::error::Error;
 use crate::shared::{
-    AddressInfo, FileContents, FileContentsCursor, FileContentsWrapper, FileLocation,
-    FrameDebugInfo, FramesLookupResult, SourceFilePath, SymbolInfo,
+    AddressInfo, FileContents, FileContentsCursor, FileContentsWrapper, FrameDebugInfo,
+    FramesLookupResult, SourceFilePath, SymbolInfo,
 };
 use crate::symbol_map::{GetInnerSymbolMap, SymbolMap, SymbolMapTrait};
+use crate::FileAndPathHelper;
 
 pub fn is_jitdump_file<T: FileContents>(file_contents: &FileContentsWrapper<T>) -> bool {
     const MAGIC_BYTES_BE: &[u8] = b"JiTD";
@@ -162,19 +163,15 @@ pub struct JitDumpIndexEntry {
     pub code_bytes_len: u64,
 }
 
-pub fn get_symbol_map_for_jitdump<F, FL>(
-    file_contents: FileContentsWrapper<F>,
-    file_location: FL,
-) -> Result<SymbolMap<FL, F>, Error>
-where
-    F: FileContents + 'static,
-    FL: FileLocation,
-{
+pub fn get_symbol_map_for_jitdump<H: FileAndPathHelper>(
+    file_contents: FileContentsWrapper<H::F>,
+    file_location: H::FL,
+) -> Result<SymbolMap<H>, Error> {
     let outer = JitDumpSymbolMapOuter::new(file_contents)?;
     let symbol_map = JitDumpSymbolMap(Yoke::attach_to_cart(Box::new(outer), |outer| {
         outer.make_symbol_map()
     }));
-    Ok(SymbolMap::new_without(file_location, Box::new(symbol_map)))
+    Ok(SymbolMap::new_plain(file_location, Box::new(symbol_map)))
 }
 
 pub struct JitDumpSymbolMap<T: FileContents>(