🥮 mooncakes.io
    Sign in

    wasmoon_jit

    Wasmoon-specific JIT integration and native runtime glue

    wasm
    jit
    runtime
    native
    Download zip
    Author
    Version
    0.2.0
    License
    Apache-2.0
    Repository
    Last updated
    3 months ago
    Downloads
    199

    #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, cwasm artifacts, trampolines, WASI bridge glue, and integration planning for loading generated code.

    #Packages

    • Milky2018/wasmoon_jit: runtime layout, JIT integration planning, trampolines, native glue, runtime symbols, and helper APIs.
    • Milky2018/wasmoon_jit/cwasm: serialized precompiled-code artifacts.

    The current CWASM format records machine-code compilation features, including whether cooperative cancellation safepoints were emitted. Readers accept only the current format version; this prevents callers from assuming cancellation support for older or otherwise incompatible artifacts.
    • Milky2018/wasmoon_jit/perf: optional JIT performance metrics.
    • Milky2018/wasmoon_jit/jit_ffi: native stubs used by the JIT runtime.

    #When to use it

    Use wasmoon_jit when integrating generated code with the Wasmoon runtime, including VMContext layout, runtime helper symbols, trampolines, cwasm artifacts, and native glue.

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

    ///|
    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")
      inspect(
        native_glue_covers_jit_ffi_stubs(glue=plan.native_glue),
        content="true",
      )
    }

    #Example: serialize a cwasm artifact

    The cwasm package stores compiled functions, imports, memories, data segments, and target metadata in a portable artifact format.

    ///|
    test "serialize and restore a precompiled module" {
      let mod_ = @cwasm.PrecompiledModule::PrecompiledModule(AArch64)
      mod_.add_type([TYPE_I32], [TYPE_I32])
      mod_.add_import("env", "host_inc", 1, 1)
      let entry = @cwasm.CompiledEntry::CompiledEntry(0, "inc", [0xc3], 0, 0, 1, 1)
      mod_.add_function(entry)
      let encoded = mod_.serialize()
      let decoded = @cwasm.deserialize(encoded)
      debug_inspect(decoded.target, content="AArch64")
      inspect(decoded.import_count(), content="1")
      inspect(decoded.function_count(), content="1")
    }

    #Compiler pipeline

    JIT planning composes milkir, milkir_machv, the selected target package, machv_regalloc, and machv_emit. The resulting plan adds the VMContext, runtime symbols, trampolines, and native glue needed to install and invoke the code in Wasmoon.

    CHeapError

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

    CHeap error types for runtime errors

    DirectCallStubInstallError

    source
    pub suberror DirectCallStubInstallError {
      UnsupportedDirectCallStubTarget(pseudo_idx~ : Int, code_size~ : Int)
      DirectCallStubAllocationFailed(pseudo_idx~ : Int, code_size~ : Int)
    } derive(Eq, 
    Debug    )

    GCSetupError

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

    HostcallImportTrampolineError

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

    JitPipelineError

    source
    pub suberror JitPipelineError {
      PipelineFailure(message~ : String)
    } derive(Eq, 
    Debug    )

    LinkError

    source
    pub suberror LinkError {
      UnknownRuntimeSymbol(String)
    } derive(Eq, 
    Debug    )

    impl Show for LinkError

    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::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::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

    CodeCache

    source
    type CodeCache

    impl Show for CodeCache

    CodeCache::CodeCache

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

    CodeCache::clear

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

    Clear all cached functions

    CodeCache::contains

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

    Check if a function is cached and valid

    CodeCache::get

    source
    fn CodeCache::get(self : CodeCache, func_idx : Int) -> CompiledFunction?

    Look up a compiled function by index

    CodeCache::insert

    source
    fn CodeCache::insert(self : CodeCache, func_idx : Int, func : CompiledFunction) -> Unit

    Insert a compiled function into the cache

    CodeCache::invalidate

    source
    fn CodeCache::invalidate(self : CodeCache, func_idx : Int) -> Unit

    Invalidate a cached function

    CodeCache::remove

    source
    fn CodeCache::remove(self : CodeCache, func_idx : Int) -> Unit

    Remove a function from the cache

    CodeCache::stats

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

    Get cache statistics

    CompilationDecision

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

    Decision about what to do with a function call

    CompilationMode

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

    The compilation mode for a function

    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::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

    CompiledFunction

    source
    pub struct CompiledFunction {
      name : String
      code : 
    MachineCode
      entry_offset : Int
      code_size : Int
      frame_size : Int
      gc_safepoints : Array[GcSafepoint]
      gc_stackmap_blob : Bytes
      valid : Bool
    }

    A compiled function ready for Wasmoon JIT execution.

    CompiledFunction::CompiledFunction

    source
    fn CompiledFunction::CompiledFunction(name : String, code : 
    MachineCode    , frame_size : Int, gc_safepoints? : Array[GcSafepoint], gc_stackmap_blob? : Bytes) -> CompiledFunction

    CompiledFunction::get_call_fixups

    source

    Get direct function call fixups.

    CompiledFunction::get_code

    source
    fn CompiledFunction::get_code(self : CompiledFunction) -> Array[Int]

    Get the machine code bytes.

    CompiledFunction::get_func_addr_fixups

    source

    Get direct function address fixups.

    CompiledFunction::get_gc_safepoints

    source
    fn CompiledFunction::get_gc_safepoints(self : CompiledFunction) -> Array[GcSafepoint]

    Get GC safepoint metadata for this function.

    CompiledFunction::get_gc_stackmap_blob

    source
    fn CompiledFunction::get_gc_stackmap_blob(self : CompiledFunction) -> Bytes

    Get GC stack-map payload bytes for this function.

    CompiledFunction::invalidate

    source
    fn CompiledFunction::invalidate(self : CompiledFunction) -> Unit

    Invalidate this compiled function and mark it for recompilation.

    CompiledFunction::is_valid

    source
    fn CompiledFunction::is_valid(self : CompiledFunction) -> Bool

    Check if the function is still valid.

    CwasmArtifact

    source
    pub(all) struct CwasmArtifact {
      version : Int
      target : 
    TargetArch
      entry_symbol : String
      code : Array[Int]
      functions : Array[CwasmFunctionRecord]
      call_veneers : Array[CwasmCallVeneer]
      runtime_relocations : Array[ResolvedRuntimeRelocation]
      func_addr_fixups : Array[
    FuncAddrFixup    ]
      call_fixups : Array[
    CallFixup    ]
      gc_safepoints : Array[GcSafepoint]
      gc_stackmap_blob : Bytes
    } derive(
    Debug    )

    CwasmArtifact::from_jit_plan

    source
    fn CwasmArtifact::from_jit_plan(plan : JitIntegrationPlan, resolver : RuntimeSymbolResolver, function_index : Int) -> CwasmArtifact raise LinkError

    CwasmArtifact::from_jit_plan_with_signature

    source
    fn CwasmArtifact::from_jit_plan_with_signature(plan : JitIntegrationPlan, resolver : RuntimeSymbolResolver, function_index : Int, num_params : Int, num_results : Int) -> CwasmArtifact raise LinkError

    CwasmArtifact::from_linked_code_for_target

    source
    fn CwasmArtifact::from_linked_code_for_target(linked : LinkedCode, function_index : Int, target : 
    TargetArch    , entry_symbol : String) -> CwasmArtifact

    CwasmArtifact::from_linked_code_for_target_with_signature

    source
    fn CwasmArtifact::from_linked_code_for_target_with_signature(linked : LinkedCode, function_index : Int, target : 
    TargetArch    , entry_symbol : String, num_params : Int, num_results : Int) -> CwasmArtifact

    CwasmArtifact::manifest

    source
    fn CwasmArtifact::manifest(self : CwasmArtifact) -> Array[String]

    CwasmArtifact::serialize

    source
    fn CwasmArtifact::serialize(self : CwasmArtifact) -> Array[Int]

    CwasmArtifact::to_precompiled_module

    source

    CwasmCallVeneer

    source
    pub(all) struct CwasmCallVeneer {
      function_index : Int
      func_idx : Int
      offset : Int
    } derive(Eq, 
    Debug    )

    CwasmFunctionRecord

    source
    pub(all) struct CwasmFunctionRecord {
      function_index : Int
      code_offset : Int
      code_size : Int
      frame_size : Int
      num_params : Int
      num_results : Int
    } derive(Eq, 
    Debug    )

    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

    DirectCallStubSet

    source
    pub struct DirectCallStubSet {
      exec_codes : Array[ExecCode]
      targets : Map[Int, Int64]
    }

    ExecCode

    source
    type ExecCode

    GC-managed executable code block wrapper.

    ExecCode::ptr

    source
    fn ExecCode::ptr(self : ExecCode) -> Int64

    Get the function pointer from this executable code.

    ExecCode::try_alloc

    source
    fn ExecCode::try_alloc(code : Array[Int]) -> ExecCode?

    Allocate and copy code to executable memory (GC-managed).

    ExecutableRegion

    source
    type ExecutableRegion

    Represents a region of memory that can hold executable code (Abstraction - actual executable memory requires platform-specific implementation)

    ExecutableRegion::ExecutableRegion

    source
    fn ExecutableRegion::ExecutableRegion(id : Int, size : Int) -> ExecutableRegion

    ExecutableRegion::address_at

    source
    fn ExecutableRegion::address_at(self : ExecutableRegion, offset : Int) -> Int

    Get the effective address for a given offset

    ExecutableRegion::finalize

    source
    fn ExecutableRegion::finalize(self : ExecutableRegion) -> Unit

    Finalize the region (make it executable, no more writes)

    ExecutableRegion::read_at

    source
    fn ExecutableRegion::read_at(self : ExecutableRegion, offset : Int, length : Int) -> Array[Int]

    Read code at a given offset

    ExecutableRegion::remaining

    source
    fn ExecutableRegion::remaining(self : ExecutableRegion) -> Int

    Get remaining space in the region

    ExecutableRegion::write

    source
    fn ExecutableRegion::write(self : ExecutableRegion, bytes : Array[Int]) -> Result[Int, String]

    Write code bytes to the region

    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

    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

    HostcallImportTrampolineCode

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

    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    )

    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
      machv_before_regalloc : String
      machv_after_regalloc : String
      machine_code : String
    }

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

    JITFunctionDebug::JITFunctionDebug

    source
    fn JITFunctionDebug::JITFunctionDebug(ir : String, machv_before_regalloc : String, machv_after_regalloc : String, machine_code : String) -> JITFunctionDebug

    JITRuntime

    source
    type JITRuntime

    Complete JIT runtime combining code cache and memory management
    impl Show for JITRuntime

    JITRuntime::JITRuntime

    source
    fn JITRuntime::JITRuntime(cache_size : Int, region_size : Int) -> JITRuntime

    JITRuntime::clear

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

    Clear all compiled code

    JITRuntime::invalidate

    source
    fn JITRuntime::invalidate(self : JITRuntime, func_idx : Int) -> Unit

    Invalidate a function (will be recompiled on next call)

    JITRuntime::lookup

    source
    fn JITRuntime::lookup(self : JITRuntime, func_idx : Int) -> CompiledFunction?

    Look up a compiled function

    JITRuntime::register

    source
    fn JITRuntime::register(self : JITRuntime, func_idx : Int, func : CompiledFunction) -> Result[Int, String]

    Register a compiled function

    JITRuntime::stats

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

    Get runtime statistics

    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::refresh_layout

    source
    fn JITTable::refresh_layout(self : JITTable, table_ptr : Int64, size : Int) -> Unit

    Refresh table pointer and size from the active JIT context view.

    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::try_alloc

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

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

    JitIntegrationPlan

    source
    pub(all) struct JitIntegrationPlan {
      entry_symbol : String
      target : 
    EmitTarget
      native_glue : Array[NativeGlueBinding]
      object : 
    MachineCode
    }

    LinkedCode

    source
    pub(all) struct LinkedCode {
      code : Array[Int]
      frame_size : Int
      runtime_relocations : Array[ResolvedRuntimeRelocation]
      func_addr_fixups : Array[
    FuncAddrFixup    ]
      call_fixups : Array[
    CallFixup    ]
      gc_safepoints : Array[GcSafepoint]
      gc_stackmap_blob : Bytes
    } derive(
    Debug    )

    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.

    MemoryManager

    source
    type MemoryManager

    Manages executable memory regions

    MemoryManager::MemoryManager

    source
    fn MemoryManager::MemoryManager(default_region_size : Int) -> MemoryManager

    MemoryManager::alloc_region

    source
    fn MemoryManager::alloc_region(self : MemoryManager, size : Int) -> ExecutableRegion

    Allocate a new executable region

    MemoryManager::finalize_all

    source
    fn MemoryManager::finalize_all(self : MemoryManager) -> Unit

    Finalize all regions

    MemoryManager::get_current_region

    source
    fn MemoryManager::get_current_region(self : MemoryManager) -> ExecutableRegion

    Get the current region, allocating if needed

    MemoryManager::total_allocated

    source
    fn MemoryManager::total_allocated(self : MemoryManager) -> Int

    Get total allocated memory

    MemoryManager::total_used

    source
    fn MemoryManager::total_used(self : MemoryManager) -> Int

    Get total used memory

    MemoryManager::write_code

    source
    fn MemoryManager::write_code(self : MemoryManager, code : 
    MachineCode    ) -> Result[(ExecutableRegion, Int), String]

    Write code to the current region

    NativeGlueBinding

    source
    pub(all) struct NativeGlueBinding {
      kind : NativeGlueKind
      symbol : String
      sources : Array[String]
    } derive(Eq, 
    Debug    )

    NativeGlueKind

    source
    pub(all) enum NativeGlueKind {
      ExecutableMemory
      TrapHandler
      StackSwitch
      HostCallBridge
      WasmMemoryOp
      GcRuntime
      ExceptionHandling
      WasiPreview1
      DebugInfo
    } derive(Eq, 
    Debug    )

    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::alloc_wasm_stack

    source
    fn NativeJITContext::alloc_wasm_stack(self : NativeJITContext, stack_size : Int64) -> 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_stack_switch : Bool) -> Int

    NativeJITContext::clear_cancellation_callback

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

    NativeJITContext::clear_hostcall_callback

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

    NativeJITContext::func_table_ptr

    source
    fn NativeJITContext::func_table_ptr(self : NativeJITContext) -> Int64

    NativeJITContext::has_wasm_stack

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

    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::ptr

    source
    fn NativeJITContext::ptr(self : NativeJITContext) -> Int64

    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_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 : () -> Int) -> 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::try_alloc

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

    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::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

    ResolvedRuntimeRelocation

    source
    pub(all) struct ResolvedRuntimeRelocation {
      offset : Int
      symbol : String
      address : Int64
      fixup_idx : Int?
    } derive(Eq, 
    Debug    )

    RuntimeSymbol

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

    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::add_symbol_fixup

    source
    fn RuntimeSymbolResolver::add_symbol_fixup(self : RuntimeSymbolResolver, name : String, address : Int64, fixup_idx : Int) -> 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::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.

    VMContextLayout::to_embedding_context_layout

    source

    Translate Wasmoon's concrete VMContext prefix into the generic machine-level embedding context layout consumed by reusable 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.

    TYPE_F32

    source
    let TYPE_F32 : Int

    TYPE_F64

    source
    let TYPE_F64 : Int

    TYPE_I32

    source
    let TYPE_I32 : Int

    Type codes for parameter/result types

    TYPE_I64

    source
    let TYPE_I64 : Int

    TYPE_V128

    source
    let TYPE_V128 : Int

    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.

    build_aarch64_direct_call_stub

    source
    fn build_aarch64_direct_call_stub(target_ptr : Int64) -> Array[Int]

    build_aarch64_load_imm64_fixed_bytes

    source
    fn build_aarch64_load_imm64_fixed_bytes(reg : Int, imm : Int64) -> Array[Int]

    build_cwasm_entry_from_code

    source
    fn build_cwasm_entry_from_code(func_idx : Int, name : String, code : Array[Int], frame_size : Int, entry_offset : Int, num_params : Int, num_results : Int, func_addr_fixups? : Array[
    FuncAddrFixup    ], call_fixups? : Array[
    CallFixup    ], gc_safepoint_offsets? : Array[Int], gc_safepoint_root_counts? : Array[Int], gc_safepoint_root_indices? : Array[Array[Int]], gc_safepoints? : Array[
    GcSafepoint    ], gc_stackmap_blob? : Bytes) -> 
    CompiledEntry

    build_entry_trampoline_for_target

    source

    build_gc_stackmap_blob

    source
    fn build_gc_stackmap_blob(root_counts : Array[Int]) -> Bytes

    build_gc_stackmap_blob_for_safepoints

    source
    fn build_gc_stackmap_blob_for_safepoints(safepoints : Array[
    GcSafepoint    ], root_counts : Array[Int], explicit_blob? : Bytes) -> Bytes

    build_gc_stackmap_blob_v2

    source
    fn build_gc_stackmap_blob_v2(safepoints : Array[
    GcSafepoint    ], default_root_counts : Array[Int]) -> Bytes

    build_hostcall_import_trampoline_for_target

    source

    build_x64_direct_call_stub

    source
    fn build_x64_direct_call_stub(target_ptr : Int64) -> Array[Int]

    c_jit_read_i64

    source
    fn c_jit_read_i64(addr : Int64) -> Int64

    Read an int64 value from a memory address

    c_jit_write_i64

    source
    fn c_jit_write_i64(addr : Int64, value : Int64) -> Unit

    Write an int64 value to a memory address

    c_jit_write_u32

    source
    fn c_jit_write_u32(addr : Int64, value : Int) -> Unit

    Write a u32 value to a memory address

    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

    clear_segments

    source
    fn clear_segments(ctx_ptr : Int64) -> Unit

    clear_wasi_stdin_buffer

    source
    fn clear_wasi_stdin_buffer(ctx_ptr : Int64) -> Unit

    clear_wasi_stdin_callback

    source
    fn clear_wasi_stdin_callback(ctx_ptr : Int64) -> Unit

    collect_gc_root_args

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

    context_func_count

    source
    fn context_func_count(ctx_ptr : Int64) -> Int

    context_func_table_ptr

    source
    fn context_func_table_ptr(ctx_ptr : Int64) -> Int64

    context_table_ptr

    source
    fn context_table_ptr(ctx_ptr : Int64, table_idx : Int) -> Int64

    context_table_size

    source
    fn context_table_size(ctx_ptr : Int64, table_idx : Int) -> Int

    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

    default_native_glue

    source
    fn default_native_glue() -> Array[NativeGlueBinding]

    derive_gc_safepoints

    source
    fn derive_gc_safepoints(offsets : Array[Int], root_counts : Array[Int], root_indices : Array[Array[Int]]) -> Array[
    GcSafepoint    ]

    direct_call_idx_memory_copy_mem0

    source
    fn direct_call_idx_memory_copy_mem0() -> Int

    direct_call_idx_memory_fill_mem0

    source
    fn direct_call_idx_memory_fill_mem0() -> Int

    embedding_context_layout

    source

    emit_entry_trampoline

    source
    fn emit_entry_trampoline(param_types : Array[Int], result_types : Array[Int], call_conv_layout : 
    CallConventionLayout    , isa? : 
    ISA    ) -> 
    MachineCode

    Generate an entry trampoline for a specific function signature

    Trampoline signature (C calling convention): int trampoline(vmctx: X0, values_vec: X1, func_ptr: X2) -> trap_code

    The values_vec layout: [arg0, arg1, ..., argN, result0, result1, ..., resultM] Each slot is 8 bytes (int64_t), except V128 which uses 16 bytes (2 slots)

    Parameters: param_types: Array of parameter types (0=I32, 1=I64, 2=F32, 3=F64, 4=V128) result_types: Array of result types

    Approach: generate IR, then compile through the normal pipeline. The register allocator will automatically choose callee-saved registers when needed, eliminating the need for hardcoded X23/X24.

    emit_hostcall_import_trampoline

    source

    Generate a Wasm-ABI trampoline for calling a host function via a hostcall bridge.

    host_func_addr is the runtime Store function address and is passed to the dispatcher.

    emit_target_to_isa

    source

    encode_aarch64_bl_imm26

    source
    fn encode_aarch64_bl_imm26(pc : Int64, target_ptr : Int64) -> Int?

    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

    encode_x64_call_rel32_disp

    source
    fn encode_x64_call_rel32_disp(pc : Int64, target_ptr : Int64) -> Int?

    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

    exception_runtime_fixup_idx

    source
    fn exception_runtime_fixup_idx(ordinal : Int) -> Int

    Reserve negative function-index values for cwasm runtime-helper fixups.

    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_begin_frame

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

    Begin a GC frame scope for current JIT context.

    gc_clear_heap

    source
    fn gc_clear_heap(ctx_ptr : Int64) -> Unit

    Clear the GC heap pointer after JIT execution

    gc_collect_for_alloc

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

    Trigger a GC cycle for allocation retry.

    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

    gc_end_frame

    source
    fn gc_end_frame(ctx_ptr : Int64) -> Unit

    End a GC frame scope for current JIT context.

    gc_runtime_fixup_idx

    source
    fn gc_runtime_fixup_idx(ordinal : Int) -> Int

    Reserve negative function-index values for cwasm runtime-helper fixups.

    gc_safepoint_metadata_to_root_count

    source
    fn gc_safepoint_metadata_to_root_count(metadata : Int64) -> Int

    gc_set_context_heap_ptr

    source
    fn gc_set_context_heap_ptr(ctx_ptr : Int64, heap_ptr : Int64) -> Unit

    gc_set_func_safepoints

    source
    fn gc_set_func_safepoints(ctx_ptr : Int64, func_idx : Int, safepoints : Array[
    GcSafepoint    ], stackmap_blob : Bytes) -> Bool

    gc_set_heap

    source
    fn gc_set_heap(ctx_ptr : Int64, heap : CHeap) -> Unit

    Set up the GC heap for JIT execution heap: The CHeap pointer from Store

    gc_set_root_scratch

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

    Merge roots into context-local scratch storage for allocation retries.

    gc_set_safepoint_table

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

    Set safepoint metadata table pointer for current context.

    gc_setup

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

    Full GC setup for JIT: set heap and type cache func_type_indices, func_table_ptr, and num_funcs are required to keep typed funcref/ref.func operations safe and deterministic.

    gc_teardown

    source
    fn gc_teardown(ctx_ptr : Int64) -> Unit

    Clean up GC context after JIT execution

    gc_use_func_safepoints

    source
    fn gc_use_func_safepoints(ctx_ptr : Int64, func_idx : Int) -> Unit

    get_args_get_ptr

    source
    fn get_args_get_ptr() -> Int64

    get_args_sizes_get_ptr

    source
    fn get_args_sizes_get_ptr() -> Int64

    get_clock_res_get_ptr

    source
    fn get_clock_res_get_ptr() -> Int64

    get_clock_time_get_ptr

    source
    fn get_clock_time_get_ptr() -> Int64

    get_environ_get_ptr

    source
    fn get_environ_get_ptr() -> Int64

    get_environ_sizes_get_ptr

    source
    fn get_environ_sizes_get_ptr() -> Int64

    get_fd_advise_ptr

    source
    fn get_fd_advise_ptr() -> Int64

    get_fd_allocate_ptr

    source
    fn get_fd_allocate_ptr() -> Int64

    get_fd_close_ptr

    source
    fn get_fd_close_ptr() -> Int64

    get_fd_datasync_ptr

    source
    fn get_fd_datasync_ptr() -> Int64

    get_fd_fdstat_get_ptr

    source
    fn get_fd_fdstat_get_ptr() -> Int64

    get_fd_fdstat_set_flags_ptr

    source
    fn get_fd_fdstat_set_flags_ptr() -> Int64

    get_fd_fdstat_set_rights_ptr

    source
    fn get_fd_fdstat_set_rights_ptr() -> Int64

    get_fd_filestat_get_ptr

    source
    fn get_fd_filestat_get_ptr() -> Int64

    get_fd_filestat_set_size_ptr

    source
    fn get_fd_filestat_set_size_ptr() -> Int64

    get_fd_filestat_set_times_ptr

    source
    fn get_fd_filestat_set_times_ptr() -> Int64

    get_fd_pread_ptr

    source
    fn get_fd_pread_ptr() -> Int64

    get_fd_prestat_dir_name_ptr

    source
    fn get_fd_prestat_dir_name_ptr() -> Int64

    get_fd_prestat_get_ptr

    source
    fn get_fd_prestat_get_ptr() -> Int64

    get_fd_pwrite_ptr

    source
    fn get_fd_pwrite_ptr() -> Int64

    get_fd_read_ptr

    source
    fn get_fd_read_ptr() -> Int64

    get_fd_readdir_ptr

    source
    fn get_fd_readdir_ptr() -> Int64

    get_fd_renumber_ptr

    source
    fn get_fd_renumber_ptr() -> Int64

    get_fd_seek_ptr

    source
    fn get_fd_seek_ptr() -> Int64

    get_fd_sync_ptr

    source
    fn get_fd_sync_ptr() -> Int64

    get_fd_tell_ptr

    source
    fn get_fd_tell_ptr() -> Int64

    get_fd_write_ptr

    source
    fn get_fd_write_ptr() -> Int64

    get_gc_array_copy_ptr

    source
    fn get_gc_array_copy_ptr() -> Int64

    Get array.copy libcall function pointer Signature: void gc_array_copy(int64_t dst_ref, int32_t dst_off, int64_t src_ref, int32_t src_off, int32_t count) Copies array elements from source to destination

    get_gc_array_fill_ptr

    source
    fn get_gc_array_fill_ptr() -> Int64

    Get array.fill libcall function pointer Signature: void gc_array_fill(int64_t ref, int32_t offset, int64_t value, int32_t count) Fills array elements with a value

    get_gc_array_get_ptr

    source
    fn get_gc_array_get_ptr() -> Int64

    Get array.get libcall function pointer Signature: int64_t gc_array_get(int64_t ref, int type_idx, int idx) Returns the element value

    get_gc_array_len_ptr

    source
    fn get_gc_array_len_ptr() -> Int64

    Get array.len libcall function pointer Signature: int gc_array_len(int64_t ref) Returns the array length

    get_gc_array_new_ptr

    source
    fn get_gc_array_new_ptr() -> Int64

    Get array.new libcall function pointer Signature: int64_t gc_array_new(int type_idx, int len, int64_t fill) Returns encoded ArrayRef

    get_gc_array_set_ptr

    source
    fn get_gc_array_set_ptr() -> Int64

    Get array.set libcall function pointer Signature: void gc_array_set(int64_t ref, int type_idx, int idx, int64_t value)

    get_gc_ref_cast_ptr

    source
    fn get_gc_ref_cast_ptr() -> Int64

    Get ref.cast libcall function pointer Signature: int64_t gc_ref_cast(int64_t ref, int type_idx, int nullable) Returns the ref if cast succeeds, traps on failure

    get_gc_ref_test_ptr

    source
    fn get_gc_ref_test_ptr() -> Int64

    Get ref.test libcall function pointer Signature: int gc_ref_test(int64_t ref, int type_idx, int nullable) Returns 1 if test passes, 0 otherwise

    get_gc_struct_get_ptr

    source
    fn get_gc_struct_get_ptr() -> Int64

    Get struct.get libcall function pointer Signature: int64_t gc_struct_get(int64_t ref, int type_idx, int field_idx) Returns the field value

    get_gc_struct_new_ptr

    source
    fn get_gc_struct_new_ptr() -> Int64

    Get struct.new libcall function pointer Signature: int64_t gc_struct_new(int type_idx, int64_t* fields, int num_fields) Returns encoded StructRef

    get_gc_struct_set_ptr

    source
    fn get_gc_struct_set_ptr() -> Int64

    Get struct.set libcall function pointer Signature: void gc_struct_set(int64_t ref, int type_idx, int field_idx, int64_t value)

    get_gc_type_check_subtype_ptr

    source
    fn get_gc_type_check_subtype_ptr() -> Int64

    Get type check subtype libcall function pointer for call_indirect with subtyping Signature: void gc_type_check_subtype(int32_t actual_type, int32_t expected_type) Traps if actual_type is not a subtype of expected_type

    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_hostcall_values_ptr

    source
    fn get_hostcall_values_ptr() -> Int64

    Get the pointer to the hostcall scratch values_vec buffer.

    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_path_create_directory_ptr

    source
    fn get_path_create_directory_ptr() -> Int64

    get_path_filestat_get_ptr

    source
    fn get_path_filestat_get_ptr() -> Int64

    get_path_filestat_set_times_ptr

    source
    fn get_path_filestat_set_times_ptr() -> Int64

    fn get_path_link_ptr() -> Int64

    get_path_open_ptr

    source
    fn get_path_open_ptr() -> Int64

    fn get_path_readlink_ptr() -> Int64

    get_path_remove_directory_ptr

    source
    fn get_path_remove_directory_ptr() -> Int64

    get_path_rename_ptr

    source
    fn get_path_rename_ptr() -> Int64

    fn get_path_symlink_ptr() -> Int64

    fn get_path_unlink_file_ptr() -> Int64

    get_poll_oneoff_ptr

    source
    fn get_poll_oneoff_ptr() -> Int64

    get_proc_exit_ptr

    source
    fn get_proc_exit_ptr() -> Int64

    get_proc_raise_ptr

    source
    fn get_proc_raise_ptr() -> Int64

    get_random_get_ptr

    source
    fn get_random_get_ptr() -> Int64

    get_sched_yield_ptr

    source
    fn get_sched_yield_ptr() -> Int64

    get_sock_accept_ptr

    source
    fn get_sock_accept_ptr() -> Int64

    get_sock_recv_ptr

    source
    fn get_sock_recv_ptr() -> Int64

    get_sock_send_ptr

    source
    fn get_sock_send_ptr() -> Int64

    get_sock_shutdown_ptr

    source
    fn get_sock_shutdown_ptr() -> Int64

    get_spectest_print_char_ptr

    source
    fn get_spectest_print_char_ptr() -> Int64

    get_spectest_print_f32_ptr

    source
    fn get_spectest_print_f32_ptr() -> Int64

    get_spectest_print_f64_f64_ptr

    source
    fn get_spectest_print_f64_f64_ptr() -> Int64

    get_spectest_print_f64_ptr

    source
    fn get_spectest_print_f64_ptr() -> Int64

    get_spectest_print_i32_f32_ptr

    source
    fn get_spectest_print_i32_f32_ptr() -> Int64

    get_spectest_print_i32_ptr

    source
    fn get_spectest_print_i32_ptr() -> Int64

    get_spectest_print_i64_ptr

    source
    fn get_spectest_print_i64_ptr() -> Int64

    get_spectest_print_ptr

    source
    fn get_spectest_print_ptr() -> Int64

    get_temperature

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

    Determines the temperature of a function based on its call count

    host_target_arch

    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

    i64_to_value

    source

    Decode an Int64 from C heap to a Value based on expected type

    init_wasi_context

    source
    fn init_wasi_context(ctx_ptr : Int64, args : Array[String], env : Array[String], preopens : Array[(String, String)], quiet? : Bool) -> Unit

    install_direct_call_stubs_for_target

    source

    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_ffi_native_stub_sources

    source
    fn jit_ffi_native_stub_sources() -> Array[String]

    jit_runtime_fixup_idx

    source
    fn jit_runtime_fixup_idx(ordinal : Int) -> Int

    Reserve negative function-index values for cwasm runtime-helper fixups.

    jit_trap_message

    source
    fn jit_trap_message(code : Int) -> String

    lower_milkir_for_target

    source

    lower_wasm_body_milkir_for_target

    source

    machv_reloc_target_to_cwasm_func_idx

    source
    fn machv_reloc_target_to_cwasm_func_idx(target : 
    RelocTarget    ) -> Int?

    make_cstring

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

    memory_descriptor_layout

    source
    fn memory_descriptor_layout() -> MemoryDescriptorLayout

    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_glue_covers_jit_ffi_stubs

    source
    fn native_glue_covers_jit_ffi_stubs(glue? : Array[NativeGlueBinding]) -> Bool

    native_glue_covers_source

    source
    fn native_glue_covers_source(glue : Array[NativeGlueBinding], source : String) -> Bool

    patch_aarch64_call_fixups

    source
    fn patch_aarch64_call_fixups(exec_ptr : Int64, fixups : Array[
    CallFixup    ], func_table_ptr : Int64, direct_call_targets : Map[Int, Int64]) -> Unit

    patch_aarch64_call_veneer_target

    source
    fn patch_aarch64_call_veneer_target(exec_ptr : Int64, fixup : 
    CallFixup    , target_ptr : Int64) -> Unit

    patch_aarch64_direct_call

    source
    fn patch_aarch64_direct_call(exec_ptr : Int64, fixup : 
    CallFixup    , target_ptr : Int64) -> Unit

    patch_aarch64_func_addr_fixup

    source
    fn patch_aarch64_func_addr_fixup(exec_ptr : Int64, fixup : 
    FuncAddrFixup    , target_ptr : Int64) -> Unit

    patch_aarch64_func_addr_fixup_parts

    source
    fn patch_aarch64_func_addr_fixup_parts(exec_ptr : Int64, offset : Int, reg : Int, target_ptr : Int64) -> Unit

    patch_aarch64_func_addr_fixup_raw

    source
    fn patch_aarch64_func_addr_fixup_raw(exec_ptr : Int64, offset : Int, reg : Int, func_idx : Int, func_table_ptr : Int64) -> Unit

    patch_aarch64_func_addr_fixups

    source
    fn patch_aarch64_func_addr_fixups(exec_ptr : Int64, fixups : Array[
    FuncAddrFixup    ], func_table_ptr : Int64) -> Unit

    patch_aarch64_load_imm64_fixed

    source
    fn patch_aarch64_load_imm64_fixed(exec_ptr : Int64, offset : Int, reg : Int, imm : Int64) -> Unit

    patch_call_fixups_for_target

    source
    fn patch_call_fixups_for_target(target : 
    TargetArch    , exec_ptr : Int64, fixups : Array[
    CallFixup    ], func_table_ptr : Int64, direct_call_targets : Map[Int, Int64]) -> Unit

    patch_func_addr_fixup_raw_for_target

    source
    fn patch_func_addr_fixup_raw_for_target(target : 
    TargetArch    , exec_ptr : Int64, offset : Int, reg : Int, func_idx : Int, func_table_ptr : Int64) -> Unit

    patch_func_addr_fixups_for_target

    source
    fn patch_func_addr_fixups_for_target(target : 
    TargetArch    , exec_ptr : Int64, fixups : Array[
    FuncAddrFixup    ], func_table_ptr : Int64) -> Unit

    patch_x64_call_fixups

    source
    fn patch_x64_call_fixups(exec_ptr : Int64, fixups : Array[
    CallFixup    ], func_table_ptr : Int64, direct_call_targets : Map[Int, Int64]) -> Unit

    patch_x64_direct_call

    source
    fn patch_x64_direct_call(exec_ptr : Int64, fixup : 
    CallFixup    , target_ptr : Int64) -> Unit

    patch_x64_func_addr_fixup_parts

    source
    fn patch_x64_func_addr_fixup_parts(exec_ptr : Int64, offset : Int, _reg : Int, target_ptr : Int64) -> Unit

    patch_x64_func_addr_fixup_raw

    source
    fn patch_x64_func_addr_fixup_raw(exec_ptr : Int64, offset : Int, reg : Int, func_idx : Int, func_table_ptr : Int64) -> Unit

    patch_x64_func_addr_fixups

    source
    fn patch_x64_func_addr_fixups(exec_ptr : Int64, fixups : Array[
    FuncAddrFixup    ], func_table_ptr : Int64) -> Unit

    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_integration_for_target

    source

    plan_milkir_integration_for_target

    source

    plan_wasm_body_milkir_integration_for_target

    source
    fn plan_wasm_body_milkir_integration_for_target(func : 
    Function    , target : 
    EmitTarget    ) -> JitIntegrationPlan

    required_context_function_count

    source
    fn required_context_function_count(precompiled : 
    PrecompiledModule    , func_signature_count : Int) -> Int

    resolve_call_fixup_target

    source
    fn resolve_call_fixup_target(func_idx : Int, func_table_ptr : Int64, direct_call_targets : Map[Int, Int64]) -> Int64?

    resolve_func_addr_fixup_target

    source
    fn resolve_func_addr_fixup_target(func_idx : Int, func_table_ptr : Int64) -> Int64?

    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?

    resolve_runtime_func_fixup_idx

    source
    fn resolve_runtime_func_fixup_idx(idx : Int) -> Int64?

    Resolve the negative cwasm runtime-helper function index used by Wasmoon JIT call fixups. MachV emission uses named external-symbol relocations, and the cwasm artifact stores those runtime helper targets as negative function indices for the loader to patch.

    resolve_wasm_func_code_symbol

    source
    fn resolve_wasm_func_code_symbol(symbol : 
    CodeSymbol    ) -> Int?

    resolve_wasm_func_symbol

    source
    fn resolve_wasm_func_symbol(name : String) -> Int?

    runtime_hostcall_symbol

    source
    fn runtime_hostcall_symbol() -> 
    ExternalName

    sanitize_debug_filename

    source
    fn sanitize_debug_filename(s : String) -> String

    set_wasi_stderr_capture

    source
    fn set_wasi_stderr_capture(ctx_ptr : Int64, enabled : Bool) -> Unit

    set_wasi_stdin_buffer

    source
    fn set_wasi_stdin_buffer(ctx_ptr : Int64, data : Bytes) -> Unit

    set_wasi_stdin_callback

    source
    fn set_wasi_stdin_callback(ctx_ptr : Int64, callback : () -> Bytes) -> Unit

    set_wasi_stdout_capture

    source
    fn set_wasi_stdout_capture(ctx_ptr : Int64, enabled : Bool) -> Unit

    setup_segments

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

    setup_type_cache_from_types

    source
    fn setup_type_cache_from_types(ctx_ptr : Int64, types : Array[
    SubType    ], canonical_indices : Array[Int]) -> Unit

    Set up the type cache for subtyping checks from raw type data types: Array of SubType from the module canonical_indices: Array of canonical type indices

    tag_funcref_ptr

    source
    fn tag_funcref_ptr(func_ptr : Int64) -> Int64

    take_pending_trap_message

    source
    fn take_pending_trap_message() -> String?

    take_wasi_exit_code

    source
    fn take_wasi_exit_code(ctx_ptr : Int64) -> Int

    take_wasi_stderr

    source
    fn take_wasi_stderr(ctx_ptr : Int64) -> Bytes

    take_wasi_stdout

    source
    fn take_wasi_stdout(ctx_ptr : Int64) -> Bytes

    target_arch_to_isa

    source

    throw_exception_tag

    source
    fn throw_exception_tag(ctx_ptr : Int64, tag_addr : Int) -> Unit

    throw_exception_values

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

    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 to Int64 for C heap storage Encoding rules:
    • i32: sign-extended to i64
    • i64: as-is
    • f32: lower 32 bits (IEEE 754 bits)
    • f64: as-is (IEEE 754 bits)
    • 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: (value & 1) == 0 && value > 0

    value_type_may_hold_gc_ref

    source
    fn value_type_may_hold_gc_ref(ty : 
    ValueType    ) -> Bool

    vmcontext_layout

    source
    fn vmcontext_layout() -> VMContextLayout

    wasm_calling_convention

    source

    wasm_calling_convention_for_isa

    source

    Wasmoon internal Wasm-to-Wasm calling convention for a target ISA.

    wasm_context_slots

    source

    wasm_embedding_abi

    source

    wasm_embedding_abi_for_isa

    source

    Complete Wasmoon embedding ABI contract for reusable MachV/MilkIR stages.

    wasm_embedding_reg_roles

    source

    wasm_embedding_reg_roles_for_isa

    source

    Wasmoon JIT embedding register roles for a target ISA.

    These numbers preserve the historical Wasmoon ABI. They are owned here so reusable MachV ISA policy does not decide VMContext or cached-pointer roles.

    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. MachV only carries the integer payload; this module owns the Wasmoon-specific reason-to-payload policy.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io