Struct cranelift_jit::JITModule

pub struct JITModule { /* fields omitted */ }

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

See the JITBuilder for a convenient way to construct JITModule instances.

Implementations

impl JITModule

pub unsafe fn free_memory(&mut self)

Free memory allocated for code and data segments of compiled functions.

Safety

Because this function invalidates any pointers retrived from the corresponding module, it should only be used when none of the functions from that module are currently executing and none of the fn pointers are called afterwards.

pub fn get_finalized_function(&self, func_id: FuncId) -> *const u8

Returns the address of a finalized function.

pub fn get_finalized_data(&self, data_id: DataId) -> (*const u8, usize)

Returns the address and size of a finalized data object.

pub fn finalize_definitions(&mut self)

Finalize all functions and data objects that are defined but not yet finalized. All symbols referenced in their bodies that are declared as needing a definition must be defined by this point.

Use get_finalized_function and get_finalized_data to obtain the final artifacts.

pub fn new(builder: JITBuilder) -> Self

Create a new JITModule.

pub fn prepare_for_function_redefine(
    &mut self,
    func_id: FuncId
) -> ModuleResult<()>

Allow a single future define_function on a previously defined function. This allows for hot code swapping and lazy compilation of functions.

This requires hotswap support to be enabled first using JITBuilder::hotswap.

Trait Implementations

impl Module for JITModule

fn isa(&self) -> &dyn TargetIsa

Return the TargetIsa to compile for.

fn declarations(&self) -> &ModuleDeclarations

Get all declarations in this module.

fn declare_function(
    &mut self,
    name: &str,
    linkage: Linkage,
    signature: &Signature
) -> ModuleResult<FuncId>

Declare a function in this module.

fn declare_data(
    &mut self,
    name: &str,
    linkage: Linkage,
    writable: bool,
    tls: bool
) -> ModuleResult<DataId>

Declare a data object in this module.

fn declare_func_in_func(&self, func: FuncId, in_func: &mut Function) -> FuncRef

Use this when you’re building the IR of a function to reference a function.

TODO: Coalesce redundant decls and signatures. TODO: Look into ways to reduce the risk of using a FuncRef in the wrong function.

fn declare_data_in_func(&self, data: DataId, func: &mut Function) -> GlobalValue

Use this when you’re building the IR of a function to reference a data object.

TODO: Same as above.

fn declare_func_in_data(&self, func: FuncId, ctx: &mut DataContext) -> FuncRef

TODO: Same as above.

fn declare_data_in_data(
    &self,
    data: DataId,
    ctx: &mut DataContext
) -> GlobalValue

TODO: Same as above.

fn define_function(
    &mut self,
    id: FuncId,
    ctx: &mut Context,
    trap_sink: &mut dyn TrapSink
) -> ModuleResult<ModuleCompiledFunction>

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

fn define_function_bytes(
    &mut self,
    id: FuncId,
    bytes: &[u8],
    relocs: &[RelocRecord]
) -> ModuleResult<ModuleCompiledFunction>

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

fn define_data(&mut self, id: DataId, data: &DataContext) -> ModuleResult<()>

Define a data object, producing the data contents from the given DataContext.

pub fn get_name(&self, name: &str) -> Option<FuncOrDataId>

Get the module identifier for a given name, if that name has been declared.

pub fn target_config(&self) -> TargetFrontendConfig

Return the target information needed by frontends to produce Cranelift IR for the current target.

pub fn make_context(&self) -> Context

Create a new Context initialized for use with this Module.

pub fn clear_context(&self, ctx: &mut Context)

Clear the given Context and reset it for use with a new function.

pub fn make_signature(&self) -> Signature

Create a new empty Signature with the default calling convention for the TargetIsa, to which parameter and return types can be added for declaring a function to be called by this Module.

pub fn clear_signature(&self, sig: &mut Signature)

Clear the given Signature and reset for use with a new function.