Kwasm.runtime

Addresses for FunctionInstances, Memorys, Tables, and Globals.

From the docs:

Function instances, table instances, memory instances, and global instances in the store are referenced with abstract addresses. These are simply indices into the respective store component.

addr       ::= 0|1|2|...
funcaddr   ::= addr
tableaddr  ::= addr
memaddr    ::= addr
globaladdr ::= addr

An embedder may assign identity to exported store objects corresponding to their addresses, even where this identity is not observable from within WebAssembly code itself (such as for function instances or immutable globals).

Represents a runtime exported value.

From the docs:

An export instance is the runtime representation of an export. It defines the export’s name and the associated external value.

exportinst ::= {name name, value externval}

Represents either a WasmFunction from a ModuleInstance, or a HostFunction exposed to the ModuleInstance via imports.

From the docs:

A function instance is the runtime representation of a function. It effectively is a closure of the original function over the runtime module instance of its originating module. The module instance is used to resolve references to other definitions during execution of the function.

funcinst   ::= {type functype, module moduleinst, code func}
{type functype, hostcode hostfunc}
hostfunc ::= ...

A host function is a function expressed outside WebAssembly but passed to a module as an import.

From the docs:

A global instance is the runtime representation of a global variable. It holds an individual value and a flag indicating whether it is mutable.

globalinst ::= {value val, mut mut}

The value of mutable globals can be mutated through variable instructions or by external means provided by the embedder.

From the docs:

Where I is a IdentifierContext:

I  ::=   { types       (id?),
funcs       (id?),
tables      (id?),
mems        (id?),
globals     (id?),
locals      (id?),
labels      (id?),
typedefs    functype   }

Represents an external value imported by a WasmModule. Its address will be used to populate a

1. Parse WasmModules
2. Build ImportExterns from the modules' declared imports.
3. Allocate the modules with their import externs.
4. Using the allocations, update the addresses from the import externs appropriately.

Defines runtime memory for use by a wasm program, along with facilities for accessing and mutating memory by the host JVM application.

From the docs:

A memory instance is the runtime representation of a linear memory. It holds a vector of bytes and an optional maximum size, if one was specified at the definition site of the memory.

meminst ::= {data vec(byte), max u32?}

The length of the vector always is a multiple of the WebAssembly page size, which is defined to be the constant 65536 – abbreviated 64Ki. Like in a memory type, the maximum size in a memory instance is given in units of this page size.

The bytes can be mutated through memory instructions, the execution of a data segment, or by external means provided by the embedder.

It is an invariant of the semantics that the length of the byte vector, divided by page size, never exceeds the maximum size, if present.

Represents an instantiated kwasm.ast.module.WasmModule.

From the docs:

A module instance is the runtime representation of a module. It is created by instantiating a module, and collects runtime representations of all entities that are imported, defined, or exported by the module.

moduleinst ::= {
types functype*,
funcaddrs funcaddr*,
tableaddrs tableaddr*,
memaddrs memaddr*,
globaladdrs globaladdr*,
exports exportinst*
}

Each component references runtime instances corresponding to respective declarations from the original module – whether imported or defined – in the order of their static indices. Function instances, table instances, memory instances, and global instances are referenced with an indirection through their respective addresses in the store.

It is an invariant of the semantics that all export instances in a given module instance have different names.

Result of allocating a module using WasmModule.allocate.

Defines an element in one of the runtime Stacks.

From the docs:

The store represents all global state that can be manipulated by WebAssembly programs. It consists of the runtime representation of all instances of functions, tables, memories, and globals that have been allocated during the life time of the abstract machine.

Syntactically, the store is defined as a record listing the existing instances of each category:

store  ::= {
funcs funcinst*,
tables tableinst*,
mems meminst*,
globals globalinst*
}

Runtime representation of a WebAssembly Table.

From the docs:

A table instance is the runtime representation of a table. It holds a vector of function elements and an optional maximum size, if one was specified in the table type at the table’s definition site.

Each function element is either empty, representing an uninitialized table entry, or a function address. Function elements can be mutated through the execution of an element segment or by external means provided by the embedder.

tableinst ::= {elem vec(funcelem), max u32?}
funcelem ::= funcaddr?

It is an invariant of the semantics that the length of the element vector never exceeds the maximum size, if present.

Defines a value for use in WebAssembly at runtime.

From the docs:

WebAssembly computations manipulate values of the four basic value types: integers and floating-point data of 32 or 64 bit width each, respectively.

In most places of the semantics, values of different types can occur. In order to avoid ambiguities, values are therefore represented with an abstract syntax that makes their type explicit. It is convenient to reuse the same notation as for the const instructions producing them:

val    ::= i32.const i32
i64.const i64
f32.const f32
f64.const f64

Represents an empty value. Should only ever be used as a return-type for a void/Unit kwasm.api.HostFunction.

Holds a 32-bit integer Value.

Holds a 64-bit integer Value.

Holds a 32-bit floating-point Value.

Holds a 64-bit floating-point Value.

Gets the default zero Value for the receiving ValueType.