elf: supplementary object file support

Author: philipc

src/symbolize/gimli.rs

@@ -58,6 +58,7 @@ struct Mapping {
     // 'static lifetime is a lie to hack around lack of support for self-referential structs.
     cx: Context<'static>,
     _map: Mmap,
+    _map_sup: Option<Mmap>,
     _stash: Stash,
 }
 
@@ -74,6 +75,7 @@ impl Mapping {
             // only borrow `map` and `stash` and we're preserving them below.
             cx: unsafe { core::mem::transmute::<Context<'_>, Context<'static>>(cx) },
             _map: data,
+            _map_sup: None,
             _stash: stash,
         })
     }
@@ -95,6 +97,26 @@ impl<'data> Context<'data> {
 
         Some(Context { dwarf, object })
     }
+
+    fn new_sup(
+        stash: &'data Stash,
+        object: Object<'data>,
+        sup: Object<'data>,
+    ) -> Option<Context<'data>> {
+        let mut sections = gimli::Dwarf::load(|id| -> Result<_, ()> {
+            let data = object.section(stash, id.name()).unwrap_or(&[]);
+            Ok(EndianSlice::new(data, Endian))
+        })
+        .ok()?;
+        sections
+            .load_sup(|id| -> Result<_, ()> {
+                let data = sup.section(stash, id.name()).unwrap_or(&[]);
+                Ok(EndianSlice::new(data, Endian))
+            })
+            .ok()?;
+        let dwarf = addr2line::Context::from_dwarf(sections).ok()?;
+        Some(Context { dwarf, object })
+    }
 }
 
 fn mmap(path: &Path) -> Option<Mmap> {

src/symbolize/gimli/elf.rs

@@ -77,6 +77,7 @@ impl Mapping {
             // only borrow `map` and `stash` and we're preserving them below.
             cx: unsafe { core::mem::transmute::<Context<'_>, Context<'static>>(cx) },
             _map: map,
+            _map_sup: None,
             _stash: stash,
         })
     }
@@ -90,13 +91,44 @@ impl Mapping {
             // TODO: check crc
         }
 
+        // Try to locate a supplementary object file.
+        let tmp_stash = Stash::new();
+        if let Some(section) = object.section(&tmp_stash, ".gnu_debugaltlink") {
+            if let Some(len) = section.iter().position(|x| *x == 0) {
+                let filename = &section[..len];
+                let build_id_sup = &section[len + 1..];
+                if let Some(path_sup) = locate_debuglink(path, filename) {
+                    if let Some(map_sup) = super::mmap(&path_sup) {
+                        if let Some(sup) = Object::parse(&map_sup) {
+                            if sup.build_id() == Some(build_id_sup) {
+                                let stash = Stash::new();
+                                let cx = Context::new_sup(&stash, object, sup)?;
+                                return Some(Mapping {
+                                    // Convert to 'static lifetimes since the symbols should
+                                    // only borrow `map`, `map_sup`, and `stash` and we're
+                                    // preserving them below.
+                                    cx: unsafe {
+                                        core::mem::transmute::<Context<'_>, Context<'static>>(cx)
+                                    },
+                                    _map: map,
+                                    _map_sup: Some(map_sup),
+                                    _stash: stash,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
         let stash = Stash::new();
         let cx = Context::new(&stash, object)?;
         Some(Mapping {
             // Convert to 'static lifetimes since the symbols should
             // only borrow `map` and `stash` and we're preserving them below.
             cx: unsafe { core::mem::transmute::<Context<'_>, Context<'static>>(cx) },
             _map: map,
+            _map_sup: None,
             _stash: stash,
         })
     }