Add support for repairing cross compiled linux wheels

Author: messense

Cargo.lock

@@ -58,6 +58,7 @@ dialoguer = "0.9.0"
 console = "0.15.0"
 minijinja = "0.8.2"
 lddtree = "0.2.0"
+cc = "1.0.72"
 
 [dev-dependencies]
 indoc = "1.0.3"

Cargo.toml

@@ -10,9 +10,9 @@ use std::path::{Path, PathBuf};
 pub fn get_external_libs(
     artifact: impl AsRef<Path>,
     policy: &Policy,
+    sysroot: PathBuf,
 ) -> Result<Vec<lddtree::Library>, AuditWheelError> {
-    let root = PathBuf::from("/");
-    let dep_analyzer = DependencyAnalyzer::new(root);
+    let dep_analyzer = DependencyAnalyzer::new(sysroot);
     let deps = dep_analyzer.analyze(artifact).unwrap();
     let mut ext_libs = Vec::new();
     for (name, lib) in deps.libraries {

src/auditwheel/repair.rs

@@ -15,6 +15,7 @@ use lddtree::Library;
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
 
 /// The way the rust code is used in the wheel
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -272,7 +273,8 @@ impl BuildContext {
                 }
             })?;
         let external_libs = if should_repair && !self.editable {
-            get_external_libs(&artifact, &policy).with_context(|| {
+            let sysroot = get_sysroot_path(&self.target)?;
+            get_external_libs(&artifact, &policy, sysroot).with_context(|| {
                 if let Some(platform_tag) = platform_tag {
                     format!("Error repairing wheel for {} compliance", platform_tag)
                 } else {
@@ -685,6 +687,50 @@ fn relpath(to: &Path, from: &Path) -> PathBuf {
     result
 }
 
+/// Get sysroot path from target C compiler
+///
+/// Currently only gcc is supported, clang doesn't have a `--print-sysroot` option
+/// TODO: allow specify sysroot from environment variable?
+fn get_sysroot_path(target: &Target) -> Result<PathBuf> {
+    use crate::target::get_host_target;
+
+    let host_triple = get_host_target()?;
+    let target_triple = target.target_triple();
+    if host_triple != target_triple {
+        let mut build = cc::Build::new();
+        build
+            // Suppress cargo metadata for example env vars printing
+            .cargo_metadata(false)
+            // opt_level, host and target are required
+            .opt_level(0)
+            .host(&host_triple)
+            .target(target_triple);
+        let compiler = build
+            .try_get_compiler()
+            .with_context(|| format!("Failed to get compiler for {}", target_triple))?;
+        let path = compiler.path();
+        let out = Command::new(path)
+            .arg("--print-sysroot")
+            .stdout(Stdio::piped())
+            .stderr(Stdio::null())
+            .output()
+            .with_context(|| format!("Failed to run `{} --print-sysroot`", path.display()))?;
+        if out.status.success() {
+            let sysroot = String::from_utf8(out.stdout)
+                .context("Failed to read the sysroot path")?
+                .trim()
+                .to_owned();
+            return Ok(PathBuf::from(sysroot));
+        } else {
+            bail!(
+                "Failed to get the sysroot path: {}",
+                String::from_utf8(out.stderr)?
+            );
+        }
+    }
+    Ok(PathBuf::from("/"))
+}
+
 #[cfg(test)]
 mod test {
     use super::relpath;