Trait cranelift_wasm::ModuleEnvironment

source · [−]
pub trait ModuleEnvironment<'data>: TargetEnvironment {

Show 57 methods    fn declare_type_func(
        &mut self, 
        wasm_func_type: WasmFuncType, 
        sig: Signature
    ) -> WasmResult<()>;

    fn declare_func_import(
        &mut self, 
        index: TypeIndex, 
        module: &'data str, 
        field: Option<&'data str>
    ) -> WasmResult<()>;

    fn declare_table_import(
        &mut self, 
        table: Table, 
        module: &'data str, 
        field: Option<&'data str>
    ) -> WasmResult<()>;

    fn declare_memory_import(
        &mut self, 
        memory: Memory, 
        module: &'data str, 
        field: Option<&'data str>
    ) -> WasmResult<()>;

    fn declare_global_import(
        &mut self, 
        global: Global, 
        module: &'data str, 
        field: Option<&'data str>
    ) -> WasmResult<()>;

    fn declare_func_type(&mut self, index: TypeIndex) -> WasmResult<()>;

    fn declare_table(&mut self, table: Table) -> WasmResult<()>;

    fn declare_memory(&mut self, memory: Memory) -> WasmResult<()>;

    fn declare_global(&mut self, global: Global) -> WasmResult<()>;

    fn declare_func_export(
        &mut self, 
        func_index: FuncIndex, 
        name: &'data str
    ) -> WasmResult<()>;

    fn declare_table_export(
        &mut self, 
        table_index: TableIndex, 
        name: &'data str
    ) -> WasmResult<()>;

    fn declare_memory_export(
        &mut self, 
        memory_index: MemoryIndex, 
        name: &'data str
    ) -> WasmResult<()>;

    fn declare_global_export(
        &mut self, 
        global_index: GlobalIndex, 
        name: &'data str
    ) -> WasmResult<()>;

    fn declare_start_func(&mut self, index: FuncIndex) -> WasmResult<()>;

    fn declare_table_elements(
        &mut self, 
        table_index: TableIndex, 
        base: Option<GlobalIndex>, 
        offset: usize, 
        elements: Box<[FuncIndex]>
    ) -> WasmResult<()>;

    fn declare_passive_element(
        &mut self, 
        index: ElemIndex, 
        elements: Box<[FuncIndex]>
    ) -> WasmResult<()>;

    fn declare_passive_data(
        &mut self, 
        data_index: DataIndex, 
        data: &'data [u8]
    ) -> WasmResult<()>;

    fn define_function_body(
        &mut self, 
        validator: FuncValidator<ValidatorResources>, 
        body: FunctionBody<'data>
    ) -> WasmResult<()>;

    fn declare_data_initialization(
        &mut self, 
        memory_index: MemoryIndex, 
        base: Option<GlobalIndex>, 
        offset: usize, 
        data: &'data [u8]
    ) -> WasmResult<()>;

    fn reserve_types(&mut self, _num: u32) -> WasmResult<()> { ... }

    fn declare_type_module(
        &mut self, 
        imports: &[(&'data str, Option<&'data str>, EntityType)], 
        exports: &[(&'data str, EntityType)]
    ) -> WasmResult<()> { ... }

    fn declare_type_instance(
        &mut self, 
        exports: &[(&'data str, EntityType)]
    ) -> WasmResult<()> { ... }

    fn type_to_signature(&self, index: TypeIndex) -> WasmResult<SignatureIndex> { ... }

    fn type_to_module_type(
        &self, 
        index: TypeIndex
    ) -> WasmResult<ModuleTypeIndex> { ... }

    fn type_to_instance_type(
        &self, 
        index: TypeIndex
    ) -> WasmResult<InstanceTypeIndex> { ... }

    fn reserve_imports(&mut self, _num: u32) -> WasmResult<()> { ... }

    fn declare_event_import(
        &mut self, 
        event: Event, 
        module: &'data str, 
        field: Option<&'data str>
    ) -> WasmResult<()> { ... }

    fn declare_module_import(
        &mut self, 
        ty_index: TypeIndex, 
        module: &'data str, 
        field: Option<&'data str>
    ) -> WasmResult<()> { ... }

    fn declare_instance_import(
        &mut self, 
        ty_index: TypeIndex, 
        module: &'data str, 
        field: Option<&'data str>
    ) -> WasmResult<()> { ... }

    fn finish_imports(&mut self) -> WasmResult<()> { ... }

    fn reserve_func_types(&mut self, _num: u32) -> WasmResult<()> { ... }

    fn reserve_tables(&mut self, _num: u32) -> WasmResult<()> { ... }

    fn reserve_memories(&mut self, _num: u32) -> WasmResult<()> { ... }

    fn reserve_events(&mut self, _num: u32) -> WasmResult<()> { ... }

    fn declare_event(&mut self, event: Event) -> WasmResult<()> { ... }

    fn reserve_globals(&mut self, _num: u32) -> WasmResult<()> { ... }

    fn reserve_exports(&mut self, _num: u32) -> WasmResult<()> { ... }

    fn declare_event_export(
        &mut self, 
        event_index: EventIndex, 
        name: &'data str
    ) -> WasmResult<()> { ... }

    fn declare_instance_export(
        &mut self, 
        index: InstanceIndex, 
        name: &'data str
    ) -> WasmResult<()> { ... }

    fn declare_module_export(
        &mut self, 
        index: ModuleIndex, 
        name: &'data str
    ) -> WasmResult<()> { ... }

    fn finish_exports(&mut self) -> WasmResult<()> { ... }

    fn reserve_table_elements(&mut self, _num: u32) -> WasmResult<()> { ... }

    fn reserve_passive_data(&mut self, count: u32) -> WasmResult<()> { ... }

    fn reserve_function_bodies(&mut self, bodies: u32, code_section_offset: u64) { ... }

    fn reserve_data_initializers(&mut self, _num: u32) -> WasmResult<()> { ... }

    fn declare_module_name(&mut self, _name: &'data str) { ... }

    fn declare_func_name(&mut self, _func_index: FuncIndex, _name: &'data str) { ... }

    fn declare_local_name(
        &mut self, 
        _func_index: FuncIndex, 
        _local_index: u32, 
        _name: &'data str
    ) { ... }

    fn custom_section(
        &mut self, 
        _name: &'data str, 
        _data: &'data [u8]
    ) -> WasmResult<()> { ... }

    fn wasm_features(&self) -> WasmFeatures { ... }

    fn reserve_modules(&mut self, amount: u32) { ... }

    fn declare_module(&mut self, ty: TypeIndex) -> WasmResult<()> { ... }

    fn module_start(&mut self, index: usize) { ... }

    fn module_end(&mut self, index: usize) { ... }

    fn reserve_instances(&mut self, amount: u32) { ... }

    fn declare_instance(
        &mut self, 
        module: ModuleIndex, 
        args: Vec<EntityIndex>
    ) -> WasmResult<()> { ... }

    fn declare_alias(&mut self, alias: Alias) -> WasmResult<()> { ... }

}
Expand description

An object satisfying the ModuleEnvironment trait can be passed as argument to the translate_module function. These methods should not be called by the user, they are only for cranelift-wasm internal use.

Required methods

Declares a function signature to the environment.

Declares a function import to the environment.

Declares a table import to the environment.

Declares a memory import to the environment.

Declares a global import to the environment.

Declares the type (signature) of a local function in the module.

Declares a table to the environment.

Declares a memory to the environment

Declares a global to the environment.

Declares a function export to the environment.

Declares a table export to the environment.

Declares a memory export to the environment.

Declares a global export to the environment.

Declares the optional start function.

Fills a declared table with references to functions in the module.

Declare a passive element segment.

Declare a passive data segment.

source

fn define_function_body(
    &mut self,
    validator: FuncValidator<ValidatorResources>,
    body: FunctionBody<'data>
) -> WasmResult<()>

Provides the contents of a function body.

Fills a declared memory with bytes at module instantiation.

Provided methods

Provides the number of types up front. By default this does nothing, but implementations can use this to preallocate memory if desired.

Declares a module type signature to the environment.

Declares an instance type signature to the environment.

Translates a type index to its signature index, only called for type indices which point to functions.

Translates a type index to its module type index, only called for type indices which point to modules.

Translates a type index to its instance type index, only called for type indices which point to instances.

Provides the number of imports up front. By default this does nothing, but implementations can use this to preallocate memory if desired.

Declares an event import to the environment.

Declares a module import to the environment.

Declares an instance import to the environment.

Notifies the implementation that all imports have been declared.

Provides the number of defined functions up front. By default this does nothing, but implementations can use this to preallocate memory if desired.

Provides the number of defined tables up front. By default this does nothing, but implementations can use this to preallocate memory if desired.

Provides the number of defined memories up front. By default this does nothing, but implementations can use this to preallocate memory if desired.

Provides the number of defined events up front. By default this does nothing, but implementations can use this to preallocate memory if desired.

Declares an event to the environment

Provides the number of defined globals up front. By default this does nothing, but implementations can use this to preallocate memory if desired.

Provides the number of exports up front. By default this does nothing, but implementations can use this to preallocate memory if desired.

Declares an event export to the environment.

Declares an instance export to the environment.

Declares an instance export to the environment.

Notifies the implementation that all exports have been declared.

Provides the number of element initializers up front. By default this does nothing, but implementations can use this to preallocate memory if desired.

Provides the number of passive data segments up front.

By default this does nothing, but implementations may use this to pre-allocate memory if desired.

Indicates how many functions the code section reports and the byte offset of where the code sections starts.

Provides the number of data initializers up front. By default this does nothing, but implementations can use this to preallocate memory if desired.

Declares the name of a module to the environment.

By default this does nothing, but implementations can use this to read the module name subsection of the custom name section if desired.

Declares the name of a function to the environment.

By default this does nothing, but implementations can use this to read the function name subsection of the custom name section if desired.

Declares the name of a function’s local to the environment.

By default this does nothing, but implementations can use this to read the local name subsection of the custom name section if desired.

Indicates that a custom section has been found in the wasm file

Returns the list of enabled wasm features this translation will be using.

Indicates that this module will have amount submodules.

Note that this is just child modules of this module, and each child module may have yet more submodules.

Declares that a module will come later with the type signature provided.

Called at the beginning of translating a module.

The index argument is a monotonically increasing index which corresponds to the nth module that’s being translated. This is not the 32-bit index in the current module’s index space. For example the first call to module_start will have index 0.

Note that for nested modules this may be called multiple times.

Called at the end of translating a module.

Note that for nested modules this may be called multiple times.

Indicates that this module will have amount instances.

Declares a new instance which this module will instantiate before it’s instantiated.

Declares a new alias being added to this module.

The alias comes from the instance specified (or the parent if None is supplied) and the index is either in the module’s own index spaces for the parent or an index into the exports for nested instances.

Implementors