Struct cranelift_module::Module

pub struct Module<B> where
    B: Backend,  { /* fields omitted */ }

A Module is a utility for collecting functions and data objects, and linking them together.

Methods

impl<B> Module<B> where     B: Backend,

pub fn new(backend_builder: B::Builder) -> Self

Create a new Module.

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 pointer_type(&self) -> Type

Return then pointer type for the current target.

pub fn make_context(&self) -> Context

Create a new Context initialized for use with this Module.

This ensures that the Context is initialized with the default calling convention for the TargetIsa.

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

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

This ensures that the Context is initialized with the default calling convention for the TargetIsa.

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.

This ensures that the Signature is initialized with the default calling convention for the TargetIsa.

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

Declare a function in this module.

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

Declare a data object in this module.

pub 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.

pub 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.

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

TODO: Same as above.

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

TODO: Same as above.

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

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

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

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

pub fn write_data_funcaddr(     &mut self,     data: DataId,     offset: usize,     what: FuncRef )

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

pub fn write_data_dataaddr(     &mut self,     data: DataId,     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.

pub fn finalize_function(&mut self, func: FuncId) -> B::FinalizedFunction

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

Panics

When the function has already been finalized this panics.

pub fn get_finalized_function(&mut self, func: FuncId) -> B::FinalizedFunction

Return the finalized artifact from the backend, if it provides one.

pub fn finalize_data(&mut self, data: DataId) -> B::FinalizedData

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

Panics

When the data object has already been finalized this panics.

pub fn get_finalized_data(&mut self, data: DataId) -> B::FinalizedData

Return the finalized artifact from the backend, if it provides one.

pub fn finalize_all(&mut self)

Finalize all functions and data objects. Note that this doesn't return the final artifacts returned from finalize_function or finalize_data. Use get_finalized_function and get_finalized_data to obtain the final artifacts.

pub fn finish(self) -> B::Product

Consume the module and return the resulting Product. Some Backend implementations may provide additional functionality available after a Module is complete.