Add AIX support

Author: Kai Luo

src/symbolize/gimli.rs

@@ -41,6 +41,7 @@ cfg_if::cfg_if! {
         target_os = "openbsd",
         target_os = "solaris",
         target_os = "illumos",
+        target_os = "aix",
     ))] {
         #[path = "gimli/mmap_unix.rs"]
         mod mmap;
@@ -151,6 +152,9 @@ cfg_if::cfg_if! {
     ))] {
         mod macho;
         use self::macho::Object;
+    } else if #[cfg(target_os = "aix")] {
+        mod xcoff;
+        use self::xcoff::Object;
     } else {
         mod elf;
         use self::elf::Object;
@@ -192,6 +196,9 @@ cfg_if::cfg_if! {
     } else if #[cfg(target_os = "haiku")] {
         mod libs_haiku;
         use libs_haiku::native_libraries;
+    } else if #[cfg(target_os = "aix")] {
+        mod libs_aix;
+        use libs_aix::native_libraries;
     } else {
         // Everything else should doesn't know how to load native libraries.
         fn native_libraries() -> Vec<Library> {

src/symbolize/gimli/libs_aix.rs

@@ -0,0 +1,37 @@
+use super::mystd::borrow::ToOwned;
+use super::mystd::ffi::{CStr, OsStr};
+use super::mystd::os::unix::prelude::*;
+use super::{Library, LibrarySegment, Vec};
+
+pub(super) fn native_libraries() -> Vec<Library> {
+    let mut ret = Vec::new();
+    unsafe {
+        const BUFFER_SIZE: usize = 4 << 20;
+        let mut buffer = vec![0i8; BUFFER_SIZE];
+        if libc::loadquery(libc::L_GETINFO, buffer.as_mut_ptr(), BUFFER_SIZE as u32) < 0 {
+            panic!("loadquery failed");
+        }
+        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 text_size = (*current).ldinfo_textsize as usize;
+                let bytes = CStr::from_ptr(&(*current).ldinfo_filename[0]).to_bytes();
+                let name = OsStr::from_bytes(bytes).to_owned();
+                ret.push(Library {
+                    name,
+                    segments: vec![LibrarySegment {
+                        stated_virtual_memory_address: text_base,
+                        len: text_size,
+                    }],
+                    bias: 0,
+                });
+            }
+            if (*current).ldinfo_next == 0 {
+                break;
+            }
+            current = ((current as i64) + ((*current).ldinfo_next) as i64) as *mut libc::ld_info;
+        }
+    }
+    return ret;
+}

src/symbolize/gimli/xcoff.rs

@@ -0,0 +1,67 @@
+use super::{Context, Mapping, Path, Stash, Vec};
+use object::read::xcoff::XcoffFile64;
+use object::Object as _;
+use object::ObjectSection as _;
+use object::ObjectSymbol as _;
+
+impl Mapping {
+    pub fn new(path: &Path) -> Option<Mapping> {
+        let map = super::mmap(path)?;
+        Mapping::mk(map, |data, stash| {
+            Context::new(stash, Object::parse(data)?, None)
+        })
+    }
+}
+
+struct ParsedSym<'a> {
+    address: u64,
+    size: u64,
+    name: &'a str,
+}
+
+pub struct Object<'a> {
+    syms: Vec<ParsedSym<'a>>,
+    file: XcoffFile64<'a>,
+}
+
+impl<'a> Object<'a> {
+    fn parse(data: &'a [u8]) -> Option<Object<'a>> {
+        let file = XcoffFile64::parse(data).ok()?;
+        let mut syms = file
+            .symbols()
+            .map(|sym| {
+                let address = sym.address();
+                let size = sym.size();
+                let name = sym.name().map_or("", |v| v);
+                ParsedSym {
+                    address,
+                    size,
+                    name,
+                }
+            })
+            .collect::<Vec<_>>();
+        syms.sort_unstable_by_key(|s| s.address);
+        return Some(Object { syms, file });
+    }
+
+    pub fn section(&self, _: &Stash, name: &str) -> Option<&'a [u8]> {
+        Some(self.file.section_by_name(name)?.data().ok()?)
+    }
+
+    pub fn search_symtab<'b>(&'b self, addr: u64) -> Option<&'b [u8]> {
+        let i = match self.syms.binary_search_by_key(&addr, |sym| sym.address) {
+            Ok(i) => i,
+            Err(i) => i.checked_sub(1)?,
+        };
+        let sym = self.syms.get(i)?;
+        if sym.address <= addr && addr <= sym.address + sym.size {
+            Some(sym.name.strip_prefix(".")?.as_bytes())
+        } else {
+            None
+        }
+    }
+
+    pub(super) fn search_object_map(&self, _addr: u64) -> Option<(&Context<'_>, u64)> {
+        None
+    }
+}

tests/accuracy/main.rs

@@ -31,6 +31,8 @@ fn doit() {
             dir.push("dylib_dep.dll");
         } else if cfg!(target_os = "macos") {
             dir.push("libdylib_dep.dylib");
+        } else if cfg!(target_os = "aix") {
+            dir.push("libdylib_dep.a");
         } else {
             dir.push("libdylib_dep.so");
         }