🥮 mooncakes.io

    wasmoon_jit

    Wasmoon-specific JIT integration and native runtime glue

    wasm
    jit
    runtime
    native
    Download zip
    Author
    Version
    0.15.0
    License
    Apache-2.0
    Repository
    Last updated
    10 days ago
    Downloads
    135

    Dependencies

    #wasmoon_jit

    JIT integration and native runtime support for Wasmoon.

    wasmoon_jit connects the compiler pipeline to Wasmoon's runtime. It provides VMContext layouts, native runtime helpers, v9 artifacts, trampolines, WASI bridge glue, and integration planning for loading generated code.

    #Packages

    • Milky2018/wasmoon_jit: runtime layout, JIT integration planning, trampolines, runtime symbols, and helper APIs.
    • Milky2018/wasmoon_jit/artifact: target-portable Cwasm manifests, symbolic function identities, signatures, and unlinked code-object data.
    • Milky2018/wasmoon_jit/perf: optional JIT performance metrics.

    #When to use it

    Use wasmoon_jit when integrating generated code with the Wasmoon runtime, including VMContext layout, runtime helper symbols, trampolines, v9 artifacts, and installed-code lifecycle management.

    load_artifact keeps loading separate from installation: it performs bounded decoding, exact manifest and CPU-feature compatibility checks, symbolic target validation, and code-object verification without resolving an address or allocating executable memory.

    #Example: plan MilkIR through the Wasmoon JIT pipeline

    This API runs a MilkIR function through target lowering, register allocation, and emission, then returns the generated bytes and runtime integration data. Dialect verification failures are returned as JitPipelineError before register allocation or emission.

    ///|
    test "plan a small MilkIR function for x64 JIT integration" {
      let signature = @milkir.Signature::Signature([I64, I64], [I64])
      let milk = @milkir.Function::with_signature("add64", signature)
      let lhs = milk.param(0).unwrap()
      let rhs = milk.param(1).unwrap()
      let sum = milk.new_value(I64)
      let entry = milk.new_block([])
      entry.append_inst(milk.new_inst(Scalar(IntBinary(Add)), [lhs, rhs], [sum]))
      entry.set_terminator(Return([sum]))
      let plan = plan_milkir_integration_for_target(milk, X64)
      inspect(plan.entry_symbol, content="add64")
      debug_inspect(plan.target, content="X64")
      inspect(plan.object.get_bytes().length() > 0, content="true")
    }

    #Persisted artifacts

    Milky2018/wasmoon_jit/artifact defines the v9 ordinary-data format. The live compiler produces symbolic, unlinked function code; load_artifact performs bounded decoding and exact compatibility verification; and JitCodeInstaller owns relocation, executable-memory mutation, and publication. There is no compatibility decoder for the removed v8 format.

    #Compiler pipeline

    JIT planning composes milkir, milkir/native, wasm_milkir/native, vcode_regalloc, and the selected target package. Each target owns instruction selection, allocation policy, frame layout, and emission. The resulting code object is combined with VMContext metadata, runtime symbols, and trampolines before it is installed and invoked by Wasmoon. Native stubs are private implementation details of this package rather than a separate public package.

    ArtifactIncompatible

    source
    pub suberror ArtifactIncompatible {
      TargetMismatch(expected~ : 
    TargetSpec    , actual~ : 
    TargetSpec    )
      MissingCpuFeature(name~ : String)
      DuplicateCpuFeature(name~ : String)
      JitAbiVersionMismatch(expected~ : Int, actual~ : Int)
      CodegenRevisionMismatch(expected~ : String, actual~ : String)
      ModuleIdentityMismatch(expected~ : 
    ModuleIdentity    , actual~ : 
    ModuleIdentity    )
      CompilationPolicyMismatch(expected~ : 
    CompilationPolicy    , actual~ : 
    CompilationPolicy    )
      DuplicateFunctionIndex(index~ : Int)
      DuplicateSymbol(name~ : String)
      UnknownSymbol(kind~ : String, name~ : String)
    } derive(Eq, 
    Debug    )

    ArtifactIncompatible::equal

    source

    ArtifactIncompatible::not_equal

    source

    ArtifactIncompatible::to_repr

    source

    ArtifactLoadError

    source

    ArtifactLoadError::equal

    source

    ArtifactLoadError::not_equal

    source
    fn ArtifactLoadError::not_equal(x : ArtifactLoadError, y : ArtifactLoadError) -> Bool

    ArtifactLoadError::to_repr

    source

    CHeapError

    source
    pub(all) suberror CHeapError {
      OutOfBoundsArrayAccess
      NullReference
      OutOfMemory
    }

    CHeap error types for runtime errors

    GCSetupError

    source
    pub(all) suberror GCSetupError {
      MissingJITContext
      InvalidFuncCount(num_funcs~ : Int)
      FuncTypeIndicesLengthMismatch(func_type_indices_len~ : Int, num_funcs~ : Int)
      MissingFunctionTableContext(num_funcs~ : Int)
    } derive(
    Debug    )

    Error for invalid JIT GC setup context

    GCSetupError::output

    source
    fn GCSetupError::output(self : GCSetupError, logger : &Logger) -> Unit

    GCSetupError::to_repr

    source

    GCSetupError::to_string

    source
    fn GCSetupError::to_string(self : GCSetupError) -> String

    HostcallImportTrampolineError

    source
    pub suberror HostcallImportTrampolineError {
      UnsupportedHostcallImportTrampoline(message~ : String)
    } derive(Eq, 
    Debug    )

    HostcallImportTrampolineError::equal

    source

    HostcallImportTrampolineError::not_equal

    source

    HostcallImportTrampolineError::output

    source

    HostcallImportTrampolineError::to_repr

    source

    HostcallImportTrampolineError::to_string

    source

    JitInstallError

    source
    pub 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)
    } derive(Eq, 
    Debug    )

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

    JitInstallError::equal

    source

    JitInstallError::not_equal

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

    JitInstallError::to_repr

    source

    JitPipelineError

    source
    pub suberror JitPipelineError {
      NativeLoweringFailed(cause~ : 
    NativeLowerError    )
      AArch64AbiInvalid(cause~ : 
    InternalAbiError    )
      X64AbiInvalid(cause~ : 
    InternalAbiError    )
      AArch64LoweringFailed(cause~ : 
    AArch64LowerError    )
      X64LoweringFailed(cause~ : 
    X64LowerError    )
      AArch64CompilationFailed(cause~ : 
    AArch64CompileError    )
      X64CompilationFailed(cause~ : 
    X64CompileError    )
      AArch64LinkPreparationFailed(cause~ : 
    AArch64LinkError    )
      X64LinkPreparationFailed(cause~ : 
    X64LinkError    )
      InvalidJitRelocation(target~ : NativeTarget, index~ : Int, message~ : String)
      UnsupportedEntrySignature(message~ : String)
      UnsupportedHostArchitecture(tag~ : Int)
      UnsupportedHostOsAbi(tag~ : Int)
      InvalidFunctionIndex(index~ : Int)
    } derive(
    Debug    )

    JitPipelineError::output

    source
    fn JitPipelineError::output(self : JitPipelineError, logger : &Logger) -> Unit

    JitPipelineError::to_repr

    source

    JitPipelineError::to_string

    source
    fn JitPipelineError::to_string(self : JitPipelineError) -> String

    NativeExecutionStateError

    source
    pub suberror NativeExecutionStateError {
      ExecutionStateSealed
      UnknownInvocation(Int64)
      InvocationNotActive(Int64)
      InvocationNotParked(Int64)
      InvocationNotCurrent(Int64)
    } derive(Eq, 
    Debug    )

    Invalid transition in the Store-owned native invocation state machine.

    NativeExecutionStateError::equal

    source

    NativeExecutionStateError::not_equal

    source

    NativeExecutionStateError::output

    source
    fn NativeExecutionStateError::output(self : NativeExecutionStateError, logger : &Logger) -> Unit

    NativeExecutionStateError::to_repr

    source

    NativeExecutionStateError::to_string

    source

    NativeFiberError

    source
    pub suberror NativeFiberError {
      StackAllocationFailed(Int64)
      WrongThread
      InvalidTransition(NativeFiberPhase)
      InvalidState(Int)
      UnexpectedYield(Int64)
      NativeFailure(Int)
    } derive(Eq, 
    Debug    )

    NativeFiberError::equal

    source

    NativeFiberError::not_equal

    source
    fn NativeFiberError::not_equal(x : NativeFiberError, y : NativeFiberError) -> Bool

    NativeFiberError::output

    source
    fn NativeFiberError::output(self : NativeFiberError, logger : &Logger) -> Unit

    NativeFiberError::to_repr

    source

    NativeFiberError::to_string

    source
    fn NativeFiberError::to_string(self : NativeFiberError) -> String

    ArtifactCompatibility

    source

    Host and module contract used to accept or reject a decoded artifact.

    ArtifactCompatibility::equal

    source

    ArtifactCompatibility::not_equal

    source

    ArtifactCompatibility::to_repr

    source

    BacktraceFrame

    source
    pub struct BacktraceFrame {
      pc : Int64
      name : String
      offset : Int64
      func_idx : Int
    }

    Backtrace frame

    CHeap

    source
    pub struct CHeap {
      ptr : Int64
    } derive(
    Debug    )

    C-managed GC Heap The heap is automatically freed when this object is garbage collected.

    CHeap::CHeap

    source
    fn CHeap::CHeap(capacity? : Int) -> CHeap

    Create a new C heap with the given initial capacity

    CHeap::alloc_array

    source
    fn CHeap::alloc_array(self : CHeap, type_idx : Int, len : Int, init_value : 
    Value    ) -> Int raise CHeapError

    Allocate a new array with initial value Returns gc_ref (0-based index for external use)

    CHeap::alloc_array_from_values

    source
    fn CHeap::alloc_array_from_values(self : CHeap, type_idx : Int, elements : Array[
    Value    ]) -> Int raise CHeapError

    Allocate a new array from existing values Returns gc_ref (0-based index for external use)

    CHeap::alloc_struct

    source
    fn CHeap::alloc_struct(self : CHeap, type_idx : Int, fields : Array[
    Value    ]) -> Int raise CHeapError

    Allocate a new struct Returns gc_ref (0-based index for external use)

    CHeap::array_copy

    source
    fn CHeap::array_copy(self : CHeap, dst_idx : Int, dst_offset : Int, src_idx : Int, src_offset : Int, count : Int) -> Unit raise CHeapError

    Copy array elements

    CHeap::array_fill

    source
    fn CHeap::array_fill(self : CHeap, array_idx : Int, offset : Int, value : 
    Value    , count : Int) -> Unit raise CHeapError

    Fill array elements with a value

    CHeap::array_get

    source
    fn CHeap::array_get(self : CHeap, array_idx : Int, elem_idx : Int, elem_type : 
    ValueType    ) -> 
    Value     raise CHeapError

    Get an array element

    CHeap::array_len

    source
    fn CHeap::array_len(self : CHeap, array_idx : Int) -> Int

    Get array length

    CHeap::array_set

    source
    fn CHeap::array_set(self : CHeap, array_idx : Int, elem_idx : Int, value : 
    Value    ) -> Unit raise CHeapError

    Set an array element

    CHeap::collect

    source
    fn CHeap::collect(self : CHeap, roots : Array[
    Value    ]) -> Int

    Perform garbage collection with given roots Returns the number of objects collected

    CHeap::free

    source
    fn CHeap::free(self : CHeap) -> Unit

    Free the C heap (called explicitly if needed before GC)

    CHeap::get_barrier_writes

    source
    fn CHeap::get_barrier_writes(self : CHeap) -> Int

    Get total number of write-barrier calls recorded

    CHeap::get_base

    source
    fn CHeap::get_base(self : CHeap) -> Int64

    Get heap base pointer (for JIT inline access)

    CHeap::get_capacity

    source
    fn CHeap::get_capacity(self : CHeap) -> Int64

    Get heap capacity (total allocated bytes)

    CHeap::get_kind

    source
    fn CHeap::get_kind(self : CHeap, idx : Int) -> Int

    Get the kind of an object (1=struct, 2=array)

    CHeap::get_object_count

    source
    fn CHeap::get_object_count(self : CHeap) -> Int

    Get number of objects in heap

    CHeap::get_offset

    source
    fn CHeap::get_offset(self : CHeap, idx : Int) -> Int

    Get object offset in heap (for JIT inline access)

    CHeap::get_ptr

    source
    fn CHeap::get_ptr(self : CHeap) -> Int64

    Get the raw C pointer (for JIT)

    CHeap::get_size

    source
    fn CHeap::get_size(self : CHeap) -> Int64

    Get current heap size (bytes used)

    CHeap::get_total_allocations

    source
    fn CHeap::get_total_allocations(self : CHeap) -> Int

    Get total number of allocations since heap creation

    CHeap::get_total_collections

    source
    fn CHeap::get_total_collections(self : CHeap) -> Int

    Get total number of GC cycles performed

    CHeap::get_type_idx

    source
    fn CHeap::get_type_idx(self : CHeap, idx : Int) -> Int

    Get the type index of an object

    CHeap::get_usage_ratio

    source
    fn CHeap::get_usage_ratio(self : CHeap) -> Double

    Get heap usage ratio (0.0 to 1.0)

    CHeap::is_array

    source
    fn CHeap::is_array(self : CHeap, idx : Int) -> Bool

    Check if this is an array

    CHeap::is_struct

    source
    fn CHeap::is_struct(self : CHeap, idx : Int) -> Bool

    Check if this is a struct

    CHeap::is_valid

    source
    fn CHeap::is_valid(self : CHeap, idx : Int) -> Bool

    Check if an object reference is valid

    CHeap::make_allocation_rollback

    source
    fn CHeap::make_allocation_rollback(self : CHeap, roots : () -> Array[
    Value    ]) -> (() -> Unit)

    Return an owner-bound action that reclaims later allocations unless they remain reachable when the action runs. Retained object-table indices are never reused.

    CHeap::should_collect

    source
    fn CHeap::should_collect(self : CHeap, threshold? : Double) -> Bool

    Check if GC should be triggered based on heap usage Default threshold is 75% of capacity

    CHeap::struct_get

    source
    fn CHeap::struct_get(self : CHeap, struct_idx : Int, field_idx : Int, field_type : 
    ValueType    ) -> 
    Value

    Get a struct field value

    CHeap::struct_set

    source
    fn CHeap::struct_set(self : CHeap, struct_idx : Int, field_idx : Int, value : 
    Value    ) -> Unit

    Set a struct field value

    CHeap::to_repr

    source

    CHeap::verify

    source
    fn CHeap::verify(self : CHeap, verbose? : Bool) -> Bool

    Verify heap invariants (for debugging)

    CallCounter

    source
    pub(all) struct CallCounter {
      counts : Map[Int, Int]
      total_calls : Int
    }

    Stores call counts for each function

    CallCounter::CallCounter

    source
    fn CallCounter::CallCounter() -> CallCounter

    CallCounter::clear

    source
    fn CallCounter::clear(self : CallCounter) -> Unit

    Clear all counters

    CallCounter::get_count

    source
    fn CallCounter::get_count(self : CallCounter, func_idx : Int) -> Int

    Get the call count for a function

    CallCounter::increment

    source
    fn CallCounter::increment(self : CallCounter, func_idx : Int) -> Int

    Increment the call count for a function

    CallCounter::reset

    source
    fn CallCounter::reset(self : CallCounter, func_idx : Int) -> Unit

    Reset counter for a specific function

    CallCounter::total

    source
    fn CallCounter::total(self : CallCounter) -> Int

    Get total number of calls tracked

    CallCounter::unique_functions

    source
    fn CallCounter::unique_functions(self : CallCounter) -> Int

    Get the number of unique functions called

    CompilationDecision

    source
    pub(all) enum CompilationDecision {
      Interpret
      CompileAndExecute(CompilationMode)
      ExecuteCompiled
    }

    Decision about what to do with a function call

    CompilationDecision::output

    source
    fn CompilationDecision::output(self : CompilationDecision, logger : &Logger) -> Unit

    CompilationDecision::to_string

    source
    fn CompilationDecision::to_string(self : CompilationDecision) -> String

    CompilationMode

    source
    pub(all) enum CompilationMode {
      Interpret
      Baseline
      Optimized
    }

    The compilation mode for a function

    CompilationMode::output

    source
    fn CompilationMode::output(self : CompilationMode, logger : &Logger) -> Unit

    CompilationMode::to_string

    source
    fn CompilationMode::to_string(self : CompilationMode) -> String

    CompilationQueue

    source
    pub(all) struct CompilationQueue {
      requests : Array[CompilationRequest]
      max_size : Int
    }

    Queue of pending compilation requests

    CompilationQueue::CompilationQueue

    source
    fn CompilationQueue::CompilationQueue(max_size : Int) -> CompilationQueue

    CompilationQueue::clear

    source
    fn CompilationQueue::clear(self : CompilationQueue) -> Unit

    Clear the queue

    CompilationQueue::contains

    source
    fn CompilationQueue::contains(self : CompilationQueue, func_idx : Int) -> Bool

    Check if a function is in the queue

    CompilationQueue::dequeue

    source

    Get the next request to process

    CompilationQueue::enqueue

    source
    fn CompilationQueue::enqueue(self : CompilationQueue, request : CompilationRequest) -> Bool

    Add a compilation request to the queue

    CompilationQueue::is_empty

    source
    fn CompilationQueue::is_empty(self : CompilationQueue) -> Bool

    Check if queue is empty

    CompilationQueue::length

    source
    fn CompilationQueue::length(self : CompilationQueue) -> Int

    Get queue length

    CompilationRequest

    source
    pub(all) struct CompilationRequest {
      func_idx : Int
      mode : CompilationMode
      priority : Int
    }

    A request to compile a function

    CompilationRequest::CompilationRequest

    source
    fn CompilationRequest::CompilationRequest(func_idx : Int, mode : CompilationMode) -> CompilationRequest

    CompilationRequest::with_priority

    source
    fn CompilationRequest::with_priority(func_idx : Int, mode : CompilationMode, priority : Int) -> CompilationRequest

    CompilationStrategy

    source
    pub(all) struct CompilationStrategy {
      profiler : Profiler
      queue : CompilationQueue
      config : TieredConfig
      decisions_interpret : Int
      decisions_compile : Int
      decisions_compiled : Int
    }

    The main compilation strategy manager

    CompilationStrategy::CompilationStrategy

    source
    fn CompilationStrategy::CompilationStrategy(config : TieredConfig) -> CompilationStrategy

    CompilationStrategy::decide

    source
    fn CompilationStrategy::decide(self : CompilationStrategy, func_idx : Int) -> CompilationDecision

    Make a compilation decision for a function call

    CompilationStrategy::is_compiled

    source
    fn CompilationStrategy::is_compiled(self : CompilationStrategy, func_idx : Int) -> Bool

    Check if a function is compiled

    CompilationStrategy::mark_compiled

    source
    fn CompilationStrategy::mark_compiled(self : CompilationStrategy, func_idx : Int) -> Unit

    Mark a function as compiled

    CompilationStrategy::next_to_compile

    source

    Get the next function to compile (for background compilation)

    CompilationStrategy::output

    source
    fn CompilationStrategy::output(self : CompilationStrategy, logger : &Logger) -> Unit

    CompilationStrategy::schedule_compilation

    source
    fn CompilationStrategy::schedule_compilation(self : CompilationStrategy, func_idx : Int, mode : CompilationMode) -> Bool

    Schedule a function for background compilation

    CompilationStrategy::stats

    source
    fn CompilationStrategy::stats(self : CompilationStrategy) -> (Int, Int, Int, Int, Int, Int)

    Get strategy statistics

    CompilationStrategy::to_string

    source
    fn CompilationStrategy::to_string(self : CompilationStrategy) -> String

    DWARFBuilder

    source
    pub struct DWARFBuilder {
      // private fields
    }

    DWARF debug info builder Accumulates function metadata and generates DWARF sections

    DWARFBuilder::DWARFBuilder

    source
    fn DWARFBuilder::DWARFBuilder() -> DWARFBuilder

    Create a new DWARF builder

    DWARFBuilder::add_function

    source
    fn DWARFBuilder::add_function(self : DWARFBuilder, name : String, addr : Int64, size : Int, func_idx : Int) -> Unit

    Add a function to the DWARF debug info Parameters: name: Function name (e.g., "func_42" or "my_function") addr: Function start address in memory size: Function size in bytes func_idx: WebAssembly function index

    DWARFBuilder::capture_backtrace

    source
    fn DWARFBuilder::capture_backtrace(self : DWARFBuilder) -> Array[BacktraceFrame]

    Capture and format a backtrace from the current trap state Returns an array of backtrace frames

    DWARFBuilder::destroy

    source
    fn DWARFBuilder::destroy(self : DWARFBuilder) -> Unit

    Destroy the DWARF builder and free all resources This also unregisters the debug info if it was registered

    DWARFBuilder::format_backtrace

    source
    fn DWARFBuilder::format_backtrace(_self : DWARFBuilder, frames : Array[BacktraceFrame]) -> String

    Format a backtrace as a string

    DWARFBuilder::lookup_address

    source
    fn DWARFBuilder::lookup_address(self : DWARFBuilder, addr : Int64) -> FunctionInfo?

    Lookup an address to find which function it belongs to Returns None if the address is not in any known function

    DWARFBuilder::register

    source
    fn DWARFBuilder::register(self : DWARFBuilder, verbose? : Bool) -> Unit

    Register the DWARF debug info with the debugger This generates an in-memory Mach-O/ELF object file with DWARF sections and registers it with LLDB/GDB via the standard JIT interface. After calling this, function names will appear in stack traces. Also sets this builder as the active one for backtrace lookups. verbose: if true, print debug info to stderr

    DWARFBuilder::unregister

    source
    fn DWARFBuilder::unregister(self : DWARFBuilder) -> Unit

    Unregister DWARF debug info from the debugger Call this before destroying if you want to explicitly unregister

    ExecCode

    source
    type ExecCode

    GC-managed executable code block wrapper.

    FunctionInfo

    source
    pub struct FunctionInfo {
      name : String
      func_idx : Int
      offset : Int64
    }

    Function lookup result

    FunctionTemperature

    source
    pub(all) enum FunctionTemperature {
      Cold
      Warm
      Hot
    }

    Temperature of a function based on call frequency

    FunctionTemperature::output

    source
    fn FunctionTemperature::output(self : FunctionTemperature, logger : &Logger) -> Unit

    FunctionTemperature::to_string

    source
    fn FunctionTemperature::to_string(self : FunctionTemperature) -> String

    GcSafepoint

    source
    pub struct GcSafepoint {
      code_offset : Int
      live_refs : Array[Int]
      metadata : Int64
    } derive(
    Debug    )

    Information about a GC safepoint in generated code.

    GcSafepoint::GcSafepoint

    source
    fn GcSafepoint::GcSafepoint(code_offset : Int, live_refs : Array[Int], metadata : Int64) -> GcSafepoint

    GcSafepoint::to_repr

    source

    GcSlot

    source
    pub struct GcSlot {
      lo : Int64
      hi : Int64
    } derive(Eq, 
    Debug    )

    One field or element as the C heap stores it.

    lo is the runtime word. Every value kind except v128 is encoded entirely into it, and it is the only word the collector scans for references, so a reference must never be written to hi.

    GcSlot::equal

    source
    fn GcSlot::equal(GcSlot, GcSlot) -> Bool

    GcSlot::not_equal

    source
    fn GcSlot::not_equal(x : GcSlot, y : GcSlot) -> Bool

    GcSlot::to_repr

    source

    HostcallImportTrampolineCode

    source
    pub(all) struct HostcallImportTrampolineCode {
      code : Array[Int]
    }

    Machine-code bytes for Wasm-ABI import trampolines that call the wasmoon_jit_hostcall C bridge.

    HostcallImportTrampolineLayout

    source
    pub(all) struct HostcallImportTrampolineLayout {
      arg_slots : Int
      result_slots : Int
      values_vec_bytes : Int
      int_overflow_count : Int
      float_overflow_types : Array[
    ValueType    ]
    }

    HotThreshold

    source
    pub(all) struct HotThreshold {
      warm_threshold : Int
      hot_threshold : Int
    }

    Configuration for hot function detection

    HotThreshold::aggressive

    source
    fn HotThreshold::aggressive() -> HotThreshold

    HotThreshold::conservative

    source
    fn HotThreshold::conservative() -> HotThreshold

    HotThreshold::default

    source
    fn HotThreshold::default() -> HotThreshold

    ImportFunctionResolution

    source
    pub(all) enum ImportFunctionResolution {
      DirectImportFunction(Int64)
      HostImportFunctionAddr(Int)
      UnsupportedImportFunction
    } derive(Eq, 
    Debug    )

    ImportFunctionResolution::equal

    source

    ImportFunctionResolution::not_equal

    source

    ImportFunctionResolution::to_repr

    source

    InstalledCode

    source
    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

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

    InstalledCode::functions

    source

    InstalledCode::imports

    source

    InstalledCode::release

    source
    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

    source
    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

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

    InstalledFunction::code_size

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

    InstalledFunction::entry_address

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

    InstalledFunction::entry_offset

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

    InstalledFunction::frame_size

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

    InstalledFunction::identity

    source

    InstalledFunction::safepoints

    source

    InstalledFunction::sources

    source

    InstalledFunction::traps

    source

    InstalledFunction::unwind

    source

    InstalledImport

    source
    pub struct InstalledImport {
      // private fields
    }

    A resolved import retained by a committed installation.

    InstalledImport::address

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

    InstalledImport::identity

    source

    InstalledTrampoline

    source
    pub struct InstalledTrampoline {
      // private fields
    }

    Opaque ownership of process-local executable trampoline code.

    InstalledTrampoline::entry_address

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

    InstalledTrampoline::release

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

    Release this trampoline after its owning execution context is closed.

    JITDebugDB

    source
    pub struct JITDebugDB {
      entries : Map[Int, JITFunctionDebug]
    }

    Optional in-memory database of per-function debug dumps.

    JITDebugDB::JITDebugDB

    source
    fn JITDebugDB::JITDebugDB() -> JITDebugDB

    JITDebugDB::get

    source
    fn JITDebugDB::get(self : JITDebugDB, func_idx : Int) -> JITFunctionDebug?

    JITDebugDB::set

    source
    fn JITDebugDB::set(self : JITDebugDB, func_idx : Int, debug : JITFunctionDebug) -> Unit

    JITFunctionDebug

    source
    pub struct JITFunctionDebug {
      ir : String
      target_vcode : String
      allocated_vcode : String
      machine_code : String
    }

    Per-function compilation dumps captured for dump-on-trap.

    JITFunctionDebug::JITFunctionDebug

    source
    fn JITFunctionDebug::JITFunctionDebug(ir : String, target_vcode : String, allocated_vcode : String, machine_code : String) -> JITFunctionDebug

    JITTable

    source

    Shared indirect table that can be used by multiple JIT modules.

    JITTable::get_entry_type

    source
    fn JITTable::get_entry_type(self : JITTable, table_idx : Int) -> Int

    Read raw entry type index from the shared table.

    JITTable::get_entry_value

    source
    fn JITTable::get_entry_value(self : JITTable, table_idx : Int) -> Int64

    Read raw entry value bits from the shared table.

    JITTable::get_max

    source
    fn JITTable::get_max(self : JITTable) -> Int?

    Get the table max size.

    JITTable::get_size

    source
    fn JITTable::get_size(self : JITTable) -> Int

    Get the table size.

    JITTable::raw_ptr

    source
    fn JITTable::raw_ptr(self : JITTable) -> Int64

    Get the raw shared table pointer.

    JITTable::set

    source
    fn JITTable::set(self : JITTable, table_idx : Int, func_ptr : Int64, type_hash : Int) -> Unit

    Set an entry in the shared table.

    JITTable::to_repr

    source

    JITTableOwner

    source
    type JITTableOwner derive(
    Debug    )

    Destruction capability for one shared JIT table allocation.

    JITTableOwner::close

    source
    fn JITTableOwner::close(self : JITTableOwner) -> Unit

    Release the owned shared table allocation. Repeated close calls are harmless.

    JITTableOwner::table

    source
    fn JITTableOwner::table(self : JITTableOwner) -> JITTable

    Borrow the table without transferring its destruction capability.

    JITTableOwner::to_repr

    source

    JITTableOwner::try_alloc

    source
    fn JITTableOwner::try_alloc(size : Int, max : Int?) -> JITTableOwner?

    Create a new owned shared JIT table. Note: size 0 is valid (empty table that can grow later).

    JitCodeInstaller

    source
    pub struct JitCodeInstaller {
      // private fields
    }

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

    JitCodeInstaller::current

    source

    Return the last fully committed installation, if any.

    JitCodeInstaller::install

    source

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

    JitCodeInstaller::install_trampoline

    source
    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.

    JitCodeInstaller::new

    source

    JitCodeObject

    source
    pub struct JitCodeObject {
      // private fields
    } derive(
    Debug    )

    JitCodeObject::get_bytes

    source
    fn JitCodeObject::get_bytes(self : JitCodeObject) -> Array[Int]

    JitCodeObject::to_repr

    source

    JitIntegrationPlan

    source
    pub(all) struct JitIntegrationPlan {
      entry_symbol : String
      target : NativeTarget
      object : JitCodeObject
    }

    JitPipelineDiagnostics

    source
    pub struct JitPipelineDiagnostics {
      target_vcode : String
      allocated_vcode : String
      code_object : String
      machine_code : String
    } derive(
    Debug    )

    Stable, read-only renderings of the final native compilation checkpoints. Concrete target instruction, allocation, and frame types remain owned by their target modules and do not cross this diagnostics facade.

    JitPipelineDiagnostics::to_repr

    source

    LoadedArtifact

    source

    A decoded artifact whose manifest and every code object have been checked.

    LoadedArtifact::artifact

    source

    LoadedArtifact::code_objects

    source

    MemoryDescriptorLayout

    source
    pub(all) struct MemoryDescriptorLayout {
      base_offset : Int
      current_length_offset : Int
    }

    Fixed prefix layout of wasmoon_memory_t accessed by generated JIT code.

    Keep these offsets in sync with jit_ffi/jit_ffi.h::wasmoon_memory_t.

    MemoryInfo

    source
    pub struct MemoryInfo {
      ptr : Int64
      size : Int64
      max_pages : Int?
    }

    Memory information for JIT execution.

    MemoryInfo::MemoryInfo

    source
    fn MemoryInfo::MemoryInfo(ptr : Int64, size : Int64, max_pages : Int?) -> MemoryInfo

    Create a new MemoryInfo.

    NativeCompiler

    source
    pub struct NativeCompiler {
      // private fields
    }

    Compile one verified Wasm MilkIR body directly into the final unlinked artifact representation. Symbolic relocations are retained unchanged.

    NativeCompiler::compile_wasm_body_artifact_function

    source
    fn NativeCompiler::compile_wasm_body_artifact_function(self : NativeCompiler, function : 
    Function    , validation_context : 
    WasmValidationContext    , function_index~ : Int, signature~ : 
    Signature    , use_subtype_indirect_check? : Bool, canonical_type_indices? : Array[Int]) -> 
    FunctionCode     raise JitPipelineError

    Compile one function while retaining target allocator scratch capacity for the next serial call on this compiler.

    NativeCompiler::new

    source

    NativeExecutionState

    source
    type NativeExecutionState

    Store-scoped owner of native invocation lifetimes.

    The active stack models nested native entry. Parked invocations remain in invocations but are absent from active, so any number of component tasks can retain distinct native resources without sharing an execution stack.

    NativeExecutionState::NativeExecutionState

    source
    fn NativeExecutionState::NativeExecutionState() -> NativeExecutionState

    NativeExecutionState::active_depth

    source
    fn NativeExecutionState::active_depth(self : NativeExecutionState) -> Int

    NativeExecutionState::begin

    source

    NativeExecutionState::current_invocation

    source
    fn NativeExecutionState::current_invocation(self : NativeExecutionState) -> Int64?

    NativeExecutionState::live_count

    source
    fn NativeExecutionState::live_count(self : NativeExecutionState) -> Int

    NativeExecutionState::parked_count

    source
    fn NativeExecutionState::parked_count(self : NativeExecutionState) -> Int

    NativeExecutionState::release_if_live

    source
    fn NativeExecutionState::release_if_live(self : NativeExecutionState, id : Int64) -> Unit

    Best-effort scope cleanup after an error.

    Strict user-visible transitions use complete and cancel; this method is intentionally idempotent so a defer can release an unfinished invocation without masking the original trap.

    NativeExecutionState::seal

    source

    Irreversibly reject new invocations while preserving cleanup operations for existing handles.

    NativeExecutionState::to_repr

    source

    NativeFiber

    source
    type NativeFiber

    Fixed-stack, single-threaded native fiber.

    The external object owns a guarded native stack and the entry closure. A fiber may only be continued or cancelled on the thread that created it.

    NativeFiber::cancel

    source
    fn NativeFiber::cancel(self : NativeFiber) -> Unit raise NativeFiberError

    NativeFiber::continue_with

    source
    fn NativeFiber::continue_with(self : NativeFiber, value? : Int64) -> NativeFiberEvent raise NativeFiberError

    NativeFiber::guard_size

    source
    fn NativeFiber::guard_size(self : NativeFiber) -> Int64

    NativeFiber::new

    source
    fn NativeFiber::new(entry : () -> Int64, stack_size? : Int64) -> NativeFiber raise NativeFiberError

    NativeFiber::phase

    source

    NativeFiber::stack_size

    source
    fn NativeFiber::stack_size(self : NativeFiber) -> Int64

    NativeFiber::suspend

    source
    fn NativeFiber::suspend(value : Int64) -> Int64

    Suspend the currently running native fiber and return the next resume value.

    NativeFiber::to_repr

    source

    NativeFiberEvent

    source
    pub(all) enum NativeFiberEvent {
      Yielded(Int64)
      Finished(Int64)
    } derive(Eq, 
    Debug    )

    Result of entering or continuing a native fiber.

    NativeFiberEvent::equal

    source

    NativeFiberEvent::not_equal

    source
    fn NativeFiberEvent::not_equal(x : NativeFiberEvent, y : NativeFiberEvent) -> Bool

    NativeFiberEvent::to_repr

    source

    NativeFiberPhase

    source
    pub(all) enum NativeFiberPhase {
      Ready
      Running
      Suspended
      Returned
      Cancelled
    } derive(Eq, 
    Debug    )

    Observable lifecycle of a single-threaded native fiber.

    NativeFiberPhase::equal

    source

    NativeFiberPhase::not_equal

    source
    fn NativeFiberPhase::not_equal(x : NativeFiberPhase, y : NativeFiberPhase) -> Bool

    NativeFiberPhase::to_repr

    source

    NativeHostcallOutcome

    source
    pub(all) enum NativeHostcallOutcome {
      HostcallCompleted
      HostcallTrap(Int)
      HostcallSuspended
    } derive(Eq, 
    Debug    )

    Typed result returned by a JIT hostcall dispatcher.

    NativeHostcallOutcome::equal

    source

    NativeHostcallOutcome::not_equal

    source

    NativeHostcallOutcome::to_repr

    source

    NativeInvocationHandle

    source
    type NativeInvocationHandle

    Stable handle for one Store-owned native invocation.

    NativeInvocationHandle::cancel

    source

    NativeInvocationHandle::complete

    source

    NativeInvocationHandle::id

    source

    NativeInvocationHandle::park

    source

    NativeInvocationHandle::phase

    source

    NativeInvocationHandle::reactivate

    source

    NativeInvocationHandle::release_if_live

    source
    fn NativeInvocationHandle::release_if_live(self : NativeInvocationHandle) -> Unit

    NativeInvocationHandle::resource_id

    source

    NativeInvocationHandle::to_repr

    source

    NativeInvocationPhase

    source
    pub(all) enum NativeInvocationPhase {
      Active
      Parked
    } derive(Eq, 
    Debug    )

    Lifecycle phase of a Store-owned native invocation.

    NativeInvocationPhase::equal

    source

    NativeInvocationPhase::not_equal

    source

    NativeInvocationPhase::to_repr

    source

    NativeJITContext

    source
    type NativeJITContext

    NativeJITContext::alloc_guarded_memory

    source
    fn NativeJITContext::alloc_guarded_memory(self : NativeJITContext, initial_pages : Int, max_pages : Int?) -> Int64

    NativeJITContext::alloc_indirect_table

    source
    fn NativeJITContext::alloc_indirect_table(self : NativeJITContext, count : Int) -> Bool

    NativeJITContext::call_trampoline

    source
    fn NativeJITContext::call_trampoline(self : NativeJITContext, trampoline_ptr : Int64, func_ptr : Int64, values_vec : FixedArray[Int64], values_len : Int, use_native_fiber : Bool) -> Int raise NativeFiberError

    NativeJITContext::clear_cancellation_callback

    source
    fn NativeJITContext::clear_cancellation_callback(self : NativeJITContext) -> Unit

    NativeJITContext::clear_gc_heap

    source
    fn NativeJITContext::clear_gc_heap(self : NativeJITContext) -> Unit

    NativeJITContext::clear_hostcall_callback

    source
    fn NativeJITContext::clear_hostcall_callback(self : NativeJITContext) -> Unit

    NativeJITContext::clear_segments

    source
    fn NativeJITContext::clear_segments(self : NativeJITContext) -> Unit

    NativeJITContext::clear_wasi_stdin_buffer

    source
    fn NativeJITContext::clear_wasi_stdin_buffer(self : NativeJITContext) -> Unit

    NativeJITContext::clear_wasi_stdin_callback

    source
    fn NativeJITContext::clear_wasi_stdin_callback(self : NativeJITContext) -> Unit

    NativeJITContext::configure_native_fiber_stack_size

    source
    #alias(alloc_wasm_stack, deprecated="Use configure_native_fiber_stack_size instead")
    fn NativeJITContext::configure_native_fiber_stack_size(self : NativeJITContext, stack_size : Int64) -> Bool

    Configure the guarded stack size used by future native JIT continuations. The stack mapping is allocated only when a continuation starts.

    NativeJITContext::func_count

    source
    fn NativeJITContext::func_count(self : NativeJITContext) -> Int

    NativeJITContext::func_ptr

    source
    fn NativeJITContext::func_ptr(self : NativeJITContext, func_idx : Int) -> Int64

    NativeJITContext::gc_begin_frame

    source
    fn NativeJITContext::gc_begin_frame(self : NativeJITContext, frame_id : Int64) -> Unit

    NativeJITContext::gc_collect_for_alloc

    source
    fn NativeJITContext::gc_collect_for_alloc(self : NativeJITContext, roots : Array[Int64]) -> Int

    NativeJITContext::gc_end_frame

    source
    fn NativeJITContext::gc_end_frame(self : NativeJITContext) -> Unit

    NativeJITContext::gc_environment_is_clear

    source
    fn NativeJITContext::gc_environment_is_clear(self : NativeJITContext) -> Bool

    NativeJITContext::gc_set_root_scratch

    source
    fn NativeJITContext::gc_set_root_scratch(self : NativeJITContext, roots : Array[Int64]) -> Bool

    NativeJITContext::gc_set_safepoint_table

    source
    fn NativeJITContext::gc_set_safepoint_table(self : NativeJITContext, table_ptr : Int64) -> Unit

    NativeJITContext::gc_use_func_safepoints

    source
    fn NativeJITContext::gc_use_func_safepoints(self : NativeJITContext, func_idx : Int) -> Unit

    NativeJITContext::has_configured_native_fiber_stack_size

    source
    #alias(has_wasm_stack, deprecated="Use has_configured_native_fiber_stack_size instead")
    fn NativeJITContext::has_configured_native_fiber_stack_size(self : NativeJITContext) -> Bool

    Check whether a native-fiber stack size override has been configured.

    NativeJITContext::init_wasi

    source
    fn NativeJITContext::init_wasi(self : NativeJITContext, args : Array[String], env : Array[String], preopens : Array[(String, String)], quiet? : Bool) -> Unit

    NativeJITContext::memory_ptr

    source
    fn NativeJITContext::memory_ptr(self : NativeJITContext, memidx : Int) -> Int64

    NativeJITContext::memory_size

    source
    fn NativeJITContext::memory_size(self : NativeJITContext, memidx : Int) -> Int64

    NativeJITContext::refresh_table_layout

    source
    fn NativeJITContext::refresh_table_layout(self : NativeJITContext, table_idx : Int) -> Bool

    Refresh one borrowed table from the context it was registered with. The context supplies both the table identity and its live C-side layout.

    NativeJITContext::register_safepoints

    source
    fn NativeJITContext::register_safepoints(self : NativeJITContext, func_idx : Int, safepoints : Array[
    SafepointSite    ]) -> Bool

    NativeJITContext::set_cancellation_callback

    source
    fn NativeJITContext::set_cancellation_callback(self : NativeJITContext, callback : () -> Bool) -> Unit

    NativeJITContext::set_func

    source
    fn NativeJITContext::set_func(self : NativeJITContext, idx : Int, func_ptr : Int64) -> Unit

    NativeJITContext::set_gc_heap

    source
    fn NativeJITContext::set_gc_heap(self : NativeJITContext, heap : CHeap) -> Unit

    NativeJITContext::set_gc_heap_ptr

    source
    fn NativeJITContext::set_gc_heap_ptr(self : NativeJITContext, heap_ptr : Int64) -> Unit

    NativeJITContext::set_globals

    source
    fn NativeJITContext::set_globals(self : NativeJITContext, globals_ptr : Int64) -> Unit

    NativeJITContext::set_hostcall_callback

    source
    fn NativeJITContext::set_hostcall_callback(self : NativeJITContext, callback : () -> NativeHostcallOutcome) -> Unit

    NativeJITContext::set_indirect

    source
    fn NativeJITContext::set_indirect(self : NativeJITContext, table_idx : Int, func_idx : Int, type_idx : Int) -> Unit

    NativeJITContext::set_memory

    source
    fn NativeJITContext::set_memory(self : NativeJITContext, mem0_ptr : Int64) -> Unit

    NativeJITContext::set_memory_pointers

    source
    fn NativeJITContext::set_memory_pointers(self : NativeJITContext, memories : Array[MemoryInfo]) -> Unit

    NativeJITContext::set_table_pointers

    source
    fn NativeJITContext::set_table_pointers(self : NativeJITContext, jit_tables : Array[JITTable?]) -> Unit

    NativeJITContext::set_wasi_stderr_capture

    source
    fn NativeJITContext::set_wasi_stderr_capture(self : NativeJITContext, enabled : Bool) -> Unit

    NativeJITContext::set_wasi_stdin_buffer

    source
    fn NativeJITContext::set_wasi_stdin_buffer(self : NativeJITContext, data : Bytes) -> Unit

    NativeJITContext::set_wasi_stdin_callback

    source
    fn NativeJITContext::set_wasi_stdin_callback(self : NativeJITContext, callback : () -> Bytes) -> Unit

    NativeJITContext::set_wasi_stdout_capture

    source
    fn NativeJITContext::set_wasi_stdout_capture(self : NativeJITContext, enabled : Bool) -> Unit

    NativeJITContext::setup_gc

    source
    fn NativeJITContext::setup_gc(self : NativeJITContext, heap : CHeap, types : Array[
    SubType    ], canonical_indices : Array[Int], func_type_indices : Array[Int]) -> Unit raise GCSetupError

    NativeJITContext::setup_gc_with_func_table

    source
    fn NativeJITContext::setup_gc_with_func_table(self : NativeJITContext, heap : CHeap, types : Array[
    SubType    ], canonical_indices : Array[Int], func_type_indices : Array[Int], func_table_ptr : Int64, num_funcs : Int) -> Unit raise GCSetupError

    NativeJITContext::setup_segments

    source
    fn NativeJITContext::setup_segments(self : NativeJITContext, datas : Array[
    Data    ], elem_segments : Array[Array[Int64]], data_dropped? : Array[Bool], elem_dropped? : Array[Bool]) -> Unit

    NativeJITContext::start_continuation

    source
    fn NativeJITContext::start_continuation(self : NativeJITContext, trampoline_ptr : Int64, func_ptr : Int64, values : FixedArray[Int64], values_len : Int, stack_size? : Int64) -> NativeJITContinuation raise NativeFiberError

    NativeJITContext::take_wasi_exit_code

    source
    fn NativeJITContext::take_wasi_exit_code(self : NativeJITContext) -> Int

    NativeJITContext::take_wasi_stderr

    source
    fn NativeJITContext::take_wasi_stderr(self : NativeJITContext) -> Bytes

    NativeJITContext::take_wasi_stdout

    source
    fn NativeJITContext::take_wasi_stdout(self : NativeJITContext) -> Bytes

    NativeJITContext::teardown_gc

    source
    fn NativeJITContext::teardown_gc(self : NativeJITContext) -> Unit

    NativeJITContext::throw_exception_tag

    source
    fn NativeJITContext::throw_exception_tag(self : NativeJITContext, tag_addr : Int) -> Unit

    NativeJITContext::throw_exception_values

    source
    fn NativeJITContext::throw_exception_values(self : NativeJITContext, tag_addr : Int, values : Array[Int64]) -> Unit

    NativeJITContext::try_alloc

    source
    fn NativeJITContext::try_alloc(total_funcs : Int) -> NativeJITContext?

    NativeJITContinuation

    source
    type NativeJITContinuation

    Stackful JIT invocation whose entry frame is entirely native.

    MoonBit hostcall callbacks always return before this continuation yields.

    NativeJITContinuation::cancel

    source

    NativeJITContinuation::continue_after_hostcall

    source
    fn NativeJITContinuation::continue_after_hostcall(self : NativeJITContinuation, retry~ : Bool) -> NativeJITContinuationEvent raise NativeFiberError

    Resume a continuation stopped at an imported hostcall.

    retry=true re-enters only the suspended hostcall before continuing the native guest frame. It never restarts the guest function from its entry.

    NativeJITContinuation::continue_with

    source

    NativeJITContinuation::phase

    source

    NativeJITContinuationEvent

    source
    pub(all) enum NativeJITContinuationEvent {
      NativeHostcallSuspended
      NativeJITCompleted
      NativeJITTrapped(Int)
    } derive(Eq, 
    Debug    )

    Result of advancing a stackful JIT invocation.

    NativeJITContinuationEvent::equal

    source

    NativeJITContinuationEvent::not_equal

    source

    NativeJITContinuationEvent::to_repr

    source

    NativeTarget

    source
    pub(all) enum NativeTarget {
      X64
      AArch64
    } derive(Eq, 
    Debug    )

    NativeTarget::equal

    source

    NativeTarget::not_equal

    source
    fn NativeTarget::not_equal(x : NativeTarget, y : NativeTarget) -> Bool

    NativeTarget::to_repr

    source

    Profiler

    source
    pub(all) struct Profiler {
      counter : CallCounter
      threshold : HotThreshold
      hot_functions : 
    HashSet    [Int]
      pending_compilation : 
    HashSet    [Int]
      compiled_functions : 
    HashSet    [Int]
    }

    Complete profiler combining call counting and hot detection
    impl Show for Profiler

    Profiler::Profiler

    source
    fn Profiler::Profiler(threshold : HotThreshold) -> Profiler

    Profiler::get_function_temperature

    source
    fn Profiler::get_function_temperature(self : Profiler, func_idx : Int) -> FunctionTemperature

    Get temperature for a specific function

    Profiler::get_pending

    source
    fn Profiler::get_pending(self : Profiler) -> Array[Int]

    Get list of functions pending compilation

    Profiler::is_compiled

    source
    fn Profiler::is_compiled(self : Profiler, func_idx : Int) -> Bool

    Check if a function is compiled

    Profiler::mark_compiled

    source
    fn Profiler::mark_compiled(self : Profiler, func_idx : Int) -> Unit

    Mark a function as compiled

    Profiler::output

    source
    fn Profiler::output(self : Profiler, logger : &Logger) -> Unit

    Profiler::record_call

    source
    fn Profiler::record_call(self : Profiler, func_idx : Int) -> (Int, Bool)

    Record a function call and return whether it should be compiled Returns: (new_count, should_compile)

    Profiler::should_use_jit

    source
    fn Profiler::should_use_jit(self : Profiler, func_idx : Int) -> Bool

    Check if a function should use JIT code

    Profiler::stats

    source
    fn Profiler::stats(self : Profiler) -> (Int, Int, Int, Int)

    Get profiling statistics

    Profiler::to_string

    source
    fn Profiler::to_string(self : Profiler) -> String

    RuntimeSymbol

    source
    pub(all) struct RuntimeSymbol {
      name : String
      address : Int64
    } derive(Eq, 
    Debug    )

    RuntimeSymbol::equal

    source

    RuntimeSymbol::not_equal

    source
    fn RuntimeSymbol::not_equal(x : RuntimeSymbol, y : RuntimeSymbol) -> Bool

    RuntimeSymbol::to_repr

    source

    RuntimeSymbolResolver

    source
    pub(all) struct RuntimeSymbolResolver {
      symbols : Array[RuntimeSymbol]
    } derive(
    Debug    )

    RuntimeSymbolResolver::RuntimeSymbolResolver

    source
    fn RuntimeSymbolResolver::RuntimeSymbolResolver() -> RuntimeSymbolResolver

    RuntimeSymbolResolver::add_symbol

    source
    fn RuntimeSymbolResolver::add_symbol(self : RuntimeSymbolResolver, name : String, address : Int64) -> Unit

    RuntimeSymbolResolver::resolve

    source
    fn RuntimeSymbolResolver::resolve(self : RuntimeSymbolResolver, name : String) -> Int64?

    RuntimeSymbolResolver::resolve_symbol

    source
    fn RuntimeSymbolResolver::resolve_symbol(self : RuntimeSymbolResolver, name : String) -> RuntimeSymbol?

    RuntimeSymbolResolver::to_repr

    source

    RuntimeSymbolResolver::with_wasmoon_runtime_symbols

    source
    fn RuntimeSymbolResolver::with_wasmoon_runtime_symbols() -> RuntimeSymbolResolver

    TieredConfig

    source
    pub(all) struct TieredConfig {
      baseline_threshold : Int
      optimize_threshold : Int
      synchronous : Bool
      max_concurrent : Int
    }

    Configuration for tiered compilation

    TieredConfig::default

    source
    fn TieredConfig::default() -> TieredConfig

    TieredConfig::deferred

    source
    fn TieredConfig::deferred() -> TieredConfig

    TieredConfig::eager

    source
    fn TieredConfig::eager() -> TieredConfig

    TrapDetails

    source
    pub struct TrapDetails {
      signal : Int
      pc : Int64
      lr : Int64
      fp : Int64
      frame_lr : Int64
      fault_addr : Int64
      brk_imm : Int
      func_idx : Int
      x0 : Int64
      x1 : Int64
      x2 : Int64
      x3 : Int64
      x6 : Int64
      x7 : Int64
      x8 : Int64
      x9 : Int64
      x10 : Int64
      x11 : Int64
      x15 : Int64
    }

    Low-level trap detail captured by the JIT signal handlers (best-effort).

    TrapDetails::TrapDetails

    source
    fn TrapDetails::TrapDetails() -> TrapDetails

    TrapReport

    source
    pub(all) struct TrapReport {
      trap_kind : String
      message : String
      signal : Int
      signal_name : String
      pc : Int64
      lr : Int64
      fp : Int64
      frame_lr : Int64
      fault_addr : Int64
      brk_imm : Int
      wasm_func_idx : Int?
      wasm_func_name : String?
      wasm_offset : Int64?
      wasm_frames : Array[WasmTrapFrame]
      host_frames : Array[String]
      dump_path : String?
    }

    Structured trap report for native integrations.

    VMContextLayout

    source
    pub(all) struct VMContextLayout {
      memory0_offset : Int
      memory0_base_offset : Int
      memory0_size_offset : Int
      func_table_offset : Int
      table0_base_offset : Int
      table0_elements_offset : Int
      globals_offset : Int
      tables_offset : Int
      table_count_offset : Int
      func_count_offset : Int
      table_sizes_offset : Int
      table_max_sizes_offset : Int
      memories_offset : Int
      memory_count_offset : Int
      debug_current_func_idx_offset : Int
      gc_heap_ptr_offset : Int
      gc_heap_limit_offset : Int
      gc_heap_offset : Int
      pointer_stride : Int
      global_value_stride : Int
      table_entry_value_offset : Int
      table_entry_stride : Int
      func_table_entry_stride : Int
    }

    Fixed VMContext prefix layout accessed by generated JIT code.

    Keep these offsets in sync with jit_ffi/jit_ffi.h::jit_context_t. Embedders and frontends should query this value instead of copying raw offsets into lowering code.

    WasmTrapFrame

    source
    pub(all) struct WasmTrapFrame {
      pc : Int64
      func_idx : Int
      func_name : String
      wasm_offset : Int64
    }

    A resolved wasm frame in a native trap report.

    WASMOON_CODEGEN_REVISION

    source
    let WASMOON_CODEGEN_REVISION : String

    Revision of the current direct native target code generator.

    Advance this value whenever compiler changes can alter emitted code while preserving the artifact format and JIT ABI. Persistent caches use it as part of their compatibility identity.

    WASMOON_JIT_ABI_VERSION

    source
    let WASMOON_JIT_ABI_VERSION : Int

    Version of the Wasmoon internal JIT calling and runtime contract.

    alloc_guarded_memory_desc

    source
    fn alloc_guarded_memory_desc(initial_pages : Int, max_pages : Int?) -> Int64

    Allocate a guarded (reserved) memory descriptor for memory32 memory0. This is required for bounds-check elimination; out-of-bounds accesses trap via guard pages.

    alloc_memory

    source
    fn alloc_memory(size : Int64) -> Int64

    Allocate linear memory for WASM (returns 0 on failure).

    alloc_memory_desc

    source
    fn alloc_memory_desc(size_bytes : Int64, max_pages : Int?, is_memory64? : Bool, page_size_log2? : Int, is_shared? : Bool) -> Int64

    Allocate a wasmoon_memory_t descriptor with owned backing memory.

    artifact_compatibility

    source

    artifact_module_identity

    source
    fn artifact_module_identity(name : String, source_module : Bytes, semantic_features : Bytes) -> 
    ModuleIdentity

    build_artifact_manifest

    source

    Build the exact compatibility manifest for a selected target.

    required_cpu_features contains only optional features beyond the baseline architecture contract. AArch64 Advanced SIMD and x64 SSE2 are baseline requirements of the corresponding Wasmoon targets and are therefore not repeated here.

    build_entry_trampoline_for_target

    source
    fn build_entry_trampoline_for_target(param_types : Array[
    ValueType    ], result_types : Array[
    ValueType    ], target : NativeTarget) -> Array[Int] raise HostcallImportTrampolineError

    build_host_artifact_manifest

    source

    Build a manifest for the current process without guessing an unsupported architecture or operating-system ABI.

    build_hostcall_import_trampoline_for_target

    source
    fn build_hostcall_import_trampoline_for_target(param_types : Array[
    ValueType    ], result_types : Array[
    ValueType    ], host_func_addr : Int, target : NativeTarget) -> HostcallImportTrampolineCode raise HostcallImportTrampolineError

    can_use_reusable_entry_trampoline

    source
    fn can_use_reusable_entry_trampoline(param_types : Array[
    ValueType    ], result_types : Array[
    ValueType    ]) -> Bool

    classify_import_function_ptr

    source
    fn classify_import_function_ptr(ptr : Int64) -> ImportFunctionResolution

    collect_gc_root_args

    source
    fn collect_gc_root_args(args : Array[Int64], param_types : Array[
    ValueType    ]) -> Array[Int64]

    compile_wasm_body_artifact_function

    source
    fn compile_wasm_body_artifact_function(function : 
    Function    , validation_context : 
    WasmValidationContext    , target : NativeTarget, function_index~ : Int, signature~ : 
    Signature    , use_subtype_indirect_check? : Bool, canonical_type_indices? : Array[Int]) -> 
    FunctionCode     raise JitPipelineError

    compile_wasm_body_diagnostics_for_target

    source
    fn compile_wasm_body_diagnostics_for_target(function : 
    Function    , validation_context : 
    WasmValidationContext    , target : NativeTarget, use_subtype_indirect_check? : Bool, canonical_type_indices? : Array[Int]) -> JitPipelineDiagnostics raise JitPipelineError

    count_entry_trampoline_slots

    source
    fn count_entry_trampoline_slots(types : Array[
    ValueType    ]) -> Int

    decode_externref

    source
    fn decode_externref(raw : Int64) -> Int?

    decode_funcref_idx

    source
    fn decode_funcref_idx(raw : Int64) -> Int?

    decode_gc_heap_ref

    source
    fn decode_gc_heap_ref(raw : Int64) -> Int?

    decode_heap_ref

    source
    fn decode_heap_ref(encoded : Int64) -> Int

    Decode a heap reference from JIT representation Returns 0-based heap_idx for MoonBit Store/CHeap

    decode_i31

    source
    fn decode_i31(encoded : Int64) -> Int

    Decode an i31 value from JIT representation

    encode_externref

    source
    fn encode_externref(host_idx : Int) -> Int64

    encode_funcref_idx

    source
    fn encode_funcref_idx(func_idx : Int) -> Int64

    encode_gc_heap_ref

    source
    fn encode_gc_heap_ref(heap_idx0 : Int) -> Int64

    encode_heap_ref

    source
    fn encode_heap_ref(heap_idx : Int) -> Int64

    Encode a heap reference (struct or array) for JIT heap_idx is 0-based (from MoonBit Store/CHeap) JIT uses 1-based gc_ref internally to avoid collision with null (0)

    encode_i31

    source
    fn encode_i31(value : Int) -> Int64

    Encode an i31 value for JIT (tagged pointer with lowest bit = 1)

    encode_null_ref

    source
    fn encode_null_ref() -> Int64

    entry_trampoline_signature_hash

    source
    fn entry_trampoline_signature_hash(param_types : Array[
    ValueType    ], result_types : Array[
    ValueType    ]) -> Int64

    entry_trampoline_type_codes

    source
    fn entry_trampoline_type_codes(types : Array[
    ValueType    ]) -> Array[Int]

    entry_trampoline_value_type_code

    source
    fn entry_trampoline_value_type_code(ty : 
    ValueType    ) -> Int

    format_signal_name

    source
    fn format_signal_name(sig : Int) -> String

    format_trap_report_message

    source
    fn format_trap_report_message(report : TrapReport) -> String

    format_u64_hex

    source
    fn format_u64_hex(v : Int64) -> String

    free_memory

    source
    fn free_memory(mem_ptr : Int64) -> Unit

    free_memory_desc

    source
    fn free_memory_desc(mem_desc_ptr : Int64) -> Unit

    gc_debug_set_fail_alloc

    source
    fn gc_debug_set_fail_alloc(fail_at : Int, fail_every? : Int) -> Unit

    Configure allocation fault injection for debugging

    get_hostcall_func_addr

    source
    fn get_hostcall_func_addr() -> Int

    Get the runtime store function address for the current JIT -> hostcall.

    This value is set by wasmoon_jit_hostcall right before invoking the MoonBit hostcall callback.

    get_hostcall_num_arg_slots

    source
    fn get_hostcall_num_arg_slots() -> Int

    Get the number of argument slots in values_vec.

    Note: slots are 8 bytes each; V128 occupies 2 slots.

    get_hostcall_num_result_slots

    source
    fn get_hostcall_num_result_slots() -> Int

    Get the number of result slots in values_vec.

    Note: slots are 8 bytes each; V128 occupies 2 slots.

    get_import_trampoline

    source
    fn get_import_trampoline(module_name : String, field_name : String) -> Int64?

    Get trampoline function pointer for an import. Returns None if the import is not supported by JIT.

    get_last_trap_details

    source
    fn get_last_trap_details() -> TrapDetails

    Get the last captured trap details (best-effort). These fields are reset at the start of each JIT call.

    get_temperature

    source
    fn get_temperature(count : Int, threshold : HotThreshold) -> FunctionTemperature

    Determines the temperature of a function based on its call count

    host_native_target

    source
    fn host_native_target() -> NativeTarget raise JitPipelineError

    host_operating_system_abi

    source

    hostcall_value_byte_count

    source
    fn hostcall_value_byte_count(ty : 
    ValueType    ) -> Int

    hostcall_value_slot_count

    source
    fn hostcall_value_slot_count(ty : 
    ValueType    ) -> Int

    hostcall_value_slot_read

    source
    fn hostcall_value_slot_read(slot : Int) -> Int64

    hostcall_value_slot_write

    source
    fn hostcall_value_slot_write(slot : Int, value : Int64) -> Unit

    i64_to_value

    source

    Decode a runtime word to a Value based on expected type.

    A word carries no high half, so a V128 request yields a vector whose upper 8 bytes are zero. Callers reading a stored field want slot_to_value, which has the other half.

    is_cancelled_trap_code

    source
    fn is_cancelled_trap_code(code : Int) -> Bool

    is_funcref_ptr

    source
    fn is_funcref_ptr(raw : Int64) -> Bool

    is_i31

    source
    fn is_i31(value : Int64) -> Bool

    Check if a JIT value is an i31 (has tag bit set)

    is_jit_supported_module

    source
    fn is_jit_supported_module(module_name : String) -> Bool

    Check if a module is known to JIT (has trampoline support).

    is_null

    source
    fn is_null(value : Int64) -> Bool

    Check if a JIT value is null

    is_null_ref

    source
    fn is_null_ref(raw : Int64) -> Bool

    is_wasi_exit_trap_code

    source
    fn is_wasi_exit_trap_code(code : Int) -> Bool

    jit_trap_message

    source
    fn jit_trap_message(code : Int) -> String

    load_artifact

    source
    fn load_artifact(bytes : Bytes, compatibility : ArtifactCompatibility, limits? : 
    DecodeLimits    ) -> LoadedArtifact raise ArtifactLoadError

    Decode, check compatibility, and reconstruct verified unlinked code objects.

    Decoded and live artifacts converge on verify_artifact, before the shared installer resolves any symbol or allocates executable memory.

    make_cstring

    source
    fn make_cstring(s : String) -> FixedArray[Byte]

    memory_descriptor_fill

    source
    fn memory_descriptor_fill(mem_desc_ptr : Int64, destination : Int64, value : Int, size : Int) -> Int

    memory_descriptor_grow

    source
    fn memory_descriptor_grow(mem_desc_ptr : Int64, delta_pages : Int, max_pages : Int) -> Int

    memory_descriptor_layout

    source
    fn memory_descriptor_layout() -> MemoryDescriptorLayout

    memory_descriptor_length

    source
    fn memory_descriptor_length(mem_desc_ptr : Int64) -> Int64

    memory_descriptor_move

    source
    fn memory_descriptor_move(mem_desc_ptr : Int64, destination : Int64, source : Int64, size : Int) -> Int

    memory_descriptor_read

    source
    fn memory_descriptor_read(mem_desc_ptr : Int64, offset : Int64, out : FixedArray[Byte], size : Int) -> Int

    memory_descriptor_write

    source
    fn memory_descriptor_write(mem_desc_ptr : Int64, offset : Int64, data : FixedArray[Byte], size : Int) -> Int

    memory_descriptor_write_bytes

    source
    fn memory_descriptor_write_bytes(mem_desc_ptr : Int64, offset : Int64, data : Bytes, size : Int) -> Int

    memory_init

    source
    fn memory_init(mem_ptr : Int64, offset : Int64, data : Bytes) -> Bool

    Initialize memory with data at offset.

    memory_read

    source
    fn memory_read(mem_ptr : Int64, offset : Int64, size : Int) -> Bytes

    Read size bytes from linear memory at offset.

    native_value_slot_read

    source
    fn native_value_slot_read(base : Int64, slot : Int) -> Int64

    Read an i64-sized slot from a JIT-owned native value area.

    native_value_slot_write

    source
    fn native_value_slot_write(base : Int64, slot : Int, value : Int64) -> Unit

    Write an i64-sized slot in a JIT-owned native value area.

    plan_entry_trampoline_for_target

    source

    plan_hostcall_import_trampoline_layout

    source
    fn plan_hostcall_import_trampoline_layout(param_types : Array[
    ValueType    ], result_types : Array[
    ValueType    ], max_int_regs : Int, max_float_regs : Int) -> HostcallImportTrampolineLayout

    plan_milkir_integration_for_target

    source
    fn plan_milkir_integration_for_target(func : 
    Function    , target : NativeTarget) -> JitIntegrationPlan raise JitPipelineError

    plan_wasm_body_aarch64_code_object

    source
    fn plan_wasm_body_aarch64_code_object(function : 
    Function    , validation_context : 
    WasmValidationContext    , use_subtype_indirect_check? : Bool, canonical_type_indices? : Array[Int]) -> 
    UnlinkedCodeObject     raise JitPipelineError

    plan_wasm_body_milkir_integration_for_target

    source
    fn plan_wasm_body_milkir_integration_for_target(func : 
    Function    , validation_context : 
    WasmValidationContext    , target : NativeTarget) -> JitIntegrationPlan raise JitPipelineError

    plan_wasm_body_x64_code_object

    source
    fn plan_wasm_body_x64_code_object(function : 
    Function    , validation_context : 
    WasmValidationContext    , use_subtype_indirect_check? : Bool, canonical_type_indices? : Array[Int]) -> 
    UnlinkedCodeObject     raise JitPipelineError

    resolve_import_function

    source
    fn resolve_import_function(external_imports : Map[String, Map[String, Int64]], module_name : String, field_name : String) -> ImportFunctionResolution

    resolve_import_function_ptr

    source
    fn resolve_import_function_ptr(external_imports : Map[String, Map[String, Int64]], module_name : String, field_name : String) -> Int64?

    sanitize_debug_filename

    source
    fn sanitize_debug_filename(s : String) -> String

    slot_to_value

    source

    Decode a C heap slot to a Value based on expected type.

    Total, and inverse to value_to_slot: every ValueType names a value this can produce, so no case has to fall back to a value of some other type the way V128 => I64(raw) once did.

    tag_funcref_ptr

    source
    fn tag_funcref_ptr(func_ptr : Int64) -> Int64

    take_pending_trap_message

    source
    fn take_pending_trap_message() -> String?

    untag_funcref_ptr

    source
    fn untag_funcref_ptr(tagged_ptr : Int64) -> Int64

    value_to_i64

    source
    fn value_to_i64(value : 
    Value    ) -> Int64

    Encode a Value as a bare runtime word, for the root array the collector scans. A root's high word would never be read, so dropping it is not a loss of information here.

    value_to_slot

    source
    fn value_to_slot(value : 
    Value    ) -> GcSlot

    Encode a Value into a C heap slot.

    Total, and that is the point: a slot is 16 bytes, so there is no value this cannot represent and no case left to abort on.

    Encoding rules for lo:
    • i32: sign-extended to i64
    • i64: as-is
    • f32: lower 32 bits (IEEE 754 bits)
    • f64: as-is (IEEE 754 bits)
    • v128: low 8 bytes, with the high 8 in hi
    • structref/arrayref: (gc_ref) << 1, where gc_ref = idx + 1 (even, low bit = 0)
    • funcref: function index + 1 (0 = null)
    • externref: extern index + 1 (0 = null)
    • exnref: exception index + 1 (0 = null)
    • i31: (value << 1) | 1 (tagged, low bit = 1)
    • null: 0

    GC reference detection in gc_heap_mark uses: (lo & 1) == 0 && lo > 0

    value_type_may_hold_gc_ref

    source
    fn value_type_may_hold_gc_ref(ty : 
    ValueType    ) -> Bool

    verify_artifact

    source

    Check compatibility and reconstruct verified unlinked code objects from an in-memory artifact produced by the live compiler.

    No symbol is resolved and no executable memory is allocated or published.

    vmcontext_layout

    source
    fn vmcontext_layout() -> VMContextLayout

    wasm_function_signature

    source

    wasm_import_identity

    source
    fn wasm_import_identity(function_index : Int, module_name : String, function_name : String, function_type : 
    FuncType    ) -> 
    ImportIdentity

    wasm_runtime_symbols

    source

    wasm_trap_payload

    source
    fn wasm_trap_payload(reason : String) -> Int

    Map Wasm trap reasons to the payload consumed by Wasmoon's native trap handler. Native lowering only carries the integer payload; this module owns the Wasmoon-specific reason-to-payload policy.

    wasmoon_runtime_external_symbols

    source
    fn wasmoon_runtime_external_symbols() -> Array[
    ExternalSymbol    ]

    Stable external-symbol whitelist accepted by Wasmoon artifacts.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io