Struct Program 

pub struct Program { /* private fields */ }

Assemble one bytecode module.

Implementations

impl Program

pub fn new(name: impl Into<String>) -> Self

Start a new module named name.

Examples found in repository

examples/throughput.rs (line 12)

fn trivial_chunk() -> byteflow::Chunk {
    let mut program = Program::new("throughput");
    program.function("worker", 0, |f| {
        let one = f.load_i32(1);
        f.return_(one);
    });
    program.build()
}

examples/jit_loop.rs (line 12)

fn loop_chunk(iterations: i32) -> byteflow::Chunk {
    let mut program = Program::new("jit-loop");
    program.function("main", 0, |f| {
        let limit = f.load_int(i64::from(iterations));
        let counter = f.load_i32(0);
        f.while_lt(counter, limit, |f| f.add_imm(counter, 1));
        f.return_(counter);
    });
    program.build()
}

pub fn function( &mut self, name: impl Into<String>, arity: u8, body: impl FnOnce(&mut Fn<'_>), ) -> FuncId

Define a function and run body against a fresh Fn context.

Returns the function index for Fn::spawn / Fn::call.

Examples found in repository

examples/throughput.rs (lines 13-16)

fn trivial_chunk() -> byteflow::Chunk {
    let mut program = Program::new("throughput");
    program.function("worker", 0, |f| {
        let one = f.load_i32(1);
        f.return_(one);
    });
    program.build()
}

examples/jit_loop.rs (lines 13-18)

fn loop_chunk(iterations: i32) -> byteflow::Chunk {
    let mut program = Program::new("jit-loop");
    program.function("main", 0, |f| {
        let limit = f.load_int(i64::from(iterations));
        let counter = f.load_i32(0);
        f.while_lt(counter, limit, |f| f.add_imm(counter, 1));
        f.return_(counter);
    });
    program.build()
}

pub fn function_raw( &mut self, name: impl Into<String>, arity: u8, num_registers: u8, body: impl FnOnce(&mut Fn<'_>), ) -> FuncId

Define a function with an explicit register-file size.

Useful for fixed register layouts (reg(255)) or verification demos where num_registers < arity must fail static checks.

pub fn function_index(&self, name: &str) -> Option<FuncId>

Look up a function index by name (available before Self::build).

pub fn build(self) -> Chunk

Finish assembly and produce an immutable Chunk.

Examples found in repository

examples/throughput.rs (line 17)

fn trivial_chunk() -> byteflow::Chunk {
    let mut program = Program::new("throughput");
    program.function("worker", 0, |f| {
        let one = f.load_i32(1);
        f.return_(one);
    });
    program.build()
}

examples/jit_loop.rs (line 19)

fn loop_chunk(iterations: i32) -> byteflow::Chunk {
    let mut program = Program::new("jit-loop");
    program.function("main", 0, |f| {
        let limit = f.load_int(i64::from(iterations));
        let counter = f.load_i32(0);
        f.while_lt(counter, limit, |f| f.add_imm(counter, 1));
        f.return_(counter);
    });
    program.build()
}