Struct llama::Jit

pub struct Jit<'ctx> { /* private fields */ }

Jit bundles LLVMContext, LLVMBuilder and LLVMExecutionEngine

Implementations

impl<'ctx> Jit<'ctx>

pub fn new(
    name: impl AsRef<str>,
    opt: Option<usize>
) -> Result<Jit<'ctx>, Error>

Create new Jit instance

pub fn into_inner(self) -> (Context<'ctx>, Builder<'ctx>, ExecutionEngine<'ctx>)

Destruct

pub fn engine(&self) -> &ExecutionEngine<'ctx>

Access ExecutionEngine

pub fn engine_mut(&mut self) -> &mut ExecutionEngine<'ctx>

Mutable access to ExecutionEngine

pub fn build(&self) -> &Builder<'ctx>

Access Builder

pub fn build_mut(&mut self) -> &mut Builder<'ctx>

Mutable access to Builder

pub fn context(&self) -> &Context<'ctx>

Access Context

pub fn context_mut(&mut self) -> &mut Context<'ctx>

Mutable access to Context

pub fn module(&self) -> &Module<'ctx>

Access Module

pub fn module_mut(&mut self) -> &mut Module<'ctx>

Mutable access to Module

pub fn declare_function<T: Into<Value<'ctx>>, F: FnOnce(&Builder<'ctx>, Func<'ctx>) -> Result<T, Error>>(
    &self,
    name: impl AsRef<str>,
    ft: FuncType<'_>,
    def: F
) -> Result<Func<'ctx>, Error>

Declare a new function with function body

pub fn define_function(
    &self,
    name: impl AsRef<str>,
    t: FuncType<'_>
) -> Result<Func<'ctx>, Error>

Define a new function without declaring a function body

pub fn define_global(
    &self,
    name: impl AsRef<str>,
    ty: impl AsRef<Type<'ctx>>
) -> Result<Value<'ctx>, Error>

Create a new global with an empty initializer

pub fn declare_global(
    &self,
    name: impl AsRef<str>,
    t: impl AsRef<Value<'ctx>>
) -> Result<Value<'ctx>, Error>

Create a new global with the specified initializer