Inline-away LookedUpAddresses.

Author: mstange

samply-api/src/symbolicate/looked_up_addresses.rs

@@ -19,65 +19,25 @@ pub struct AddressResult {
     pub inline_frames: Option<Vec<FrameDebugInfo>>,
 }
 
-pub type AddressResults = BTreeMap<u32, Option<AddressResult>>;
-
-pub struct LookedUpAddresses {
-    pub address_results: AddressResults,
-    pub symbol_count: u32,
-}
-
-impl LookedUpAddresses {
-    pub fn for_addresses(addresses: &[u32]) -> Self {
-        LookedUpAddresses {
-            address_results: addresses.iter().map(|&addr| (addr, None)).collect(),
-            symbol_count: 0,
-        }
-    }
-
-    pub fn add_address_symbol(
-        &mut self,
-        address: u32,
-        symbol_address: u32,
-        symbol_name: String,
-        function_size: Option<u32>,
-    ) {
-        *self.address_results.get_mut(&address).unwrap() = Some(AddressResult {
+impl AddressResult {
+    pub fn new(symbol_address: u32, symbol_name: String, function_size: Option<u32>) -> Self {
+        Self {
             symbol_address,
             symbol_name,
             function_size,
             inline_frames: None,
-        });
+        }
     }
 
-    pub fn add_address_debug_info(&mut self, address: u32, frames: Vec<FrameDebugInfo>) {
+    pub fn set_debug_info(&mut self, frames: Vec<FrameDebugInfo>) {
         let outer_function_name = frames.last().and_then(|f| f.function.as_deref());
-        let entry = self.address_results.get_mut(&address).unwrap();
-
-        match entry {
-            Some(address_result) => {
-                // Overwrite the symbol name with the function name from the debug info.
-                if let Some(name) = outer_function_name {
-                    address_result.symbol_name = name.to_string();
-                }
-                // Add the inline frame info.``
-                address_result.inline_frames = Some(frames);
-            }
-            None => {
-                // add_address_symbol has not been called for this address.
-                // This happens when we only have debug info but no symbol for this address.
-                // This is a rare case.
-                *entry = Some(AddressResult {
-                    symbol_address: address, // TODO: Would be nice to get the actual function start address from addr2line
-                    symbol_name: outer_function_name
-                        .map_or_else(|| format!("0x{address:x}"), str::to_string),
-                    function_size: None,
-                    inline_frames: Some(frames),
-                });
-            }
+        // Overwrite the symbol name with the function name from the debug info.
+        if let Some(name) = outer_function_name {
+            self.symbol_name = name.to_string();
         }
-    }
-
-    pub fn set_total_symbol_count(&mut self, total_symbol_count: u32) {
-        self.symbol_count = total_symbol_count;
+        // Add the inline frame info.
+        self.inline_frames = Some(frames);
     }
 }
+
+pub type AddressResults = BTreeMap<u32, Option<AddressResult>>;

samply-api/src/symbolicate/mod.rs

@@ -7,15 +7,14 @@ use samply_symbols::{
 };
 
 use crate::error::Error;
-use crate::symbolicate::looked_up_addresses::PathResolver;
+use crate::symbolicate::looked_up_addresses::{AddressResult, AddressResults, PathResolver};
 use crate::symbolicate::response_json::{PerLibResult, Response};
 use crate::to_debug_id;
 
 pub mod looked_up_addresses;
 pub mod request_json;
 pub mod response_json;
 
-use looked_up_addresses::LookedUpAddresses;
 use request_json::Lib;
 
 impl<H: FileAndPathHelper> PathResolver for SymbolMap<H> {
@@ -95,21 +94,21 @@ impl<'a, H: FileAndPathHelper + 'static> SymbolicateApi<'a, H> {
         };
         let symbol_map = self.symbol_manager.load_symbol_map(&info).await?;
         symbol_map.set_access_pattern_hint(AccessPatternHint::SequentialLookup);
-        let mut symbolication_result = LookedUpAddresses::for_addresses(&addresses);
 
-        symbolication_result.set_total_symbol_count(symbol_map.symbol_count() as u32);
+        let mut address_results: AddressResults =
+            addresses.iter().map(|&addr| (addr, None)).collect();
 
         for &address in &addresses {
             if let Some(address_info) = symbol_map.lookup_sync(LookupAddress::Relative(address)) {
-                symbolication_result.add_address_symbol(
-                    address,
+                let address_result = address_results.get_mut(&address).unwrap();
+                *address_result = Some(AddressResult::new(
                     address_info.symbol.address,
                     address_info.symbol.name,
                     address_info.symbol.size,
-                );
+                ));
                 match address_info.frames {
                     Some(FramesLookupResult::Available(frames)) => {
-                        symbolication_result.add_address_debug_info(address, frames)
+                        address_result.as_mut().unwrap().set_debug_info(frames)
                     }
                     Some(FramesLookupResult::External(ext_address)) => {
                         external_addresses.push((address, ext_address));
@@ -127,12 +126,13 @@ impl<'a, H: FileAndPathHelper + 'static> SymbolicateApi<'a, H> {
 
         for (address, ext_address) in external_addresses {
             if let Some(frames) = symbol_map.lookup_external(&ext_address).await {
-                symbolication_result.add_address_debug_info(address, frames);
+                let address_result = address_results.get_mut(&address).unwrap();
+                address_result.as_mut().unwrap().set_debug_info(frames);
             }
         }
 
         let outcome = PerLibResult {
-            address_results: symbolication_result,
+            address_results,
             symbol_map: Arc::new(symbol_map),
         };
 

samply-api/src/symbolicate/response_json.rs

@@ -5,14 +5,13 @@ use std::sync::Arc;
 use samply_symbols::{FileAndPathHelper, FrameDebugInfo, SymbolMap};
 use serde::ser::{SerializeMap, SerializeSeq};
 
-use super::looked_up_addresses::LookedUpAddresses;
 use super::request_json::{Job, Lib, RequestFrame, RequestStack};
 use crate::api_file_path::to_api_file_path;
 use crate::symbolicate::looked_up_addresses::{AddressResults, PathResolver};
 use crate::symbolicate::request_json::Request;
 
 pub struct PerLibResult<H: FileAndPathHelper> {
-    pub address_results: LookedUpAddresses,
+    pub address_results: AddressResults,
     pub symbol_map: Arc<SymbolMap<H>>,
 }
 
@@ -59,7 +58,7 @@ impl<H: FileAndPathHelper> serde::Serialize for Response<H> {
 }
 
 pub struct PerLibResultRef<'a> {
-    pub address_results: std::result::Result<&'a LookedUpAddresses, &'a samply_symbols::Error>,
+    pub address_results: std::result::Result<&'a AddressResults, &'a samply_symbols::Error>,
     pub path_resolver: &'a dyn PathResolver,
 }
 
@@ -106,9 +105,9 @@ impl<'a> serde::Serialize for Result<'a> {
             if let Some(per_lib_result) = self.per_lib_results.get(lib) {
                 let module_key = format!("{}/{}", lib.debug_name, lib.breakpad_id);
                 match per_lib_result.address_results {
-                    Ok(symbols) => {
+                    Ok(address_results) => {
                         let module_results = PerModuleResultsRef {
-                            address_results: &symbols.address_results,
+                            address_results,
                             path_resolver: per_lib_result.path_resolver,
                         };
                         symbols_by_module_index.insert(module_index as u32, module_results);