An anyref GC reference.
A reference to a GC-managed array instance.
An allocator for a particular Wasm GC array type.
The type of a WebAssembly array.
A structure representing the caller’s context when creating a function
via
Func::wrap.
Builder-style structure used to create a
Module or
pre-compile a module to a serialized list of bytes.
Management of executable memory within a MmapVec
A compiled wasm module, ready to be instantiated.
Global configuration options used to create an
Engine
and customize its behavior.
An Engine which is a global context for compilation and management of wasm
modules.
A weak reference to an
Engine.
A reference to a GC-managed object that can be tested for equality.
The Error type, a wrapper around a dynamic error type.
An exported WebAssembly value.
A descriptor for an exported WebAssembly value.
An opaque, GC-managed reference to some host data that can be passed to
WebAssembly.
The type of a struct field or an array’s elements.
Debug information for a symbol that is attached to a
FrameInfo.
A WebAssembly function which can be called.
The type of a WebAssembly function.
An error returned when attempting to allocate a GC-managed object, but the
GC heap is out of memory.
A WebAssembly global value which can be read and written to.
A WebAssembly global descriptor.
Collects basic profiling data for a single WebAssembly guest.
A 31-bit integer.
A descriptor for an imported value into a wasm module.
An instantiated WebAssembly module.
An instance, pre-instantiation, that is ready to be instantiated.
Structure used to link wasm modules/instances together.
A rooted reference to a garbage-collected T with arbitrary lifetime.
A WebAssembly linear memory.
Error for out of bounds
Memory access.
A descriptor for a WebAssembly memory type.
A compiled WebAssembly module, ready to be instantiated.
Describes the location of an export in a module.
A reference to the abstract noextern heap value.
A reference to the abstract nofunc heap value.
A reference to the abstract none heap value.
An error returned when the pooling allocator cannot allocate a table,
memory, etc… because the maximum number of concurrent allocations for that
entity has been reached.
Opaque references to data in the Wasm heap or to host data.
A summary of the amount of resources required to instantiate a particular
Module or
Component.
Nested rooting scopes.
A scoped, rooted reference to a garbage-collected T.
A constructor for externally-created shared memory.
A
Store is a collection of WebAssembly instances and host-defined state.
Provides limits for a
Store.
A reference to a GC-managed struct instance.
An allocator for a particular Wasm GC struct type.
The type of a WebAssembly struct.
A WebAssembly table, or an array of values.
A descriptor for a table in a WebAssembly module.
A statically typed WebAssembly function.
Error for an unresolvable import.
Representation of a 128-bit vector type, v128, for WebAssembly.
Representation of a backtrace of function frames in a WebAssembly module for
where an error happened.
Representation of a core dump of a WebAssembly module
Passed to the argument of
Store::call_hook to indicate a state transition in
the WebAssembly VM.
Possible garbage collector implementations for Wasm.
An external item to a WebAssembly module, or a list of what can possibly be
exported from a wasm module.
A list of all possible types which can be externally referenced from a
WebAssembly module.
Indicator of whether a type is final or not.
The heap types that can Wasm can have references to.
Represents the module instance allocation strategy to use.
Configure the strategy used for versioning in serializing and deserializing
crate::Module.
Describe the tri-state configuration of memory protection keys (MPK).
Indicator of whether a global value, struct’s field, or array type’s
elements are mutable or not.
Possible optimization levels for the Cranelift codegen backend.
Select which profiling technique to support.
A reference.
Possible register allocator algorithms for the Cranelift codegen backend.
The storage type of a struct field or array element.
Possible Compilation strategies for a wasm module.
What to do after returning from a callback when the engine epoch reaches
the deadline for a Store during execution of a function using that store.
Possible runtime values that a WebAssembly module can either consume or
produce.
A list of all possible value types in WebAssembly.
Result of Memory::atomic_wait32 and Memory::atomic_wait64
Select how wasm backtrace detailed information is handled.
A trait used to get shared access to a
Store in Wasmtime.
A trait used to get exclusive mutable access to a
Store in Wasmtime.
Implementation of an incremental compilation’s key/value cache store.
An object that can take callbacks when the runtime enters or exits hostcalls.
A common trait implemented by all garbage-collected reference types.
A linear memory. This trait provides an interface for raw memory buffers
which are used by wasmtime, e.g. inside [‘Memory’]. Such buffers are in
principle not thread safe. By implementing this trait together with
MemoryCreator, one can supply wasmtime with custom allocated host managed
memory.
A memory creator. Can be used to provide a memory creator
to wasmtime which supplies host managed memory.
Used by hosts to limit resource consumption of instances.
Used by hosts to limit resource consumption of instances, blocking
asynchronously if necessary.
A trait implemented for GC references that are guaranteed to be rooted:
A stack creator. Can be used to provide a stack creator to wasmtime
which supplies stacks for async support.
A stack memory. This trait provides an interface for raw memory buffers
which are used by wasmtime inside of stacks which wasmtime executes
WebAssembly in for async support. By implementing this trait together
with StackCreator, one can supply wasmtime with custom allocated host
managed stacks.
A trait used for
Func::typed and with
TypedFunc to represent the set of
parameters for wasm functions.
A trait implemented for types which can be returned from closures passed to
Func::wrap and friends.
A trait implemented for types which can be arguments and results for
closures passed to
Func::wrap as well as parameters to
Func::typed.
Trait implemented for various tuples made up of types which implement
WasmTy that can be passed to
Func::wrap_inner and
[
HostContext::from_closure].