Update gimli and addr2line dependencies (#12424)

* Update gimli and addr2line dependencies

gimli has a significant number of breaking changes to adapt to.

* Add vets

---------

Co-authored-by: Alex Crichton <[email protected]>

Author: philipc

Cargo.lock

@@ -363,8 +363,8 @@ backtrace = "0.3.75"
 mutatis = "0.3.2"
 cc = "1.2.41"
 object = { version = "0.37.3", default-features = false, features = ['read_core', 'elf'] }
-gimli = { version = "0.32.3", default-features = false, features = ['read'] }
-addr2line = { version = "0.25.1", default-features = false }
+gimli = { version = "0.33.0", default-features = false, features = ['read'] }
+addr2line = { version = "0.26.0", default-features = false }
 anyhow = { version = "1.0.100", default-features = false }
 anyhow-for-testing = { package = "anyhow", version = "1.0.100", default-features = false }
 windows-sys = "0.61.2"

Cargo.toml

@@ -137,7 +137,7 @@ fn has_die_back_edge(die: &read::DebuggingInformationEntry<Reader<'_>>) -> read:
         | constants::DW_TAG_imported_declaration
         | constants::DW_TAG_imported_module
         | constants::DW_TAG_module => false,
-        constants::DW_TAG_subprogram => die.attr(constants::DW_AT_declaration)?.is_some(),
+        constants::DW_TAG_subprogram => die.attr(constants::DW_AT_declaration).is_some(),
         _ => true,
     };
     Ok(result)
@@ -150,14 +150,14 @@ fn has_valid_code_range(
 ) -> read::Result<bool> {
     match die.tag() {
         constants::DW_TAG_subprogram => {
-            if let Some(ranges_attr) = die.attr_value(constants::DW_AT_ranges)? {
+            if let Some(ranges_attr) = die.attr_value(constants::DW_AT_ranges) {
                 let offset = match ranges_attr {
                     read::AttributeValue::RangeListsRef(val) => unit.ranges_offset_from_raw(val),
                     read::AttributeValue::DebugRngListsIndex(index) => unit.ranges_offset(index)?,
                     _ => return Ok(false),
                 };
                 let mut has_valid_base = if let Some(read::AttributeValue::Addr(low_pc)) =
-                    die.attr_value(constants::DW_AT_low_pc)?
+                    die.attr_value(constants::DW_AT_low_pc)
                 {
                     Some(at.can_translate_address(low_pc))
                 } else {
@@ -200,7 +200,7 @@ fn has_valid_code_range(
                     }
                 }
                 return Ok(false);
-            } else if let Some(low_pc) = die.attr_value(constants::DW_AT_low_pc)? {
+            } else if let Some(low_pc) = die.attr_value(constants::DW_AT_low_pc) {
                 if let read::AttributeValue::Addr(a) = low_pc {
                     return Ok(at.can_translate_address(a));
                 } else if let read::AttributeValue::DebugAddrIndex(i) = low_pc {
@@ -222,9 +222,8 @@ fn build_die_dependencies(
 ) -> read::Result<()> {
     let entry = die.entry();
     let offset = entry.offset().to_unit_section_offset(&unit);
-    let mut attrs = entry.attrs();
-    while let Some(attr) = attrs.next()? {
-        build_attr_dependencies(&attr, offset, unit, at, deps)?;
+    for attr in entry.attrs() {
+        build_attr_dependencies(attr, offset, unit, at, deps)?;
     }
 
     let mut children = die.children();
@@ -256,7 +255,7 @@ fn build_attr_dependencies(
             deps.add_edge(offset, ref_offset);
         }
         read::AttributeValue::DebugInfoRef(val) => {
-            let ref_offset = UnitSectionOffset::DebugInfoOffset(val);
+            let ref_offset = UnitSectionOffset(val.0);
             deps.add_edge(offset, ref_offset);
         }
         _ => (),

crates/cranelift/src/debug/gc.rs

@@ -76,8 +76,7 @@ pub(crate) fn clone_die_attributes<'a>(
     let mut is_obj_ptr = false;
     prepare_die_context(unit, entry, &mut attr_context, &mut is_obj_ptr)?;
 
-    let mut attrs = entry.attrs();
-    while let Some(attr) = attrs.next()? {
+    for attr in entry.attrs() {
         match attr.name() {
             gimli::DW_AT_low_pc | gimli::DW_AT_high_pc | gimli::DW_AT_ranges => {
                 // Handled by RangeInfoBuilder.
@@ -420,13 +419,13 @@ fn is_obj_ptr_param<'a>(
     // why do we need this heuristic as well?
     // A: Declarations do not include DW_AT_object_pointer.
     if param_num == 0
-        && entry.attr_value(gimli::DW_AT_artificial)? == Some(AttributeValue::Flag(true))
+        && entry.attr_value(gimli::DW_AT_artificial) == Some(AttributeValue::Flag(true))
     {
         // Either this has no name (declarations omit them), or its explicitly "this".
-        let name = entry.attr_value(gimli::DW_AT_name)?;
+        let name = entry.attr_value(gimli::DW_AT_name);
         if name.is_none() || unit.attr_string(name.unwrap())?.slice().eq(b"this") {
             // Finally, a type check. We expect a pointer.
-            if let Some(type_attr) = entry.attr_value(gimli::DW_AT_type)? {
+            if let Some(type_attr) = entry.attr_value(gimli::DW_AT_type) {
                 if let Some(type_die) = resolve_die_ref(unit, &type_attr)? {
                     return Ok(type_die.tag() == gimli::DW_TAG_pointer_type);
                 }

crates/cranelift/src/debug/transform/attr.rs

@@ -1,10 +1,7 @@
 use crate::{debug::Reader, translate::get_vmctx_value_label};
 use core::fmt;
 use cranelift_codegen::{LabelValueLoc, ValueLabelsRanges, ir::ValueLabel, isa::TargetIsa};
-use gimli::{
-    AttributeValue, DebuggingInformationEntry, LittleEndian, UnitOffset, UnitRef,
-    UnitSectionOffset, write,
-};
+use gimli::{AttributeValue, DebuggingInformationEntry, LittleEndian, UnitOffset, UnitRef, write};
 
 macro_rules! dbi_log_enabled {
     () => {
@@ -29,8 +26,7 @@ pub struct CompileUnitSummary<'a, 'r> {
 impl<'a, 'r> fmt::Debug for CompileUnitSummary<'a, 'r> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let unit = self.unit;
-        let offs = get_offset_value(unit.header.offset());
-        write!(f, "0x{offs:08x} [")?;
+        write!(f, "0x{:08x} [", unit.header.offset().0)?;
         let comp_dir = match unit.comp_dir {
             Some(dir) => &dir.to_string_lossy(),
             None => "None",
@@ -56,8 +52,7 @@ pub struct DieRefSummary<'a, 'r> {
 impl<'a, 'r> fmt::Debug for DieRefSummary<'a, 'r> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let section_offs = self.unit_ref.to_unit_section_offset(&self.unit);
-        let offs = get_offset_value(section_offs);
-        write!(f, "0x{offs:08x}")
+        write!(f, "0x{:08x}", section_offs.0)
     }
 }
 
@@ -70,7 +65,7 @@ pub fn log_get_die_ref<'a, 'r>(
 
 struct DieDetailedSummary<'a, 'r> {
     unit: UnitRef<'a, Reader<'r>>,
-    die: &'a DebuggingInformationEntry<'a, 'a, Reader<'r>>,
+    die: &'a DebuggingInformationEntry<Reader<'r>>,
 }
 
 pub fn log_begin_input_die<'r>(
@@ -92,8 +87,7 @@ impl<'a, 'r> fmt::Debug for DieDetailedSummary<'a, 'r> {
         let unit = self.unit;
         write!(f, "{}\n", die.tag())?;
 
-        let mut attrs = die.attrs();
-        while let Some(attr) = attrs.next().unwrap_or(None) {
+        for attr in die.attrs() {
             write!(f, "  {} (", attr.name())?;
             let attr_value = attr.value();
             match attr_value {
@@ -150,8 +144,7 @@ impl<'a, 'r> fmt::Debug for DieDetailedSummary<'a, 'r> {
                 AttributeValue::Inline(value) => write!(f, "{value}"),
                 AttributeValue::Ordering(value) => write!(f, "{value}"),
                 AttributeValue::UnitRef(offset) => {
-                    let section_offset = offset.to_unit_section_offset(&unit);
-                    write!(f, "0x{:08x}", get_offset_value(section_offset))
+                    write!(f, "0x{:08x}", offset.to_unit_section_offset(&unit).0)
                 }
                 AttributeValue::DebugInfoRef(offset) => write!(f, "0x{:08x}", offset.0),
                 unexpected_attr => write!(f, "<unexpected attr: {unexpected_attr:?}>"),
@@ -226,8 +219,8 @@ impl<'a> fmt::Debug for OutDieDetailedSummary<'a> {
                 write::AttributeValue::Ordering(value) => write!(f, "{value}"),
                 write::AttributeValue::UnitRef(unit_ref) => write!(f, "{unit_ref:?}>"),
                 write::AttributeValue::DebugInfoRef(reference) => match reference {
-                    write::Reference::Symbol(index) => write!(f, "symbol #{index}>"),
-                    write::Reference::Entry(unit_id, die_id) => {
+                    write::DebugInfoRef::Symbol(index) => write!(f, "symbol #{index}>"),
+                    write::DebugInfoRef::Entry(unit_id, die_id) => {
                         write!(f, "{die_id:?} in {unit_id:?}>")
                     }
                 },
@@ -273,13 +266,6 @@ pub fn log_end_output_die_skipped(
     );
 }
 
-fn get_offset_value(offset: UnitSectionOffset) -> usize {
-    match offset {
-        UnitSectionOffset::DebugInfoOffset(offs) => offs.0,
-        UnitSectionOffset::DebugTypesOffset(offs) => offs.0,
-    }
-}
-
 pub fn log_get_value_name(value: ValueLabel) -> ValueNameSummary {
     ValueNameSummary { value }
 }

crates/cranelift/src/debug/transform/debug_transform_logging.rs

@@ -647,7 +647,9 @@ where
             | Operation::ImplicitValue { .. }
             | Operation::ImplicitPointer { .. }
             | Operation::EntryValue { .. }
-            | Operation::ParameterRef { .. } => {
+            | Operation::ParameterRef { .. }
+            | Operation::VariableValue { .. }
+            | Operation::Uninitialized => {
                 return Ok(None);
             }
             Operation::WasmGlobal { index: _ } | Operation::WasmStack { index: _ } => {