type AotEntry = extern "C" fn(*mut fusevm::VM) -> i64;
static NATIVE_FNS: std::sync::OnceLock<Vec<AotEntry>> = std::sync::OnceLock::new();
pub fn register_native_fns(addrs: Vec<usize>) {
let fns: Vec<AotEntry> = addrs
.into_iter()
.map(|a| unsafe { std::mem::transmute::<usize, AotEntry>(a) })
.collect();
let _ = NATIVE_FNS.set(fns);
}
pub fn native_entry(native_id: u32) -> Option<AotEntry> {
if native_id == 0 {
return None;
}
let f = NATIVE_FNS.get()?.get((native_id - 1) as usize).copied();
if std::env::var_os("RUBYLANG_AOT_TRACE").is_some() {
eprintln!(
"[aot] dispatch native_id={native_id} -> {}",
if f.is_some() { "NATIVE" } else { "miss" }
);
}
f
}
pub fn build(file: &str) -> Result<String, String> {
let (stmts, report) = crate::bundle::bundle(std::path::Path::new(file))?;
let prog = crate::compiler::compile(&stmts, false)?;
let (nmethods, nprocs, nops) = (prog.methods.len(), prog.procs.len(), prog.main.ops.len());
let src = std::fs::read_to_string(file).map_err(|e| format!("cannot read {file}: {e}"))?;
let abs = std::fs::canonicalize(file)
.map_err(|e| format!("cannot read {file}: {e}"))?
.to_string_lossy()
.into_owned();
let mut deps = Vec::with_capacity(report.files.len());
for p in &report.files {
let fsrc =
std::fs::read_to_string(p).map_err(|e| format!("cannot read {}: {e}", p.display()))?;
deps.push((
p.to_string_lossy().into_owned(),
crate::cache::key_for(&fsrc),
));
}
crate::cache::store_bundle(&abs, &src, &prog, deps)?;
let nfiles = report.files.len();
let dynamic = if report.dynamic > 0 {
format!(", {} runtime require(s) left dynamic", report.dynamic)
} else {
String::new()
};
Ok(format!(
"built {file}: {nfiles} file(s) bundled, {nops} top-level ops, {nmethods} methods, {nprocs} blocks{dynamic} -> ~/.rubylang/scripts.rkyv"
))
}
pub fn run_embedded(script: &str, synth_base: u64) -> i32 {
let prog = embedded_program();
let argv: Vec<String> = std::env::args().skip(1).collect();
crate::host::reset_host();
let r = crate::host::with_gvl(|| {
seed_embedded_host();
crate::host::push_file_path(script.to_string());
crate::host::with_host(|h| h.set_program_args(&argv, script));
crate::seed_verbosity(&crate::RunConfig::default());
crate::compiler::advance_synth_ids(synth_base);
let crate::compiler::Program {
mut main,
methods,
classes,
begins,
procs,
} = prog;
crate::host::with_host(|h| h.load_program(methods, classes, begins, procs));
crate::run_prelude()?;
main.native_id = NATIVE_FNS.get().map_or(0, |f| f.len() as u32);
crate::end_program(crate::host::run_main(main))
});
use std::io::Write;
let _ = std::io::stdout().flush();
match r {
Ok(_) => 0,
Err(e) => {
eprintln!("{e}");
1
}
}
}
fn embedded_program() -> crate::compiler::Program {
extern "C" {
static rubylang_aot_program_blob: u8;
static rubylang_aot_program_len: u64;
}
let blob = unsafe {
let len = rubylang_aot_program_len as usize;
std::slice::from_raw_parts(&rubylang_aot_program_blob as *const u8, len)
};
crate::cache::program_from_blob(blob)
.unwrap_or_else(|e| panic!("aot: embedded program blob: {e}"))
}
fn seed_embedded_host() {
let cwd = std::env::current_dir().unwrap_or_default();
crate::host::with_host(|h| h.init_load_path(&cwd.to_string_lossy()));
crate::host::push_file_dir(cwd);
}
#[no_mangle]
pub unsafe extern "C" fn fusevm_aot_register_builtins(vm: *mut fusevm::VM) {
let vm = &mut *vm;
crate::builtins::install(vm);
vm.set_numeric_hook(std::sync::Arc::new(|op, a, b| {
crate::builtins::numeric_hook(op, a, b)
}));
crate::host::reset_host();
seed_embedded_host();
let prog = embedded_program();
let crate::compiler::Program {
main: _,
methods,
classes,
begins,
procs,
} = prog;
crate::host::with_host(|h| h.load_program(methods, classes, begins, procs));
}
fn locate_runtime() -> Result<(std::path::PathBuf, std::path::PathBuf), String> {
let exe = std::env::current_exe().map_err(|e| format!("aot: current_exe: {e}"))?;
let dir = exe
.parent()
.ok_or("aot: cannot find target dir next to the ruby binary")?;
let rlib = dir.join("librubylang.rlib");
let deps = dir.join("deps");
if !rlib.exists() {
return Err(format!(
"aot: rubylang rlib not found at {} — --build --native needs the \
build tree (run from a `cargo build` target dir)",
rlib.display()
));
}
Ok((rlib, deps))
}
pub fn build_native(file: &str) -> Result<String, String> {
use std::path::Path;
let (stmts, report) = crate::bundle::bundle(Path::new(file))?;
let mut prog = crate::compiler::compile(&stmts, false)?;
let synth_base = crate::compiler::synth_ids_used();
let (nmethods, nprocs, nops) = (prog.methods.len(), prog.procs.len(), prog.main.ops.len());
let src_abs =
std::fs::canonicalize(file).map_err(|e| format!("aot: cannot read {file}: {e}"))?;
let stem = src_abs
.file_stem()
.ok_or_else(|| format!("aot: no file stem for {file}"))?
.to_string_lossy()
.into_owned();
let out_exe = src_abs
.parent()
.map(|p| p.join(&stem))
.unwrap_or_else(|| Path::new(&stem).to_path_buf());
let work = std::env::temp_dir().join(format!("rubylang-aot-{}-{}", stem, std::process::id()));
std::fs::create_dir_all(&work).map_err(|e| format!("aot: mkdir {}: {e}", work.display()))?;
let mut next_id = 1u32;
for (_, m) in &mut prog.methods {
let c = std::sync::Arc::make_mut(&mut m.chunk);
c.native_id = next_id;
c.aot_seeded_slots = m.slot_params;
next_id += 1;
}
for (_, c) in &mut prog.classes {
for (_, m) in &mut c.methods {
let c = std::sync::Arc::make_mut(&mut m.chunk);
c.native_id = next_id;
c.aot_seeded_slots = m.slot_params;
next_id += 1;
}
for (_, m) in &mut c.class_methods {
let c = std::sync::Arc::make_mut(&mut m.chunk);
c.native_id = next_id;
c.aot_seeded_slots = m.slot_params;
next_id += 1;
}
}
for p in &mut prog.procs {
p.chunk.native_id = next_id;
next_id += 1;
}
let n_native = next_id - 1;
let mut extras: Vec<(String, &fusevm::Chunk)> = Vec::new();
for (_, m) in &prog.methods {
extras.push((format!("fusevm_aot_fn_{}", m.chunk.native_id), &m.chunk));
}
for (_, c) in &prog.classes {
for (_, m) in &c.methods {
extras.push((format!("fusevm_aot_fn_{}", m.chunk.native_id), &m.chunk));
}
for (_, m) in &c.class_methods {
extras.push((format!("fusevm_aot_fn_{}", m.chunk.native_id), &m.chunk));
}
}
for p in &prog.procs {
extras.push((format!("fusevm_aot_fn_{}", p.chunk.native_id), &p.chunk));
}
let obj = work.join("app.o");
fusevm::aot::compile_program_object(&prog.main, &extras, &obj)?;
let blob = crate::cache::program_to_blob(&prog)?;
let blob_path = work.join("program.blob");
std::fs::write(&blob_path, &blob)
.map_err(|e| format!("aot: write {}: {e}", blob_path.display()))?;
let mut fn_externs = String::new();
let mut fn_addrs = String::new();
for i in 1..=n_native {
fn_externs.push_str(&format!(" fn fusevm_aot_fn_{i}(vm: *mut u8) -> i64;\n"));
fn_addrs.push_str(&format!("fusevm_aot_fn_{i} as *const () as usize, "));
}
fn_addrs.push_str("fusevm_aot_entry as *const () as usize");
let frontend = work.join("aot_main.rs");
let frontend_src = format!(
"//! Generated by `ruby --build --native` — do not edit.\n\
#![allow(unused_extern_crates, non_upper_case_globals)]\n\
extern crate rubylang;\n\n\
#[no_mangle]\n\
pub static rubylang_aot_program_blob: [u8; {len}] = *include_bytes!({blob:?});\n\
#[no_mangle]\n\
pub static rubylang_aot_program_len: u64 = {len};\n\n\
extern \"C\" {{\n fn fusevm_aot_entry(vm: *mut u8) -> i64;\n{fn_externs}}}\n\n\
fn main() {{\n \
// Register every AOT-lowered driver (main's last) before the program runs.\n \
rubylang::aot::register_native_fns(vec![{fn_addrs}]);\n \
// Seed the host as `ruby FILE` does, run, and end through the\n \
// interpreter's own path: exit status, uncaught report, at_exit.\n \
std::process::exit(rubylang::aot::run_embedded({script:?}, {synth_base}));\n}}\n",
len = blob.len(),
blob = blob_path.to_string_lossy(),
script = file,
);
std::fs::write(&frontend, &frontend_src)
.map_err(|e| format!("aot: write {}: {e}", frontend.display()))?;
let (rlib, deps) = locate_runtime()?;
let status = std::process::Command::new("rustc")
.arg("--edition")
.arg("2021")
.arg(&frontend)
.arg("--extern")
.arg(format!("rubylang={}", rlib.display()))
.arg("-L")
.arg(format!("dependency={}", deps.display()))
.arg("-C")
.arg(format!("link-arg={}", obj.display()))
.arg("-A")
.arg("linker_messages")
.arg("-o")
.arg(&out_exe)
.status()
.map_err(|e| format!("aot: invoke rustc: {e}"))?;
if !status.success() {
return Err(format!(
"aot: rustc link failed (status {status}); frontend + object kept in {}",
work.display()
));
}
let size = std::fs::metadata(&out_exe).map(|m| m.len()).unwrap_or(0);
let _ = std::fs::remove_dir_all(&work);
let nfiles = report.files.len();
Ok(format!(
"built {file}: {nfiles} file(s) bundled, {nops} main ops, {nmethods} methods, \
{nprocs} blocks, {n_native} chunk(s) lowered to native -> {} ({} KiB standalone executable)",
out_exe.display(),
size / 1024
))
}