Sign in

    Milky2018/wasmoon_jit/artifact/installer does not have a README file

    JitInstallError

    pub(all) suberror JitInstallError {
    ResolutionFailed(kind~ : String, name~ : String)
    AllocationFailed(function_index~ : Int)
    RelocationFailed(function_index~ : Int, message~ : String)
    ProtectionFailed(function_index~ : Int)
    RegistrationFailed(function_index~ : Int, message~ : String)
    PublicationFailed(message~ : String)
    TrampolineAllocationFailed(code_size~ : Int)
    CodeQuotaExceeded
    } derive(Eq,
    Debug
    )

    Structured failures from the Wasmoon-owned executable-code transaction.

    JitInstallError::equal

    JitInstallError::not_equal

    fn JitInstallError::not_equal(x : JitInstallError, y : JitInstallError) -> Bool

    ExecCode

    type ExecCode

    GC-managed executable code block wrapper.

    InstalledCode

    pub struct InstalledCode {
    // private fields
    }

    Opaque ownership of a fully linked and executable artifact.

    Construction is the publication boundary: no staged address is returned before every mapping, relocation, metadata record, permission transition, and instruction-cache flush has succeeded.

    InstalledCode::entry_address

    fn InstalledCode::entry_address(self : InstalledCode, function_index : Int) -> Int64?

    InstalledCode::functions

    InstalledCode::imports

    InstalledCode::release

    fn InstalledCode::release(self : InstalledCode) -> Unit

    Release every executable mapping owned by this installation.

    The embedding must ensure that no invocation or continuation can still enter these addresses. Repeated calls are harmless.

    InstalledFunction

    pub struct InstalledFunction {
    // private fields
    }

    Address-dependent metadata and entry identity for one committed function.

    Returned metadata arrays are copies. The addresses remain valid only while the owning InstalledCode is retained.

    InstalledFunction::code_address

    fn InstalledFunction::code_address(self : InstalledFunction) -> Int64

    InstalledFunction::code_size

    fn InstalledFunction::code_size(self : InstalledFunction) -> Int

    InstalledFunction::entry_address

    fn InstalledFunction::entry_address(self : InstalledFunction) -> Int64

    InstalledFunction::entry_offset

    fn InstalledFunction::entry_offset(self : InstalledFunction) -> Int

    InstalledFunction::frame_size

    fn InstalledFunction::frame_size(self : InstalledFunction) -> Int

    InstalledImport

    pub struct InstalledImport {
    // private fields
    }

    A resolved import retained by a committed installation.

    InstalledImport::address

    fn InstalledImport::address(self : InstalledImport) -> Int64

    InstalledTrampoline

    pub struct InstalledTrampoline {
    // private fields
    }

    Opaque ownership of process-local executable trampoline code.

    InstalledTrampoline::entry_address

    fn InstalledTrampoline::entry_address(self : InstalledTrampoline) -> Int64

    InstalledTrampoline::release

    fn InstalledTrampoline::release(self : InstalledTrampoline) -> Unit

    Release this trampoline after its owning execution context is closed.

    JitCodeInstaller

    pub struct JitCodeInstaller {
    // private fields
    }

    Installer policy plus the embedding-provided external/data symbol resolver.

    JitCodeInstaller::current

    Return the last fully committed installation, if any.

    JitCodeInstaller::install

    Install one verified live or decoded artifact as a single transaction.

    JitCodeInstaller::install_trampoline

    fn JitCodeInstaller::install_trampoline(self : JitCodeInstaller, code : Array[Int]) -> InstalledTrampoline raise JitInstallError

    Install process-local trampoline bytes without exposing allocation, copying, permission changes, or instruction-cache mutation.

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io