wasm-posix-host
    Preparing search index...

    Interface LoadSharedLibraryOptions

    Options for loading a shared library.

    interface LoadSharedLibraryOptions {
        allocateContinuation?: ContinuationAllocate;
        allocateMemory?: (size: number, align: number) => number;
        cppExceptionTag?: Tag;
        deallocateContinuation?: ContinuationDeallocate;
        deallocateMemory?: (addr: number, size: number) => void;
        globalSymbols: Map<string, Function | Global<keyof ValueTypeMap>>;
        got: Map<string, Global<keyof ValueTypeMap>>;
        heapPointer?: { value: number };
        loadedLibraries: Map<string, LoadedSharedLibrary>;
        longjmpTag?: Tag;
        mainModuleSymbols?: ReadonlySet<string>;
        memory: Memory;
        ptrWidth?: 4 | 8;
        resolveLibrary?: (
            name: string,
        ) => Promise<Uint8Array<ArrayBufferLike> | null>;
        resolveLibrarySync?: (name: string) => Uint8Array<ArrayBufferLike> | null;
        sideModuleFork?: SideModuleForkSupport;
        sideModuleForkUnavailableReason?: string;
        stackPointer: Global;
        table: Table;
    }
    Index

    Properties

    allocateContinuation? allocateMemory? cppExceptionTag? deallocateContinuation? deallocateMemory? globalSymbols got heapPointer? loadedLibraries longjmpTag? mainModuleSymbols? memory ptrWidth? resolveLibrary? resolveLibrarySync? sideModuleFork? sideModuleForkUnavailableReason? stackPointer table

    Properties

    allocateContinuation?: ContinuationAllocate

    Page-granular process mapping used only for linked continuation chunks.

    allocateMemory?: (size: number, align: number) => number

    Allocate side-module linear-memory data in the process address space

    cppExceptionTag?: Tag

    Process-owned C++ exception tag shared by every C++ side module. C++ exceptions crossing side-module calls require tag identity as well as a matching payload type, so this must not be allocated per dlopen.

    deallocateContinuation?: ContinuationDeallocate

    Release one inherited or parent-owned continuation mapping.

    deallocateMemory?: (addr: number, size: number) => void

    Release a successful allocateMemory result when loading rolls back.

    globalSymbols: Map<string, Function | Global<keyof ValueTypeMap>>

    Global symbol table: name → function or WebAssembly.Global

    got: Map<string, Global<keyof ValueTypeMap>>

    GOT entries: symbol name → mutable pointer-width WebAssembly.Global

    heapPointer?: { value: number }

    Current heap pointer — updated after allocation when no allocator is supplied

    loadedLibraries: Map<string, LoadedSharedLibrary>

    Already-loaded libraries for dedup and dependency resolution

    longjmpTag?: Tag

    Process-owned exception tag shared by the main image and every side module. When omitted, standalone linker users get one tag lazily and it is retained on this options object for subsequent loads.

    mainModuleSymbols?: ReadonlySet<string>

    Immutable symbol names exported by the main module.

    memory: Memory

    The shared Wasm.Memory used by the process

    ptrWidth?: 4 | 8

    Process pointer width, which also determines the __c_longjmp payload.

    resolveLibrary?: (name: string) => Promise<Uint8Array<ArrayBufferLike> | null>

    Callback to locate and read a library file by name (async version)

    resolveLibrarySync?: (name: string) => Uint8Array<ArrayBufferLike> | null

    Callback to locate and read a library file by name (sync version)

    sideModuleFork?: SideModuleForkSupport

    Present only in a process worker that can drive side-module unwind.

    sideModuleForkUnavailableReason?: string

    Precise rebuild/boundary diagnostic when sideModuleFork is unavailable.

    stackPointer: Global

    Stack pointer global (shared across all modules)

    table: Table

    The process's indirect function table

    Settings

    Member Visibility

    On This Page

    Properties