fixup! Fixes

Author: d-e-s-o

dev/build.rs

@@ -664,7 +664,6 @@ fn prepare_test_files() {
             &["-gstrict-dwarf", "-gdwarf-5", "-gz=zstd"],
         );
     }
-    gnu_debugdata(&data_dir.join("test-no-debug.bin"), "test-debugdata.bin");
 
     // Generate this binary by passing the source file name without a
     // path to the compiler (which means we need to `cd` into the
@@ -756,6 +755,7 @@ fn prepare_test_files() {
             &format!("--add-gnu-debuglink={}", dbg.display()),
         ],
     );
+    gnu_debugdata(&src, "test-stable-addrs-debugdata.bin");
 
     let elf = data_dir.join("test-stable-addrs-no-dwarf.bin");
     objcopy(

src/elf/parser.rs

@@ -286,6 +286,13 @@ fn decompress_xz(data: &[u8]) -> Result<Vec<u8>> {
     Ok(decompressed)
 }
 
+#[cfg(not(feature = "xz"))]
+fn decompress_xz(_data: &[u8]) -> Result<Vec<u8>> {
+    Err(Error::with_unsupported(
+        "ELF section is xz compressed but xz compression support is not enabled",
+    ))
+}
+
 
 #[derive(Debug)]
 struct EhdrExt<'elf> {
@@ -823,26 +830,18 @@ where
         Ok(syms)
     }
 
-    #[cfg(feature = "xz")]
     fn parse_debugdata(&self) -> Result<Vec<u8>> {
         if let Some(idx) = self.find_section(".gnu_debugdata")? {
-            let data = self.section_data_raw(idx)?;
-            if !data.is_empty() {
-                decompress_xz(&data)
-            } else {
-                Ok(Vec::new())
-            }
+            // NB: We assume here that `.gnu_debugdata` will never be
+            //     of type `SHT_NOBITS`, which just logically doesn't
+            //     make sense to be used.
+            self.section_data_raw(idx)
+                .and_then(|data| decompress_xz(&data))
         } else {
             Ok(Vec::new())
         }
     }
 
-    #[cfg(not(feature = "xz"))]
-    fn parse_debugdata(&self) -> Result<Vec<u8>> {
-        // We don't have the means to decompress it, fake an empty one.
-        return Ok(Vec::new())
-    }
-
     fn ensure_symtab_cache(&self) -> Result<&SymbolTableCache<'_>> {
         self.symtab.get_or_try_init_(move || {
             let mut syms = self.parse_syms(".symtab")? as ElfN_Syms<'_>;
@@ -2215,21 +2214,6 @@ mod tests {
         assert_eq!(new_data, data);
     }
 
-    /// Make sure that we can look up a symbol residing in `.gnu_debugdata`.
-    #[test]
-    fn lookup_from_gnu_debugdata() {
-        let bin_name = Path::new(&env!("CARGO_MANIFEST_DIR"))
-            .join("data")
-            .join("test-debugdata.bin");
-
-        let parser = ElfParser::open(bin_name.as_path()).unwrap();
-        let opts = FindAddrOpts::default();
-        let addr = parser.find_addr("fibonacci", &opts).unwrap();
-        assert_eq!(addr.len(), 1);
-        let sym = &addr[0];
-        assert_eq!(sym.name, "fibonacci");
-    }
-
     /// Benchmark creation of our "str2symtab" table.
     ///
     /// Creating this table exercises a lot of the parser code paths and

tests/suite/symbolize.rs

@@ -463,6 +463,26 @@ fn symbolize_elf_stripped() {
     assert_eq!(result, Symbolized::Unknown(Reason::MissingSyms));
 }
 
+/// Make sure that we can symbolize data from a compressed
+/// `.gnu_debugdata` section.
+#[tag(other_os)]
+#[test]
+fn symbolize_elf_compressed_gnu_debugdata() {
+    let path = Path::new(&env!("CARGO_MANIFEST_DIR"))
+        .join("data")
+        .join("test-stable-addrs-debugdata.bin");
+    let src = Source::Elf(Elf::new(path));
+    let symbolizer = Symbolizer::new();
+    let result = symbolizer
+        .symbolize_single(&src, Input::VirtOffset(0x2000200))
+        .unwrap()
+        .into_sym()
+        .unwrap();
+
+    assert_eq!(result.name, "factorial");
+    assert_eq!(result.addr, 0x2000200);
+}
+
 /// Check that we can symbolize data in a non-existent ELF binary after
 /// caching it.
 #[test]