ci: run macos in CI

.github/workflows/ci.yml

@@ -7,27 +7,42 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
-  LLVM_VERSION: "17.0"
+  LLVM_VERSION: "17"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
 
 jobs:
   test:
-    name: test +${{ matrix.toolchain }} ${{ matrix.profile }}
-    runs-on: ubuntu-latest
+    name: test +${{ matrix.runner }}-${{ matrix.arch }}-${{ matrix.toolchain }} ${{ matrix.profile }}
+    runs-on: ${{ matrix.runner }}
     timeout-minutes: 30
     strategy:
       fail-fast: false
       matrix:
+        runner: ["ubuntu-latest", "macos-14"]
+        arch: ["x64", "arm64"]
         toolchain: ["stable", "nightly"]
         profile: ["dev", "release"]
+        exclude:
+          - runner: "ubuntu-latest"
+            arch: "arm64"
+          - runner: "macos-14"
+            arch: "x64"
     steps:
       - uses: actions/checkout@v4
-      - uses: KyleMayes/install-llvm-action@v1
+      - uses: KyleMayes/[email protected]
+        if: ${{ !contains(matrix.runner, 'macos') }}
         with:
           version: ${{ env.LLVM_VERSION }}
+      - name: Install LLVM
+        if: ${{ contains(matrix.runner, 'macos') }}
+        run: |
+          v=${{ env.LLVM_VERSION }}
+          brew install "llvm@${v}"
+          echo "LLVM_SYS_${v}0_PREFIX=$(brew --prefix llvm@${v})" >> $GITHUB_ENV
+          echo "/opt/homebrew/opt/llvm@${v}/bin" >> $GITHUB_PATH
       - name: llvm-config
         run: llvm-config --version --bindir --libdir
       - uses: dtolnay/rust-toolchain@master
@@ -37,14 +52,14 @@ jobs:
         with:
           cache-on-failure: true
       - name: test
-        run: cargo test --all-features --workspace --verbose --profile ${{ matrix.profile }}
+        run: cargo test --all-features --workspace --profile ${{ matrix.profile }}
 
   feature-checks:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
-      - uses: KyleMayes/install-llvm-action@v1
+      - uses: KyleMayes/install-llvm-action@v2.0.2
         with:
           version: ${{ env.LLVM_VERSION }}
       - uses: dtolnay/rust-toolchain@stable
@@ -61,7 +76,7 @@ jobs:
     timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
-      - uses: KyleMayes/install-llvm-action@v1
+      - uses: KyleMayes/install-llvm-action@v2.0.2
         with:
           version: ${{ env.LLVM_VERSION }}
       - uses: dtolnay/rust-toolchain@clippy
@@ -77,7 +92,7 @@ jobs:
     timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
-      - uses: KyleMayes/install-llvm-action@v1
+      - uses: KyleMayes/install-llvm-action@v2.0.2
         with:
           version: ${{ env.LLVM_VERSION }}
       - uses: dtolnay/rust-toolchain@nightly

README.md

@@ -5,9 +5,12 @@ Experimental [JIT] and [AOT] compiler for the [Ethereum Virtual Machine][EVM].
 The compiler implementation is abstracted over an intermediate representation backend.
 
 This repository hosts two backend implementations:
+
 - [LLVM] ([`revm-jit-llvm`]): main backend with full test coverage;
 - [Cranelift] ([`revm-jit-cranelift`]); currently not functional due to missing `i256` support in Cranelift. This will likely require a custom fork of Cranelift.
 
+Compiling the crate requires LLVM 17.
+
 [JIT]: https://en.wikipedia.org/wiki/Just-in-time_compilation
 [AOT]: https://en.wikipedia.org/wiki/Ahead-of-time_compilation
 [EVM]: https://ethereum.org/en/developers/docs/evm/

crates/revm-jit/src/linker.rs

@@ -4,6 +4,7 @@ use std::path::{Path, PathBuf};
 #[derive(Debug)]
 pub struct Linker {
     cc: Option<PathBuf>,
+    linker: Option<PathBuf>,
     cflags: Vec<String>,
 }
 
@@ -16,14 +17,19 @@ impl Default for Linker {
 impl Linker {
     /// Creates a new linker.
     pub fn new() -> Self {
-        Self { cc: None, cflags: vec![] }
+        Self { cc: None, linker: None, cflags: vec![] }
     }
 
-    /// Sets the C compiler to use for linking.
+    /// Sets the C compiler to use for linking. Default: "cc".
     pub fn cc(&mut self, cc: Option<PathBuf>) {
         self.cc = cc;
     }
 
+    /// Sets the linker to use for linking. Default: `lld`.
+    pub fn linker(&mut self, linker: Option<PathBuf>) {
+        self.linker = linker;
+    }
+
     /// Sets the C compiler flags to use for linking.
     pub fn cflags(&mut self, cflags: impl IntoIterator<Item = impl Into<String>>) {
         self.cflags.extend(cflags.into_iter().map(Into::into));
@@ -62,11 +68,16 @@ impl Linker {
         cmd.arg("-o").arg(out);
         cmd.arg("-shared");
         cmd.arg("-O3");
-        if !cfg!(debug_assertions) {
-            cmd.arg("-Wl,--gc-sections");
-            cmd.arg("-Wl,--strip-all");
+        if let Some(linker) = &self.linker {
+            cmd.arg(format!("-fuse-ld={}", linker.display()));
+        } else {
+            cmd.arg("-fuse-ld=lld");
+        }
+        if cfg!(target_vendor = "apple") {
+            cmd.arg("-Wl,-dead_strip,-undefined,dynamic_lookup");
+        } else {
+            cmd.arg("-Wl,--gc-sections,--strip-all,--undefined");
         }
-        cmd.arg("-Wl,-undefined");
         cmd.args(&self.cflags);
         cmd.args(objects);
         debug!(cmd=?cmd.get_program(), "linking");
@@ -112,10 +123,32 @@ mod tests {
         assert!(obj.exists());
 
         // Link object to shared library.
-        let linker = Linker::new();
-        if let Err(e) = linker.link(&so, [&obj]) {
-            panic!("failed to link: {e}");
+        let mut linker = Linker::new();
+        let mut n = 0;
+        for driver in ["cc", "gcc", "clang"] {
+            if !command_v(driver) {
+                continue;
+            }
+            n += 1;
+
+            let _ = std::fs::remove_file(&so);
+            linker.cc = Some(driver.into());
+            if let Err(e) = linker.link(&so, [&obj]) {
+                panic!("failed to link with {driver}: {e}");
+            }
+            assert!(so.exists());
+        }
+        assert!(n > 0, "no C compiler found");
+    }
+
+    fn command_v(cmd: &str) -> bool {
+        let Ok(output) = std::process::Command::new(cmd).arg("--version").output() else {
+            return false;
+        };
+        if !output.status.success() {
+            eprintln!("command {cmd} failed: {output:#?}");
+            return false;
         }
-        assert!(so.exists());
+        true
     }
 }