Updated cross compile

Author: dipankar

.github/workflows/cross_compile.yml

@@ -0,0 +1,88 @@
+name: Cross-compile
+
+# Verifies every v1.9 cross-compile target produces a binary of the right
+# architecture / ABI. Uses `zig cc` for the backend and skips gracefully
+# if zig isn't on the runner (currently shouldn't happen — ubuntu-latest
+# installs zig in the first step).
+#
+# Matrix is single-OS (ubuntu-latest) because the cross-compile is by
+# definition target-OS-agnostic: we ask zig cc to emit the right format.
+# Running on macOS or Windows would test the same thing more slowly.
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+env:
+  CARGO_TERM_COLOR: always
+  RUST_BACKTRACE: 1
+
+jobs:
+  cross-compile:
+    name: Cross-compile (${{ matrix.triple }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        triple:
+          - aarch64-linux-musl
+          - x86_64-linux-musl
+          - aarch64-linux-gnu
+          - x86_64-linux-gnu
+          - aarch64-macos
+          - x86_64-macos
+          - wasm32-wasi
+          - riscv64-linux-musl
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: "1.85"
+
+      - name: Cache cargo
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-xc-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Install zig (cross-compile backend)
+        uses: mlugg/setup-zig@v2
+        with:
+          version: 0.13.0
+
+      - name: Build release fastc
+        run: cargo build --release -p fastc
+
+      - name: Verify backend available
+        run: ./target/release/fastc target check ${{ matrix.triple }}
+
+      - name: Cross-compile hello.fc
+        run: |
+          mkdir -p /tmp/xc/src
+          cp examples/hello.fc /tmp/xc/src/main.fc
+          cat > /tmp/xc/fastc.toml <<EOF
+          [package]
+          name = "hello_xc"
+          version = "0.1.0"
+          EOF
+          cd /tmp/xc && $GITHUB_WORKSPACE/target/release/fastc build --target=${{ matrix.triple }}
+
+      - name: Inspect output
+        run: |
+          if [ -f /tmp/xc/build/main.wasm ]; then
+            file /tmp/xc/build/main.wasm
+          else
+            file /tmp/xc/build/main
+          fi
+
+      - name: Run cross-compile integration test for this triple
+        run: cargo test -p fastc --test cross_compile --release

README.md

@@ -23,6 +23,7 @@ fastC is a modern C-like language for a world where most code is written by an A
 | Vendor-first deps (no central registry) | N/A | crates.io | Zon | modules | **✓** |
 | Sigstore / SLSA provenance | ✗ | ✗ | ✗ | ✗ | **scheduled** |
 | Stripped binary (hello) | 33 KB | 341 KB | 50 KB | 2.4 MB | **53 KB** |
+| Cross-compile, no sysroot setup | depends on toolchain | rustup per-target dance | ✓ (`zig cc`, 50+) | ✓ (`GOOS`/`GOARCH`) | **✓ (8 presets via `zig cc`, any C cross-toolchain via `--cc-override`)** |
 
 Each row has a paragraph of context at [docs.skelfresearch.com/fastc/why/rubric](https://docs.skelfresearch.com/fastc/why/rubric). The honest framing of which trade-offs fastC actually wins on (and which it loses) is in [docs/MANIFESTO.md](docs/MANIFESTO.md).
 
@@ -83,6 +84,8 @@ The scripts and golden data are in [`benchmarks/cross-lang/`](benchmarks/cross-l
 
 The [supply-chain side-by-side demo](examples/supply_chain_demo/) shows `cargo build` executing a malicious `build.rs` vs `fastc.toml` rejecting the same shape at parse time.
 
+**Cross-compile, one flag.** `fastc build --target=<triple>` ships eight pre-wired presets via `zig cc` (aarch64/x86_64 × linux-musl/linux-gnu, aarch64/x86_64-macos, wasm32-wasi, riscv64-linux-musl). One `brew install zig` and `fastc build --target=aarch64-linux-musl` produces a statically-linked ARM Linux binary, or `--target=wasm32-wasi` a `.wasm` for sandboxed runtimes. `--cc-override=<path>` swaps in a proprietary toolchain when needed. fastC emits portable C11, so any C cross-compiler in the world targets fastC binaries — we just default to the best one. See [docs/cross-compile.md](docs/cross-compile.md) and `fastc target list` for the live matrix.
+
 ## Quick Start
 
 ```bash

crates/fastc/src/build.rs

@@ -346,30 +346,50 @@ impl BuildContext {
 
     /// Compile the generated C code with a C compiler
     ///
-    /// Returns the path to the executable
+    /// `compiler_prefix_args` are inserted right after the compiler binary
+    /// and before the source file. Cross-compile uses this for `zig cc
+    /// --target=...` — `compiler="zig"`, `compiler_prefix_args=["cc",
+    /// "--target=aarch64-linux-musl"]`. The `output_ext` lets WASI targets
+    /// override the default empty extension with `.wasm`.
+    ///
+    /// Returns the path to the executable.
     pub fn cc_compile(
         &self,
         c_file: &Path,
         compiler: &str,
+        compiler_prefix_args: &[&str],
         cflags: &[&str],
         release: bool,
+        output_ext: &str,
     ) -> Result<PathBuf, BuildError> {
         let output_dir = c_file.parent().unwrap_or(Path::new("."));
         let base_name = c_file.file_stem().unwrap().to_string_lossy();
 
-        // Output executable name (add .exe on Windows)
-        #[cfg(windows)]
-        let exe_name = format!("{}.exe", base_name);
-        #[cfg(not(windows))]
-        let exe_name = base_name.to_string();
+        // Output executable name (add .exe on Windows when no explicit ext).
+        let exe_name = if !output_ext.is_empty() {
+            format!("{}{}", base_name, output_ext)
+        } else {
+            #[cfg(windows)]
+            {
+                format!("{}.exe", base_name)
+            }
+            #[cfg(not(windows))]
+            {
+                base_name.to_string()
+            }
+        };
 
         let executable = output_dir.join(&exe_name);
 
         eprintln!("Compiling C code with {}...", compiler);
 
-        // Build compiler arguments
-        let mut args: Vec<&str> =
-            vec![c_file.to_str().unwrap(), "-o", executable.to_str().unwrap()];
+        // Build compiler arguments. `compiler_prefix_args` first (e.g. zig's
+        // `cc` subcommand, --target flag), then the source file.
+        let mut args: Vec<&str> = Vec::new();
+        args.extend(compiler_prefix_args.iter().copied());
+        args.push(c_file.to_str().unwrap());
+        args.push("-o");
+        args.push(executable.to_str().unwrap());
 
         // Add runtime include path
         // Try to find the runtime directory relative to the executable or use env var

crates/fastc/src/lib.rs

@@ -23,6 +23,7 @@ pub mod parser;
 pub mod prelude;
 pub mod resolve;
 pub mod scaffold;
+pub mod targets;
 pub mod timing;
 pub mod typecheck;