Update addr2line and crossterm dependencies (#778)

Author: jessebraham

Cargo.lock

@@ -25,13 +25,13 @@ path              = "./src/bin/espflash.rs"
 required-features = ["cli", "serialport"]
 
 [dependencies]
-addr2line       = { version = "0.22.0", optional = true }
+addr2line       = { version = "0.24.2", optional = true }
 base64          = "0.22.1"
 bytemuck        = { version = "1.21.0", features = ["derive"] }
 clap            = { version = "4.5.24", features = ["derive", "env", "wrap_help"], optional = true }
 clap_complete   = { version = "4.5.41", optional = true }
 comfy-table     = { version = "7.1.3", optional = true }
-crossterm       = { version = "0.25.0", optional = true }
+crossterm       = { version = "0.28.1", optional = true }
 ctrlc           = { version = "3.4.5", optional = true }
 defmt-decoder   = { version = "=0.4.0", features = ["unstable"], optional = true }
 defmt-parser    = { version = "=0.4.1", features = ["unstable"], optional = true }
@@ -45,6 +45,7 @@ indicatif       = { version = "0.17.9", optional = true }
 log             = "0.4.22"
 md-5            = "0.10.6"
 miette          = "7.4.0"
+object          = "0.36.7"
 regex           = { version = "1.11.1", optional = true }
 serde           = { version = "1.0.217", features = ["derive"] }
 serde_json      = "1.0.138"

espflash/Cargo.toml

@@ -1,43 +1,53 @@
 use std::error::Error;
 
 use addr2line::{
-    gimli::{EndianRcSlice, RunTimeEndian},
-    object::{read::File, Object, ObjectSegment, ObjectSymbol},
+    gimli::{self, Dwarf, EndianSlice, LittleEndian, SectionId},
     Context,
     LookupResult,
 };
+use object::{read::File, Object, ObjectSection, ObjectSegment, ObjectSymbol};
 
 // Wrapper around addr2line that allows to look up function names and
 // locations from a given address.
 pub(crate) struct Symbols<'sym> {
-    file: File<'sym, &'sym [u8]>,
-    ctx: Context<EndianRcSlice<RunTimeEndian>>,
+    object: File<'sym, &'sym [u8]>,
+    ctx: Context<EndianSlice<'sym, LittleEndian>>,
 }
 
 impl<'sym> Symbols<'sym> {
     pub fn try_from(bytes: &'sym [u8]) -> Result<Self, Box<dyn Error>> {
-        let file = File::parse(bytes)?;
-        let ctx = Context::new(&file)?;
+        let object = File::parse(bytes)?;
+        let dwarf = Dwarf::load(
+            |id: SectionId| -> Result<EndianSlice<'sym, LittleEndian>, gimli::Error> {
+                let data = object
+                    .section_by_name(id.name())
+                    .and_then(|section| section.data().ok())
+                    .unwrap_or(&[][..]);
+                Ok(EndianSlice::new(data, LittleEndian))
+            },
+        )?;
 
-        Ok(Self { file, ctx })
+        let ctx = Context::from_dwarf(dwarf)?;
+
+        Ok(Self { object, ctx })
     }
 
     /// Returns the name of the function at the given address, if one can be
     /// found.
     pub fn get_name(&self, addr: u64) -> Option<String> {
-        // no need to try an address not contained in any segment
-        if !self.file.segments().any(|segment| {
+        // No need to try an address not contained in any segment:
+        if !self.object.segments().any(|segment| {
             (segment.address()..(segment.address() + segment.size())).contains(&addr)
         }) {
             return None;
         }
 
         // The basic steps here are:
-        //   1. find which frame `addr` is in
-        //   2. look up and demangle the function name
-        //   3. if no function name is found, try to look it up in the object file
+        //   1. Find which frame `addr` is in
+        //   2. Look up and demangle the function name
+        //   3. If no function name is found, try to look it up in the object file
         //      directly
-        //   4. return a demangled function name, if one was found
+        //   4. Return a demangled function name, if one was found
         let mut frames = match self.ctx.find_frames(addr) {
             LookupResult::Output(result) => result.unwrap(),
             LookupResult::Load { .. } => unimplemented!(),
@@ -55,7 +65,7 @@ impl<'sym> Symbols<'sym> {
             .or_else(|| {
                 // Don't use `symbol_map().get(addr)` - it's documentation says "Get the symbol
                 // before the given address." which might be totally wrong
-                let symbol = self.file.symbols().find(|symbol| {
+                let symbol = self.object.symbols().find(|symbol| {
                     (symbol.address()..=(symbol.address() + symbol.size())).contains(&addr)
                 });