feat: Wire up LLVM AOT and JIT backends in CLI

darmie · darmie · commit 87a89768ab17 · 2025-11-25T14:45:41.000Z
- Add llvm-backend feature flag to zyntax_cli
- Implement compile_llvm() for AOT compilation to native executables
- Implement compile_and_run_llvm() for JIT execution
- Add LlvmJit backend variant for REPL support
- Use log:: macros instead of println/eprintln
- Provide clear error messages when LLVM feature is disabled

Backend options:
- jit, cranelift: Cranelift JIT (default)
- llvm, llvm-aot: LLVM AOT compilation
- llvm-jit: LLVM JIT execution

To enable LLVM: cargo build --release --features llvm-backend
diff --git a/crates/zyntax_cli/Cargo.toml b/crates/zyntax_cli/Cargo.toml
@@ -9,7 +9,7 @@ path = "src/main.rs"
 
 [dependencies]
 zyntax_typed_ast = { path = "../typed_ast" }
-zyntax_compiler = { path = "../compiler" }
+zyntax_compiler = { path = "../compiler", features = ["cranelift-backend"] }
 zyn_peg = { path = "../zyn_peg" }
 pest = "2.7"
 pest_derive = "2.7"
@@ -46,3 +46,11 @@ log = "0.4"
 # REPL
 rustyline = "14.0"
 dirs = "5.0"
+
+# LLVM backend (optional)
+inkwell = { version = "0.4", features = ["llvm17-0"], optional = true }
+
+[features]
+default = []
+llvm-backend = ["zyntax_compiler/llvm-backend", "inkwell"]
+all-backends = ["llvm-backend"]
diff --git a/crates/zyntax_cli/src/backends/llvm_aot.rs b/crates/zyntax_cli/src/backends/llvm_aot.rs
@@ -1,10 +1,129 @@
 //! LLVM AOT backend compilation
+//!
+//! Compiles HIR modules to native executables using LLVM's optimizing compiler.
+//! This backend produces highly optimized machine code suitable for production use.
 
 use colored::Colorize;
+use log::{debug, error, info};
 use std::path::PathBuf;
 use zyntax_compiler::hir::HirModule;
 
 /// Compile HIR module with LLVM AOT backend
+#[cfg(feature = "llvm-backend")]
+pub fn compile_llvm(
+    module: HirModule,
+    output: Option<PathBuf>,
+    opt_level: u8,
+    verbose: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    use inkwell::context::Context;
+    use inkwell::targets::{
+        CodeModel, FileType, InitializationConfig, RelocMode, Target, TargetMachine,
+    };
+    use inkwell::OptimizationLevel;
+    use zyntax_compiler::llvm_backend::LLVMBackend;
+
+    let output_path = output.unwrap_or_else(|| PathBuf::from("a.out"));
+
+    if verbose {
+        info!("Initializing LLVM backend...");
+    }
+
+    // Initialize LLVM targets
+    Target::initialize_native(&InitializationConfig::default())
+        .map_err(|e| format!("Failed to initialize LLVM target: {}", e))?;
+
+    // Create LLVM context and backend
+    let context = Context::create();
+    let mut backend = LLVMBackend::new(&context, "zyntax_aot");
+
+    if verbose {
+        info!("Compiling HIR to LLVM IR...");
+    }
+
+    // Compile HIR module to LLVM IR
+    let llvm_ir = backend
+        .compile_module(&module)
+        .map_err(|e| format!("Compilation failed: {}", e))?;
+
+    if verbose {
+        info!("Generated {} bytes of LLVM IR", llvm_ir.len());
+    }
+
+    // Get target triple for the host machine
+    let triple = TargetMachine::get_default_triple();
+    let target = Target::from_triple(&triple)
+        .map_err(|e| format!("Failed to get target: {}", e))?;
+
+    // Map optimization level
+    let llvm_opt = match opt_level {
+        0 => OptimizationLevel::None,
+        1 => OptimizationLevel::Less,
+        2 => OptimizationLevel::Default,
+        _ => OptimizationLevel::Aggressive,
+    };
+
+    if verbose {
+        info!(
+            "Target: {}, Optimization: {:?}",
+            triple.as_str().to_str().unwrap_or("unknown"),
+            llvm_opt
+        );
+    }
+
+    // Create target machine
+    let target_machine = target
+        .create_target_machine(
+            &triple,
+            "generic",
+            "",
+            llvm_opt,
+            RelocMode::Default,
+            CodeModel::Default,
+        )
+        .ok_or("Failed to create target machine")?;
+
+    // Write object file
+    let obj_path = output_path.with_extension("o");
+
+    if verbose {
+        info!("Writing object file to {:?}...", obj_path);
+    }
+
+    target_machine
+        .write_to_file(backend.module(), FileType::Object, &obj_path)
+        .map_err(|e| format!("Failed to write object file: {}", e))?;
+
+    // Link to create executable
+    if verbose {
+        info!("Linking executable...");
+    }
+
+    let status = std::process::Command::new("cc")
+        .arg(&obj_path)
+        .arg("-o")
+        .arg(&output_path)
+        .status()
+        .map_err(|e| format!("Failed to run linker: {}", e))?;
+
+    if !status.success() {
+        return Err(format!("Linker failed with status: {}", status).into());
+    }
+
+    // Clean up object file
+    let _ = std::fs::remove_file(&obj_path);
+
+    println!(
+        "{} Successfully compiled to {}",
+        "success:".green().bold(),
+        output_path.display()
+    );
+
+    Ok(())
+}
+
+/// Compile HIR module with LLVM AOT backend (stub when feature not enabled)
+#[cfg(not(feature = "llvm-backend"))]
 pub fn compile_llvm(
     _module: HirModule,
     output: Option<PathBuf>,
@@ -13,9 +132,129 @@ pub fn compile_llvm(
 ) -> Result<(), Box<dyn std::error::Error>> {
     let output_path = output.unwrap_or_else(|| PathBuf::from("a.out"));
 
-    // TODO: Implement LLVM backend compilation
-    eprintln!("{} LLVM backend not yet implemented", "error:".red());
-    eprintln!("Output would be: {}", output_path.display());
+    error!("LLVM backend not enabled");
+    error!("Rebuild with: cargo build --release --features llvm-backend");
+    debug!("Output would be: {}", output_path.display());
+
+    Err("LLVM backend not enabled. Rebuild with --features llvm-backend".into())
+}
+
+/// Compile and run with LLVM JIT backend
+#[cfg(feature = "llvm-backend")]
+pub fn compile_and_run_llvm(
+    module: HirModule,
+    opt_level: u8,
+    verbose: bool,
+) -> Result<i64, Box<dyn std::error::Error>> {
+    use inkwell::context::Context;
+    use inkwell::OptimizationLevel;
+    use zyntax_compiler::llvm_jit_backend::LLVMJitBackend;
+
+    if verbose {
+        info!("Initializing LLVM JIT backend...");
+    }
+
+    // Create LLVM context
+    let context = Context::create();
+
+    // Map optimization level
+    let llvm_opt = match opt_level {
+        0 => OptimizationLevel::None,
+        1 => OptimizationLevel::Less,
+        2 => OptimizationLevel::Default,
+        _ => OptimizationLevel::Aggressive,
+    };
+
+    // Create JIT backend
+    let mut backend = LLVMJitBackend::with_opt_level(&context, llvm_opt)
+        .map_err(|e| format!("Failed to create JIT backend: {}", e))?;
+
+    if verbose {
+        info!("Compiling module with LLVM JIT...");
+    }
+
+    // Compile module
+    backend
+        .compile_module(&module)
+        .map_err(|e| format!("JIT compilation failed: {}", e))?;
+
+    // Find main function
+    let (main_id, main_fn) = module
+        .functions
+        .iter()
+        .find(|(_, func)| {
+            func.name
+                .resolve_global()
+                .map(|name| name == "main")
+                .unwrap_or(false)
+        })
+        .ok_or("No 'main' function found in module")?;
+
+    let main_id = *main_id;
+
+    // Get function pointer
+    let fn_ptr = backend
+        .get_function_pointer(main_id)
+        .ok_or("Failed to get main function pointer")?;
+
+    if verbose {
+        debug!("Executing main() at {:?}...", fn_ptr);
+    }
+
+    // Execute main function
+    let result = unsafe {
+        if main_fn.signature.returns.is_empty() {
+            let f: fn() = std::mem::transmute(fn_ptr);
+            f();
+            0
+        } else {
+            match &main_fn.signature.returns[0] {
+                zyntax_compiler::hir::HirType::I32 => {
+                    let f: fn() -> i32 = std::mem::transmute(fn_ptr);
+                    f() as i64
+                }
+                zyntax_compiler::hir::HirType::I64 => {
+                    let f: fn() -> i64 = std::mem::transmute(fn_ptr);
+                    f()
+                }
+                zyntax_compiler::hir::HirType::F32 => {
+                    let f: fn() -> f32 = std::mem::transmute(fn_ptr);
+                    f() as i64
+                }
+                zyntax_compiler::hir::HirType::F64 => {
+                    let f: fn() -> f64 = std::mem::transmute(fn_ptr);
+                    f() as i64
+                }
+                zyntax_compiler::hir::HirType::Void => {
+                    let f: fn() = std::mem::transmute(fn_ptr);
+                    f();
+                    0
+                }
+                _ => {
+                    return Err(format!(
+                        "Unsupported return type: {:?}",
+                        main_fn.signature.returns[0]
+                    )
+                    .into());
+                }
+            }
+        }
+    };
+
+    println!("{} main() returned: {}", "result:".green().bold(), result);
+
+    Ok(result)
+}
+
+/// Compile and run with LLVM JIT backend (stub when feature not enabled)
+#[cfg(not(feature = "llvm-backend"))]
+pub fn compile_and_run_llvm(
+    _module: HirModule,
+    _opt_level: u8,
+    _verbose: bool,
+) -> Result<i64, Box<dyn std::error::Error>> {
+    error!("LLVM JIT backend not enabled");
+    error!("Rebuild with: cargo build --release --features llvm-backend");
 
-    Err("LLVM backend not implemented".into())
+    Err("LLVM backend not enabled. Rebuild with --features llvm-backend".into())
 }
diff --git a/crates/zyntax_cli/src/backends/mod.rs b/crates/zyntax_cli/src/backends/mod.rs
@@ -7,21 +7,23 @@ use std::path::PathBuf;
 use zyntax_compiler::hir::HirModule;
 
 pub use cranelift_jit::compile_jit;
-pub use llvm_aot::compile_llvm;
+pub use llvm_aot::{compile_llvm, compile_and_run_llvm};
 
 /// Backend type
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Backend {
     CraneliftJit,
     LlvmAot,
+    LlvmJit,
 }
 
 impl Backend {
     pub fn from_str(s: &str) -> Result<Self, Box<dyn std::error::Error>> {
         match s {
             "jit" | "cranelift" => Ok(Backend::CraneliftJit),
-            "llvm" | "aot" => Ok(Backend::LlvmAot),
-            _ => Err(format!("Unknown backend: {}", s).into()),
+            "llvm" | "aot" | "llvm-aot" => Ok(Backend::LlvmAot),
+            "llvm-jit" => Ok(Backend::LlvmJit),
+            _ => Err(format!("Unknown backend: {}. Use: jit, cranelift, llvm, llvm-aot, llvm-jit", s).into()),
         }
     }
 }
@@ -38,6 +40,14 @@ pub fn compile(
     match backend {
         Backend::CraneliftJit => compile_jit(module, opt_level, run, verbose),
         Backend::LlvmAot => compile_llvm(module, output, opt_level, verbose),
+        Backend::LlvmJit => {
+            if run {
+                compile_and_run_llvm(module, opt_level, verbose)?;
+                Ok(())
+            } else {
+                Err("LLVM JIT backend requires --run flag".into())
+            }
+        }
     }
 }
 
@@ -50,6 +60,7 @@ pub fn compile_and_run_repl(
 ) -> Result<i64, Box<dyn std::error::Error>> {
     match backend {
         Backend::CraneliftJit => cranelift_jit::compile_and_run_repl(module, opt_level, verbose),
-        Backend::LlvmAot => Err("LLVM backend does not support REPL mode".into()),
+        Backend::LlvmAot => Err("LLVM AOT backend does not support REPL mode. Use --backend llvm-jit".into()),
+        Backend::LlvmJit => compile_and_run_llvm(module, opt_level, verbose),
     }
 }
