Trait cranelift_module::Module[−][src]

pub trait Module {

Show 19 methods    fn isa(&self) -> &dyn TargetIsa;

    fn declarations(&self) -> &ModuleDeclarations;

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

    fn declare_anonymous_function(
        &mut self, 
        signature: &Signature
    ) -> ModuleResult<FuncId>;

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

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

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

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

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

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

    fn target_config(&self) -> TargetFrontendConfig { ... }

    fn make_context(&self) -> Context { ... }

    fn clear_context(&self, ctx: &mut Context) { ... }

    fn make_signature(&self) -> Signature { ... }

    fn clear_signature(&self, sig: &mut Signature) { ... }

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

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

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

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

}
Expand description

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

Required methods

Return the TargetIsa to compile for.

Get all declarations in this module.

Declare a function in this module.

Declare an anonymous function in this module.

Declare a data object in this module.

Declare an anonymous data object in this module.

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.

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.

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

Provided methods

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

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

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.

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.

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.

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.

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.

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

TODO: Same as above.

TODO: Same as above.

TODO: Same as above.

Implementations on Foreign Types

Implementors