Struct InstanceGroupState 

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

Fields

main_instance: Option<Instance>

main_instance_tls_base: Option<u64>

side_instances: HashMap<ModuleHandle, DlInstance>

stack_pointer: Global

memory: Memory

indirect_function_table: Table

c_longjmp: Tag

cpp_exception: Tag

recv_pending_operation_barrier: BusReader<Arc<Barrier>>

recv_pending_operation: BusReader<DlOperation>

Implementations

impl InstanceGroupState

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

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

pub(in state::linker) 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>

impl InstanceGroupState

pub(in state::linker) 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>

pub(in state::linker) 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 define_common_import( &self, module_handle: ModuleHandle, store: &mut impl AsStoreMut, import: &ImportType, imports: &mut Imports, well_known_imports: &[(&str, &str, u64)], memory_import_mode: MemoryImportMode, ) -> Result<bool, LinkError>

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

impl InstanceGroupState

pub(in state::linker) 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.

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

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

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

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

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

impl InstanceGroupState

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

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

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

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

pub(super) 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>

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

pub(super) fn complete_side_module_from_linker( &mut self, prepared: PreparedSideFromLinker, tls_base: Option<u64>, store: &mut impl AsStoreMut, ) -> Result<(), LinkError>

pub(super) 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>

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

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

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

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