Trait cranelift_module::Backend

pub trait Backend where
    Self: Sized, {
    type Builder;
    type CompiledFunction;
    type CompiledData;
    type FinalizedFunction;
    type FinalizedData;
    type Product;
    fn new(_: Self::Builder) -> Self;
    fn isa(&self) -> &dyn TargetIsa;
    fn declare_function(&mut self, id: FuncId, name: &str, linkage: Linkage);
    fn declare_data(
        &mut self, 
        id: DataId, 
        name: &str, 
        linkage: Linkage, 
        writable: bool, 
        align: Option<u8>
    );
    fn define_function(
        &mut self, 
        id: FuncId, 
        name: &str, 
        ctx: &Context, 
        namespace: &ModuleNamespace<Self>, 
        code_size: u32
    ) -> ModuleResult<Self::CompiledFunction>;
    fn define_function_bytes(
        &mut self, 
        id: FuncId, 
        name: &str, 
        bytes: &[u8], 
        namespace: &ModuleNamespace<Self>, 
        traps: Vec<TrapSite>
    ) -> ModuleResult<Self::CompiledFunction>;
    fn define_data(
        &mut self, 
        id: DataId, 
        name: &str, 
        writable: bool, 
        align: Option<u8>, 
        data_ctx: &DataContext, 
        namespace: &ModuleNamespace<Self>
    ) -> ModuleResult<Self::CompiledData>;
    fn write_data_funcaddr(
        &mut self, 
        data: &mut Self::CompiledData, 
        offset: usize, 
        what: FuncRef
    );
    fn write_data_dataaddr(
        &mut self, 
        data: &mut Self::CompiledData, 
        offset: usize, 
        what: GlobalValue, 
        addend: Addend
    );
    fn finalize_function(
        &mut self, 
        id: FuncId, 
        func: &Self::CompiledFunction, 
        namespace: &ModuleNamespace<Self>
    ) -> Self::FinalizedFunction;
    fn get_finalized_function(
        &self, 
        func: &Self::CompiledFunction
    ) -> Self::FinalizedFunction;
    fn finalize_data(
        &mut self, 
        id: DataId, 
        data: &Self::CompiledData, 
        namespace: &ModuleNamespace<Self>
    ) -> Self::FinalizedData;
    fn get_finalized_data(
        &self, 
        data: &Self::CompiledData
    ) -> Self::FinalizedData;
    fn publish(&mut self);
    fn finish(self, namespace: &ModuleNamespace<Self>) -> Self::Product;
}

A Backend implements the functionality needed to support a Module.

Three notable implementations of this trait are:

• SimpleJITBackend, defined in cranelift-simplejit, which JITs the contents of a Module to memory which can be directly executed.
• ObjectBackend, defined in cranelift-object, which writes the contents of a Module out as a native object file.
• FaerieBackend, defined in cranelift-faerie, which writes the contents of a Module out as a native object file.

Associated Types

type Builder

A builder for constructing Backend instances.

type CompiledFunction

The results of compiling a function.

type CompiledData

The results of "compiling" a data object.

type FinalizedFunction

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

type FinalizedData

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

type Product

This is an object returned by Module's finish function, if the Backend has a purpose for this.

Loading content...

Required methods

fn new(_: Self::Builder) -> Self

Create a new Backend instance.

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.

Functions must be declared before being defined.

fn define_function_bytes(
    &mut self,
    id: FuncId,
    name: &str,
    bytes: &[u8],
    namespace: &ModuleNamespace<Self>,
    traps: Vec<TrapSite>
) -> ModuleResult<Self::CompiledFunction>

Define a function, taking the function body from the given bytes.

Functions must be declared before being defined.

fn define_data(
    &mut self,
    id: DataId,
    name: &str,
    writable: bool,
    align: Option<u8>,
    data_ctx: &DataContext,
    namespace: &ModuleNamespace<Self>
) -> ModuleResult<Self::CompiledData>

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

Data objects must be declared before being defined.

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,
    addend: 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.

This method is not relevant for Backend implementations that do not provide Backend::FinalizedFunction.

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.

This method is not relevant for Backend implementations that do not provide Backend::FinalizedData.

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.

This method is not relevant for Backend implementations that do not provide Backend::FinalizedFunction or Backend::FinalizedData.

fn finish(self, namespace: &ModuleNamespace<Self>) -> Self::Product

Consume this Backend and return a result. Some implementations may provide additional functionality through this result.

Loading content...

Implementors

Loading content...