Handle archived dylibs on AIX

In recent Rust versions, the dylib format for AIX
has changed to reflect that shared libraries on
AIX are normal archived, in the Big archive format.
See rust-lang/rust#132362.

However, Python wheels on the platforms still use
un-archived shared objects, so this change updates
module_writer to unarchive the archived dylib
before we copy it over to the wheel.

Author: daltenty

src/module_writer.rs

@@ -793,6 +793,32 @@ fn handle_cffi_call_result(
     }
 }
 
+// Extract the shared object from a AIX big library archive
+fn unpack_big_archive(
+    target: &Target,
+    artifact: &Path,
+    temp_dir_path: &Path,
+) -> Result<PathBuf> {
+    // Newer rust generates archived dylibs on AIX, as shared
+    // libraries are typically archived on the platform.
+    if target.cross_compiling() {
+        bail!("can't unpack big archive format while cross_compiling")
+    }
+    debug!("Unpacking archive {}", artifact.display());
+    let mut ar_command = Command::new("ar");
+    ar_command
+        .current_dir(temp_dir_path)
+        .arg("-X64")
+        .arg("x")
+        .arg(artifact);
+    let status = ar_command.status().expect("Failed to run ar");
+    if !status.success() {
+        bail!(r#"ar finished with "{}": `{:?}`"#, status, ar_command,)
+    }
+    let unpacked_artifact = temp_dir_path.join(artifact.with_extension("so").file_name().unwrap());
+    Ok(unpacked_artifact)
+}
+
 /// Copies the shared library into the module, which is the only extra file needed with bindings
 #[allow(clippy::too_many_arguments)]
 #[instrument(skip_all)]
@@ -825,23 +851,32 @@ pub fn write_bindings_module(
         python_interpreter.get_library_name(ext_name)
     };
 
+    let artifact_is_big_ar = target.is_aix() && artifact.extension().unwrap_or(OsStr::new(" ")) == OsStr::new("a");
+    let temp_dir= if artifact_is_big_ar { Some(tempfile::tempdir()?)} else {None};
+    let artifact_buff = if artifact_is_big_ar { Some(unpack_big_archive(target, artifact, temp_dir.as_ref().unwrap().path())?) } else { None };
+    let artifact = if artifact_is_big_ar { artifact_buff.as_ref().unwrap() } else { artifact };
+
     if !editable {
         write_python_part(writer, project_layout, pyproject_toml)
             .context("Failed to add the python module to the package")?;
     }
     if let Some(python_module) = &project_layout.python_module {
         if editable {
-            let target = project_layout.rust_module.join(&so_filename);
+            let target_file = project_layout.rust_module.join(&so_filename);
             // Remove existing so file to avoid triggering SIGSEV in running process
             // See https://github.com/PyO3/maturin/issues/758
-            debug!("Removing {}", target.display());
-            let _ = fs::remove_file(&target);
+            debug!("Removing {}", target_file.display());
+            let _ = fs::remove_file(&target_file);
 
-            debug!("Copying {} to {}", artifact.display(), target.display());
-            fs::copy(artifact, &target).context(format!(
+            debug!(
+                "Copying {} to {}",
+                artifact.display(),
+                target_file.display()
+            );
+            fs::copy(artifact, &target_file).context(format!(
                 "Failed to copy {} to {}",
                 artifact.display(),
-                target.display()
+                target_file.display()
             ))?;
         } else {
             let relative = project_layout

src/target.rs

@@ -616,6 +616,12 @@ impl Target {
         self.os == Os::Hurd
     }
 
+    /// Returns true if we're building a binary for AIX
+    #[inline]
+    pub fn is_aix(&self) -> bool {
+        self.os == Os::Aix
+    }
+
     /// Returns true if the current platform's target env is Musl
     #[inline]
     pub fn is_musl_libc(&self) -> bool {