Cranelift JIT Code Generation & SIMD Vectorization

Why Cranelift Beats LLVM for JIT Workloads

While LLVM produces extraordinary peak optimizations for AOT compilation, its multi-pass pipeline is too heavy for interactive latency (compiling hundreds of lines can take seconds). Cranelift (the Bytecode Alliance code generator powering Wasmtime, rustc_codegen_cranelift, and Vitalis Stage 0) generates optimized native machine code (x86_64, AArch64, RISC-V64, s390x) up to 10x faster via cranelift-jit (in-memory JIT) and cranelift-object (AOT object files).

Generating Machine Code with cranelift-jit

use cranelift::prelude::*;
use cranelift_jit::{JITBuilder, JITModule};
use cranelift_module::{Module, Linkage};

pub fn build_native_jit_add() -> fn(i64, i64) -> i64 {
    let mut flag_builder = settings::builder();
    flag_builder.set("opt_level", "speed").unwrap();
    let isa = isa::lookup(target_lexicon::Triple::host()).unwrap().finish(settings::Flags::new(flag_builder)).unwrap();

    let builder = JITBuilder::with_isa(isa, cranelift_module::default_libcall_names());
    let mut module = JITModule::new(builder);
    let mut ctx = module.make_context();

    let mut sig = module.make_signature();
    sig.params.push(AbiParam::new(types::I64));
    sig.params.push(AbiParam::new(types::I64));
    sig.returns.push(AbiParam::new(types::I64));

    let func_id = module.declare_function("jit_add", Linkage::Export, &sig).unwrap();
    ctx.func.signature = sig;

    let mut builder_context = FunctionBuilderContext::new();
    let mut fb = FunctionBuilder::new(&mut ctx.func, &mut builder_context);
    let block = fb.create_block();
    fb.append_block_params_for_function_params(block);
    fb.switch_to_block(block);

    let p0 = fb.block_params(block)[0];
    let p1 = fb.block_params(block)[1];
    let sum = fb.ins().iadd(p0, p1);
    fb.ins().return_(&[sum]);
    fb.seal_all_blocks();
    fb.finalize();

    module.define_function(func_id, &mut ctx).unwrap();
    module.clear_context(&mut ctx);
    module.finalize_definitions().unwrap();

    let code_ptr = module.get_finalized_function(func_id);
    unsafe { std::mem::transmute::<*const u8, fn(i64, i64) -> i64>(code_ptr) }
}