packages /

llvm 0.1.0

Bindings to LLVM's C API (LLVM 23), for the Auk compiler's back end: build IR, verify and print it, optimize it, emit object files and bitcode, link modules,...

files / src/kit.auk 7.1 kB · 190 lines

/// Hand-written helpers over the generated bindings (the parts of `src/mir/llvm/mod.rs` and
/// `jit.rs` every user needs): target setup, LLVM errors as Auk errors, object and bitcode
/// emission as bytes, and ORC LLJIT with absolute symbols and calls into JIT code.

/// How hard the code generator works (`LLVMCodeGenOptLevel`).
pub enum Level { None, Less, Default, Aggressive }

fn level_code(l: Level): int = match l {
  None => llvm.CODE_GEN_LEVEL_NONE
  Less => llvm.CODE_GEN_LEVEL_LESS
  Default => llvm.CODE_GEN_LEVEL_DEFAULT
  Aggressive => llvm.CODE_GEN_LEVEL_AGGRESSIVE
}

/// Register the AArch64 and x86 targets, their assemblers and printers (what the
/// `LLVM_InitializeNative*` inline functions do). Calling it again is harmless.
pub fn init_native() uses ffi {
  llvm.target.initialize_aarch64_target_info()
  llvm.target.initialize_aarch64_target()
  llvm.target.initialize_aarch64_target_mc()
  llvm.target.initialize_aarch64_asm_printer()
  llvm.target.initialize_aarch64_asm_parser()
  llvm.target.initialize_x86_target_info()
  llvm.target.initialize_x86_target()
  llvm.target.initialize_x86_target_mc()
  llvm.target.initialize_x86_asm_printer()
  llvm.target.initialize_x86_asm_parser()
}

/// `none` (success) as `ok`, an LLVM error as `fail` with its message (the error is consumed).
pub fn check(e: llvm.Error?): ()! uses ffi {
  match e {
    some(x) => fail(llvm.orc.get_error_message(x))
    none => {}
  }
}

/// A target machine for this computer (position-independent code), as `auk build` makes it.
/// `Level.None` also picks FastISel over GlobalISel, which is quadratic on big blocks.
pub fn host_machine(level: Level): llvm.TargetMachine! uses ffi {
  init_native()
  let triple = llvm.target.get_default_target_triple()
  var t: llvm.Target? = none
  var why: str? = none
  if llvm.target.get_target_from_triple(triple, &t, &why) != 0 {
    fail(why else "unknown target {triple}")
  }
  let tm = llvm.target.create_target_machine(
    t!,
    triple,
    llvm.target.get_host_cpu_name(),
    llvm.target.get_host_cpu_features(),
    level_code(level),
    llvm.RELOC_PIC,
    llvm.CODE_MODEL_DEFAULT,
  ) else {
    fail("cannot create an LLVM target machine for {triple}")
  }
  if level == None {
    llvm.target.set_target_machine_global_isel(tm, 0)
    llvm.target.set_target_machine_fast_isel(tm, 1)
  }
  tm
}

/// Give module `m` the target machine's triple and data layout.
pub fn set_target(m: llvm.Module, tm: llvm.TargetMachine) uses ffi {
  llvm.ir.set_target(m, llvm.target.get_target_machine_triple(tm))
  let dl = llvm.target.create_target_data_layout(tm)
  llvm.target.set_module_data_layout(m, dl)
  llvm.target.dispose_target_data(dl)
}

/// Verify `m`: `fail` with LLVM's message when it's invalid.
pub fn verify(m: llvm.Module): ()! uses ffi {
  var msg: str? = none
  if llvm.ir.verify_module(m, llvm.RETURN_STATUS_ACTION, &msg) != 0 {
    fail(msg else "invalid module")
  }
}

/// Run a pass pipeline (`"default<O2>"`, `"globaldce,function(sroa)"`, ...) over `m`.
pub fn run_passes(m: llvm.Module, passes: str, tm: llvm.TargetMachine?): ()! uses ffi {
  let opts = llvm.passes.create_pass_builder_options()
  let r = llvm.passes.run_passes(m, passes, tm, opts)
  llvm.passes.dispose_pass_builder_options(opts)
  check(r)?
}

/// The bytes of a memory buffer, copied; the buffer is disposed of.
pub fn take_bytes(b: llvm.MemoryBuffer): [int] uses ffi {
  let out = ffi.bytes(llvm.bitcode.get_buffer_start(b), llvm.bitcode.get_buffer_size(b))
  llvm.bitcode.dispose_memory_buffer(b)
  out
}

/// Machine code for `m`: an object file (`asm`: assembly text instead), as bytes.
pub fn emit(tm: llvm.TargetMachine, m: llvm.Module, asm: bool): [int]! uses ffi {
  var why: str? = none
  var buf: llvm.MemoryBuffer? = none
  let kind = if asm { llvm.ASSEMBLY_FILE } else { llvm.OBJECT_FILE }
  if llvm.target.target_machine_emit_to_memory_buffer(tm, m, kind, &why, &buf) != 0 {
    fail(why else "emitting machine code failed")
  }
  take_bytes(buf!)
}

/// `m` as bitcode.
pub fn bitcode(m: llvm.Module): [int] uses ffi =
  take_bytes(llvm.bitcode.write_bitcode_to_memory_buffer(m))

/// Read bitcode into a new module of context `c`.
pub fn parse_bitcode(c: llvm.Context, bc: [int]): llvm.Module! uses ffi {
  let buf = llvm.bitcode.create_memory_buffer_with_memory_range_copy(bc, "bitcode")
  var m: llvm.Module? = none
  let bad = llvm.bitcode.parse_bitcode_in_context2(c, buf, &m)
  llvm.bitcode.dispose_memory_buffer(buf)
  if bad != 0 { fail("invalid bitcode") }
  m!
}

// ---- ORC LLJIT ----

/// A JIT for one object file: dispose of it with `close`.
pub struct Jit { j: llvm.OrcLLJIT, dylib: llvm.OrcJITDylib }

/// A new LLJIT whose main dylib also finds this process's symbols (libc, loaded libraries).
pub fn jit(): Jit! uses ffi {
  init_native()
  var j: llvm.OrcLLJIT? = none
  check(llvm.orc.orc_create_lljit(&j, llvm.orc.orc_create_lljit_builder()))?
  let jit = j!
  let jd = llvm.orc.orc_lljit_get_main_jit_dylib(jit)
  var g: llvm.OrcDefinitionGenerator? = none
  let prefix = llvm.orc.orc_lljit_get_global_prefix(jit)
  check(
    llvm.orc.orc_create_dynamic_library_search_generator_for_process(
      &g,
      prefix,
      ffi.null,
      ffi.null,
    ),
  )?
  llvm.orc.orc_jit_dylib_add_generator(jd, g!)
  Jit { j: jit, dylib: jd }
}

// An interned name as a plain pointer, to store in C memory.
extern fn entry_ptr(e: llvm.OrcSymbolStringPoolEntry): ffi.Ptr = "(void *)"

/// Define symbols at fixed addresses in the JIT's main dylib (how `auk run` hands the runtime
/// to JIT code). `LLVMOrcCSymbolMapPair` is laid out by hand: the interned name (8 bytes), the
/// address (8), the generic and target flags (1 + 1, padded to 8).
pub fn define(jt: Jit, syms: [(str, ffi.Ptr)]): ()! uses ffi {
  if syms.len() == 0 { return }
  let size = 24
  let pairs = ffi.alloc(size * syms.len())
  let flags = llvm.JIT_SYMBOL_GENERIC_FLAGS_EXPORTED + llvm.JIT_SYMBOL_GENERIC_FLAGS_CALLABLE
  for i in 0..syms.len() {
    let (name, at) = syms[i]
    ffi.write_ptr(pairs, i * size, entry_ptr(llvm.orc.orc_lljit_mangle_and_intern(jt.j, name)))
    ffi.write_ptr(pairs, i * size + 8, at)
    ffi.write_u8(pairs, i * size + 16, flags)
  }
  let mu = llvm.orc.orc_absolute_symbols(pairs, syms.len())
  ffi.free(pairs)
  check(llvm.orc.orc_jit_dylib_define(jt.dylib, mu!))?
}

/// Link object file `obj` into the JIT.
pub fn add_object(jt: Jit, obj: [int]): ()! uses ffi {
  let buf = llvm.bitcode.create_memory_buffer_with_memory_range_copy(obj, "auk")
  check(llvm.orc.orc_lljit_add_object_file(jt.j, jt.dylib, buf))?
}

/// The address of `name` (linking the code the first time).
pub fn lookup(jt: Jit, name: str): ffi.Ptr! uses ffi {
  var a = 0
  check(llvm.orc.orc_lljit_lookup(jt.j, &a, name))?
  ffi.ptr(a)
}

/// Free the JIT and its code.
pub fn close(jt: Jit): ()! uses ffi = check(llvm.orc.orc_dispose_lljit(jt.j))

/// Call JIT code `f: (i64, i64) -> i64`; other signatures are one `extern fn` each, the same way:
/// `extern fn call(f: ffi.Ptr, x: float): float = "double (*)(double)"`.
pub extern fn call_ii_i(f: ffi.Ptr, a: int, b: int): int = "int64_t (*)(int64_t, int64_t)"
/// Call JIT code `f: (i64) -> i64`.
pub extern fn call_i_i(f: ffi.Ptr, a: int): int = "int64_t (*)(int64_t)"