Support Mach-O backtraces without dsymutil

Author: philipc

Cargo.toml

@@ -38,10 +38,12 @@ cpp_demangle = { default-features = false, version = "0.3.0", optional = true }
 addr2line = { version = "0.13.0", optional = true, default-features = false }
 miniz_oxide = { version = "0.4.0", optional = true, default-features = false }
 [dependencies.object]
+git = "https://github.com/philipc/object"
+branch = "object-map"
 version = "0.21"
 optional = true
 default-features = false
-features = ['read_core', 'elf', 'macho', 'pe', 'unaligned']
+features = ['read_core', 'elf', 'macho', 'pe', 'unaligned', 'archive']
 
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3.3", optional = true }

src/symbolize/gimli.rs

@@ -547,7 +547,7 @@ impl Cache {
             .next()
     }
 
-    fn mapping_for_lib<'a>(&'a mut self, lib: usize) -> Option<&'a Context<'a>> {
+    fn mapping_for_lib<'a>(&'a mut self, lib: usize) -> Option<&'a mut Context<'a>> {
         let idx = self.mappings.iter().position(|(idx, _)| *idx == lib);
 
         // Invariant: after this conditional completes without early returning
@@ -573,10 +573,10 @@ impl Cache {
             self.mappings.insert(0, (lib, mapping));
         }
 
-        let cx: &'a Context<'static> = &self.mappings[0].1.cx;
+        let cx: &'a mut Context<'static> = &mut self.mappings[0].1.cx;
         // don't leak the `'static` lifetime, make sure it's scoped to just
         // ourselves
-        Some(unsafe { mem::transmute::<&'a Context<'static>, &'a Context<'a>>(cx) })
+        Some(unsafe { mem::transmute::<&'a mut Context<'static>, &'a mut Context<'a>>(cx) })
     }
 }
 
@@ -613,7 +613,18 @@ pub unsafe fn resolve(what: ResolveWhat<'_>, cb: &mut dyn FnMut(&super::Symbol))
                 });
             }
         }
-
+        if let Some((object_cx, object_addr)) = cx.object.search_object_map(addr as u64) {
+            if let Ok(mut frames) = object_cx.dwarf.find_frames(object_addr) {
+                while let Ok(Some(frame)) = frames.next() {
+                    any_frames = true;
+                    call(Symbol::Frame {
+                        addr: addr as *mut c_void,
+                        location: frame.location,
+                        name: frame.function.map(|f| f.name.slice()),
+                    });
+                }
+            }
+        }
         if !any_frames {
             if let Some(name) = cx.object.search_symtab(addr as u64) {
                 call(Symbol::Symtab {

src/symbolize/gimli/coff.rs

@@ -102,4 +102,8 @@ impl<'a> Object<'a> {
         };
         self.symbols[i].1.name(self.strings).ok()
     }
+
+    pub(super) fn search_object_map(&self, _addr: u64) -> Option<(&Context, u64)> {
+        None
+    }
 }

src/symbolize/gimli/elf.rs

@@ -162,6 +162,10 @@ impl<'a> Object<'a> {
             None
         }
     }
+
+    pub(super) fn search_object_map(&self, _addr: u64) -> Option<(&Context, u64)> {
+        None
+    }
 }
 
 fn decompress_zlib(input: &[u8], output: &mut [u8]) -> Option<()> {

src/symbolize/gimli/macho.rs

@@ -142,16 +142,21 @@ pub struct Object<'a> {
     data: Bytes<'a>,
     dwarf: Option<&'a [MachSection]>,
     syms: Vec<(&'a [u8], u64)>,
+    object_map: Option<object::ObjectMap<'a>>,
+    object_mappings: Vec<Option<Option<Mapping>>>,
 }
 
 impl<'a> Object<'a> {
     fn parse(mach: &'a Mach, endian: NativeEndian, data: Bytes<'a>) -> Option<Object<'a>> {
+        let is_object = mach.filetype(endian) == object::macho::MH_OBJECT;
         let mut dwarf = None;
         let mut syms = Vec::new();
         let mut commands = mach.load_commands(endian, data).ok()?;
+        let mut object_map = None;
+        let mut object_mappings = Vec::new();
         while let Ok(Some(command)) = commands.next() {
             if let Some((segment, section_data)) = MachSegment::from_command(command).ok()? {
-                if segment.name() == b"__DWARF" {
+                if segment.name() == b"__DWARF" || (is_object && segment.name() == b"") {
                     dwarf = segment.sections(endian, section_data).ok();
                 }
             } else if let Some(symtab) = command.symtab().ok()? {
@@ -160,14 +165,19 @@ impl<'a> Object<'a> {
                     .iter()
                     .filter_map(|nlist: &MachNlist| {
                         let name = nlist.name(endian, symbols.strings()).ok()?;
-                        if name.len() > 0 && !nlist.is_undefined() {
+                        if name.len() > 0 && nlist.is_definition() {
                             Some((name, u64::from(nlist.n_value(endian))))
                         } else {
                             None
                         }
                     })
                     .collect();
                 syms.sort_unstable_by_key(|(_, addr)| *addr);
+                if !is_object {
+                    let map = symbols.object_map(endian);
+                    object_mappings.resize_with(map.objects().len(), || None);
+                    object_map = Some(map);
+                }
             }
         }
 
@@ -176,6 +186,8 @@ impl<'a> Object<'a> {
             data,
             dwarf,
             syms,
+            object_map,
+            object_mappings,
         })
     }
 
@@ -201,4 +213,72 @@ impl<'a> Object<'a> {
         let (sym, _addr) = self.syms.get(i)?;
         Some(sym)
     }
+
+    /// Try to load a context for an object file.
+    ///
+    /// If dsymutil was not run, then the DWARF may be found in the source object files.
+    pub(super) fn search_object_map<'b>(&'b mut self, addr: u64) -> Option<(&Context<'b>, u64)> {
+        // `object_map` contains a map from addresses to symbols and object paths.
+        // Look up the address and get a mapping for the object.
+        let object_map = self.object_map.as_ref()?;
+        let symbol = object_map.get(addr)?;
+        let object_index = symbol.object_index();
+        let mapping = self.object_mappings.get_mut(object_index)?;
+        if mapping.is_none() {
+            // No cached mapping, so create it.
+            *mapping = Some(object_mapping(object_map.objects().get(object_index)?));
+        }
+        let cx: &'b Context<'static> = &mapping.as_ref()?.as_ref()?.cx;
+        // Don't leak the `'static` lifetime, make sure it's scoped to just ourselves.
+        let cx = unsafe { core::mem::transmute::<&'b Context<'static>, &'b Context<'b>>(cx) };
+
+        // We must translate the address in order to be able to look it up
+        // in the DWARF in the object file.
+        let object_symbol = cx.object.syms.iter().find(|sym| sym.0 == symbol.name())?;
+        let object_addr = addr
+            .wrapping_sub(symbol.address())
+            .wrapping_add(object_symbol.1);
+        Some((cx, object_addr))
+    }
+}
+
+fn object_mapping(path: &[u8]) -> Option<Mapping> {
+    use super::mystd::ffi::OsStr;
+    use super::mystd::os::unix::prelude::*;
+
+    // `N_OSO` symbol names can be either `/path/to/object.o` or `/path/to/archive.a(object.o)`.
+    if let Some((archive_path, member_name)) = split_archive_path(path) {
+        let map = super::mmap(Path::new(OsStr::from_bytes(archive_path)))?;
+        let archive = object::read::archive::ArchiveFile::parse(&map).ok()?;
+        for member in archive.members() {
+            let member = member.ok()?;
+            if member.name() == member_name {
+                let (macho, data) = find_header(Bytes(member.data()))?;
+                let endian = macho.endian().ok()?;
+                let object = Object::parse(macho, endian, data)?;
+                let stash = Stash::new();
+                let inner = super::cx(&stash, object)?;
+                return Some(mk!(Mapping { map, inner, stash }));
+            }
+        }
+        None
+    } else {
+        let map = super::mmap(Path::new(OsStr::from_bytes(path)))?;
+        let (macho, data) = find_header(Bytes(&map))?;
+        let endian = macho.endian().ok()?;
+        let object = Object::parse(macho, endian, data)?;
+        let stash = Stash::new();
+        let inner = super::cx(&stash, object)?;
+        Some(mk!(Mapping { map, inner, stash }))
+    }
+}
+
+fn split_archive_path(path: &[u8]) -> Option<(&[u8], &[u8])> {
+    let (last, path) = path.split_last()?;
+    if *last != b')' {
+        return None;
+    }
+    let index = path.iter().position(|&x| x == b'(')?;
+    let (archive, rest) = path.split_at(index);
+    Some((archive, &rest[1..]))
 }