Add --target flag for AOT: macos-arm64 and macos-x86_64 alongside ios-arm64

Each invocation emits a thin Mach-O for one architecture; combine the
outputs with `lipo -create` to produce a fat universal object (the
pattern build-xcframework.sh already uses).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: wtholliday

cli/src/main.rs

@@ -56,15 +56,21 @@ struct Args {
     #[clap(long)]
     entry: Option<String>,
 
-    /// Ahead-of-time compile to an arm64-apple-ios Mach-O object file at the
-    /// given path. A companion `.h` is written next to it. Requires the
-    /// `llvm` feature and implies `--no-recursion`.
+    /// Ahead-of-time compile to a Mach-O object file at the given path. A
+    /// companion `.h` is written next to it. Requires the `llvm` feature and
+    /// implies `--no-recursion`. Combine outputs from multiple `--target`
+    /// runs with `lipo -create` to produce a fat universal object.
     #[clap(long)]
     aot: Option<String>,
 
     /// Symbol prefix for AOT outputs. Defaults to the stem of the --aot path.
     #[clap(long)]
     aot_prefix: Option<String>,
+
+    /// Target for `--aot`. One of: `ios-arm64` (default), `macos-arm64`,
+    /// `macos-x86_64`.
+    #[clap(long, default_value = "ios-arm64")]
+    target: String,
 }
 
 fn run(args: Args) -> i32 {
@@ -182,7 +188,12 @@ fn run(args: Args) -> i32 {
     #[cfg(feature = "llvm")]
     {
         if let Some(out) = args.aot.as_deref() {
-            return run_aot(&mut compiler, out, args.aot_prefix.as_deref());
+            return run_aot(
+                &mut compiler,
+                out,
+                args.aot_prefix.as_deref(),
+                &args.target,
+            );
         }
     }
     #[cfg(not(feature = "llvm"))]
@@ -422,6 +433,7 @@ fn run_aot(
     compiler: &mut lyte::Compiler,
     output: &str,
     prefix_override: Option<&str>,
+    target_str: &str,
 ) -> i32 {
     if !compiler.no_recursion {
         eprintln!("--aot requires --no-recursion");
@@ -431,6 +443,13 @@ fn run_aot(
         eprintln!("--aot: no declarations to compile");
         return 1;
     }
+    let target = match lyte::llvm_aot::AotTarget::parse(target_str) {
+        Ok(t) => t,
+        Err(e) => {
+            eprintln!("{}", e);
+            return 1;
+        }
+    };
     if let Err(e) = compiler.specialize() {
         eprintln!("{}", e);
         return 1;
@@ -448,7 +467,7 @@ fn run_aot(
         eprintln!("--aot: prefix is empty (use --aot-prefix to override)");
         return 1;
     }
-    match compiler.compile_aot(&path, &prefix) {
+    match compiler.compile_aot(&path, &prefix, target) {
         Ok(()) => 0,
         Err(e) => {
             eprintln!("{}", e);

cli/tests/cli.rs

@@ -171,3 +171,35 @@ fn contains_substr(haystack: &[u8], needle: &[u8]) -> bool {
         .windows(needle.len())
         .any(|w| w == needle)
 }
+
+#[test]
+#[cfg(feature = "llvm")]
+fn aot_target_macos_x86_64_emits_x86_object() {
+    use std::io::Write;
+    let tmp = std::env::temp_dir().join("lyte_aot_x86");
+    let _ = std::fs::remove_dir_all(&tmp);
+    std::fs::create_dir_all(&tmp).unwrap();
+    let src = tmp.join("sx.lyte");
+    let mut f = std::fs::File::create(&src).unwrap();
+    writeln!(f, "go(x: f32) -> f32 {{ return x * x }}").unwrap();
+    drop(f);
+    let out_o = tmp.join("sx.o");
+    let status = std::process::Command::new(LYTE_BIN)
+        .arg(&src)
+        .arg("--no-recursion")
+        .arg("--entry")
+        .arg("go")
+        .arg("--target")
+        .arg("macos-x86_64")
+        .arg("--aot")
+        .arg(&out_o)
+        .status()
+        .expect("failed to invoke lyte");
+    assert!(status.success(), "--aot exited with {}", status);
+    // Mach-O 64-bit x86_64: same magic 0xfeedfacf, cputype 0x01000007.
+    let bytes = std::fs::read(&out_o).expect("read .o");
+    let magic = u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);
+    let cputype = u32::from_le_bytes([bytes[4], bytes[5], bytes[6], bytes[7]]);
+    assert_eq!(magic, 0xfeed_facf);
+    assert_eq!(cputype, 0x0100_0007, "expected x86_64 cputype (got {:#x})", cputype);
+}

src/compiler.rs

@@ -768,17 +768,20 @@ impl Compiler {
         }
     }
 
-    /// Ahead-of-time compile to an `arm64-apple-ios` Mach-O object file and
-    /// write a companion C header. Output paths are derived from
-    /// `output_path` (e.g. `path/biquad.o` → `path/biquad.h`).
+    /// Ahead-of-time compile to a Mach-O object file for `target` and write
+    /// a companion C header. Output paths are derived from `output_path`
+    /// (e.g. `path/biquad.o` → `path/biquad.h`).
     ///
     /// `prefix` is applied to every externally-visible symbol so multiple
     /// AOT objects can be linked into the same binary without collisions.
+    /// For a fat universal object, run once per target and combine the
+    /// resulting thin objects with `lipo -create`.
     #[cfg(feature = "llvm")]
     pub fn compile_aot(
         &self,
         output_path: &std::path::Path,
         prefix: &str,
+        target: crate::llvm_aot::AotTarget,
     ) -> Result<(), String> {
         if self.decls.decls.is_empty() {
             return Err("No declarations to compile".into());
@@ -795,6 +798,7 @@ impl Compiler {
             &entry_points,
             output_path,
             prefix,
+            target,
             self.print_ir,
         )
     }

src/llvm_aot.rs

@@ -78,34 +78,86 @@ pub struct AotEntry {
     pub returns_via_ptr: bool,
 }
 
-/// Compile entry points to a Mach-O arm64 object file and write a companion
-/// `.h` header. Output paths are derived from `output_path` (e.g. for
-/// `path/to/biquad.o` we also write `path/to/biquad.h`).
+/// Apple platform target for AOT compile. Each produces a thin Mach-O object
+/// for one architecture; combine multiple outputs with `lipo -create` if a fat
+/// universal object is needed (matches the pattern in build-xcframework.sh).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AotTarget {
+    IosArm64,
+    MacosArm64,
+    MacosX86_64,
+}
+
+impl AotTarget {
+    /// Parse a CLI-style identifier. Accepts ios-arm64, macos-arm64,
+    /// macos-x86_64 (and aliases macos-x64, macos-intel).
+    pub fn parse(s: &str) -> Result<Self, String> {
+        match s {
+            "ios-arm64" => Ok(Self::IosArm64),
+            "macos-arm64" => Ok(Self::MacosArm64),
+            "macos-x86_64" | "macos-x64" | "macos-intel" => Ok(Self::MacosX86_64),
+            other => Err(format!(
+                "unknown --target '{}'. Expected one of: ios-arm64, macos-arm64, macos-x86_64",
+                other
+            )),
+        }
+    }
+
+    fn triple(self) -> &'static str {
+        match self {
+            // iOS deployment target matches build-xcframework.sh.
+            Self::IosArm64 => "arm64-apple-ios16.0",
+            // macOS deployment target matches build-xcframework.sh (15.0).
+            Self::MacosArm64 => "arm64-apple-macosx15.0",
+            Self::MacosX86_64 => "x86_64-apple-macosx15.0",
+        }
+    }
+
+    fn cpu(self) -> &'static str {
+        match self {
+            // apple-a12 covers every iPhone since the XS / Apple silicon Macs.
+            Self::IosArm64 | Self::MacosArm64 => "apple-a12",
+            // macOS requires x86-64-v2 (Haswell) at minimum.
+            Self::MacosX86_64 => "x86-64",
+        }
+    }
+}
+
+/// Compile entry points to a Mach-O object file for `target` and write a
+/// companion `.h` header. Output paths are derived from `output_path`
+/// (e.g. for `path/to/biquad.o` we also write `path/to/biquad.h`).
 pub fn compile_aot(
     decls: &DeclTable,
     entry_points: &[Name],
     output_path: &Path,
     prefix: &str,
+    target: AotTarget,
     print_ir: bool,
 ) -> Result<(), String> {
-    // Set up the iOS target machine. Must initialize AArch64 specifically;
-    // `Target::initialize_native` only sets up the host arch, which on x86_64
-    // hosts wouldn't be enough.
-    Target::initialize_aarch64(&InitializationConfig::default());
+    // Initialize the LLVM backend for this target. We do this rather than
+    // `initialize_native` because the host arch may not match the AOT target.
+    match target {
+        AotTarget::IosArm64 | AotTarget::MacosArm64 => {
+            Target::initialize_aarch64(&InitializationConfig::default());
+        }
+        AotTarget::MacosX86_64 => {
+            Target::initialize_x86(&InitializationConfig::default());
+        }
+    }
 
-    let triple = inkwell::targets::TargetTriple::create("arm64-apple-ios16.0");
-    let target =
+    let triple = inkwell::targets::TargetTriple::create(target.triple());
+    let llvm_target =
         Target::from_triple(&triple).map_err(|e| format!("LLVM target from triple: {}", e))?;
-    let machine = target
+    let machine = llvm_target
         .create_target_machine(
             &triple,
-            "apple-a12",
+            target.cpu(),
             "",
             OptimizationLevel::Aggressive,
             RelocMode::PIC,
             CodeModel::Default,
         )
-        .ok_or("failed to create AArch64 target machine")?;
+        .ok_or_else(|| format!("failed to create target machine for {:?}", target))?;
 
     let context = Context::create();
     let (mut state, _build_elapsed) = build_module(
@@ -171,7 +223,12 @@ pub fn compile_aot(
 
     // Header lives next to the object file, with the same stem.
     let header_path = output_path.with_extension("h");
-    let header = build_header(prefix, &entries, &collect_globals(decls, state.globals_size));
+    let header = build_header(
+        prefix,
+        &entries,
+        &collect_globals(decls, state.globals_size),
+        target,
+    );
     std::fs::write(&header_path, header)
         .map_err(|e| format!("write header {}: {}", header_path.display(), e))?;
 
@@ -567,12 +624,18 @@ fn set_internal_linkage(state: &mut LLVMJITState<'_>, public_names: &HashSet<Str
 
 // ─── Header generation ────────────────────────────────────────────────────────
 
-fn build_header(prefix: &str, entries: &[AotEntry], globals: &AotGlobalsLayout) -> String {
+fn build_header(
+    prefix: &str,
+    entries: &[AotEntry],
+    globals: &AotGlobalsLayout,
+    target: AotTarget,
+) -> String {
     let upper = prefix.to_uppercase();
     let mut s = String::new();
     use std::fmt::Write;
 
     let _ = writeln!(s, "// Generated by the lyte AOT backend. Do not edit.");
+    let _ = writeln!(s, "// Target: {} ({})", target.triple(), target.cpu());
     let _ = writeln!(s, "//");
     let _ = writeln!(
         s,