wip: macos compilation

.github/workflows/cargo_build.yml

@@ -20,6 +20,12 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
+    - name: Install LLVM (for llvm-copy)
+      if: matrix.platform == 'macos-latest'
+      run: |
+        brew update
+        brew install llvm@17
+        echo "$(brew --prefix llvm@17)/bin" >> $GITHUB_PATH
     - name: Update submodules
       run: git submodule update --init --recursive
     - name: Build

crates/whisper_cpp_sys/build.rs

@@ -1,7 +1,5 @@
-use std::{env, fs};
 use std::path::PathBuf;
-#[cfg(feature = "compat")]
-use std::process::Command;
+use std::{env, fs};
 
 // TODO add feature compatibility checks
 
@@ -74,16 +72,24 @@ fn main() {
 
     #[cfg(feature = "compat")]
     {
+        compat::redefine_symbols(out_path);
+    }
+}
+
+#[cfg(feature = "compat")]
+mod compat {
+    use std::path::Path;
+    use std::process::Command;
+
+    pub fn redefine_symbols(out_path: impl AsRef<Path>) {
         // TODO this whole section is a bit hacky, could probably clean it up a bit, particularly the retrieval of symbols from the library files
+        // TODO do this for cuda if necessary
 
-        let (whisper_lib_name, nm_name, objcopy_name) =
-            if cfg!(target_os = "linux") || cfg!(target_os = "macos") {
-                ("libwhisper.a", "nm", "objcopy")
-            } else {
-                ("whisper.lib", "llvm-nm", "llvm-objcopy")
-            };
+        let whisper_lib_name = lib_name();
+        let (nm_name, objcopy_name) = tool_names();
+        println!("Modifying {whisper_lib_name}, symbols acquired via \"{nm_name}\" and modified via \"{objcopy_name}\"");
 
-        let lib_path = out_path.join("lib").join("static");
+        let lib_path = out_path.as_ref().join("lib").join("static");
 
         // Modifying symbols exposed by the ggml library
 
@@ -142,45 +148,113 @@ fn main() {
             );
         }
     }
-}
 
-#[cfg(feature = "compat")]
-struct Filter<'a> {
-    prefix: &'a str,
-    sym_type: char,
-}
+    /// Returns *Whisper.cpp*'s compiled library name, based on the operating system.
+    fn lib_name() -> &'static str {
+        if cfg!(target_family = "windows") {
+            "whisper.lib"
+        } else if cfg!(target_family = "unix") {
+            "libwhisper.a"
+        } else {
+            println!("cargo:warning=Unknown target family, defaulting to Unix lib names");
+            "libwhisper.a"
+        }
+    }
 
-/// Helper function to turn **`nm`**'s output into an iterator of [`str`] symbols.
-///
-/// This function expects **`nm`** to be called using the **`-p`** and **`-P`** flags.
-#[cfg(feature = "compat")]
-fn get_symbols<'a, const N: usize>(
-    nm_output: &'a str,
-    filters: [Filter<'a>; N],
-) -> impl Iterator<Item=&'a str> + 'a {
-    nm_output
-        .lines()
-        .map(|symbol| {
-            // Strip irrelevant information
-
-            let mut stripped = symbol;
-            while stripped.split(' ').count() > 2 {
-                let idx = unsafe { stripped.rfind(' ').unwrap_unchecked() };
-                stripped = &stripped[..idx]
+    /// Returns the names of tools equivalent to [nm][nm] and [objcopy][objcopy].
+    ///
+    /// [nm]: https://www.man7.org/linux/man-pages/man1/nm.1.html
+    /// [objcopy]: https://www.man7.org/linux/man-pages/man1/objcopy.1.html
+    fn tool_names() -> (&'static str, &'static str) {
+        let nm_names;
+        let objcopy_names;
+        if cfg!(target_family = "unix") {
+            nm_names = vec!["nm", "llvm-nm"];
+            objcopy_names = vec!["objcopy", "llvm-objcopy"];
+        } else {
+            nm_names = vec!["llvm-nm"];
+            objcopy_names = vec!["llvm-objcopy"];
+        }
+
+        let nm_name;
+
+        if let Some(path) = option_env!("NM_PATH") {
+            nm_name = path;
+        } else {
+            println!("Looking for \"nm\" or an equivalent tool");
+            nm_name = find_tool(&nm_names).expect(
+                "No suitable tool equivalent to \"nm\" has been found in \
+            PATH, if one is already installed, either add it to PATH or set NM_PATH to its full path",
+            );
+        }
+
+        let objcopy_name;
+        if let Some(path) = option_env!("OBJCOPY_PATH") {
+            objcopy_name = path;
+        } else {
+            println!("Looking for \"objcopy\" or an equivalent tool");
+            objcopy_name = find_tool(&objcopy_names).expect("No suitable tool equivalent to \"objcopy\" has \
+            been found in PATH, if one is already installed, either add it to PATH or set OBJCOPY_PATH to its full path");
+        }
+
+        (nm_name, objcopy_name)
+    }
+
+    /// Returns the first tool found in the system, given a list of tool names, returning the first one found and
+    /// printing its version.
+    ///
+    /// Returns [`Option::None`] if no tool is found.
+    fn find_tool<'a>(names: &[&'a str]) -> Option<&'a str> {
+        for name in names {
+            if let Ok(output) = Command::new(name).arg("--version").output() {
+                if output.status.success() {
+                    let out_str = String::from_utf8_lossy(&output.stdout);
+                    println!("Valid \"tool\" found:\n{out_str}");
+                    return Some(name);
+                }
             }
-            stripped
-        })
-        .filter(move |symbol| {
-            // Filter matching symbols
-
-            if symbol.split(' ').count() == 2 {
-                for filter in &filters {
-                    if symbol.ends_with(filter.sym_type) && symbol.starts_with(filter.prefix) {
-                        return true;
+        }
+
+        None
+    }
+
+    /// A filter for a symbol in a library.
+    struct Filter<'a> {
+        prefix: &'a str,
+        sym_type: char,
+    }
+
+    /// Turns **`nm`**'s output into an iterator of [`str`] symbols.
+    ///
+    /// This function expects **`nm`** to be called using the **`-p`** and **`-P`** flags.
+    fn get_symbols<'a, const N: usize>(
+        nm_output: &'a str,
+        filters: [Filter<'a>; N],
+    ) -> impl Iterator<Item = &'a str> + 'a {
+        nm_output
+            .lines()
+            .map(|symbol| {
+                // Strip irrelevant information
+
+                let mut stripped = symbol;
+                while stripped.split(' ').count() > 2 {
+                    let idx = unsafe { stripped.rfind(' ').unwrap_unchecked() };
+                    stripped = &stripped[..idx]
+                }
+                stripped
+            })
+            .filter(move |symbol| {
+                // Filter matching symbols
+
+                if symbol.split(' ').count() == 2 {
+                    for filter in &filters {
+                        if symbol.ends_with(filter.sym_type) && symbol.starts_with(filter.prefix) {
+                            return true;
+                        }
                     }
                 }
-            }
-            false
-        })
-        .map(|symbol| &symbol[..symbol.len() - 2]) // Strip the type, so only the symbol remains
+                false
+            })
+            .map(|symbol| &symbol[..symbol.len() - 2]) // Strip the type, so only the symbol remains
+    }
 }