Struct cranelift_simplejit::SimpleJITBackend

pub struct SimpleJITBackend { /* fields omitted */ }

A SimpleJITBackend implements Backend and emits code and data into memory where it can be directly called and accessed.

See the SimpleJITBuilder for a convenient way to construct SimpleJITBackend instances.

Trait Implementations

impl<'simple_jit_backend> Backend for SimpleJITBackend

type Builder = SimpleJITBuilder

A builder for constructing Backend instances.

type CompiledFunction = SimpleJITCompiledFunction

SimpleJIT compiled function and data objects may have outstanding relocations that need to be performed before the memory can be used. These relocations are performed within finalize_function and finalize_data.

type CompiledData = SimpleJITCompiledData

The results of "compiling" a data object.

type FinalizedFunction = *const u8

SimpleJIT emits code and data into memory, and provides raw pointers to them. They are valid for the remainder of the program's life, unless free_memory is used.

type FinalizedData = (*mut u8, usize)

The completed output artifact for a data object, if this is meaningful for the Backend.

type Product = SimpleJITMemoryHandle

SimpleJIT emits code and data into memory as it processes them, so it doesn't need to provide anything after the Module is complete. The handle object that is returned can optionally be used to free allocated memory if required.

fn new(builder: SimpleJITBuilder) -> Self

Create a new SimpleJITBackend.

fn isa(&self) -> &dyn TargetIsa

Return the TargetIsa to compile for.

fn declare_function(&mut self, _id: FuncId, _name: &str, _linkage: Linkage)

Declare a function.

fn declare_data(
    &mut self,
    _id: DataId,
    _name: &str,
    _linkage: Linkage,
    _writable: bool,
    _align: Option<u8>
)

Declare a data object.

fn define_function(
    &mut self,
    _id: FuncId,
    name: &str,
    ctx: &Context,
    _namespace: &ModuleNamespace<Self>,
    code_size: u32
) -> ModuleResult<Self::CompiledFunction>

Define a function, producing the function body from the given Context.

fn define_data(
    &mut self,
    _id: DataId,
    _name: &str,
    writable: bool,
    align: Option<u8>,
    data: &DataContext,
    _namespace: &ModuleNamespace<Self>
) -> ModuleResult<Self::CompiledData>

Define a zero-initialized data object of the given size.

fn write_data_funcaddr(
    &mut self,
    _data: &mut Self::CompiledData,
    _offset: usize,
    _what: FuncRef
)

Write the address of what into the data for data at offset. data must refer to a defined data object.

fn write_data_dataaddr(
    &mut self,
    _data: &mut Self::CompiledData,
    _offset: usize,
    _what: GlobalValue,
    _usize: Addend
)

Write the address of what plus addend into the data for data at offset. data must refer to a defined data object.

fn finalize_function(
    &mut self,
    _id: FuncId,
    func: &Self::CompiledFunction,
    namespace: &ModuleNamespace<Self>
) -> Self::FinalizedFunction

Perform all outstanding relocations on the given function. This requires all Local and Export entities referenced to be defined.

fn get_finalized_function(
    &self,
    func: &Self::CompiledFunction
) -> Self::FinalizedFunction

Return the finalized artifact from the backend, if relevant.

fn finalize_data(
    &mut self,
    _id: DataId,
    data: &Self::CompiledData,
    namespace: &ModuleNamespace<Self>
) -> Self::FinalizedData

Perform all outstanding relocations on the given data object. This requires all Local and Export entities referenced to be defined.

fn get_finalized_data(&self, data: &Self::CompiledData) -> Self::FinalizedData

Return the finalized artifact from the backend, if relevant.

fn publish(&mut self)

"Publish" all finalized functions and data objects to their ultimate destinations.

fn finish(self) -> Self::Product

SimpleJIT emits code and data into memory as it processes them. This method performs no additional processing, but returns a handle which allows freeing the allocated memory. Otherwise said memory is leaked to enable safe handling of the resulting pointers.

This method does not need to be called when access to the memory handle is not required.