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

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 declared_functions(&self) -> Iter<ModuleFunction<B>>

An iterator over functions that have been declared in this module.

pub fn declare_data(
    &mut self,
    name: &str,
    linkage: Linkage,
    writable: bool,
    align: Option<u8>
) -> 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<CodeOffset>

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

Returns the size of the function's code and constant data.

Note: After calling this function the given Context will contain the compiled function.

pub fn define_function_bytes(
    &mut self,
    func: FuncId,
    bytes: &[u8],
    traps: Vec<TrapSite>
) -> ModuleResult<CodeOffset>

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

This function is generally only useful if you need to precisely specify the emitted instructions for some reason; otherwise, you should use define_function.

Returns the size of the function's code.

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

Define a data object, 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_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.

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

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

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

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

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

pub fn isa(&self) -> &dyn TargetIsa

Return the target isa

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.