Struct CallableJitFunction 

pub struct CallableJitFunction<F> { /* private fields */ }

A JIT-compiled function that can be called directly

This structure wraps executable machine code and provides type-safe calling methods. While the type parameter F represents a Rust function signature, the actual execution uses C ABI for stability.

Supported Signatures

Currently supports function signatures with 0-7 arguments:

• fn() -> R
• fn(A1) -> R
• fn(A1, A2) -> R
• … up to fn(A1, A2, A3, A4, A5, A6, A7) -> R

For unsupported signatures, use RawCallableJitFunction instead.

Implementations

impl<F> CallableJitFunction<F>

pub fn new(code: &[u8]) -> Result<Self, JitError>

Create a new callable JIT function from instruction bytes

impl<R> CallableJitFunction<fn() -> R>

Direct call methods based on function signature

These methods provide type-safe calling with automatic ABI conversion from Rust function types to C ABI. Currently supports 0-7 arguments.

The conversion from fn(...) to extern "C" fn(...) is handled internally for ABI stability across Rust versions.

pub fn call(&self) -> R

Call with no arguments - natural syntax: func.call()

impl<A1, R> CallableJitFunction<fn(A1) -> R>

pub fn call(&self, arg1: A1) -> R

Call with one argument - natural syntax: func.call(arg)

impl<A1, A2, R> CallableJitFunction<fn(A1, A2) -> R>

pub fn call(&self, arg1: A1, arg2: A2) -> R

Call with two arguments - natural syntax: func.call(arg1, arg2)

impl<A1, A2, A3, R> CallableJitFunction<fn(A1, A2, A3) -> R>

pub fn call(&self, arg1: A1, arg2: A2, arg3: A3) -> R

Call with three arguments - natural syntax: func.call(arg1, arg2, arg3)

impl<A1, A2, A3, A4, R> CallableJitFunction<fn(A1, A2, A3, A4) -> R>

pub fn call(&self, arg1: A1, arg2: A2, arg3: A3, arg4: A4) -> R

Call with four arguments - natural syntax: func.call(arg1, arg2, arg3, arg4)

impl<A1, A2, A3, A4, A5, R> CallableJitFunction<fn(A1, A2, A3, A4, A5) -> R>

pub fn call(&self, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) -> R

Call with five arguments

impl<A1, A2, A3, A4, A5, A6, R> CallableJitFunction<fn(A1, A2, A3, A4, A5, A6) -> R>

pub fn call( &self, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, ) -> R

Call with six arguments

impl<A1, A2, A3, A4, A5, A6, A7, R> CallableJitFunction<fn(A1, A2, A3, A4, A5, A6, A7) -> R>

pub fn call( &self, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, ) -> R

Call with seven arguments