Struct JITModule 

pub struct JITModule { /* private fields */ }

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(self)

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

Safety

Because this function invalidates any pointers retrieved 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.

The pointer remains valid until either JITModule::free_memory is called or in the future some way of deallocating this individual function is used.

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

Returns the address and size of a finalized data object.

The pointer remains valid until either JITModule::free_memory is called or in the future some way of deallocating this individual data object is used.

pub fn finalize_definitions(&mut self) -> Result<(), ModuleError>

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.

Returns ModuleError in case of allocation or syscall failure

pub fn new(builder: JITBuilder) -> JITModule

Create a new JITModule.

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, ) -> Result<FuncId, ModuleError>

Declare a function in this module.

fn declare_anonymous_function( &mut self, signature: &Signature, ) -> Result<FuncId, ModuleError>

Declare an anonymous function in this module.

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

Declare a data object in this module.

fn declare_anonymous_data( &mut self, writable: bool, tls: bool, ) -> Result<DataId, ModuleError>

Declare an anonymous data object in this module.

fn define_function_with_control_plane( &mut self, id: FuncId, ctx: &mut Context, ctrl_plane: &mut ControlPlane, ) -> Result<(), ModuleError>

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

fn define_function_bytes( &mut self, id: FuncId, alignment: u64, bytes: &[u8], relocs: &[ModuleReloc], ) -> Result<(), ModuleError>

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

fn define_data( &mut self, id: DataId, data: &DataDescription, ) -> Result<(), ModuleError>

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

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

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

fn target_config(&self) -> TargetFrontendConfig

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

fn make_context(&self) -> Context

Create a new Context initialized for use with this Module.

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

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

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.

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

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

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

Use this when you’re building the IR of a function to reference a 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.

fn declare_func_in_data( &self, func_id: FuncId, data: &mut DataDescription, ) -> FuncRef

TODO: Same as above.

fn declare_data_in_data( &self, data_id: DataId, data: &mut DataDescription, ) -> GlobalValue

TODO: Same as above.

fn define_function( &mut self, func: FuncId, ctx: &mut Context, ) -> Result<(), ModuleError>

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