Update gimli and addr2line (probe-rs#3796)

Author: bugadani

Cargo.lock

@@ -14,9 +14,9 @@ description = "Debugging functionality built on top of the probe-rs crate"
 exclude = ["tests/debug-unwind-tests"]
 
 [dependencies]
-addr2line = "0.25.0"
+addr2line = "0.26"
 bitfield = "0.19.0"
-gimli = "0.32.0"
+gimli = "0.33.0"
 itertools = "0.14.0"
 object = "0.38"
 parse_int = "0.9.0"

probe-rs-debug/Cargo.toml

@@ -259,11 +259,14 @@ impl DebugInfo {
         match parent_variable.variable_node_type {
             VariableNodeType::TypeOffset(header_offset, unit_offset)
             | VariableNodeType::DirectLookup(header_offset, unit_offset) => {
-                let Some(unit_info) = self
-                    .unit_infos
-                    .iter()
-                    .find(|unit_info| unit_info.unit.header.offset() == header_offset.into())
-                else {
+                let Some(unit_info) = self.unit_infos.iter().find(|unit_info| {
+                    unit_info
+                        .unit
+                        .header
+                        .offset()
+                        .to_debug_info_offset(&unit_info.unit)
+                        == Some(header_offset)
+                }) else {
                     return Err(DebugError::Other(
                         "Failed to find unit info for offset lookup.".to_string(),
                     ));
@@ -294,7 +297,7 @@ impl DebugInfo {
 
                     // Only process statics for this unit header.
                     // Navigate the current unit from the header down.
-                    let (_, unit_node) = entries.next_dfs()?.unwrap();
+                    let unit_node = entries.next_dfs()?.unwrap();
                     let unit_offset = unit_node.offset();
 
                     let mut type_tree = unit_info.unit.entries_tree(Some(unit_offset))?;
@@ -952,13 +955,13 @@ impl DebugInfo {
         attribute: gimli::DwAt,
         die: &Die,
         unit_info: &'unit_info UnitInfo,
-    ) -> Option<Die<'debug_info, 'debug_info>>
+    ) -> Option<Die>
     where
         'unit_info: 'debug_info,
     {
-        let attr = die.attr(attribute).ok().flatten()?;
+        let attr = die.attr(attribute)?;
 
-        self.resolve_die_reference_with_unit(&attr, unit_info)
+        self.resolve_die_reference_with_unit(attr, unit_info)
             .ok()
             .map(|(_, die)| die)
     }
@@ -973,7 +976,7 @@ impl DebugInfo {
         &'debug_info self,
         attr: &gimli::Attribute<GimliReader>,
         unit_info: &'unit_info UnitInfo,
-    ) -> Result<(&'debug_info UnitInfo, Die<'debug_info, 'debug_info>), DebugError>
+    ) -> Result<(&'debug_info UnitInfo, Die), DebugError>
     where
         'unit_info: 'debug_info,
     {
@@ -1151,7 +1154,7 @@ pub fn unwind_register(
     // If we do not have unwind info, or there is no register rule, then use UnwindRule::Undefined.
     let register_rule = debug_register
         .dwarf_id
-        .map(|register_position| unwind_info.register(gimli::Register(register_position)))
+        .and_then(|register_position| unwind_info.register(gimli::Register(register_position)))
         .unwrap_or(RegisterRule::Undefined);
 
     unwind_register_using_rule(

probe-rs-debug/src/debug_info.rs

@@ -1,4 +1,4 @@
-use gimli::{RunTimeEndian, UnitOffset};
+use gimli::UnitOffset;
 use std::ops::Range;
 
 use crate::{MemoryInterface, stack_frame::StackFrameInfo};
@@ -8,27 +8,26 @@ use super::{
     unit_info::{ExpressionResult, UnitInfo},
 };
 
-pub(crate) type Die<'abbrev, 'unit> =
-    gimli::DebuggingInformationEntry<'abbrev, 'unit, debug_info::GimliReader, usize>;
+pub(crate) type Die = gimli::DebuggingInformationEntry<debug_info::GimliReader, usize>;
 
 /// Reference to a DIE for a function
 #[derive(Clone)]
 pub(crate) struct FunctionDie<'data> {
     /// A reference to the compilation unit this function belongs to.
     pub(crate) unit_info: &'data UnitInfo,
     /// The DIE (Debugging Information Entry) for the function.
-    pub(crate) function_die: Die<'data, 'data>,
+    pub(crate) function_die: Die,
     /// The optional specification DIE for the function, if it has one.
     /// - For regular functions, this applies to the `function_die`.
     /// - For inlined functions, this applies to the `abstract_die`.
     ///
     /// The specification DIE will contain separately declared attributes,
     /// e.g. for the function name.
     /// See DWARF spec, 2.13.2.
-    pub(crate) specification_die: Option<Die<'data, 'data>>,
+    pub(crate) specification_die: Option<Die>,
     /// Only present for inlined functions, where this is a reference
     /// to the declaration of the function.
-    pub(crate) abstract_die: Option<Die<'data, 'data>>,
+    pub(crate) abstract_die: Option<Die>,
     /// The address ranges for which this function is valid.
     pub(crate) ranges: Vec<Range<u64>>,
 }
@@ -39,7 +38,7 @@ impl<'a> FunctionDie<'a> {
     /// relevant to the address/program counter specified.
     /// Other DIE's will return None, and should be ignored.
     pub(crate) fn new(
-        function_die: Die<'a, 'a>,
+        function_die: Die,
         unit_info: &'a UnitInfo,
         debug_info: &'a DebugInfo,
         address: u64,
@@ -198,11 +197,14 @@ impl<'a> FunctionDie<'a> {
         debug_info: &super::DebugInfo,
         attribute_name: gimli::DwAt,
     ) -> Option<debug_info::GimliAttribute> {
-        let attribute =
-            collapsed_attribute(&self.function_die, &self.specification_die, attribute_name);
+        let attribute = collapsed_attribute(
+            &self.function_die,
+            self.specification_die.as_ref(),
+            attribute_name,
+        );
 
         if attribute.is_some() {
-            return attribute;
+            return attribute.cloned();
         }
 
         // For inlined function, the *abstract instance* has to be checked if we cannot find the
@@ -213,11 +215,14 @@ impl<'a> FunctionDie<'a> {
                 abstract_die,
                 self.unit_info,
             );
-            let inline_attribute =
-                collapsed_attribute(abstract_die, &inlined_specification_die, attribute_name);
+            let inline_attribute = collapsed_attribute(
+                abstract_die,
+                inlined_specification_die.as_ref(),
+                attribute_name,
+            );
 
             if inline_attribute.is_some() {
-                return inline_attribute;
+                return inline_attribute.cloned();
             }
         }
 
@@ -259,21 +264,13 @@ impl<'a> FunctionDie<'a> {
 }
 
 // Try to retrieve the attribute from the specification or the function DIE.
-fn collapsed_attribute(
-    function_die: &Die,
-    specification_die: &Option<Die>,
+fn collapsed_attribute<'a>(
+    function_die: &'a Die,
+    specification_die: Option<&'a Die>,
     attribute_name: gimli::DwAt,
-) -> Option<gimli::Attribute<gimli::EndianReader<RunTimeEndian, std::rc::Rc<[u8]>>>> {
+) -> Option<&'a debug_info::GimliAttribute> {
     specification_die
         .as_ref()
-        .and_then(|specification_die| {
-            specification_die
-                .attr(attribute_name)
-                .map_or(None, |attribute| attribute)
-        })
-        .or_else(|| {
-            function_die
-                .attr(attribute_name)
-                .map_or(None, |attribute| attribute)
-        })
+        .and_then(|specification_die| specification_die.attr(attribute_name))
+        .or_else(|| function_die.attr(attribute_name))
 }

probe-rs-debug/src/function_die.rs

@@ -206,7 +206,7 @@ fn extract_file(
 /// If a DW_AT_byte_size attribute exists, return the u64 value, otherwise (including errors) return None
 fn extract_byte_size(node_die: &DebuggingInformationEntry<GimliReader>) -> Option<u64> {
     match node_die.attr(gimli::DW_AT_byte_size) {
-        Ok(Some(byte_size_attr)) => match byte_size_attr.value() {
+        Some(byte_size_attr) => match byte_size_attr.value() {
             AttributeValue::Udata(byte_size) => Some(byte_size),
             AttributeValue::Data1(byte_size) => Some(byte_size as u64),
             AttributeValue::Data2(byte_size) => Some(byte_size as u64),
@@ -217,14 +217,7 @@ fn extract_byte_size(node_die: &DebuggingInformationEntry<GimliReader>) -> Optio
                 None
             }
         },
-        Ok(None) => None,
-        Err(error) => {
-            tracing::warn!(
-                "Failed to extract byte_size: {error:?} for debug_entry {:?}",
-                node_die.tag().static_string()
-            );
-            None
-        }
+        None => None,
     }
 }
 
@@ -244,9 +237,7 @@ pub(crate) fn _print_all_attributes(
     tag: &gimli::DebuggingInformationEntry<DwarfReader>,
     print_depth: usize,
 ) {
-    let mut attrs = tag.attrs();
-
-    while let Some(attr) = attrs.next().unwrap() {
+    for attr in tag.attrs() {
         for _ in 0..print_depth {
             print!("\t");
         }