Support .gnu_debugdata section

Cargo.toml

@@ -175,6 +175,7 @@ miniz_oxide = {version = "0.8", default-features = false, features = ["simd", "w
 nom = {version = "7", optional = true}
 rustc-demangle = {version = "0.1", optional = true}
 tracing = {version = "0.1", default-features = false, features = ["attributes"], optional = true}
+xz2 = "0.1.7"
 zstd = {version = "0.13", default-features = false, optional = true}
 
 [dev-dependencies]

src/elf/parser.rs

@@ -7,6 +7,7 @@ use std::fmt::Formatter;
 use std::fmt::Result as FmtResult;
 use std::fs::File;
 use std::io;
+use std::io::Read as _;
 use std::io::Seek as _;
 use std::io::SeekFrom;
 use std::mem;
@@ -437,6 +438,8 @@ struct Cache<'elf, B> {
     dynsym: OnceCell<SymbolTableCache<'elf>>,
     /// The section data.
     section_data: OnceCell<Box<[OnceCell<Cow<'elf, [u8]>>]>>,
+    /// Potential gnu_debugdata contents.
+    debugdata: OnceCell<Cow<'elf, [u8]>>,
 }
 
 impl<'elf, B> Cache<'elf, B>
@@ -454,6 +457,7 @@ where
             symtab: OnceCell::new(),
             dynsym: OnceCell::new(),
             section_data: OnceCell::new(),
+            debugdata: OnceCell::new(),
         }
     }
 
@@ -807,10 +811,61 @@ where
         Ok(syms)
     }
 
+    fn parse_debugdata(&self) -> Result<Option<Vec<u8>>> {
+        let idx = if let Some(idx) = self.find_section(".gnu_debugdata")? {
+            idx
+        } else {
+            // The symbol table does not exists. Fake an empty one.
+            return Ok(None)
+        };
+
+        let shdr = self.section_hdr(idx)?;
+
+        // XXX not sure if this can actually happen for .gnu_debugdata
+        if shdr.type_() == SHT_NOBITS {
+            return Ok(None)
+        }
+
+        let sh_size = shdr.size();
+        let sh_offset = shdr.offset();
+
+        let data = self.backend.read_pod_slice::<u8>(sh_offset, sh_size as usize)
+            .with_context(|| "failed to read .gnu_debugdata section data")?;
+
+        // decompress xz data
+        let mut decoder = xz2::read::XzDecoder::new(data.deref());
+        let mut decompressed = Vec::new();
+        decoder
+                .read_to_end(&mut decompressed)
+                .with_context(|| "failed to decompress .gnu_debugdata section data")?;
+
+        Ok(Some(decompressed))
+    }
+
     fn ensure_symtab_cache(&self) -> Result<&SymbolTableCache<'elf>> {
         self.symtab.get_or_try_init_(|| {
-            let syms = self.parse_syms(".symtab")?;
-            let strtab = self.parse_strs(".strtab")?;
+            let mut syms = self.parse_syms(".symtab")?;
+            let mut strtab = self.parse_strs(".strtab")?;
+            if syms.is_empty() {
+                let data = self.debugdata.get_or_try_init_(|| {
+                    if let Some(data) = self.parse_debugdata()? {
+                        Result::<_, Error>::Ok(Cow::Owned(data))
+                    } else {
+                        Ok(Cow::Borrowed([].as_slice()))
+                    }
+                })?;
+                if !data.is_empty() {
+                    // to allow self-referentiality here, we have to artificially
+                    // extend the lifetime of `data` to `'elf`
+                    // XXX is this safe, is there a better way?
+                    let data_slice = unsafe {
+                        mem::transmute::<&[u8], &'elf [u8]>(&data)
+                    };
+                    let cache = Cache::new(data_slice);
+                    syms = cache.parse_syms(".symtab")?;
+                    strtab = cache.parse_strs(".strtab")?;
+                }
+            }
             let cache = SymbolTableCache::new(syms, strtab);
             Ok(cache)
         })
@@ -2052,6 +2107,7 @@ mod tests {
             symtab: OnceCell::new(),
             dynsym: OnceCell::new(),
             section_data: OnceCell::new(),
+            debugdata: OnceCell::new(),
         };
 
         assert_eq!(cache.find_section(".symtab").unwrap(), Some(2));
@@ -2158,6 +2214,7 @@ mod tests {
             symtab: OnceCell::new(),
             dynsym: OnceCell::new(),
             section_data: OnceCell::from(vec![OnceCell::new(), OnceCell::new()].into_boxed_slice()),
+            debugdata: OnceCell::new(),
         };
 
         let new_data = cache.section_data(1).unwrap();