Remove dladdr fallback and implementation

This has been present for a very long time but I believe this has never
actually been that necessary. Non-MSVC platforms all use libbacktrace by
default, and libbacktrace will consult symbol tables of object files to
do what `dladdr` does, just inside of libbacktrace. Additionally gimli
implements the same logic. I believe that this means that `dladdr` isn't
necessary for resolving any symbols since our other strategies should
already be doing everything for us.

This commit makes the feature defunkt and otherwise removes the various
forms of fallback to dladdr.

Author: alexcrichton

Cargo.toml

@@ -49,7 +49,7 @@ winapi = { version = "0.3.3", optional = true }
 # Note that not all features are available on all platforms, so even though a
 # feature is enabled some other feature may be used instead.
 [features]
-default = ["std", "libunwind", "libbacktrace", "dladdr", "dbghelp"]
+default = ["std", "libunwind", "libbacktrace", "dbghelp"]
 
 # Include std support.
 std = []
@@ -81,16 +81,12 @@ kernel32 = []
 #   can also provide filename/line number information if debuginfo is
 #   compiled in. This library currently only primarily works on unixes that
 #   are not OSX, however.
-# - dladdr: this feature uses the dladdr(3) function (a glibc extension) to
-#   resolve symbol names. This is fairly unreliable on linux, but works well
-#   enough on OSX.
 # - gimli-symbolize: use the `gimli-rs/addr2line` crate to symbolicate
 #   addresses into file, line, and name using DWARF debug information. At
 #   the moment, this is only possible when targetting Linux, since macOS
 #   splits DWARF out into a separate object file. Enabling this feature
 #   means one less C dependency.
 libbacktrace = ["backtrace-sys/backtrace-sys"]
-dladdr = []
 gimli-symbolize = ["addr2line", "goblin"]
 
 #=======================================
@@ -105,6 +101,7 @@ serialize-serde = ["serde"]
 #
 # Only here for backwards compatibility purposes, they do nothing now.
 coresymbolication = []
+dladdr = []
 
 #=======================================
 # Internal features for testing and such.

crates/without_debuginfo/Cargo.toml

@@ -12,9 +12,6 @@ features = [
   'libunwind',
   'dbghelp',
 
-  # Allow fallback to dladdr
-  'dladdr',
-
   # Yes, we have `std`
   'std',
 ]

src/symbolize/dladdr.rs

@@ -7,7 +7,6 @@
 use self::gimli::read::EndianSlice;
 use self::gimli::LittleEndian as Endian;
 use self::mmap::Mmap;
-use crate::symbolize::dladdr;
 use crate::symbolize::ResolveWhat;
 use crate::types::BytesOrWideString;
 use crate::SymbolName;
@@ -632,10 +631,12 @@ impl Cache {
 
 pub unsafe fn resolve(what: ResolveWhat, cb: &mut FnMut(&super::Symbol)) {
     let addr = what.address_or_ip();
-    let mut cb = DladdrFallback {
-        cb,
-        addr,
-        called: false,
+    let mut call = |sym: Symbol| {
+        // Extend the lifetime of `sym` to `'static` since we are unfortunately
+        // required to here, but it's ony ever going out as a reference so no
+        // reference to it should be persisted beyond this frame anyway.
+        let sym = mem::transmute::<Symbol, Symbol<'static>>(sym);
+        (cb)(&super::Symbol { inner: sym });
     };
 
     Cache::with_global(|cache| {
@@ -650,60 +651,27 @@ pub unsafe fn resolve(what: ResolveWhat, cb: &mut FnMut(&super::Symbol)) {
             Some(cx) => cx,
             None => return,
         };
+        let mut any_frames = false;
         if let Ok(mut frames) = cx.dwarf.find_frames(addr as u64) {
             while let Ok(Some(frame)) = frames.next() {
-                cb.call(Symbol::Frame {
+                any_frames = true;
+                call(Symbol::Frame {
                     addr: addr as *mut c_void,
                     location: frame.location,
                     name: frame.function.map(|f| f.name.slice()),
                 });
             }
         }
 
-        if !cb.called {
+        if !any_frames {
             if let Some(name) = cx.object.search_symtab(addr as u64) {
-                cb.call(Symbol::Symtab {
+                call(Symbol::Symtab {
                     addr: addr as *mut c_void,
                     name,
                 });
             }
         }
     });
-
-    drop(cb);
-}
-
-struct DladdrFallback<'a, 'b> {
-    addr: *mut c_void,
-    called: bool,
-    cb: &'a mut (FnMut(&super::Symbol) + 'b),
-}
-
-impl DladdrFallback<'_, '_> {
-    fn call(&mut self, sym: Symbol) {
-        self.called = true;
-
-        // Extend the lifetime of `sym` to `'static` since we are unfortunately
-        // required to here, but it's ony ever going out as a reference so no
-        // reference to it should be persisted beyond this frame anyway.
-        let sym = unsafe { mem::transmute::<Symbol, Symbol<'static>>(sym) };
-        (self.cb)(&super::Symbol { inner: sym });
-    }
-}
-
-impl Drop for DladdrFallback<'_, '_> {
-    fn drop(&mut self) {
-        if self.called {
-            return;
-        }
-        unsafe {
-            dladdr::resolve(self.addr, &mut |sym| {
-                (self.cb)(&super::Symbol {
-                    inner: Symbol::Dladdr(sym),
-                })
-            });
-        }
-    }
 }
 
 pub enum Symbol<'a> {
@@ -717,15 +685,11 @@ pub enum Symbol<'a> {
     /// Couldn't find debug information, but we found it in the symbol table of
     /// the elf executable.
     Symtab { addr: *mut c_void, name: &'a [u8] },
-    /// We weren't able to find anything in the original file, so we had to fall
-    /// back to using `dladdr` which had a hit.
-    Dladdr(dladdr::Symbol<'a>),
 }
 
 impl Symbol<'_> {
     pub fn name(&self) -> Option<SymbolName> {
         match self {
-            Symbol::Dladdr(s) => s.name(),
             Symbol::Frame { name, .. } => {
                 let name = name.as_ref()?;
                 Some(SymbolName::new(name))
@@ -736,15 +700,13 @@ impl Symbol<'_> {
 
     pub fn addr(&self) -> Option<*mut c_void> {
         match self {
-            Symbol::Dladdr(s) => s.addr(),
             Symbol::Frame { addr, .. } => Some(*addr),
             Symbol::Symtab { .. } => None,
         }
     }
 
     pub fn filename_raw(&self) -> Option<BytesOrWideString> {
         match self {
-            Symbol::Dladdr(s) => return s.filename_raw(),
             Symbol::Frame { location, .. } => {
                 let file = location.as_ref()?.file?;
                 Some(BytesOrWideString::Bytes(file.as_bytes()))
@@ -755,7 +717,6 @@ impl Symbol<'_> {
 
     pub fn filename(&self) -> Option<&Path> {
         match self {
-            Symbol::Dladdr(s) => return s.filename(),
             Symbol::Frame { location, .. } => {
                 let file = location.as_ref()?.file?;
                 Some(Path::new(file))
@@ -766,7 +727,6 @@ impl Symbol<'_> {
 
     pub fn lineno(&self) -> Option<u32> {
         match self {
-            Symbol::Dladdr(s) => return s.lineno(),
             Symbol::Frame { location, .. } => location.as_ref()?.line,
             Symbol::Symtab { .. } => None,
         }