Struct llvm_rs::JitEngine

pub struct JitEngine(_);

The MCJIT backend, which compiles functions and values into machine code.

Implementations

impl<'a> JitEngine

pub fn with_function<C, A, R>(&self, function: &'a Function, cb: C)where
    A: Compile<'a>,
    R: Compile<'a>,
    C: FnOnce(extern "C" fn(_: A) -> R),

Run the closure cb with the machine code for the function function.

If the function takes multiple arguments, these should be wrapped in a tuple due to the limitations of Rust’s type system.

This will check that the types match at runtime when in debug mode, but not release mode. You should make sure to use debug mode if you want it to error when the types don’t match.

pub unsafe fn with_function_unchecked<C, A, R>(
    &self,
    function: &'a Function,
    cb: C
)where
    A: Compile<'a>,
    R: Compile<'a>,
    C: FnOnce(extern "C" fn(_: A) -> R),

Run the closure cb with the machine code for the function function.

pub unsafe fn get_function<A, R>(
    &self,
    function: &'a Function
) -> extern "C" fn(_: A) -> R

Returns a pointer to the machine code for the function function.

This is marked as unsafe because the types given as arguments and return could be different from their internal representation.

Trait Implementations

impl DisposeRef for JitEngine

type RefTo = LLVMOpaqueExecutionEngine

What a reference to this type represents as a C pointer.

unsafe fn dispose(ptr: *mut LLVMOpaqueExecutionEngine)

Destroy the contents at the pointer’s location.

impl<'a> ExecutionEngine<'a> for JitEngine

type Options = JitOptions

The options given to the engine upon creation.

fn new(
    module: &'a Module,
    options: JitOptions
) -> Result<CSemiBox<'a, JitEngine>, CBox<str>>

Create a new execution engine with the given Module and optiions, or return a description of the error.

fn add_module(&'a self, module: &'a Module)

Add a module to the list of modules to interpret or compile.

fn remove_module(&'a self, module: &'a Module) -> &'a Module

Remove a module from the list of modules to interpret or compile.

fn run_static_constructors(&'a self)

Execute all of the static constructors for this program.

fn run_static_destructors(&'a self)

Execute all of the static destructors for this program.

fn find_function(&'a self, name: &str) -> Option<&'a Function>

Attempt to find a function with the name given, or None if there wasn’t a function with that name.

fn run_function(
    &'a self,
    function: &'a Function,
    args: &[&'a GenericValue]
) -> &'a GenericValue

Run function with the arguments given as ``GenericValue`s, then return the result as one.

unsafe fn get_global<T>(&'a self, global: &'a Value) -> &'a T

Returns a pointer to the global value given.

unsafe fn find_global<T>(&'a self, name: &str) -> Option<&'a T>

Returns a pointer to the global value with the name given.

impl<'a> From<&'a JitEngine> for LLVMExecutionEngineRef

fn from(ty: &'a JitEngine) -> LLVMExecutionEngineRef

Converts to this type from the input type.

impl<'a> From<&'a mut JitEngine> for LLVMExecutionEngineRef

fn from(ty: &'a mut JitEngine) -> LLVMExecutionEngineRef

Converts to this type from the input type.

impl<'a> From<*mut LLVMOpaqueExecutionEngine> for &'a JitEngine

fn from(ty: LLVMExecutionEngineRef) -> &'a JitEngine

Converts to this type from the input type.

impl<'a> From<*mut LLVMOpaqueExecutionEngine> for &'a mut JitEngine

fn from(ty: LLVMExecutionEngineRef) -> &'a mut JitEngine

Converts to this type from the input type.

impl<'a> PartialEq<JitEngine> for &'a JitEngine

fn eq(&self, other: &JitEngine) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<JitEngine> for JitEngine

fn eq(&self, other: &JitEngine) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for JitEngine