Struct cranelift_simplejit::SimpleJITBackend

pub struct SimpleJITBackend { /* private fields */ }

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 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 FinalizedFunction = *const u8

SimpleJIT emits code and data into memory, and provides raw pointers to them.

type Product = ()

SimpleJIT emits code and data into memory as it processes them, so it doesn’t need to provide anything after the Module is complete.

fn new(builder: SimpleJITBuilder) -> Self

Create a new SimpleJITBackend.

fn finish(self)

SimpleJIT emits code and data into memory as it processes them, so it doesn’t need to provide anything after the Module is complete.

type Builder = SimpleJITBuilder

A builder for constructing Backend instances.

type CompiledData = SimpleJITCompiledData

The results of “compiling” a data object.

type FinalizedData = (*mut u8, usize)

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

fn isa(&self) -> &dyn TargetIsa

Return the TargetIsa to compile for.

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

Declare a function.

fn declare_data(&mut self, _name: &str, _linkage: Linkage, _writable: bool)

Declare a data object.

fn define_function(
    &mut self,
    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,
    _name: &str,
    writable: bool,
    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,
    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,
    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.