Support merging archives on MacOS for desktop/iOS targets

We use libtool on Mac instead of the Rust `ar` library,
and gobjcopy from `binutils` instead of objcopy.

Author: tux3

.gitignore

@@ -1 +1,2 @@
 /target
+/local

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "armerge"
-version = "1.0.0"
+version = "1.1.0"
 authors = ["tux3 <[email protected]>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
@@ -17,3 +17,4 @@ rand = "0.7.3"
 object = "0.21.1"
 regex = "1.3.9"
 rayon = "1.4.0"
+which = "4.0.2"

Cargo.toml

@@ -4,7 +4,9 @@
 You can use armerge to combine multiple static libraries into a single merged `ar` archive.  
 Optionally, it is possible to generate a static archive containing a single merged object file, where all non-public symbols are localized (hidden).
 
-This tool requires `ranlib`, `ld`, and `llvm-objcopy` installed on your host system. You may specify a different linker using the `LD` environment variable.
+This tool requires `ranlib`, `ld`, and `objcopy` installed on your host system.  
+On macOS, `libtool`, `ld` and `gobjcopy` are used instead.  
+You may specify a different linker using the `LD` environment variable.
 
 ```
 USAGE:

README.md

@@ -0,0 +1,23 @@
+use std::error::Error;
+use std::path::Path;
+
+#[cfg(not(target_os = "macos"))]
+mod common;
+
+#[cfg(target_os = "macos")]
+mod mac;
+
+pub trait ArBuilder {
+    fn append_obj<P: AsRef<Path>>(&mut self, path: P) -> Result<(), Box<dyn Error>>;
+    fn close(self) -> Result<(), Box<dyn Error>>;
+}
+
+#[cfg(not(target_os = "macos"))]
+pub fn platform_builder(path: &Path, verbose: bool) -> impl ArBuilder {
+    common::CommonArBuilder::new(path, verbose)
+}
+
+#[cfg(target_os = "macos")]
+pub fn platform_builder(path: &Path, verbose: bool) -> impl ArBuilder {
+    mac::MacArBuilder::new(path, verbose)
+}

src/arbuilder.rs

@@ -0,0 +1,48 @@
+use crate::arbuilder::ArBuilder;
+use crate::archives;
+use ar::Builder;
+use std::error::Error;
+use std::fs::File;
+use std::path::{Path, PathBuf};
+
+pub struct CommonArBuilder {
+    builder: Builder<File>,
+    output_path: PathBuf,
+    closed: bool,
+}
+
+impl ArBuilder for CommonArBuilder {
+    fn append_obj<P: AsRef<Path>>(&mut self, path: P) -> Result<(), Box<dyn Error>> {
+        self.builder.append_path(path)?;
+        Ok(())
+    }
+
+    fn close(mut self) -> Result<(), Box<dyn Error>> {
+        self.finalize_index()
+    }
+}
+
+impl CommonArBuilder {
+    pub fn new(path: &Path, _verbose: bool) -> Self {
+        Self {
+            builder: Builder::new(File::create(path).expect("Failed to create output library")),
+            output_path: path.to_owned(),
+            closed: false,
+        }
+    }
+
+    fn finalize_index(&mut self) -> Result<(), Box<dyn Error>> {
+        if self.closed {
+            return Ok(());
+        }
+        self.closed = true;
+
+        archives::create_index(&self.output_path)
+    }
+}
+
+impl Drop for CommonArBuilder {
+    fn drop(&mut self) {
+        self.finalize_index().unwrap();
+    }
+}

src/arbuilder/common.rs

@@ -0,0 +1,70 @@
+use crate::arbuilder::ArBuilder;
+use std::error::Error;
+use std::ffi::OsString;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+pub struct MacArBuilder {
+    output_path: PathBuf,
+    obj_paths: Vec<PathBuf>,
+    verbose: bool,
+    closed: bool,
+}
+
+impl ArBuilder for MacArBuilder {
+    fn append_obj<P: AsRef<Path>>(&mut self, path: P) -> Result<(), Box<dyn Error>> {
+        self.obj_paths.push(path.as_ref().to_owned());
+        Ok(())
+    }
+
+    fn close(mut self) -> Result<(), Box<dyn Error>> {
+        self.write_obj()
+    }
+}
+
+impl MacArBuilder {
+    pub fn new(path: &Path, verbose: bool) -> Self {
+        Self {
+            output_path: path.to_owned(),
+            obj_paths: vec![],
+            verbose,
+            closed: false,
+        }
+    }
+
+    fn write_obj(&mut self) -> Result<(), Box<dyn Error>> {
+        if self.closed {
+            return Ok(());
+        }
+        self.closed = true;
+
+        let mut args = [
+            OsString::from("-static"),
+            OsString::from("-o"),
+            self.output_path.as_os_str().to_owned(),
+        ]
+        .to_vec();
+        let mut count = 0;
+        args.extend(
+            self.obj_paths
+                .iter()
+                .inspect(|_| count += 1)
+                .map(|p| p.as_os_str().into()),
+        );
+        if self.verbose {
+            println!("Merging {} objects", count);
+        }
+
+        Command::new("libtool")
+            .args(args)
+            .status()
+            .unwrap_or_else(|_| panic!("Failed to merged object files with `libtool`"));
+        Ok(())
+    }
+}
+
+impl Drop for MacArBuilder {
+    fn drop(&mut self) {
+        self.write_obj().unwrap();
+    }
+}

src/arbuilder/mac.rs

@@ -1,12 +1,11 @@
+use crate::arbuilder::ArBuilder;
 use crate::objects::ObjectTempDir;
-use ar::{Archive, Builder};
+use ar::Archive;
 use rand::distributions::Alphanumeric;
 use rand::{thread_rng, Rng};
 use std::error::Error;
 use std::fs::File;
-use std::io::Write;
-use std::path::{Path, PathBuf};
-use std::process::Command;
+use std::path::PathBuf;
 use std::str::from_utf8;
 use tempdir::TempDir;
 
@@ -32,7 +31,10 @@ pub fn extract_objects(archives: &[PathBuf]) -> Result<ObjectTempDir, Box<dyn Er
     Ok(ObjectTempDir { dir, objects })
 }
 
-pub fn create_index(archive_path: &Path) -> Result<(), Box<dyn Error>> {
+#[cfg(not(target_os = "macos"))]
+pub fn create_index(archive_path: &std::path::Path) -> Result<(), Box<dyn Error>> {
+    use std::process::Command;
+
     Command::new("ranlib")
         .args(vec![archive_path])
         .status()
@@ -41,14 +43,13 @@ pub fn create_index(archive_path: &Path) -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
-pub fn merge<T: Write>(mut output: Builder<T>, archives: &[PathBuf]) -> Result<(), Box<dyn Error>> {
-    for archive_path in archives {
-        let mut archive = Archive::new(File::open(archive_path)?);
-        while let Some(entry_result) = archive.next_entry() {
-            let mut entry = entry_result?;
-            let header = entry.header().clone();
-            output.append(&header, &mut entry)?;
-        }
+pub fn merge(mut output: impl ArBuilder, archives: &[PathBuf]) -> Result<(), Box<dyn Error>> {
+    let objects_dir = extract_objects(archives)?;
+
+    for obj_path in objects_dir.objects {
+        output.append_obj(obj_path)?;
     }
+
+    output.close()?;
     Ok(())
 }

src/archives.rs

@@ -1,10 +1,9 @@
+mod arbuilder;
 mod archives;
 mod object_syms;
 mod objects;
 
-use ar::Builder;
 use std::error::Error;
-use std::fs::File;
 use std::path::PathBuf;
 use structopt::StructOpt;
 
@@ -31,14 +30,13 @@ struct Opt {
 fn main() -> Result<(), Box<dyn Error>> {
     let opt = Opt::from_args();
 
-    let builder = Builder::new(File::create(&opt.output)?);
+    let builder = arbuilder::platform_builder(&opt.output, opt.verbose);
     if opt.keep_symbols.is_empty() {
         archives::merge(builder, &opt.inputs)?;
     } else {
         let objects_dir = archives::extract_objects(&opt.inputs)?;
         objects::merge(builder, objects_dir, opt.keep_symbols, opt.verbose)?;
     }
-    archives::create_index(&opt.output)?;
 
     Ok(())
 }

src/main.rs

@@ -1,12 +1,11 @@
+use crate::arbuilder::ArBuilder;
 use crate::object_syms::ObjectSyms;
-use ar::{Builder, Header};
 use object::{Object, SymbolKind};
 use rayon::prelude::*;
 use regex::Regex;
 use std::collections::{HashMap, HashSet};
 use std::error::Error;
 use std::ffi::OsString;
-use std::fs::File;
 use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -168,30 +167,49 @@ fn create_filter_list(
     Ok(filter_path)
 }
 
+fn find_objcopy() -> Result<String, Box<dyn Error>> {
+    for objcopy_name in &["objcopy", "gobjcopy"] {
+        if which::which(objcopy_name).is_ok() {
+            return Ok(objcopy_name.to_string());
+        }
+    }
+
+    let brew_gobjcopy = "/usr/local/opt/binutils/bin/gobjcopy";
+    if Path::new(brew_gobjcopy).exists() {
+        return Ok(brew_gobjcopy.to_owned());
+    }
+
+    Err(From::from("Unable to find `objcopy` or `gobjcopy` on your system, please install binutils and update your PATH"))
+}
+
 fn filter_symbols(object_path: &Path, filter_list_path: &Path) -> Result<(), Box<dyn Error>> {
     let args = vec![
         OsString::from("--localize-symbols"),
         filter_list_path.as_os_str().to_owned(),
         object_path.as_os_str().to_owned(),
     ];
-    Command::new("llvm-objcopy")
+    Command::new(find_objcopy()?)
         .args(args)
         .status()
-        .expect("Failed to filter symbols with `llvm-objcopy`");
+        .expect("Failed to filter symbols with objcopy");
 
     Ok(())
 }
 
-pub fn merge<T: Write>(
-    mut output: Builder<T>,
+pub fn merge(
+    mut output: impl ArBuilder,
     objects: ObjectTempDir,
-    keep_regexes: Vec<String>,
+    mut keep_regexes: Vec<String>,
     verbose: bool,
 ) -> Result<(), Box<dyn Error>> {
     let merged_name = "merged.o";
     let mut merged_path = objects.dir.path().to_owned();
     merged_path.push(merged_name);
 
+    // When filtering symbols to keep just the public API visible,
+    // we must make an exception for the personality routines (if linked statically)
+    keep_regexes.push("_?__g.._personality_.*".into());
+
     let keep_regexes = keep_regexes
         .into_iter()
         .map(|r| Regex::new(&r))
@@ -203,17 +221,8 @@ pub fn merge<T: Write>(
     let filter_path = create_filter_list(&merged_path, &keep_regexes, verbose)?;
     filter_symbols(&merged_path, &filter_path)?;
 
-    let obj = File::open(&merged_path)?;
-    let header = Header::new(
-        merged_path
-            .file_name()
-            .unwrap()
-            .to_string_lossy()
-            .as_bytes()
-            .to_vec(),
-        obj.metadata()?.len(),
-    );
-    output.append(&header, &obj)?;
+    output.append_obj(merged_path)?;
+    output.close()?;
 
     Ok(())
 }