Avoid conditionally-destructuring struct field

Instead, we now attempt to parse /proc/self/maps upfront.

Author: sudoBash418

src/symbolize/gimli/libs_dl_iterate_phdr.rs

@@ -6,41 +6,43 @@ use super::mystd::borrow::ToOwned;
 use super::mystd::env;
 use super::mystd::ffi::{CStr, OsStr};
 use super::mystd::os::unix::prelude::*;
-use super::{Library, LibrarySegment, OsString, Vec};
+use super::{parse_running_mmaps, Library, LibrarySegment, OsString, Vec};
 use core::slice;
 
 struct CallbackData {
     libs: Vec<Library>,
-    #[cfg(target_os = "android")]
-    maps: Option<Vec<super::parse_running_mmaps::MapsEntry>>,
+    maps: Option<Vec<parse_running_mmaps::MapsEntry>>,
 }
 pub(super) fn native_libraries() -> Vec<Library> {
     let mut cb_data = CallbackData {
         libs: Vec::new(),
-        #[cfg(target_os = "android")]
-        maps: super::parse_running_mmaps::parse_maps().ok(),
+        #[cfg(not(target_os = "hurd"))]
+        maps: parse_running_mmaps::parse_maps().ok(),
+        #[cfg(target_os = "hurd")]
+        maps: None,
     };
     unsafe {
         libc::dl_iterate_phdr(Some(callback), core::ptr::addr_of_mut!(cb_data).cast());
     }
     cb_data.libs
 }
 
-fn infer_current_exe(base_addr: usize) -> OsString {
-    cfg_if::cfg_if! {
-        if #[cfg(not(target_os = "hurd"))] {
-                if let Ok(entries) = super::parse_running_mmaps::parse_maps() {
-                let opt_path = entries
-                    .iter()
-                    .find(|e| e.ip_matches(base_addr) && e.pathname().len() > 0)
-                    .map(|e| e.pathname())
-                    .cloned();
-                if let Some(path) = opt_path {
-                    return path;
-                }
-            }
+fn infer_current_exe(
+    maps: &Option<Vec<parse_running_mmaps::MapsEntry>>,
+    base_addr: usize,
+) -> OsString {
+    #[cfg(not(target_os = "hurd"))]
+    if let Some(entries) = maps {
+        let opt_path = entries
+            .iter()
+            .find(|e| e.ip_matches(base_addr) && e.pathname().len() > 0)
+            .map(|e| e.pathname())
+            .cloned();
+        if let Some(path) = opt_path {
+            return path;
         }
     }
+
     env::current_exe().map(|e| e.into()).unwrap_or_default()
 }
 
@@ -59,11 +61,7 @@ unsafe extern "C" fn callback(
     let dlpi_phdr = unsafe { (*info).dlpi_phdr };
     let dlpi_phnum = unsafe { (*info).dlpi_phnum };
     // SAFETY: We assured this.
-    let CallbackData {
-        libs,
-        #[cfg(target_os = "android")]
-        maps,
-    } = unsafe { &mut *data.cast::<CallbackData>() };
+    let CallbackData { libs, maps } = unsafe { &mut *data.cast::<CallbackData>() };
     // most implementations give us the main program first
     let is_main = libs.is_empty();
     // we may be statically linked, which means we are main and mostly one big blob of code
@@ -76,7 +74,7 @@ unsafe extern "C" fn callback(
         // don't try to look up our name from /proc/self/maps, it'll get silly
         env::current_exe().unwrap_or_default().into_os_string()
     } else if is_main && no_given_name {
-        infer_current_exe(dlpi_addr as usize)
+        infer_current_exe(&maps, dlpi_addr as usize)
     } else {
         // this fallback works even if we are main, because some platforms give the name anyways
         if dlpi_name.is_null() {