Struct InstanceGroupState

struct InstanceGroupState {
    main_instance: Option<Instance>,
    main_instance_tls_base: u64,
    side_instances: HashMap<ModuleHandle, DlInstance>,
    stack_pointer: Global,
    memory: Memory,
    indirect_function_table: Table,
    recv_pending_operation_barrier: BusReader<Arc<Barrier>>,
    recv_pending_operation: BusReader<DlOperation>,
}

Fields

main_instance: Option<Instance>

main_instance_tls_base: u64

side_instances: HashMap<ModuleHandle, DlInstance>

stack_pointer: Global

memory: Memory

indirect_function_table: Table

recv_pending_operation_barrier: BusReader<Arc<Barrier>>

recv_pending_operation: BusReader<DlOperation>

Implementations

impl InstanceGroupState

fn main_instance(&self) -> Option<&Instance>

fn tls_base(&self, module_handle: ModuleHandle) -> Option<u64>

fn try_instance(&self, handle: ModuleHandle) -> Option<&Instance>

fn instance(&self, handle: ModuleHandle) -> &Instance

fn allocate_function_table( &mut self, store: &mut impl AsStoreMut, table_size: u32, table_alignment: u32, ) -> Result<u64, RuntimeError>

Allocate space on the indirect function table for the given number of functions

table_alignment is the alignment of the table as a power of two.

fn append_to_function_table( &self, store: &mut impl AsStoreMut, func: Function, ) -> Result<u32, RuntimeError>

fn place_in_function_table_at( &self, store: &mut impl AsStoreMut, func: Function, index: u32, ) -> Result<(), RuntimeError>

fn instantiate_side_module_from_link_state( &mut self, linker_state: &mut LinkerState, store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>, link_state: &mut InProgressLinkState, module_handle: ModuleHandle, ) -> Result<(), LinkError>

fn allocate_function_table_for_existing_module( &mut self, linker_state: &LinkerState, store: &mut impl AsStoreMut, module_handle: ModuleHandle, ) -> Result<(), LinkError>

fn instantiate_side_module_from_linker( &mut self, linker_state: &LinkerState, store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>, module_handle: ModuleHandle, pending_resolutions: &mut PendingResolutionsFromLinker, ) -> Result<(), LinkError>

fn finalize_pending_resolutions_from_linker( &self, pending_resolutions: &PendingResolutionsFromLinker, store: &mut impl AsStoreMut, ) -> Result<(), LinkError>

fn apply_resolved_function( &self, store: &mut impl AsStoreMut, name: &str, resolved_from: ModuleHandle, function_table_index: u32, ) -> Result<(), LinkError>

pub fn apply_function_table_allocation( &mut self, store: &mut impl AsStoreMut, index: u32, size: u32, ) -> Result<(), LinkError>

fn apply_dl_operation( &mut self, linker_state: &LinkerState, operation: DlOperation, store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>, ) -> Result<(), LinkError>

fn apply_requested_symbols_from_linker( &self, store: &mut impl AsStoreMut, linker_state: &LinkerState, ) -> Result<(), LinkError>

fn resolve_exported_symbol( &self, symbol: &str, ) -> Option<(ModuleHandle, &Extern)>

fn populate_imports_from_link_state( &self, module_handle: ModuleHandle, linker_state: &mut LinkerState, link_state: &mut InProgressLinkState, store: &mut impl AsStoreMut, module: &Module, imports: &mut Imports, env: &FunctionEnv<WasiEnv>, well_known_imports: &[(&str, &str, u64)], ) -> Result<(), LinkError>

fn populate_imports_from_linker( &self, module_handle: ModuleHandle, linker_state: &LinkerState, store: &mut impl AsStoreMut, module: &Module, imports: &mut Imports, env: &FunctionEnv<WasiEnv>, well_known_imports: &[(&str, &str, u64)], pending_resolutions: &mut PendingResolutionsFromLinker, ) -> Result<(), LinkError>

fn resolve_export( &self, linker_state: &LinkerState, store: &mut impl AsStoreMut, module_handle: Option<ModuleHandle>, symbol: &str, allow_hidden: bool, ) -> Result<(PartiallyResolvedExport, ModuleHandle), ResolveError>

fn resolve_export_from( &self, store: &mut impl AsStoreMut, module_handle: ModuleHandle, symbol: &str, instance: &Instance, dylink_info: &DylinkInfo, memory_base: u64, tls_base: Option<u64>, allow_hidden: bool, ) -> Result<PartiallyResolvedExport, ResolveError>

fn generate_stub_function( &self, store: &mut impl AsStoreMut, ty: &FunctionType, env: &FunctionEnv<WasiEnv>, requesting_module: ModuleHandle, name: String, ) -> Function

fn finalize_pending_globals( &self, linker_state: &mut LinkerState, store: &mut impl AsStoreMut, unresolved_globals: &Vec<UnresolvedGlobal>, ) -> Result<(), LinkError>