Crate juicebox_asm
source ·Expand description
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
- Trait definitions of various instructions.
Structs
x64
jit assembler.- Type representing an 8 bit immediate.
- Type representing a 16 bit immediate.
- Type representing a 32 bit immediate.
- Type representing a 64 bit immediate.
- A label which is used as target for jump instructions.
- A simple
mmap
ed runtime with executable pages.
Enums
- Type representing a memory operand.
- Definition of 8 bit registers.
- Definition of 16 bit registers.
- Definition of 32 bit registers.
- Definition of 64 bit registers.