Crate juicebox_asm

A simple x64 jit assembler with a minimal runtime to execute emitted code for fun.

The following is an fibonacci example implementation.

use juicebox_asm::{Asm, Reg64, Imm64, Label};
use juicebox_asm::insn::*;
use juicebox_asm::Runtime;

const fn fib_rs(n: u64) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => fib_rs(n - 2) + fib_rs(n - 1),
    }
}

fn main() {
    let mut asm = Asm::new();

    let mut lp = Label::new();
    let mut end = Label::new();

    // Reference implementation:
    //
    // int fib(int n) {
    //   int tmp = 0;
    //   int prv = 1;
    //   int sum = 0;
    // loop:
    //   if (n == 0) goto end;
    //   tmp = sum;
    //   sum += prv;
    //   prv = tmp;
    //   --n;
    //   goto loop;
    // end:
    //   return sum;
    // }

    // SystemV abi:
    //   rdi -> first argument
    //   rax -> return value
    let n = Reg64::rdi;
    let sum = Reg64::rax;

    let tmp = Reg64::rcx;
    let prv = Reg64::rbx;

    asm.mov(tmp, Imm64::from(0));
    asm.mov(prv, Imm64::from(1));
    asm.mov(sum, Imm64::from(0));

    asm.bind(&mut lp);
    asm.test(n, n);
    asm.jz(&mut end);
    asm.mov(tmp, sum);
    asm.add(sum, prv);
    asm.mov(prv, tmp);
    asm.dec(n);
    asm.jmp(&mut lp);
    asm.bind(&mut end);
    asm.ret();

    // Move code into executable page and get function pointer to it.
    let mut rt = Runtime::new();
    let fib = unsafe { rt.add_code::<extern "C" fn(u64) -> u64>(&asm.into_code()) };

    for n in 0..15 {
        let fib_jit = fib(n);
        println!("fib({}) = {}", n, fib_jit);
        assert_eq!(fib_jit, fib_rs(n));
    }
}

Modules

• insn
  Trait definitions of various instructions.

Structs

• Asm
  x64 jit assembler.
• Imm8
  Type representing an 8 bit immediate.
• Imm16
  Type representing a 16 bit immediate.
• Imm32
  Type representing a 32 bit immediate.
• Imm64
  Type representing a 64 bit immediate.
• Label
  A label which is used as target for jump instructions.
• Mem8
  A memory operand with byte size (8 bit).
• Mem16
  A memory operand with word size (16 bit).
• Mem32
  A memory operand with dword size (32 bit).
• Mem64
  A memory operand with qword size (64 bit).
• Runtime
  A simple mmaped runtime with executable pages.

Enums

• Reg8
  Definition of 8 bit registers.
• Reg16
  Definition of 16 bit registers.
• Reg32
  Definition of 32 bit registers.
• Reg64
  Definition of 64 bit registers.