chore(deps): update rust crate gimli to 0.33.0 (#648)

renovate[bot] · JonasKruckenberg · web-flow · commit e27de2af0188 · 2026-02-14T15:51:49.000+01:00
* chore(deps): update rust crate gimli to 0.33.0

* update to new gimli version

---------

Co-authored-by: renovate[bot] &lt;29139614+renovate[bot]@users.noreply.github.com&gt;
Co-authored-by: JonasKruckenberg &lt;iterpre@protonmail.com&gt;
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -109,7 +109,7 @@ lock_api = "0.4.13"
 static_assertions = "1.1.0"
 rand = { version = "0.9.2", default-features = false }
 rand_chacha = { version = "0.9.0", default-features = false }
-gimli = { version = "0.31.1", default-features = false, features = ["read"] }
+gimli = { version = "0.33.0", default-features = false, features = ["read"] }
 talc = { version = "4.4.2", default-features = false, features = ["lock_api", "counters"] }
 smallvec = { version = "1", default-features = false }
 rustc-demangle = "0.1"
diff --git a/libs/abort/src/lib.rs b/libs/abort/src/lib.rs
@@ -30,7 +30,8 @@ pub fn abort() -> ! {
         } else if #[cfg(any(target_arch = "riscv64", target_arch = "riscv32"))] {
             riscv::exit(1);
         } else {
-            compile_error!("unsupported target architecture")
+            loop {}
+            // compile_error!("unsupported target architecture")
         }
     }
 }
diff --git a/libs/addr2line/src/function.rs b/libs/addr2line/src/function.rs
@@ -9,6 +9,8 @@ use alloc::boxed::Box;
 use alloc::vec::Vec;
 use core::cmp::Ordering;
 
+use gimli::ReaderOffset;
+
 // use crate::lazy::LazyResult;
 use crate::{Context, DebugFile, Error, RangeAttributes};
 use crate::{LazyResult, maybe_small};
@@ -304,7 +306,7 @@ impl<R: gimli::Reader> Function<R> {
     }
 
     fn skip(
-        entries: &mut gimli::EntriesRaw<'_, '_, R>,
+        entries: &mut gimli::EntriesRaw<'_, R>,
         abbrev: &gimli::Abbreviation,
         depth: isize,
     ) -> Result<(), Error> {
@@ -458,7 +460,7 @@ impl<R: gimli::Reader> InlinedFunction<R> {
 
 struct InlinedState<'a, R: gimli::Reader> {
     // Mutable fields.
-    entries: gimli::EntriesRaw<'a, 'a, R>,
+    entries: gimli::EntriesRaw<'a, R>,
     functions: Vec<InlinedFunction<R>>,
     addresses: Vec<InlinedFunctionAddress>,
 
@@ -520,7 +522,7 @@ where
     let abbrev = if let Some(abbrev) = entries.read_abbreviation()? {
         abbrev
     } else {
-        return Err(gimli::Error::NoEntryAtGivenOffset);
+        return Err(gimli::Error::NoEntryAtGivenOffset(offset.0.into_u64()));
     };
 
     let mut name = None;
diff --git a/libs/addr2line/src/lib.rs b/libs/addr2line/src/lib.rs
@@ -29,6 +29,8 @@ extern crate alloc;
 use alloc::sync::Arc;
 use core::ops::ControlFlow;
 
+use gimli::ReaderOffset;
+
 use crate::function::{Function, InlinedFunction, LazyFunctions};
 use crate::line::{LazyLines, LineLocationRangeIter, Lines};
 use crate::lookup::{LoopingLookup, SimpleLookup};
@@ -90,6 +92,9 @@ impl<R: gimli::Reader> Context<R> {
         debug_rnglists: gimli::DebugRngLists<R>,
         debug_str: gimli::DebugStr<R>,
         debug_str_offsets: gimli::DebugStrOffsets<R>,
+        debug_macinfo: gimli::DebugMacinfo<R>,
+        debug_macro: gimli::DebugMacro<R>,
+        debug_names: gimli::DebugNames<R>,
         default_section: R,
     ) -> Result<Self, Error> {
         Self::from_dwarf(gimli::Dwarf {
@@ -101,6 +106,9 @@ impl<R: gimli::Reader> Context<R> {
             debug_line_str,
             debug_str,
             debug_str_offsets,
+            debug_macinfo,
+            debug_macro,
+            debug_names,
             debug_types: default_section.clone().into(),
             locations: gimli::LocationLists::new(
                 default_section.clone().into(),
@@ -214,12 +222,12 @@ impl<R: gimli::Reader> Context<R> {
         let unit = match file {
             DebugFile::Primary => self.units.find_offset(offset)?,
             DebugFile::Supplementary => self.sup_units.find_offset(offset)?,
-            DebugFile::Dwo => return Err(gimli::Error::NoEntryAtGivenOffset),
+            DebugFile::Dwo => return Err(gimli::Error::NoEntryAtGivenOffset(offset.0.into_u64())),
         };
 
         let unit_offset = offset
             .to_unit_offset(&unit.header)
-            .ok_or(gimli::Error::NoEntryAtGivenOffset)?;
+            .ok_or(gimli::Error::NoEntryAtGivenOffset(offset.0.into_u64()))?;
         Ok((unit, unit_offset))
     }
 }
diff --git a/libs/addr2line/src/unit.rs b/libs/addr2line/src/unit.rs
@@ -11,6 +11,7 @@ use alloc::vec::Vec;
 use core::cmp;
 
 use fallible_iterator::FallibleIterator;
+use gimli::ReaderOffset;
 
 use crate::{
     Context, DebugFile, Error, Function, LazyFunctions, LazyLines, LazyResult,
@@ -203,7 +204,7 @@ impl<R: gimli::Reader> ResUnits<R> {
         let mut units = sections.units();
         while let Some(header) = units.next()? {
             let unit_id = res_units.len();
-            let offset = match header.offset().as_debug_info_offset() {
+            let offset = match header.offset().to_debug_info_offset(&header) {
                 Some(offset) => offset,
                 None => continue,
             };
@@ -365,7 +366,7 @@ impl<R: gimli::Reader> ResUnits<R> {
             .binary_search_by_key(&offset.0, |unit| unit.offset.0)
         {
             // There is never a DIE at the unit offset or before the first unit.
-            Ok(_) | Err(0) => Err(gimli::Error::NoEntryAtGivenOffset),
+            Ok(_) | Err(0) => Err(gimli::Error::NoEntryAtGivenOffset(offset.0.into_u64())),
             Err(i) => Ok(&self.units[i - 1].dw_unit),
         }
     }
@@ -479,7 +480,7 @@ impl<R: gimli::Reader> SupUnits<R> {
         let mut sup_units = Vec::new();
         let mut units = sections.units();
         while let Some(header) = units.next()? {
-            let offset = match header.offset().as_debug_info_offset() {
+            let offset = match header.offset().to_debug_info_offset(&header) {
                 Some(offset) => offset,
                 None => continue,
             };
@@ -503,7 +504,7 @@ impl<R: gimli::Reader> SupUnits<R> {
             .binary_search_by_key(&offset.0, |unit| unit.offset.0)
         {
             // There is never a DIE at the unit offset or before the first unit.
-            Ok(_) | Err(0) => Err(gimli::Error::NoEntryAtGivenOffset),
+            Ok(_) | Err(0) => Err(gimli::Error::NoEntryAtGivenOffset(offset.0.into_u64())),
             Err(i) => Ok(&self.units[i - 1].dw_unit),
         }
     }
diff --git a/libs/unwind/src/arch/aarch64.rs b/libs/unwind/src/arch/aarch64.rs
@@ -10,7 +10,7 @@
 use core::{fmt, ops};
 
 use cfg_if::cfg_if;
-use gimli::{AArch64, Register};
+use gimli::{AArch64, Register, RegisterRule};
 
 // Match DWARF_FRAME_REGISTERS in libgcc
 pub const MAX_REG_RULES: usize = 97;
@@ -30,6 +30,25 @@ cfg_if! {
     }
 }
 
+/// Returns the default register rule for the given register on this architecture.
+pub fn default_register_rule_for(reg: Register) -> RegisterRule<usize> {
+    // the AArch64 DWARF standard requires rules for callee-saved registers and
+    //  "registers intentionally unused by the program, for example as a consequence of the procedure call standard"
+    //  to be initialized to `RegisterRule::SameValue` while other registers should be initialized to `RegisterRule::Undefined`.
+    //  <https://github.com/ARM-software/abi-aa/blob/main/aadwarf64/aadwarf64.rst#43common-information-entries>
+    //
+    // <https://github.com/ARM-software/abi-aa/blob/main/aapcs64/aapcs64.rst#61machine-registers>
+    // defines callee-saved registers to be
+    //
+    // general purpose registers r19-r28
+    // and SIMD/fp registers v8-v15
+    match reg {
+        Register(19..=28) => RegisterRule::SameValue,
+        Register(72..=79) => RegisterRule::SameValue,
+        _ => RegisterRule::Undefined,
+    }
+}
+
 /// Register context when unwinding.
 ///
 /// This type is architecture-dependent, but generally holds a copy of all registers that are required
diff --git a/libs/unwind/src/arch/riscv64.rs b/libs/unwind/src/arch/riscv64.rs
@@ -10,7 +10,7 @@
 use core::{fmt, ops};
 
 use cfg_if::cfg_if;
-use gimli::{Register, RiscV};
+use gimli::{Register, RegisterRule, RiscV};
 
 // Match DWARF_FRAME_REGISTERS in libgcc
 pub const MAX_REG_RULES: usize = 65;
@@ -33,6 +33,12 @@ pub const UNWIND_DATA_REG: (Register, Register) = (RiscV::A0, RiscV::A1);
 #[cfg(all(target_feature = "f", not(target_feature = "d")))]
 compile_error!("RISC-V with only F extension is not supported");
 
+/// Returns the default register rule for the given register on this architecture.
+pub fn default_register_rule_for(_reg: Register) -> RegisterRule<usize> {
+    // As far as I can tell RISCV has no special requirements
+    RegisterRule::Undefined
+}
+
 /// Register context when unwinding.
 ///
 /// This type is architecture-dependent, but generally holds a copy of all registers that are required
diff --git a/libs/unwind/src/arch/x86_64.rs b/libs/unwind/src/arch/x86_64.rs
@@ -4,3 +4,9 @@
 // http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.
+
+/// Returns the default register rule for the given register on this architecture.
+pub fn default_register_rule_for(_reg: Register) -> RegisterRule<usize> {
+    // As far as I can tell x86_64 has no special requirements
+    RegisterRule::Undefined
+}
diff --git a/libs/unwind/src/eh_action.rs b/libs/unwind/src/eh_action.rs
@@ -143,20 +143,20 @@ fn read_encoded_pointer(
         constants::DW_EH_PE_pcrel => input.slice().as_ptr() as u64,
         constants::DW_EH_PE_funcrel => {
             if frame.symbol_address() == 0 {
-                return Err(gimli::Error::UnsupportedPointerEncoding);
+                return Err(gimli::Error::UnsupportedPointerEncoding(encoding));
             }
             frame.symbol_address()
         }
         constants::DW_EH_PE_textrel => frame
             .text_rel_base()
-            .ok_or(gimli::Error::UnsupportedPointerEncoding)?,
+            .ok_or(gimli::Error::UnsupportedPointerEncoding(encoding))?,
         constants::DW_EH_PE_datarel => frame
             .data_rel_base()
-            .ok_or(gimli::Error::UnsupportedPointerEncoding)?,
+            .ok_or(gimli::Error::UnsupportedPointerEncoding(encoding))?,
         constants::DW_EH_PE_aligned => {
-            return Err(gimli::Error::UnsupportedPointerEncoding);
+            return Err(gimli::Error::UnsupportedPointerEncoding(encoding));
         }
-        _ => return Err(gimli::Error::UnsupportedPointerEncoding),
+        _ => return Err(gimli::Error::UnsupportedPointerEncoding(encoding)),
     };
 
     debug_assert_ne!(base, 0);
diff --git a/libs/unwind/src/frame.rs b/libs/unwind/src/frame.rs
@@ -188,7 +188,10 @@ impl<'a> Frame<'a> {
         for reg in 0..arch::MAX_REG {
             let reg = Register(reg);
 
-            let rule = row.register(reg);
+            let rule = row
+                .register(reg)
+                // Some architectures (e.g. aarch64) have implicit SameValue rules for callee-saved registers.
+                .unwrap_or_else(|| arch::default_register_rule_for(reg));
 
             match rule {
                 // According to LLVM libunwind (and this appears to be true in practice as well)
@@ -222,7 +225,6 @@ impl<'a> Frame<'a> {
                 }
                 RegisterRule::Architectural => unreachable!(),
                 RegisterRule::Constant(value) => new_regs[reg] = usize::try_from(value).unwrap(),
-                _ => unreachable!(),
             }
         }
 
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -1,5 +1,5 @@
 [toolchain]
 channel = "nightly-2025-07-11"
 components = ["rustfmt", "miri", "clippy", "rust-src", "llvm-tools"]
-targets = ["wasm32-unknown-unknown", "riscv64gc-unknown-none-elf"]
+targets = ["wasm32-unknown-unknown", "riscv64gc-unknown-none-elf", "aarch64-unknown-none"]
 profile = "minimal"

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,8 @@ pub fn abort() -> ! {`
`30`	`30`	`} else if #[cfg(any(target_arch = "riscv64", target_arch = "riscv32"))] {`
`31`	`31`	`riscv::exit(1);`
`32`	`32`	`} else {`
`33`		`- compile_error!("unsupported target architecture")`
	`33`	`+ loop {}`
	`34`	`+ // compile_error!("unsupported target architecture")`
`34`	`35`	`}`
`35`	`36`	`}`
`36`	`37`	`}`