Parse xcoff member in big archive

Author: Kai Luo

src/symbolize/gimli.rs

@@ -235,6 +235,8 @@ struct Cache {
 
 struct Library {
     name: OsString,
+    #[cfg(target_os = "aix")]
+    member_name: OsString,
     /// Segments of this library loaded into memory, and where they're loaded.
     segments: Vec<LibrarySegment>,
     /// The "bias" of this library, typically where it's loaded into memory.
@@ -254,6 +256,19 @@ struct LibrarySegment {
     len: usize,
 }
 
+#[cfg(target_os = "aix")]
+fn create_map(lib: &Library) -> Option<Mapping> {
+    let name = &lib.name;
+    let member_name = &lib.member_name;
+    Mapping::new(name.as_ref(), member_name)
+}
+
+#[cfg(not(target_os = "aix"))]
+fn create_map(lib: &Library) -> Option<Mapping> {
+    let name = &lib.name;
+    Mapping::new(name.as_ref())
+}
+
 // unsafe because this is required to be externally synchronized
 pub unsafe fn clear_symbol_cache() {
     Cache::with_global(|cache| cache.mappings.clear());
@@ -334,8 +349,7 @@ impl Cache {
             // When the mapping is not in the cache, create a new mapping,
             // insert it into the front of the cache, and evict the oldest cache
             // entry if necessary.
-            let name = &self.libraries[lib].name;
-            let mapping = Mapping::new(name.as_ref())?;
+            let mapping = create_map(&self.libraries[lib])?;
 
             if self.mappings.len() == MAPPINGS_CACHE_SIZE {
                 self.mappings.pop();

src/symbolize/gimli/libs_aix.rs

@@ -3,7 +3,7 @@ use super::mystd::env;
 use super::mystd::ffi::{CStr, OsStr};
 use super::mystd::io::Error;
 use super::mystd::os::unix::prelude::*;
-use super::{mmap, xcoff};
+use super::xcoff;
 use super::{Library, LibrarySegment, Vec};
 use alloc::vec;
 use core::mem;
@@ -32,26 +32,27 @@ pub(super) fn native_libraries() -> Vec<Library> {
         let mut current = buffer.as_ptr() as *mut libc::ld_info;
         loop {
             let text_base = (*current).ldinfo_textorg as usize;
-            if text_base != 0 {
-                let bytes = CStr::from_ptr(&(*current).ldinfo_filename[0]).to_bytes();
-                let mut name = OsStr::from_bytes(bytes).to_owned();
-                if text_base == EXE_IMAGE_BASE as usize {
-                    if let Ok(exe) = env::current_exe() {
-                        name = exe.into_os_string();
-                    }
+            let filename_ptr: *const i8 = &(*current).ldinfo_filename[0];
+            let bytes = CStr::from_ptr(filename_ptr).to_bytes();
+            let member_name_ptr = filename_ptr.offset((bytes.len() + 1) as isize);
+            let mut filename = OsStr::from_bytes(bytes).to_owned();
+            if text_base == EXE_IMAGE_BASE as usize {
+                if let Ok(exe) = env::current_exe() {
+                    filename = exe.into_os_string();
                 }
-                if let Some(map) = mmap(name.as_ref()) {
-                    if let Some(image) = xcoff::get_text_image(&map) {
-                        ret.push(Library {
-                            name,
-                            segments: vec![LibrarySegment {
-                                stated_virtual_memory_address: image.base as usize,
-                                len: image.size,
-                            }],
-                            bias: (text_base + image.offset).wrapping_sub(image.base as usize),
-                        });
-                    }
-                };
+            }
+            let bytes = CStr::from_ptr(member_name_ptr).to_bytes();
+            let member_name = OsStr::from_bytes(bytes).to_owned();
+            if let Some(image) = xcoff::parse_image(filename.as_ref(), &member_name) {
+                ret.push(Library {
+                    name: filename,
+                    member_name,
+                    segments: vec![LibrarySegment {
+                        stated_virtual_memory_address: image.base as usize,
+                        len: image.size,
+                    }],
+                    bias: (text_base + image.offset).wrapping_sub(image.base as usize),
+                });
             }
             if (*current).ldinfo_next == 0 {
                 break;

src/symbolize/gimli/xcoff.rs

@@ -1,5 +1,9 @@
+use super::mystd::ffi::{OsStr, OsString};
+use super::mystd::os::unix::ffi::OsStrExt;
 use super::mystd::str;
 use super::{Context, Mapping, Path, Stash, Vec};
+use core::ops::Deref;
+use object::read::archive::ArchiveFile;
 use object::read::xcoff::FileHeader;
 use object::read::xcoff::SectionHeader;
 use object::read::xcoff::XcoffFile;
@@ -13,10 +17,26 @@ type Xcoff = object::xcoff::FileHeader32;
 type Xcoff = object::xcoff::FileHeader64;
 
 impl Mapping {
-    pub fn new(path: &Path) -> Option<Mapping> {
+    pub fn new(path: &Path, member_name: &OsString) -> Option<Mapping> {
         let map = super::mmap(path)?;
         Mapping::mk(map, |data, stash| {
-            Context::new(stash, Object::parse(data)?, None)
+            if member_name.is_empty() {
+                Context::new(stash, Object::parse(data)?, None)
+            } else {
+                let archive = ArchiveFile::parse(data).ok()?;
+                for member in archive.members() {
+                    if let Ok(member) = member {
+                        let name = OsStr::from_bytes(member.name());
+                        if name == member_name {
+                            let member_data = member.data(data).ok()?;
+                            if let Some(obj) = Object::parse(member_data) {
+                                return Context::new(stash, obj, None);
+                            }
+                        }
+                    }
+                }
+                None
+            }
         })
     }
 }
@@ -38,10 +58,10 @@ pub struct Image {
     pub size: usize,
 }
 
-pub fn get_text_image(data: &[u8]) -> Option<Image> {
+pub fn parse_xcoff(data: &[u8]) -> Option<Image> {
     let mut offset = 0;
     let header = Xcoff::parse(data, &mut offset).ok()?;
-    let aux_header = header.aux_header(data, &mut offset).ok()?;
+    let _ = header.aux_header(data, &mut offset).ok()?;
     let sections = header.sections(data, &mut offset).ok()?;
     if let Some(section) = sections.iter().find(|s| {
         let name = str::from_utf8(&s.s_name()[0..5]).unwrap();
@@ -56,19 +76,45 @@ pub fn get_text_image(data: &[u8]) -> Option<Image> {
     return None;
 }
 
+pub fn parse_image(path: &Path, member_name: &OsString) -> Option<Image> {
+    let map = super::mmap(path)?;
+    let data = map.deref();
+    if member_name.is_empty() {
+        return parse_xcoff(data);
+    } else {
+        let archive = ArchiveFile::parse(data).ok()?;
+        for member in archive.members() {
+            if let Ok(member) = member {
+                let name = OsStr::from_bytes(member.name());
+                if name == member_name {
+                    let member_data = member.data(data).ok()?;
+                    if let Some(image) = parse_xcoff(member_data) {
+                        return Some(image);
+                    }
+                }
+            }
+        }
+        return None;
+    }
+}
+
 impl<'a> Object<'a> {
     fn parse(data: &'a [u8]) -> Option<Object<'a>> {
         let file = XcoffFile::parse(data).ok()?;
         let mut syms = file
             .symbols()
-            .map(|sym| {
+            .filter_map(|sym| {
                 let address = sym.address();
                 let size = sym.size();
                 let name = sym.name().map_or("", |v| v);
-                ParsedSym {
-                    address,
-                    size,
-                    name,
+                if name == ".text" || name == ".data" {
+                    None
+                } else {
+                    Some(ParsedSym {
+                        address,
+                        size,
+                        name,
+                    })
                 }
             })
             .collect::<Vec<_>>();
@@ -87,7 +133,7 @@ impl<'a> Object<'a> {
         };
         let sym = self.syms.get(i)?;
         if (sym.address..sym.address + sym.size).contains(&addr) {
-            Some(sym.name.strip_prefix(".")?.as_bytes())
+            Some(sym.name.trim_start_matches(".").as_bytes())
         } else {
             None
         }